<?xml version="1.0" ?>
<!DOCTYPE translationbundle>
<translationbundle lang="hr">
<translation id="1002439864875515590">Ako se to pravilo postavi na prazan niz ili se ne konfigurira, <ph name="PRODUCT_OS_NAME" /> neće prikazivati opciju za samodovršavanje tijekom postupka prijave korisnika.
      Ako se to pravilo postavi na niz koji predstavlja naziv domene, <ph name="PRODUCT_OS_NAME" /> prikazivat će opciju za samodovršavanje tijekom prijave korisnika, omogućujući korisniku da unese samo svoje korisničko ime bez proširenja naziva domene.  Korisnik će moći prebrisati proširenje naziva domene.
      Ako vrijednost tog pravila nije važeća domena, pravilo se neće primjenjivati.</translation>
<translation id="101438888985615157">Zakreni zaslon 180 stupnjeva</translation>
<translation id="1016912092715201525">Konfigurira zadane provjere preglednika u proizvodu <ph name="PRODUCT_NAME" /> i sprječava korisnike da ih promijene.

      Ako omogućite tu postavku, <ph name="PRODUCT_NAME" /> će prilikom svakog pokretanja provjeriti je li zadani preglednik i automatski se registrirati ako je moguće.

      Ako je ta postavka onemogućena, <ph name="PRODUCT_NAME" /> neće nikad provjeravati je li zadani preglednik i onemogućit će korisničke kontrole za postavljanje te opcije.

      Ako se ta postavka ne odredi, korisnik će moći odrediti je li <ph name="PRODUCT_NAME" /> zadani preglednik i trebaju li se obavijesti za korisnika prikazivati kad to nije slučaj.

      Napomena za administratore u sustavu <ph name="MS_WIN_NAME" />: omogućivanje te postavke funkcionirat će samo za računala s Windowsima 7. Za verzije Windowsa od Windowsa 8 nadalje morate implementirati datoteku "pridruživanja zadane aplikacije" koja <ph name="PRODUCT_NAME" /> čini rukovateljem za <ph name="HHTPS_PROTOCOL" /> i <ph name="HTTP_PROTOCOL" /> protokole (i prema želji <ph name="FTP_PROTOCOL" /> protokol i formate datoteka kao što su <ph name="HTML_EXTENSION" />, <ph name="HTM_EXTENSION" />, <ph name="PDF_EXTENSION" />, <ph name="SVG_EXTENSION" />, <ph name="WEBP_EXTENSION" /> itd.). Više informacija potražite na stranici <ph name="SUPPORT_URL" />.</translation>
<translation id="1017967144265860778">Upravljanje napajanjem na zaslonu za prijavu</translation>
<translation id="1019101089073227242">Postavi imenik korisničkih podataka</translation>
<translation id="1022361784792428773">ID-jevi proširenja u čijem bi instaliranju korisnik trebao biti spriječen (ili * za sve)</translation>
<translation id="102492767056134033">Postavljanje zadanog stanja zaslonske tipkovnice na zaslonu za prijavu</translation>
<translation id="1027000705181149370">Određuje hoće li se kolačići za autentifikaciju koje postavlja SAML IdP tijekom prijave prenositi na profil korisnika.

      Kada se korisnik prilikom prijave autentificira putem SAML IdP-a, kolačići koje IdP postavi prvo se zapisuju u privremeni profil. Ti se kolačići mogu prenijeti na profil korisnika radi prosljeđivanja stanja autentifikacije.

      Kada se to pravilo postavi na "true", kolačići koje postavi IdP prenose se na profil korisnika svaki put kada se korisnik tijekom prijave autentificira pomoću SAML IdP-a.

      Kada se pravilo postavi na "false" ili se ne postavi, kolačići koje postavi IdP prenose se na profil korisnika samo prilikom prve prijave na uređaj.

      To pravilo utječe samo na korisnike čija se domena podudara s domenom upisa uređaja. Za sve ostale korisnike kolačići koje postavi IdP prenose se na profil korisnika samo prilikom prve prijave na uređaj.</translation>
<translation id="1029052664284722254">Prisilno ponovo pokreni uređaj nakon odjave korisnika</translation>
<translation id="1030120600562044329">Omogućuje slanje anonimnih podataka o upotrebi i rušenjima programa <ph name="PRODUCT_NAME" /> Googleu i sprječava korisnike da promijene tu postavku.

      Ako je postavka omogućena, slanje anonimnih podataka o upotrebi i rušenjima
      šalju se Googleu.  Ako je onemogućena, ti se podaci ne šalju Googleu.  Korisnici ni u jednom slučaju ne mogu promijeniti niti nadjačati tu postavku.
      Ako se pravilo ne postavi, postavka će biti ono što korisnik odabere
      prilikom instalacije/prvog pokretanja.

      Pravilo je dostupno samo na instancama Windowsa koje su pridružene domeni <ph name="MS_AD_NAME" /> ili instancama Windowsa 10 Pro ili Enterprise prijavljenim za upravljanje uređajima.
      (Za OS Chrome pogledajte pravilo DeviceMetricsReportingEnabled.)</translation>
<translation id="1035385378988781231">To pravilo određuje hoće li značajka mrežnog dijeljenja datoteka za <ph name="PRODUCT_NAME" /> upotrebljavati NTLM za autentifikaciju.

      Ako se to pravilo postavi na True, NTLM će se upotrebljavati za autentifikaciju SMB dijeljenja ako je potrebna.
      Ako se pravilo postavi na False, NTLM autentifikacija za SMB dijeljenja bit će onemogućena.

      Ako se ne postavi, ovo će pravilo prema zadanim postavkama biti onemogućeno za upravljane korisnike u poduzećima, a za neupravljane korisnike bit će omogućeno.</translation>
<translation id="1040446814317236570">Omogući uklanjanje dijelova URL-a za PAC (za https://)</translation>
<translation id="1044878202534415707">Izvješćivanje o statističkim podacima o hardveru, primjerice, o upotrebi procesora/RAM-a.

      Ako se pravilo postavi na "neistinito", neće se izvješćivati o statističkim podacima.
      Ako se postavi na "istinito" ili se ne postavi, izvješćivat će se o statističkim podacima.</translation>
<translation id="1046484220783400299">Omogući zastarjele značajke web-platforme na ograničeno vrijeme</translation>
<translation id="1047128214168693844">Ne dopuštaj web-lokacijama praćenje fizičke lokacije korisnika</translation>
<translation id="1049138910114524876">Konfigurira oznaku zemlje/jezika koja se nameće na zaslonu za prijavu na usluzi <ph name="PRODUCT_OS_NAME" />.

      Ako se to pravilo postavi, zaslon za prijavu uvijek će se prikazivati na jeziku određenom prvom vrijednošću pravila (pravilo je definirano kao popis za kompatibilnost s budućim verzijama). Ako se to pravilo ne postavi ili se postavi na prazan popis, zaslon za prijavu prikazivat će se na jeziku zadnje korisničke sesije. Ako se to pravilo postavi na vrijednost koja nije važeća oznaka zemlje/jezika, zaslon za prijavu prikazivat će se na osnovnom jeziku (trenutačno en-US).</translation>
<translation id="1052499923181221200">To pravilo nema utjecaja ako se SamlInSessionPasswordChangeEnabled ne postavi na true.
      Ako se potonje postavi na true, a ovo pravilo (primjerice) na 14, to znači da će korisnici SAML-a primiti obavijest 14 dana prije nego što im istekne zaporka na određeni datum.
      Tako mogu odmah pristupiti rješavanju te promijeniti zaporku u okviru sesije i ažurirati je prije isteka.
      No te će se obavijesti prikazati samo ako informacije o isteku zaporke uređaju pošalje davatelj identiteta za SAML tijekom postupka SAML prijave.
      Postavljanje tog pravila na nula znači da korisnici neće biti obaviješteni unaprijed, već tek nakon isteka zaporke.

      Ako je to pravilo postavljeno, korisnik ga neće moći promijeniti ni nadjačati.</translation>
<translation id="1062011392452772310">Omogući daljinsku ovjeru za uređaj</translation>
<translation id="1062407476771304334">Zamijeni</translation>
<translation id="1079801999187584280">Onemogući upotrebu Alata za razvojne programere</translation>
<translation id="1087437665304381368">To pravilo kontrolira samo način rada razvojnog programera za <ph name="PRODUCT_OS_NAME" />. Ako želite spriječiti pristup Opcijama za razvojne programere Androida, trebate postaviti pravilo <ph name="DEVELOPER_TOOLS_DISABLED_POLICY_NAME" />.</translation>
<translation id="1093082332347834239">Ako se omogući ta postavka, host daljinske pomoći pokrenut će se u procesu s dopuštenjima <ph name="UIACCESS_PERMISSION_NAME" />. To će udaljenim korisnicima omogućiti interakciju s privilegiranim prozorima na računalu lokalnog korisnika.

          Ako je ta postavka onemogućena ili nije konfigurirana, host daljinske pomoći pokrenut će se u kontekstu korisnika i udaljeni korisnici neće moći pristupiti privilegiranim prozorima na računalu.</translation>
<translation id="1096105751829466145">Zadani davatelj usluga pretraživanja</translation>
<translation id="1099282607296956954">Omogući izolaciju web-lokacije za sve web-lokacije</translation>
<translation id="1100570158310952027">
      U pravilu se navodi popis polazišta (URL-ova) ili uzoraka naziva hosta (primjerice "*.example.com") na koje se neće primjenjivati sigurnosna ograničenja.

      Namjera je omogućiti organizacijama da postave popis dopuštenih polazišta za stare aplikacije koje ne mogu upotrebljavati TLS ili da postave pripremni (engl. staging) poslužitelj za interni mrežni razvoj kako bi njihovi razvojni programeri mogli testirati značajke kojima su potrebni sigurni konteksti bez upotrebe TLS-a na pripremnom (engl. staging) poslužitelju. Tim će se pravilima također spriječiti da polazište bude označeno kao "Nesigurno" u višenamjenskom okviru.

      Postavljanje popisa URL-ova u ovim pravilima ima jednak učinak kao i postavljanje oznake naredbenog retka '--unsafely-treat-insecure-origin-as-secure' na popis jednakih URL-ova odijeljenih zarezom. Ako je pravilo postavljeno, ono će nadjačati oznaku naredbenog retka.
      Ovo pravilo nadjačava opciju UnsafelyTreatInsecureOriginAsSecure ako je ona prisutna.

      Za više informacija o sigurnim kontekstima pogledajte
      https://www.w3.org/TR/secure-contexts/.
      </translation>
<translation id="1107764601871839136">Određuje trajanje predmemorije (u satima) za objekt pravilnika grupe (GPO). Kako se GPO-ovi ne bi ponovo preuzimali pri svakom dohvaćanju pravila, sustav može ponovo upotrijebiti predmemorirne GPO-ove dok se ne promijeni njihova verzija. Ovo pravilo navodi maksimalno vrijeme za ponovnu upotrebu predmemoriranih GPO-ova do ponovnog preuzimanja. Ponovnim pokretanjem i odjavljivanjem briše se predmemorija.

      Ako se pravilo ne postavi, predmemorirani GPO-ovi mogu se upotrebljavati najviše 25 sati.

      Ako se pravilo postavi na 0, predmemoriranje GPO-a isključeno je. To povećava opterećenje poslužitelja jer se GPO-ovi ponovo preuzimaju pri svakom dohvaćanju pravila, čak i ako se ne promijene.</translation>
<translation id="1117462881884985156"><ph name="PRODUCT_NAME" /> zaobići će sve proxy poslužitelje na ovdje navedenom popisu hostova.

          To će pravilo vrijediti samo ako odaberete ručne postavke proxyja pod stavkom "Odaberi način određivanja postavki proxy poslužitelja" i ako ne odredite pravilo <ph name="PROXY_SETTINGS_POLICY_NAME" />.

          Ne postavljajte to pravilo ako ste odabrali bilo koji drugi način za postavljanje pravila za proxy poslužitelje.

          Detaljne primjere možete pronaći ovdje:
          <ph name="PROXY_HELP_URL" />.</translation>
<translation id="1117535567637097036">Rukovatelji protokolom postavljeni putem ovog pravila ne upotrebljavaju se prilikom upotrebe Androidovih namjera.</translation>
<translation id="1118093128235245168">Dopusti web-lokacijama da traže dopuštenje korisnika za pristup povezanom USB uređaju</translation>
<translation id="1128903365609589950">Konfigurira direktorij koji će <ph name="PRODUCT_NAME" /> koristiti za pohranu predmemoriranih datoteka na disku.

      Ako postavite to pravilo, taj će direktorij <ph name="PRODUCT_NAME" /> upotrebljavati bez obzira na to je li korisnik naveo oznaku "--disk-cache-dir". Kako bi se spriječio gubitak podataka ili druge neočekivane pogreške, pravilo se ne smije postaviti na korijenski direktorij ili direktorij jedinice koji se koristi u druge svrhe jer njegovim sadržajem upravlja <ph name="PRODUCT_NAME" />.

      Na stranici https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables možete pronaći popis mogućih varijabli.

      Ako se pravilo ne postavi, koristit će se zadani direktorij predmemorije i korisnik će ga moći nadjačati oznakom naredbenog retka "--disk-cache-dir".</translation>
<translation id="113521240853905588">Konfigurira jezike koje <ph name="PRODUCT_OS_NAME" /> može upotrebljavati kao preferirane.

      Ako se to pravilo postavi, korisnik na popis preferiranih jezika može dodati samo jedan od jezika navedenih u tom pravilu. Ako se to pravilo ne postavi ili se postavi na prazan popis, korisnik može navesti bilo koji jezik kao preferirani. Ako se to pravilo postavi na popis s nevažećim vrijednostima, sve će se nevažeće vrijednosti zanemariti. Ako je korisnik na popis preferiranih jezika prethodno dodao neke jezike koji nisu dopušteni tim pravilom, oni će se ukloniti. Ako je korisnik prethodno konfigurirao da se <ph name="PRODUCT_OS_NAME" /> prikazuje na jednom od jezika koji nisu dopušteni tim pravilom, jezik prikaza prebacit će se na dopušteni jezik korisničkog sučelja sljedeći put kad se korisnik prijavi. U suprotnom, <ph name="PRODUCT_OS_NAME" /> će prijeći na prvu važeću vrijednost navedenu u pravilu ili na zamjenski jezik (trenutačno en-US), ako pravilo sadrži samo nevažeće unose.</translation>
<translation id="1135264353752122851">Konfigurira koji su rasporedi tipkovnice dopušteni za korisničke sesije za <ph name="PRODUCT_OS_NAME" />.

      Ako se to pravilo postavi, korisnik može odabrati samo jedan od načina unosa određenih tim pravilom. Ako se to pravilo ne postavi ili se postavi na prazan popis, korisnik može odabrati sve podržane načine unosa. Ako trenutačni način unosa nije dopušten tim pravilom, način unosa prebacit će se na raspored hardverske tipkovnice (ako je dopušten) ili prvi važeći unos na popisu. Svi nevažeći ili nepodržani načini unosa na popisu zanemarit će se.</translation>
<translation id="1138294736309071213">To je pravilo aktivno samo u prodajnom načinu.

      Određuje koliko će potrajati prije nego što se čuvar zaslona prikaže na zaslonu prijave za uređaje u prodajnom načinu.

      Vrijednost pravila trebala bi biti navedena u milisekundama.</translation>
<translation id="1141767714195601945">To pravilo upravlja parametrima naredbenog retka za Chrome iz Internet Explorera.

      To pravilo nema utjecaja ako nije instaliran dodatak Podrška za stare preglednike za Internet Explorer.

      Ako se pravilo ne postavi, Internet Explorer Chromeu će prosljeđivati samo URL kao parametar naredbenog retka.

      Ako se pravilo postavi na popis nizova, nizovi se spajaju razmacima i prosljeđuju Chromeu kao parametri naredbenog retka.

      Ako neki element sadrži ${url}, on se zamjenjuje URL-om stranice koja se treba otvoriti.

      Ako nijedan element ne sadrži ${url}, URL se pridodaje na kraj naredbenog retka.

      Varijable okruženja proširuju se. U sustavu Windows %ABC% se zamjenjuje vrijednošću varijable okruženja ABC.</translation>
<translation id="1151353063931113432">Dopusti slike na ovim web-lokacijama</translation>
<translation id="1152117524387175066">Generira izvješće o stanju prekidača za razvojne programere na uređaju prilikom pokretanja.

      Ako se pravilo ne postavi ili se postavi na neistinito, izvješće o stanju prekidača za razvojne programere neće se generirati.</translation>
<translation id="1160479894929412407">Dopusti QUIC protokol</translation>
<translation id="1160939557934457296">Onemogući nastavljanje sa stranice upozorenja Sigurno pregledavanje</translation>
<translation id="1189817621108632689">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju web-lokacije koje ne smiju prikazivati slike.

          Ako ovo pravilo nije postavljeno, upotrebljavat će se globalna zadana vrijednost za sve web-lokacije iz pravila "DefaultImagesSetting" ako je postavljeno, odnosno iz osobne konfiguracije korisnika ako nije.

          Napominjemo da je ovo pravilo prije bilo pogreškom omogućeno na Androidu, iako ta funkcija na Androidu nikad nije bila potpuno podržana.</translation>
<translation id="1194005076170619046">Ako je omogućeno, na programskoj traci prikazuje se veliki, crveni gumb za odjavu dok je sesija aktivna, a zaslon nije zaključan.

      Ako je onemogućeno ili nije navedeno, na programskoj traci ne prikazuje se veliki crveni gumb za odjavu.</translation>
<translation id="1197437816436565375">Android aplikacijama ne možete nametnuti upotrebu proxyja. Podskup postavki proxyja dostupan je Android aplikacijama i one ga mogu poštovati dobrovoljno. Više pojedinosti potražite u pravilu <ph name="PROXY_MODE_POLICY_NAME" />.</translation>
<translation id="1198465924256827162">Učestalost slanja prijenosa statusa uređaja u milisekundama.

      Ako se to pravilo ne postavi, zadana učestalost iznosi 3 sata. Minimalna
      dopuštena učestalost iznosi 60 sekundi.</translation>
<translation id="1204263402976895730">Omogućeni pisači tvrtke</translation>
<translation id="1216919699175573511">Omogući podršku za Potpisanu HTTP razmjenu (SXG)</translation>
<translation id="1219695476179627719">Određuje treba li se uređaj vratiti na verziju koja je postavljena pravilom <ph name="DEVICE_TARGET_VERSION_PREFIX_POLICY_NAME" /> ako već ima noviju verziju.

      Zadana postavka glasi RollbackDisabled.</translation>
<translation id="1221359380862872747">Učitaj navedene URL-ove pri demonstracijskoj prijavi</translation>
<translation id="1223789468190631420">Stanje omogućivanja Sigurnog pregledavanja za pouzdane izvore</translation>
<translation id="122899932962115297">Popis dopuštenih načina brzog otključavanja koje korisnik može konfigurirati i upotrebljavati za otključavanje zaključanog zaslona.

          Ta je vrijednost popis nizova, a važeće su stavke popisa: "all", "PIN" i "FINGERPRINT". Ako se na popis doda "all", korisniku su dostupni svi načini brzog otključavanja, uključujući one koji se uvedu naknadno. U suprotnom je dostupan samo onaj način brzog otključavanja koji je na popisu.

          Na primjer, da biste omogućili svaki način brzog otključavanja, upotrijebite ["all"]. Da biste omogućili samo otključavanje PIN-om, upotrijebite ["PIN"]. Da biste omogućili PIN i otisak prsta, upotrijebite ["PIN", "FINGERPRINT"]. Da biste onemogućili sve načine brzog otključavanja, upotrijebite [].

          Za upravljane uređaje prema zadanim postavkama nije dostupan nijedan način brzog otključavanja.</translation>
<translation id="123081309365616809">Omogući emitiranje sadržaja na uređaju</translation>
<translation id="1231349879329465225">Dopušta omogućivanje ili onemogućivanje Brzog prijelaza.
      Primjenjuje se na sve korisnike i sva sučelja na uređaju.
      Da bi se koristio Brzi prijelaz, ova postavka i ONC svojstvo po mreži moraju biti omogućeni.
      Kad se postavi, Brzi prijelaz traje dok se ne isključi tim pravilom.

      Ako se pravilo ne postavi ili se postavi na False, neće se upotrebljavati Brzi prijelaz.
      Ako se postavi na True, Brzi prijelaz upotrebljava se kad ga podržava točka bežičnog pristupa.</translation>
<translation id="1243570869342663665">Kontroliraj filtriranje sadržaja za odrasle za SafeSites.</translation>
<translation id="1257550411839719984">Postavi zadani direktorij za preuzimanje</translation>
<translation id="1265053460044691532">Ograničite vrijeme koliko se dugo korisnik autentificiran putem SAML-a može izvanmrežno prijaviti</translation>
<translation id="1290634681382861275">Upravlja raznim postavkama uključujući USB, Bluetooth, osvježavanje pravila, način rada razvojnog programera i ostalo.</translation>
<translation id="1291880496936992484">Upozorenje: RC4 potpuno će se ukloniti iz preglednika <ph name="PRODUCT_NAME" /> nakon verzije 52 (oko rujna 2016.) i ovo će pravilo tada prestati funkcionirati.

      Ako se to pravilo ne postavi ili se postavi na "False", RC4 paketi šifri u TLS-u neće biti omogućeni. U protivnom se može postaviti na "True" radi održanja kompatibilnosti sa zastarjelim poslužiteljem. To je privremena mjera i poslužitelj se treba ponovo konfigurirati.</translation>
<translation id="1297182715641689552">Upotrijebi .pac proxy skriptu</translation>
<translation id="1304973015437969093">ID-jevi proširenja/aplikacija i URL-ovi ažuriranja koja će se instalirati u pozadini</translation>
<translation id="1307454923744766368">Uzorci polazišta ili naziva hosta na koje se ograničenja o nesigurnim polazištima ne bi trebala primjenjivati</translation>
<translation id="1312799700549720683">Upravlja postavkama prikaza.</translation>
<translation id="131353325527891113">Prikaži korisnička imena na zaslonu prijave</translation>
<translation id="1327466551276625742">Omogući odzivnu poruku za konfiguraciju mreže tijekom izvanmrežnog rada</translation>
<translation id="1330145147221172764">Omogući tipkovnicu na zaslonu</translation>
<translation id="13356285923490863">Naziv pravila</translation>
<translation id="1347198119056266798">To je pravilo obustavljeno. Umjesto njega upotrijebite pravila <ph name="FORCE_GOOGLE_SAFE_SEARCH_POLICY_NAME" /> i <ph name="FORCE_YOUTUBE_RESTRICT_POLICY_NAME" />. To se pravilo zanemaruje ako se postave pravila <ph name="FORCE_GOOGLE_SAFE_SEARCH_POLICY_NAME" />, <ph name="FORCE_YOUTUBE_RESTRICT_POLICY_NAME" /> ili <ph name="FORCE_YOUTUBE_SAFETY_MODE_POLICY_NAME" /> (obustavljeno).

      Nameće da se upiti u Google pretraživanju provode uz aktivirano Sigurno pretraživanje i sprječava korisnike da promijene tu postavku. Ta postavka nameće i umjereni Ograničeni način rada na YouTubeu.

      Ako omogućite tu postavku, Sigurno pretraživanje na Google pretraživanju i umjereni Ograničeni način rada na YouTubeu bit će uvijek aktivni.

      Ako onemogućite tu postavku ili ne postavite vrijednost, Sigurno pretraživanje na Google pretraživanju i Ograničeni način rada na YouTubeu neće se primjenjivati.</translation>
<translation id="1352174694615491349">Ovim pravilom omogućuje se spajanje HTTP/2 veze kad se upotrebljava certifikat klijenta, Kako bi se spojili, i naziv hosta potencijalne nove veze i naziv hosta postojeće veze moraju se podudarati s jednim uzorkom ili više uzoraka opisanih u ovom pravilu. Pravilo je popis hostova koji upotrebljavaju format filtra za URLBlacklist: "example.com" podudara se s "example.com" i svim poddomenama (npr. "sub.example.com"), dok se ".example.net" točno podudara s "example.net".

      Zahtjevi za spajanje na različite hostove preko veza koje upotrebljavaju certifikate klijenta mogu dovesti do problema sa sigurnošću i privatnošću jer će okolno tijelo biti preneseno svim zahtjevima, čak i ako korisnik to nije izričito odobrio. Ovo je pravilo privremeno i bit će uklonjeno u budućem izdanju. Pogledajte https://crbug.com/855690.

      Ako se ovo pravilo ne postavi, upotrebljavat će se zadano ponašanje u kojemu se nijednoj HTTP/2 vezi ne dopušta spajanje s vezama koje upotrebljavaju certifikate klijenta.</translation>
<translation id="1354424209129232709">Maksimalno:</translation>
<translation id="1354452738176731363">Kad se to pravilo postavi na false, audioizlaz neće biti dostupan na uređaju dok je korisnik prijavljen.

      To pravilo utječe na sve vrste audioizlaza, a ne samo na ugrađene zvučnike. Zvučne značajke pristupačnosti također su zabranjene tim pravilom. Ne omogućujte to pravilo ako je korisniku potreban čitač zaslona.

      Ako se to pravilo postavi na true ili se ne konfigurira, korisnici mogu upotrebljavati sve podržane audioizlaze na svojem uređaju.</translation>
<translation id="1359553908012294236">Ako se pravilo postavi na "True" ili se ne konfigurira, <ph name="PRODUCT_NAME" /> omogućit će prijave gostiju. Prijave gostiju predstavljaju profile preglednika <ph name="PRODUCT_NAME" /> u kojima se svi prozori otvaraju u anonimnom načinu.

      Ako se pravilo postavi na "False", <ph name="PRODUCT_NAME" /> neće dopustiti pokretanje profila gostiju.</translation>
<translation id="1363275621236827384">Omogući slanje upita na Quirks Server za hardverske profile</translation>
<translation id="1363612796557848469">To pravilo Google asistentu daje dopuštenje za pristup kontekstu zaslona i slanje informacija poslužitelju.
      Ako se pravilo omogući, Google asistent smije pristupiti kontekstu zaslona.
      Ako se pravilo onemogući, Google asistent ne smije pristupiti kontekstu zaslona.
      Ako se pravilo ne postavi, korisnici će moći odlučiti hoće li Google asistentu dopustiti pristup kontekstu zaslona</translation>
<translation id="1376119291123231789">Omogući napredni način punjenja baterije</translation>
<translation id="1383493480903114193">To pravilo prisilno pokreće kôd za umrežavanje u procesu preglednika.

      To je pravilo onemogućeno prema zadanim postavkama i ako se omogući, korisnici će biti izloženi sigurnosnim poteškoćama kada proces umrežavanja bude u testnom okruženju.

      Tim se pravilom želi pružiti mogućnost organizacijama za prijelaz na softver treće strane koji ne ovisi o povezivanju API-ja za umrežavanje. Proxy poslužitelji preporučuju se putem LSP-ova i uz primjenu zakrpe API-ja Win32.

      Ako se pravilo ne postavi, kôd za umrežavanje može ostati bez procesa preglednika ovisno o radnim verzijama eksperimenta NetworkService.</translation>
<translation id="1384459581748403878">Referenca: <ph name="REFERENCE_URL" /></translation>
<translation id="1384653327213929024">Omogući korisnicima upravljanje instaliranim certifikatima.</translation>
<translation id="1393485621820363363">Omogućeni pisači za uređaje tvrtke</translation>
<translation id="1397855852561539316">Predloženi URL zadanog davatelja usluge pretraživanja</translation>
<translation id="1404043648050567997">Usluga Sigurno pregledavanje prikazuje stranicu upozorenja kada korisnici dođu do web-lokacija koje su označene kao potencijalno zlonamjerne. Omogućavanje te postavke sprječava korisnike da ipak krenu dalje sa stranice upozorenja do zlonamjerne web-lokacije.

      To pravilo sprječava korisnike da krenu dalje samo u slučaju upozorenja Sigurnog pregledavanja (npr. o zlonamjernom softveru ili krađi identiteta), a ne poteškoća povezanih sa SSL certifikatima (npr. nevažeći ili istekli certifikati).

      Ako se ta postavka onemogući ili ako se ne konfigurira, korisnici prema želji mogu nastaviti do označene web-lokacije nakon što im se prikazalo upozorenje.

      Više informacija o Sigurnom pregledavanju potražite na stranici https://developers.google.com/safe-browsing.</translation>
<translation id="1413936351612032792">Prijavi informacije o upotrebi Linux aplikacija</translation>
<translation id="142346659686073702">Omogućuje nepridruženim korisnicima da upotrebljavaju Crostini</translation>
<translation id="1426410128494586442">Da</translation>
<translation id="1427655258943162134">Adresa ili URL proxy poslužitelja</translation>
<translation id="1431272318313028342">Omogućuje značajku Sigurno pregledavanje preglednika <ph name="PRODUCT_NAME" /> i onemogućuje korisnicima da promijene tu postavku.

      Ako omogućite tu postavku, Sigurno pregledavanje uvijek je aktivno.

      Ako je onemogućite, Sigurno pregledavanje nikada nije aktivno.

      Ako omogućite ili onemogućite tu postavku, korisnici ne mogu promijeniti niti nadjačati postavku "Omogući zaštitu od krađe identiteta i zlonamjernog softvera" u pregledniku <ph name="PRODUCT_NAME" />.

      Ako se to pravilo ne postavi, ta će postavka biti omogućena, ali će je korisnici moći promijeniti.

      Više informacija o Sigurnom pregledavanju potražite na stranici https://developers.google.com/safe-browsing.

      Pravilo je dostupno samo na instancama Windowsa koje su pridružene domeni <ph name="MS_AD_NAME" /> ili instancama Windowsa 10 Pro ili Enterprise prijavljenim za upravljanje uređajima.</translation>
<translation id="1432194160771348078">
      Određuje popis aplikacija koje se instaliraju u pozadini na zaslonu za prijavu,
      bez interakcije korisnika i koje se ne mogu deinstalirati.
      Sva dopuštenja koja aplikacije zahtijevaju dodjeljuju se
      implicitno, bez interakcije korisnika, uključujući sva dodatna
      dopuštenja koja mogu zahtijevati buduće verzije aplikacije.

      Zbog zaštite sigurnosti i privatnosti proširenjima nije dopušteno instaliranje pomoću tog pravila. Osim toga, uređaji na stabilnom kanalu instalirat će samo one aplikacije koje se nalaze popisu dopuštenih uključenom u preglednik <ph name="PRODUCT_NAME" />. Zanemarit će se sve stavke koje ne udovoljavaju tim uvjetima.

      Ako s tog popisa uklonite aplikaciju koja je prethodno prisilno instalirana, <ph name="PRODUCT_NAME" /> automatski će je deinstalirati.

      Svaka stavka na popisu tog pravila niz je koji sadrži ID proširenja i URL za ažuriranje odvojene točkom sa zarezom (<ph name="SEMICOLON" />). ID proširenja niz je od 32 slova koji se primjerice može pronaći na stranici <ph name="CHROME_EXTENSIONS_LINK" /> u načinu rada razvojnog programera. URL za ažuriranje treba usmjeravati na XML dokument Manifest ažuriranja kao što je opisano na stranici <ph name="LINK_TO_EXTENSION_DOC1" />. URL za ažuriranje koji se postavi u ovom pravilu upotrebljava se samo za prvu instalaciju, dok se za naknadna ažuriranja proširenja upotrebljava URL za ažuriranje naveden u manifestu proširenja.

      Na primjer, <ph name="EXTENSION_POLICY_EXAMPLE" /> instalira aplikaciju <ph name="EXTENSION_POLICY_EXAMPLE_EXTENSION_NAME" /> sa standardnog URL-a za ažuriranje Chrome web-trgovine. Više informacija o hostingu proširenja potražite na stranici: <ph name="LINK_TO_EXTENSION_DOC2" />.</translation>
<translation id="1435659902881071157">Mrežna konfiguracija na razini uređaja</translation>
<translation id="1438739959477268107">Zadana postavka za generiranje ključeva</translation>
<translation id="1454846751303307294">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju web-lokacije kojima nije dopušteno pokretanje JavaScripta. Ako ovo pravilo nije postavljeno, upotrebljavat će se globalna zadana vrijednost za sve web-lokacije iz pravila "DefaultJavaScriptSetting", ako je postavljeno, odnosno iz osobne konfiguracije korisnika, ako nije.</translation>
<translation id="1456822151187621582">Windows (<ph name="PRODUCT_OS_NAME" /> klijenti):</translation>
<translation id="1458547592473993238">To je pravilo obustavljeno. Za upravljanje dostupnošću dodatka Flash upotrijebite pravilo <ph name="DEFAULT_PLUGINS_SETTING_POLICY_NAME" />, a pomoću pravila <ph name="ALWAYS_OPEN_PDF_EXTERNALLY_POLICY_NAME" /> odredite hoće li se za otvaranje PDF datoteka upotrebljavati integrirani preglednik za PDF.

      Određuje popis dodataka koji su onemogućeni u pregledniku <ph name="PRODUCT_NAME" /> i sprječava korisnike da promijene tu postavku.

      Za podudaranje nizova proizvoljnih znakova mogu se koristiti zamjenski znakovi "*" i "?". "*" odgovara proizvoljnom broju znakova, a "?" određuje opcijski pojedinačni znak, odnosno odgovara znakovima nula ili jedan. "\" je prespojni znak, tako da za podudaranje s pravim znakovima "*", "?" ili "\" možete ispred njih staviti znak "\".

      Ako omogućite tu postavku, navedeni se popis dodataka nikada neće upotrebljavati u pregledniku <ph name="PRODUCT_NAME" />. Dodaci su označeni kao onemogućeni na stranici "about:plugins" i korisnici ih ne mogu omogućiti.

      Napominjemo da se to pravilo može nadjačati pravilima EnabledPlugins i DisabledPluginsExceptions.

      Ako se pravilo ne postavi, korisnik može upotrijebiti bilo koji dodatak instaliran u sustavu osim nekompatibilnih, zastarjelih ili opasnih dodataka ugrađenih u kôd.</translation>
<translation id="1464848559468748897">Upravlja ponašanjem korisnika u sesiji s više profila na uređajima sa sustavom <ph name="PRODUCT_OS_NAME" />.

      Ako se to pravilo postavi na "MultiProfileUserBehaviorUnrestricted", korisnik može biti primarni ili sekundarni korisnik u sesiji s više profila.

      Ako se to pravilo postavi na "MultiProfileUserBehaviorMustBePrimary", korisnik može biti samo primarni korisnik u sesiji s više profila.

      Ako se to pravilo postavi na "MultiProfileUserBehaviorNotAllowed", korisnik ne može sudjelovati u sesiji s više profila.

      Ako odredite tu postavku, korisnici je ne mogu promijeniti niti premostiti.

      Ako se postavka promijeni dok je korisnik prijavljen na sesiju s više profila, provjerit će se odgovarajuće postavke svih korisnika u sesiji. Sesija će se zatvoriti ako nekom od korisnika više nije dopušteno biti u sesiji.

      Ako se pravilo ne postavi, zadana vrijednost "MultiProfileUserBehaviorMustBePrimary" primjenjuje se za korisnike kojima upravlja organizacija, a "MultiProfileUserBehaviorUnrestricted" primjenjuje se na korisnike kojima se ne upravlja.</translation>
<translation id="1465619815762735808">Kliknite za reprodukciju</translation>
<translation id="1468307069016535757">Postavi zadano stanje značajke pristupačnosti načina visokog kontrasta na zaslonu za prijavu.

          Ako se to pravilo postavi na točno, način visokog kontrasta bit će omogućen dok se prikazuje zaslon za prijavu.

          Ako se to pravilo postavi na netočno, način visokog kontrasta bit će onemogućen dok se prikazuje zaslon za prijavu.

          Ako postavite to pravilo, korisnici ga mogu privremeno premostiti omogućujući ili onemogućujući način visokog kontrasta. Međutim, korisnički odabir nije trajan i zadana se vrijednost vraća svaki put kada se zaslon za prijavu prikaže iznova ili ako taj zaslon miruje jednu minutu.

          Ako se to pravilo ne postavi, način visokog kontrasta onemogućen je pri prvom prikazivanju zaslona za prijavu. Korisnici mogu omogućiti ili onemogućiti način visokog kontrasta u bilo kojem trenutku, a njegov status na zaslonu za prijavu zadržat će se i za sljedeće korisnike.</translation>
<translation id="1468707346106619889">Ako je to pravilo postavljeno na istinito, Jedinstvena radna površina dopuštena je
      i omogućena prema zadanim postavkama, a aplikacijama omogućuje širenje na više zaslona.
      Korisnik može onemogućiti Jedinstvenu radnu površinu za pojedinačne zaslone
      poništavanjem njihova odabira u postavkama prikaza.

      Ako je pravilo postavljeno na neistinito ili nije postavljeno, Jedinstvena radna
      površina bit će onemogućena. U tom slučaju korisnik ne može omogućiti značajku.</translation>
<translation id="1474273443907024088">Onemogući TLS False Start</translation>
<translation id="1477934438414550161">TLS 1.2</translation>
<translation id="1502843533062797703">Omogući blokiranje umetanja softvera treće strane</translation>
<translation id="1507382822467487898">
          Konfigurira MAC adresu koja će se upotrebljavati kada je uređaj spojen na priključnu stanicu.

          Kada su određeni modeli uređaja spojeni na priključnu stanicu, za identifikaciju uređaja na Ethernetu prema zadanim se postavkama upotrebljava MAC adresa označene priključne stanice uređaja. To pravilo omogućuje administratoru da promijeni izvor MAC adrese dok je uređaj priključen na stanicu.

          Ako se odabere "DeviceDockMacAddress" ili se pravilo ne postavi, upotrebljavat će se MAC adresa označene priključne stanice.

          Ako se odabere "DeviceNicMacAddress", upotrebljavat će se MAC adresa upravljača mrežnog sučelja.

          Ako se odabere "DockNicMacAddress", upotrebljavat će se MAC adresa upravljača mrežnog sučelja priključne stanice.

          Korisnik ne može promijeniti tu postavku.</translation>
<translation id="1507957856411744193">Ako se to pravilo postavi na True, usluga <ph name="PRODUCT_NAME" /> povezat će se s uređajima za emitiranje na svim IP adresama, a ne samo privatnim adresama RFC1918/RFC4193.

          Ako se to pravilo postavi na False, usluga <ph name="PRODUCT_NAME" /> povezat će se s uređajima za emitiranje samo na privatnim adresama RFC1918/RFC4193.

          Ako se to pravilo ne postavi, usluga <ph name="PRODUCT_NAME" /> povezat će se s uređajima za emitiranje samo na privatnim adresama RFC1918/RFC4193, osim ako se omogući značajka CastAllowAllIPs.

          Ako se pravilo "EnableMediaRouter" postavi na False, vrijednost ovog pravila nema utjecaja.</translation>
<translation id="1509692106376861764">To se pravilo ne upotrebljava od verzije 29 sustava <ph name="PRODUCT_NAME" />.</translation>
<translation id="1514888685242892912">Omogući uslugu <ph name="PRODUCT_NAME" /></translation>
<translation id="1522425503138261032">Dopusti web-lokacijama praćenje fizičke lokacije korisnika</translation>
<translation id="1523774894176285446">Zamjenski preglednik koji se pokreće za konfigurirane web-lokacije.</translation>
<translation id="152657506688053119">Popis zamjenskih URL-ova za zadanog davatelja usluge pretraživanja</translation>
<translation id="1530812829012954197">Uvijek prikaži sljedeće URL obrasce u pregledniku hosta</translation>
<translation id="1541170838458414064">Ograniči veličinu stranice ispisa</translation>
<translation id="1553684822621013552">Kada je to pravilo postavljeno na "True", ARC će biti omogućen za korisnika
      (ovisno o dodatnim postavkama pravila – ARC i dalje neće biti
      dostupan ako su jednokratni način rada ili višestruka prijava omogućeni
      u trenutačnoj korisničkoj sesiji).

      Ako se ta postavka onemogući ili ne konfigurira, poslovni korisnici
      ne mogu upotrebljavati ARC.</translation>
<translation id="1559980755219453326">To pravilo određuje hoće li se prijavljivati podaci proširenja i dodataka.

      Ako se pravilo ne postavi ili se postavi na True, prikupljaju se podaci proširenja i dodataka.
      Ako se pravilo postavi na False, ne prikupljaju se podaci proširenja i dodataka.

      To se pravilo primjenjuje samo kada je omogućeno proširenje <ph name="CHROME_REPORTING_EXTENSION_NAME" />, a računalo je prijavljeno tokenom <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="1560205870554624777">Upravlja time je li omogućena funkcija Kerberos. Kerberos je protokol za autentifikaciju koji se može koristiti za autentifikaciju za web-aplikacije i dijeljenje datoteka.

          Ako se to pravilo omogući, omogućena je funkcija Kerberos. Kerberos računi mogu se dodati pravilom "Konfiguriraj Kerberos račune" ili pomoću postavki Kerberos računa na stranici postavki za Osobe.

          Ako se to pravilo onemogući ili ne postavi, postavke Kerberos računa nisu omogućene. Ne može se dodati nijedan Kerberos račun i ne može se koristiti autentifikacija koju pruža Kerberos. Brišu se svi postojeći Kerberos računi i sve pohranjene zaporke.</translation>
<translation id="1561424797596341174">Nadjačavanja pravila za međuverzije za otklanjanje pogrešaka hosta daljinskog pristupa</translation>
<translation id="1561967320164410511">U2F i proširenja za pojedinačno atestiranje</translation>
<translation id="1566329065312331399">
      Kada se postavi na false, to pravilo ne dopušta uređaju pokretanje Powerwasha.
      Kada se postavi na true, uređaju je dopušteno pokretanje Powerwasha.
      Ako se ne postavi, zadana je vrijednost false, što znači da uređaju nije dopušteno pokretanje Powerwasha.
      </translation>
<translation id="1574554504290354326">Ta je postavka obustavljena, upotrijebite SafeBrowsingExtendedReportingEnabled. Omogućivanje ili onemogućivanje postavke SafeBrowsingExtendedReportingEnabled ekvivalentno je postavljanju SafeBrowsingExtendedReportingOptInAllowed na False.

      Ako se to pravilo postavi na False, korisnici ne mogu odabrati slanje nekih podataka o sustavu i sadržaja stranice Googleovim poslužiteljima. Ako se pravilo postavi na True ili se ne konfigurira, korisnici će moći slati neke podatke o sustavu i sadržaj stranice Sigurnom pregledavanju radi otkrivanja opasnih aplikacija i web-lokacija.

      Više informacija o Sigurnom pregledavanju potražite na stranici https://developers.google.com/safe-browsing.</translation>
<translation id="1583248206450240930">Upotrijebi <ph name="PRODUCT_FRAME_NAME" /> kao zadano</translation>
<translation id="1599424828227887013">Omogućivanje izolacije web-lokacije za određena polazišta na Android uređajima</translation>
<translation id="1608755754295374538">URL-ovi koji će dobiti pristup uređajima za snimanje zvuka bez postavljanja upita</translation>
<translation id="1615221548356595305">Dopustite spajanje HTTP/2 veza za te hostove čak i kad se upotrebljavaju certifikati klijenta</translation>
<translation id="1615855314789673708">Navodi konfiguraciju Wilco DTC-a (kontrolera za dijagnostiku i telemetriju).

      To pravilo omogućuje navođenje konfiguracije za Wilco DTC, čija je primjena dopuštena ako je Wilco DTC dostupan na uređaju i dopušten pravilom. Veličina konfiguracije ne smije biti veća od 1 MB (1000000 bajtova) i mora biti kodirana u JSON-u. Za rukovanje time odgovoran je Wilco DTC. Za potvrdu integriteta preuzimanja koristi se kriptografsko hashiranje.

      Konfiguracija se preuzima i sprema u predmemoriju. Ponovo će se preuzeti svaki put kada se URL ili hashiranje promijene.

      Ako postavite to pravilo, korisnici ga neće moći promijeniti ni nadjačati.</translation>
<translation id="1617235075406854669">Omogući brisanje povijesti preglednika i preuzimanja</translation>
<translation id="163200210584085447">Uzorci na tom popisu usporedit će se sa sigurnosnim
      izvorištem URL-a koji šalje zahtjev. Ako se podudaranje pronađe, pristup
      uređajima za videosnimanje dodijelit će se na SAML stranicama za
      prijavu. Ako se podudaranje ne pronađe, pristup će se automatski odbiti.
      Uzorci sa zamjenskim znakovima nisu dopušteni.</translation>
<translation id="1634989431648355062">Dopusti dodatak <ph name="FLASH_PLUGIN_NAME" /> na ovim web-lokacijama</translation>
<translation id="1645793986494086629">Shema:</translation>
<translation id="1653229475925941921">Ako se to pravilo postavi, ono određuje vrstu omogućenog povećala. Postavljanjem pravila na "None" onemogućuje se povećalo.

          Ako postavite to pravilo, korisnici ga neće moći promijeniti ni nadjačati.

          Ako se pravilo ne postavi, povećalo je izvorno onemogućeno, ali ga korisnici mogu u bilo kojem trenutku omogućiti.</translation>
<translation id="1655229863189977773">Postavite veličinu predmemorije diska u bajtovima</translation>
<translation id="166427968280387991">Proxy poslužitelj</translation>
<translation id="1668836044817793277">Određuje hoće li kiosk aplikacija pokrenuta automatski bez odgode upravljati verzijom proizvoda <ph name="PRODUCT_OS_NAME" />.

      Pravilo određuje hoće li kiosk aplikacija pokrenuta automatski bez odgode upravljati verzijom proizvoda <ph name="PRODUCT_OS_NAME" /> tako što u manifestu navodi potrebnu verziju platforme i upotrebljava je kao prefiks verzije koji će se ciljati prilikom automatskog ažuriranja.

      Ako se to pravilo postavi na True, vrijednost potrebne verzije platforme ključa manifesta kiosk aplikacije pokrenute automatski bez odgode upotrebljava se kao prefiks verzije koji će se ciljati prilikom automatskog ažuriranja.

      Ako se to pravilo ne konfigurira ili se postavi na False, ključ manifesta potrebne verzije platforme zanemaruje se i automatsko ažuriranje izvodi se na uobičajen način.

      Upozorenje: ne preporučuje se ovlastiti kiosk aplikaciju za upravljanje verzijom proizvoda <ph name="PRODUCT_OS_NAME" /> jer uređaj tako može prestati primati ažuriranja softvera i važne sigurnosne ispravke. Davanje ovlasti za upravljanje verzijom proizvoda <ph name="PRODUCT_OS_NAME" /> korisnike može izložiti opasnosti.</translation>
<translation id="1675002386741412210">Podržano na:</translation>
<translation id="1700811900332333712">Dopusti uređaju zahtijevanje Powerwasha</translation>
<translation id="1704516734140344991">Konfigurira dostupnost i ponašanje funkcije ažuriranja <ph name="TPM_FIRMWARE_UPDATE_TPM" /> opreme.

      Pojedinačne postavke mogu se navesti u JSON svojstvima:

      <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_POWERWASH" />: ako se postavi na <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_POWERWASH_TRUE" />, korisnici će moći pokrenuti tijek powerwasha da bi instalirali ažuriranje <ph name="TPM_FIRMWARE_UPDATE_TPM" /> opreme.

      <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_PRESERVE_DEVICE_STATE" />: ako se postavi na <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_PRESERVE_DEVICE_STATE_TRUE" />, korisnici će moći aktivirati tijek ažuriranja <ph name="TPM_FIRMWARE_UPDATE_TPM" /> opreme koji zadržava stanje na razini uređaja (uključujući registraciju organizacije), no gubi podatke korisnika. Ovaj je tijek ažuriranja dostupan od verzije 68.

      <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_AUTO_UPDATE_MODE" />: upravlja primjenom <ph name="TPM_FIRMWARE_UPDATE_TPM" /> automatskih ažuriranja za ranjivu <ph name="TPM_FIRMWARE_UPDATE_TPM" /> opremu. Svi tijekovi zadržavaju stanje lokalnog uređaja.
        Ako se postavi na 1 ili se ne postavi, neće se provoditi ažuriranja TPM opreme.
        Ako se postavi na 2, <ph name="TPM_FIRMWARE_UPDATE_TPM" /> oprema ažurirat će se prilikom sljedećeg ponovnog pokretanja nakon što korisnik potvrdi ažuriranje.
        Ako se postavi na 3, <ph name="TPM_FIRMWARE_UPDATE_TPM" /> oprema ažurirat će se prilikom sljedećeg ponovnog pokretanja.
        Ako se postavi na 4, <ph name="TPM_FIRMWARE_UPDATE_TPM" /> oprema ažurirat će se nakon registracije, prije nego što se korisnik prijavi.
        Ova opcija dostupna je od verzije 74.

      Ako se pravilo ne postavi, funkcija ažuriranja <ph name="TPM_FIRMWARE_UPDATE_TPM" /> opreme neće biti dostupna.</translation>
<translation id="1708496595873025510">Postavljanje ograničenja za dohvaćanje vrijednosti varijacija</translation>
<translation id="1717817358640580294">Ako pravilo nije postavljeno, a Chromeov alat za čišćenje otkrije neželjeni softver, Googleu se mogu prijaviti metapodaci o pretraživanju u skladu s pravilima postavljenim pravilom SafeBrowsingExtendedReportingEnabled. Chromeov alat za čišćenje korisniku će zatim postaviti upit želi li ukloniti neželjeni softver. Korisnik može podijeliti rezultate čišćenja s Googleom za pomoć pri budućem otkrivanju neželjenog softvera. Ti rezultati sadrže metapodatke datoteka, automatski instalirana proširenja i ključeve registra kao što je opisano u Dokumentu o privatnosti preglednika Google Chrome.

      Ako se pravilo onemogući, a Chromeov alat za čišćenje otkrije neželjeni softver, Googleu se neće prijaviti metapodaci o pretraživanju, a bilo koje pravilo postavljeno pravilom SafeBrowsingExtendedReportingEnabled bit će nadjačano. Chromeov alat za čišćenje korisniku će postaviti upit želi li ukloniti neželjeni softver.  Rezultati čišćenja neće se prijaviti Googleu niti će to korisnik moći učiniti.

      Ako se pravilo omogući, a Chromeov alat za čišćenje otkrije neželjeni softver, Googleu se mogu prijaviti metapodaci o pretraživanju u skladu s pravilima postavljenim pravilom SafeBrowsingExtendedReportingEnabled. Chromeov alat za čišćenje korisniku će postaviti upit želi li ukloniti neželjeni softver.  Rezultati čišćenja prijavit će se Googleu i korisnik to neće moći spriječiti.

      Pravilo je dostupno samo na instancama Windowsa koje su pridružene domeni <ph name="MS_AD_NAME" /> ili instancama Windowsa 10 Pro ili Enterprise prijavljenim za upravljanje uređajima.</translation>
<translation id="172374442286684480">Dopusti svim web-lokacijama postavljanje lokalnih podataka</translation>
<translation id="1736269219679256369">Dopušta se nastavljanje dalje sa stranice s upozorenjem SSL-a</translation>
<translation id="1745780278307622857">Prepoznaje može li <ph name="PRODUCT_NAME" /> dopustiti preuzimanje bez provjera Sigurnog pregledavanja kada je izvor pouzdan.

      Ako je False, preuzete datoteke neće se slati na analizu Sigurnom pregledavanju ako je izvor pouzdan.

      Ako se pravilo ne postavi (ili se postavi na True), preuzete datoteke šalju se na analizu Sigurnom pregledavanju čak i ako je izvor pouzdan.

      Napominjemo da se ta ograničenja primjenjuju samo na preuzimanja koja se pokrenu iz sadržaja web-stranice i putem opcije kontekstnog izbornika "Preuzmi vezu...". Ograničenja se ne primjenjuju na spremanje/preuzimanje trenutačno prikazane stranice niti na spremanje u PDF formatu putem opcija ispisa.

      Pravilo je dostupno samo na instancama Windowsa koje su pridružene domeni <ph name="MS_AD_NAME" /> ili instancama Windowsa 10 Pro ili Enterprise prijavljenim za upravljanje uređajima.</translation>
<translation id="1749815929501097806">Postavlja Uvjete pružanja usluge koje korisnik mora prihvatiti prije nego što započne sesiju lokalnog računa na uređaju.

      Ako je ovo pravilo postavljeno, <ph name="PRODUCT_OS_NAME" /> preuzima Uvjete pružanja usluge i prikazuje ih korisniku na početku svake sesije lokalnog računa na uređaju. Korisniku se sesija dopušta samo nakon što prihvati Uvjete pružanja usluge.

      Ako pravilo nije postavljeno, Uvjeti pružanja usluge ne prikazuju se.

      Pravilo treba biti postavljeno na URL s kojeg <ph name="PRODUCT_OS_NAME" /> može preuzeti Uvjete pružanja usluge. Uvjeti pružanja usluge moraju biti običan tekst, poslužen kao vrsta "text/plain" protokola MIME. Jezik za označavanje nije dopušten.</translation>
<translation id="1750315445671978749">Blokiranje svih preuzimanja</translation>
<translation id="1767673020408652620">Omogući preporuke aplikacije u nultom stanju okvira za pretraživanje</translation>
<translation id="17719159826324007">
      Kada se postavi na ArcSession, to pravilo prisilno ponovo pokreće uređaj nakon što se korisnik odjavi, a Android je pokrenut.
      Kada se postavi na Always, pravilo prisilno ponovo pokreće uređaj nakon svake odjave korisnika.
      Ako se ne postavi, pravilo nema učinka i uređaj se neće prisilno ponovo pokrenuti nakon što se korisnik odjavi. Isto vrijedi i ako se pravilo postavi na Never.
      To pravilo utječe samo na nepovezane korisnike.
      </translation>
<translation id="1781356041596378058">To pravilo kontrolira i pristup Opcijama za razvojne programere Androida. Ako to pravilo postavite na True, korisnici ne mogu pristupiti Opcijama za razvojne programere. Ako to pravilo postavite na False ili ga ne postavite, korisnici mogu pristupiti Opcijama za razvojne programere tako što će sedam puta dodirnuti broj međuverzije u aplikaciji postavki Androida.</translation>
<translation id="1793346220873697538">Onemogući ispis s PIN-om prema zadanim postavkama</translation>
<translation id="1797233582739332495">Prikaži korisniku ponavljajuću obavijest o obaveznom ponovnom pokretanju</translation>
<translation id="1798559516913615713">Trajanje predmemorije GPO-a</translation>
<translation id="1803646570632580723">Popis prikvačenih aplikacija za prikazivanje u pokretaču</translation>
<translation id="1808715480127969042">Blokiraj kolačiće na ovim web-lokacijama</translation>
<translation id="1810261428246410396">Dopusti upotrebu Automatskog modemskog povezivanja.</translation>
<translation id="1817685358399181673">Ovo pravilo navodi <ph name="PLUGIN_VM_NAME" /> sliku za korisnika. Pravilo je postavljeno navođenjem URL-a s kojeg uređaj može preuzeti sliku i hashiranje SHA-256 za potvrdu integriteta preuzimanja.

      Pravilo se treba navesti kao niz koji izražava URL i hashiranje u JSON formatu.</translation>
<translation id="1827523283178827583">Upotrijebi fiksne proxy poslužitelje</translation>
<translation id="1831495419375964631">To je pravilo URL koji usmjerava na XML datoteku u istom formatu kao i pravilo <ph name="IEEM_SITELIST_POLICY" /> u Internet Exploreru. Ono učitava pravila iz XML datoteke i pritom ih ne dijeli s Internet Explorerom.

      Ako se pravilo ne postavi ili se ne postavi na važeći URL, <ph name="PRODUCT_NAME" /> neće ga upotrebljavati kao izvor pravila za promjenu preglednika.

      Ako se to pravilo postavi na važeći URL, <ph name="PRODUCT_NAME" /> s tog će URL-a preuzeti popis web-lokacija i primijeniti pravila kao da su konfigurirana pravilom <ph name="SITELIST_POLICY_NAME" />.

      Više informacija o pravilu <ph name="IEEM_SITELIST_POLICY" /> u Internet Exploreru dostupno je na stranici: https://docs.microsoft.com/internet-explorer/ie11-deploy-guide/what-is-enterprise-mode</translation>
<translation id="1839060937202387559">Izvješćivanje o identifikatorima i statistici hardvera za uređaje za pohranu.

      Ako se to pravilo postavi na False, neće biti izvješća o statistici.
      Ako se postavi na True ili se ne postavi, izvješćivat će se o statistici.</translation>
<translation id="1843117931376765605">Brzina osvježavanja za korisničko pravilo</translation>
<translation id="1844620919405873871">Konfigurira pravila povezana s brzim otključavanjem.</translation>
<translation id="1845405905602899692">Postavke Kioska</translation>
<translation id="1845429996559814839">Ograniči način ispisa s PIN-om</translation>
<translation id="1847960418907100918">Određuje parametre koji se upotrebljavaju prilikom pretraživanja uz značajku Instant pomoću POST metode. Sastoji se od zarezom odvojenih parova naziv/vrijednost. Ako je vrijednost parametar predloška, primjerice {searchTerms} u gornjem primjeru, zamijenit će se podacima stvarnih pojmova za pretraživanje.

          To je pravilo izborno. Ako nije postavljeno, zahtjev za pretraživanje uz značajku Instant poslat će se pomoću GET metode.

          To se pravilo poštuje samo ako je omogućeno pravilo "DefaultSearchProviderEnabled".</translation>
<translation id="1852294065645015766">Dopusti automatsku reprodukciju medija</translation>
<translation id="1857152770025485173">Ovo pravilo korisnicima onemogućuje preuzimanje web-stranica s URL-ova koji se nalaze na popisu nedopuštenih. Na tom se popisu nalaze uzorci URL-ova koji određuju URL-ove koji neće biti dopušteni.

      Uzorak URL-ova mora se oblikovati prema uputama na https://www.chromium.org/administrators/url-blacklist-filter-format.

      Iznimke se mogu definirati u pravilu za popis dopuštenih URL-ova. Ta su pravila ograničena na 1000 unosa, a daljnji će se unosi zanemariti.

      Ne preporučuje se blokiranje internih "chrome://*" URL-ova jer to može dovesti do neočekivanih pogrešaka.

      'javascript://*' možete blokirati putem M73-a URL-ova. Međutim, to utječe samo na JavaScript u adresnoj traci (ili, primjerice, opcije označavanja). URL-ovi JavaScripta unutar stranice dugački kao dinamički učitani podaci nisu podložni ovom pravilu. Na primjer, ako blokirate 'example.com/abc', stranica 'example.com' i dalje će moći učitavati 'example.com/abc' putem zahtjeva XMLHTTPRequest.

      Ako se pravilo ne postavi, nijedan URL u pregledniku neće biti zabranjen.</translation>
<translation id="1859859319036806634">Upozorenje: rezervni postupak za verziju TLS-a uklonit će se iz preglednika <ph name="PRODUCT_NAME" /> nakon verzije 52 (otprilike u rujnu 2016.) i ovo će pravilo tada prestati funkcionirati.

      U slučaju neuspjelog rukovanja TLS-a <ph name="PRODUCT_NAME" /> prije je ponovo isprobavao vezu sa starijom verzijom TLS-a da bi zaobišao programske pogreške na HTTPS poslužiteljima. Ta postavka konfigurira verziju na kojoj će se rezervni postupak zaustaviti. Ako poslužitelj ispravno dogovori verziju (tj., bez prekidanja veze), ta se postavka neće primijeniti. Neovisno o tome, postignuta veza mora i dalje biti u skladu s pravilom SSLVersionMin.

      Ako se to pravilo ne konfigurira ili se postavi na "tls1.2", <ph name="PRODUCT_NAME" /> više neće izvršavati rezervni postupak. Time se ne onemogućuje podrška za starije verzije TLS-a, već se samo određuje hoće li <ph name="PRODUCT_NAME" /> zaobilaziti poslužitelje s pogreškama koji ne mogu ispravno dogovoriti verzije.

      No ako se mora održati kompatibilnost s poslužiteljem koji sadrži pogreške, pravilo se može postaviti na "tls1.1". To je samo privremena mjera i problem na poslužitelju potrebno je brzo riješiti.</translation>
<translation id="1864382791685519617">Omogućuje mrežno predviđanje na usluzi <ph name="PRODUCT_NAME" /> i sprječava korisnike da promijene tu postavku.

      Time se kontrolira prethodno dohvaćanje DNS-a, TCP i SSL pretpovezivanje i prethodno generiranje web-stranica.

      Ako postavite to pravilo, korisnici ne mogu promijeniti ni nadjačati tu postavku na usluzi <ph name="PRODUCT_NAME" />.

      Ako se to pravilo ne postavi, mrežno predviđanje bit će omogućeno, no korisnik će to moći promijeniti.</translation>
<translation id="1865417998205858223">Glavna dopuštenja</translation>
<translation id="186719019195685253">Radnja koja se poduzima kada se dosegne odgoda zbog neaktivnosti dok je računalo priključeno na struju</translation>
<translation id="187819629719252111">Omogućuje pristup lokalnim datotekama na računalu tako da dopušta proizvodu <ph name="PRODUCT_NAME" /> prikaz dijaloških okvira za odabir datoteka. Ako omogućite ovu postavku, korisnici mogu otvarati dijaloške okvire za odabir datoteka kao i obično. Ako onemogućite ovu postavku, svaki put kad korisnik napravi neku radnju koja bi dovela do otvaranja dijaloškog okvira za odabir datoteka (poput uvoza knjižnih oznaka, prijenosa datoteka, spremanja veza itd.) umjesto dijaloškog okvira prikazat će se poruka, a za korisnika će se pretpostaviti da je kliknuo "Odustani" u dijaloškom okviru za odabir datoteka. Ako ova postavka nije postavljena, korisnici mogu otvarati dijaloške okvire za odabir datoteka kao i obično.</translation>
<translation id="1885782360784839335">Omogući prikazivanje promotivnog sadržaja na cijeloj kartici</translation>
<translation id="1888871729456797026">Token za prijavu za pravila oblaka na računalu</translation>
<translation id="1897365952389968758">Dopusti svim web-lokacijama izvođenje JavaScripta</translation>
<translation id="1906888171268104594">Kontrolira šalju li se Googleu izvješća s mjernim podacima o upotrebi i dijagnostičkim podacima, uključujući izvješća o rušenju.

      Ako se postavi na True, <ph name="PRODUCT_OS_NAME" /> slat će izvješća s mjernim podacima o upotrebi i dijagnostičkim podacima.

      Ako se postavi na False, izvješća s mjernim podacima o upotrebi i dijagnostičkim podacima bit će onemogućena.

      Ako se ne konfigurira, izvješća s mjernim podacima o upotrebi i dijagnostičkim podacima na neupravljanim će uređajima biti onemogućena, a na upravljanim omogućena.</translation>
<translation id="1907431809333268751">Konfigurira popis URL-ova za prijavu u organizacijama (samo sheme HTTP i HTTPS). Na tim će se URL-ovima snimiti otisak prsta zaporke koji će se upotrebljavati za otkrivanje ponovne upotrebe zaporke.
      Da bi <ph name="PRODUCT_NAME" /> pravilno snimao otiske prsta zaporke, vaše stranice za prijavu moraju slijediti smjernice na https://www.chromium.org/developers/design-documents/create-amazing-password-forms.

      Ako je ta postavka omogućena, usluga za zaštitu zaporke na tim će URL-ovima snimati otisak prsta zaporke u svrhu otkrivanja ponovne upotrebe zaporke.
      Ako se postavka onemogući ili ne postavi, usluga za zaštitu zaporke otisak prsta zaporke snimat će samo na stranici https://accounts.google.com.
      Pravilo je dostupno samo na instancama Windowsa koje su pridružene domeni <ph name="MS_AD_NAME" /> ili instancama Windowsa 10 Pro ili Enterprise prijavljenim za upravljanje uređajima.</translation>
<translation id="1914840757300882918">Ako se to pravilo postavi, host će upotrebljavati certifikat klijenta s danim CN-om izdavača za autentifikaciju za RemoteAccessHostTokenValidationUrl. Postavite ga na "*" da bi se upotrebljavao bilo koji dostupan certifikat klijenta.

          Ta je značajka trenutačno onemogućena na poslužitelju.</translation>
<translation id="1919802376548418720">Koristi pravila KDC-a za dodjeljivanje vjerodajnica.</translation>
<translation id="1920046221095339924">Dopusti upravljanu sesiju na uređaju</translation>
<translation id="1929709556673267855">Pruža konfiguracije za pisače tvrtke koji su povezani s uređajima.

      To vam pravilo omogućuje da pružite konfiguracije pisača za <ph name="PRODUCT_OS_NAME" /> uređaje. Format je jednak kao za rječnik NativePrinters, osim što je potrebno dodatno polje "id" ili "guid" po pisaču za dopuštanje ili ograničavanje pisača.

      Datoteka ne smije biti veća od 5 MB i mora se kodirati u JSON-u. Prema procjeni, datoteka koja sadrži približno 21.000 pisača kodirat će se kao datoteka od 5 MB. Za potvrdu integriteta preuzimanja upotrebljava se kriptografsko raspršivanje.

      Datoteka se preuzima i predmemorira. Ponovo će se preuzeti svaki put kad se URL ili raspršivanje promijene.

      Ako se to pravilo postavi, <ph name="PRODUCT_OS_NAME" /> preuzet će datoteku za konfiguriranje pisača i učiniti pisače dostupnima u skladu s pravilima <ph name="DEVICE_PRINTERS_ACCESS_MODE" />, <ph name="DEVICE_PRINTERS_WHITELIST" /> i <ph name="DEVICE_PRINTERS_BLACKLIST" />.

      To pravilo ne utječe na to mogu li korisnici konfigurirati pisače na pojedinačnim uređajima. Služi kao dodatno pravilo za konfiguraciju pisača koju vrše pojedinačni korisnici.

      To je pravilo dodatno pravilo za <ph name="BULK_PRINTERS_POLICY" />.

      Ako se to pravilo ne postavi, neće biti pisača za uređaje i ostala će se pravila za <ph name="DEVICE_PRINTERS_POLICY_PATTERN" /> zanemariti.
      </translation>
<translation id="193259052151668190">Popis dopuštenih odvojivih USB uređaja</translation>
<translation id="1933378685401357864">Pozadinska slika</translation>
<translation id="1956493342242507974">Konfigurira upravljanje potrošnjom energije na zaslonu za prijavu u proizvodu <ph name="PRODUCT_OS_NAME" />.

      Tim pravilom možete konfigurirati kako se <ph name="PRODUCT_OS_NAME" /> ponaša kada neko vrijeme nema korisničke aktivnosti dok se prikazuje zaslon za prijavu. Pravilo upravlja većim brojem postavki. Semantika i rasponi vrijednosti pojedinačnih postavki mogu se pronaći u odgovarajućim pravilima koja upravljaju potrošnjom energije u okviru sesije. Jedina su odstupanja od tih pravila sljedeća:
      * Radnjama koje se poduzimaju pri prelasku u mirovanje ili zatvaranju poklopca ne može se završiti sesija.
      * Zadana radnja koja se poduzima pri prelasku u mirovanje dok je računalo uključeno u struju jest isključivanje računala.

      Ako se postavka ne odredi, upotrijebit će se zadana vrijednost.

      Ako se pravilo ne postavi, za sve će se postavke upotrijebiti zadane vrijednosti.</translation>
<translation id="1958138414749279167">Omogućuje značajku Automatsko popunjavanje na usluzi <ph name="PRODUCT_NAME" /> i omogućuje korisnicima automatsko unošenje podataka o adresi u web-obrasce pomoću prethodno pohranjenih podataka.

      Ako se ta postavka onemogući, Automatsko popunjavanje nikad neće predlagati niti unositi podatke o adresi niti će spremati dodatne podatke o adresi koje korisnik može unijeti tijekom pregledavanja weba.

      Ako se ta postavka omogući ili nema vrijednost, korisnik će moći kontrolirati Automatsko popunjavanje za adrese na korisničkom sučelju.</translation>
<translation id="1962273523772270623">Dopusti zbirku zapisnika događaja WebRTC s Googleovih usluga</translation>
<translation id="1964634611280150550">Onemogućen je anoniman način rada</translation>
<translation id="1964802606569741174">To pravilo nema utjecaja na Android aplikaciju YouTube. Ako se treba primijeniti sigurnosni način na YouTubeu, instaliranje Android aplikacije YouTube ne može biti dopušteno.</translation>
<translation id="1969212217917526199">Nadjačava pravila na međuverzijama za otklanjanje pogrešaka hosta daljinskog pristupa.

          Vrijednost se analizira kao JSON rječnik mapiranja naziva pravila na vrijednosti pravila.</translation>
<translation id="1969808853498848952">Uvijek pokreće dodatke koji zahtijevaju autorizaciju (obustavljeno)</translation>
<translation id="1988371335297483117">Podaci automatskog ažuriranja na sustavu <ph name="PRODUCT_OS_NAME" /> mogu se preuzeti putem HTTP-a, umjesto putem HTTPS-a. Time se omogućuje transparentno HTTP predmemoriranje HTTP preuzimanja.

      Ako je ovo pravilo postavljeno na istinito, sustav <ph name="PRODUCT_OS_NAME" />pokušat će preuzeti podatke automatskog ažuriranja putem HTTP-a. Ako je pravilo postavljeno na neistinito ili nije postavljeno, za preuzimanje podataka automatskog ažuriranja upotrebljavat će se HTTPS.</translation>
<translation id="199764499252435679">Omogući ažuriranja komponenti u pregledniku <ph name="PRODUCT_NAME" /></translation>
<translation id="1997994951395619441">Ako omogućite tu postavku, <ph name="PRODUCT_NAME" /> prikazivat će traku oznaka.

      Ako onemogućite tu postavku, korisnicima se nikada neće prikazivati traka oznaka.

      Ako omogućite ili onemogućite ti postavku, korisnici je ne mogu promijeniti ni nadjačati u pregledniku <ph name="PRODUCT_NAME" />.

      Ako se ta postavka ne postavi, korisnik može odlučiti hoće li upotrebljavati tu funkciju.</translation>
<translation id="2006530844219044261">Upravljanje napajanjem</translation>
<translation id="2014757022750736514">Upravlja ponašanjem zaslona za prijavu, na kojemu se korisnici prijavljuju na svoje račune. Postavkama je određeno tko se može prijaviti, koje su vrste računa dopuštene, koje je načine autentifikacije potrebno koristiti, uz postavke opće pristupačnosti, načina unosa i zemlje/jezika.</translation>
<translation id="201557587962247231">Učestalost učitavanja izvješća o statusu uređaja</translation>
<translation id="2017301949684549118">URL-ovi za web aplikacije moraju biti instalirani u pozadini.</translation>
<translation id="2017459564744167827">Više informacija o shemi i formatiranju potražite na stranici<ph name="REFERENCE_URL" />.</translation>
<translation id="2018836497795982119">Određuje vrijeme u milisekundama tijekom kojeg se od usluge upravljanja uređajima traže podaci o korisničkim pravilima.

      Postavljanje ovog pravila nadjačava zadanu vrijednost od 3 sata. Valjane vrijednosti za ovo pravilo u rasponu su od 1800000 (30 minuta) do 86400000 (1 dan). Sve vrijednosti koje nisu u ovom rasponu prebacit će se u odgovarajuće granice. Ako platforma podržava obavijesti o pravilima, odgoda osvježavanja postavit će se na 24 sata jer se očekuje da će obavijesti o pravilima automatski nametnuti osvježavanje nakon svake promjene pravila.

      Ako ne postavite to pravilo, <ph name="PRODUCT_NAME" /> upotrebljavat će zadanu vrijednost od 3 sata.

      Ako platforma podržava obavijesti o pravilima, odgoda osvježavanja postavit će se na 24 sata (sve zadane postavke i vrijednost ovog pravila bit će zanemareni) jer se očekuje da će obavijesti o pravilima automatski nametnuti osvježavanje nakon svake promjene pravila, zbog čega su češća osvježavanja nepotrebna.</translation>
<translation id="2024476116966025075">Konfiguriraj traženi naziv domene za klijente s daljinskim pristupom</translation>
<translation id="2030905906517501646">Zadani davatelj usluga pretraživanja</translation>
<translation id="203096360153626918">To pravilo nema utjecaja na Android aplikacije. Moći će pokrenuti način prikazivanja na cijelom zaslonu čak i ako je to pravilo postavljeno na <ph name="FALSE" />.</translation>
<translation id="2043770014371753404">Onemogućeni pisači tvrtke</translation>
<translation id="2050629715135525072">Kontrolira može li korisnik povezan s hostom daljinskog pristupa prenositi datoteke između klijenta i hosta. To se ne primjenjuje na veze daljinske pomoći koje ne podržavaju prijenos datoteka.

          Ako se ta postavka onemogući, prijenos datoteka neće biti dopušten. Ako se postavka omogući ili se ne postavi, prijenos datoteka bit će dopušten.</translation>
<translation id="2057317273526988987">Dopusti pristup popisu URL-ova</translation>
<translation id="2061810934846663491">Konfiguriraj tražene nazive domena za hostove daljinskog pristupa</translation>
<translation id="206623763829450685">Određuje koje sheme HTTP autentifikacije <ph name="PRODUCT_NAME" /> podržava.

          Moguće su vrijednosti "basic" (osnovno), "digest" (sažeto), "NTLM" i "negotiate" (pregovaranje). Više vrijednosti odvojite zarezima.

          Ako se to pravilo ne postavi, upotrebljavat će se sve četiri sheme.</translation>
<translation id="2067011586099792101">Blokiraj pristup web-lokacijama izvan paketa sadržaja</translation>
<translation id="2073552873076775140">Dopusti prijavu u preglednik <ph name="PRODUCT_NAME" /></translation>
<translation id="2077129598763517140">Upotrijebi hardversko ubrzanje kada je dostupno</translation>
<translation id="2077273864382355561">Odgoda isključivanja zaslona za vrijeme baterijskog napajanja</translation>
<translation id="2082205219176343977">Konfiguriraj najmanju dopuštenu verziju Chromea za uređaj.</translation>
<translation id="209586405398070749">Stabilan kanal</translation>
<translation id="2098658257603918882">Omogući izvješćivanje o upotrebi i podatke o rušenjima programa</translation>
<translation id="2104418465060359056">Prijavi podatke proširenja i dodataka</translation>
<translation id="2106627642643925514">Nadjačava zadani način ispisa s PIN-om. Pravilo se zanemaruje ako način nije dostupan.</translation>
<translation id="2107601598727098402">
        To je pravilo obustavljeno u verziji M72. Umjesto njega upotrijebite CloudManagementEnrollmentToken.
        </translation>
<translation id="2111016292707172233">Omogućuje dostupnost značajke Dodirnite za pretraživanje u prikazu sadržaja preglednika <ph name="PRODUCT_NAME" />.

      Ako omogućite tu postavku, korisniku će biti dostupna značajka Dodirnite za pretraživanje i moći će je samostalno uključiti ili isključiti.

      Ako onemogućite tu postavku, značajka Dodirnite za pretraživanje bit će u potpunosti isključena.

      Ako se pravilo ne postavi, to ima jednak učinak kao da se omogući. Pogledajte prethodni opis.</translation>
<translation id="2113068765175018713">Ograničavanje vremena rada uređaja automatskim ponovnim pokretanjem sustava</translation>
<translation id="2116790137063002724">Pravilo određuje hoće li se prijavljivati informacije koje se mogu upotrijebiti za identifikaciju korisnika, kao što su prijava OS-a, prijava na profil <ph name="PRODUCT_NAME" />, <ph name="PRODUCT_NAME" /> naziv profila, put <ph name="PRODUCT_NAME" /> profila i izvršna putanja preglednika <ph name="PRODUCT_NAME" />.

      Ako se to pravilo ne postavi ili se postavi na True, prikupljaju se informacije koje se mogu upotrijebiti za identifikaciju korisnika.
      Ako se pravilo postavi na False, ne prikupljaju se informacije koje se mogu upotrijebiti za identifikaciju korisnika.

      To se pravilo primjenjuje samo kada je omogućeno pravilo <ph name="CHROME_REPORTING_EXTENSION_NAME" />, a računalo je prijavljeno tokenom <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="2127599828444728326">Dopuštanje obavijesti na ovim web-lokacijama</translation>
<translation id="2131902621292742709">Odgoda zatamnjivanja zaslona za vrijeme baterijskog napajanja</translation>
<translation id="2134437727173969994">Dopusti zaključavanje zaslona</translation>
<translation id="2137064848866899664">Ako se to pravilo postavi, svaki se zaslon zakreće na navedeno
      usmjerenje pri svakom ponovnom pokretanju i prilikom prvog povezivanja
      nakon promjene vrijednosti pravila. Korisnici mogu promijeniti usmjerenje
      zaslona na stranici postavki nakon prijave, no vrijednost pravila
      nadjačat će njihovu postavku prilikom sljedećeg ponovnog pokretanja.

      To se pravilo primjenjuje na primarni i sve sekundarne zaslone.

      Ako se to pravilo ne postavi, zadana je vrijednost 0 stupnjeva i korisnik
      je može promijeniti. U tom slučaju zadana vrijednost neće se ponovo
      primjenjivati nakon ponovnog pokretanja.</translation>
<translation id="2138449619211358657">To pravilo omogućuje da <ph name="PRODUCT_OS_NAME" /> zaobiđe bilo koji proxy za autentifikaciju zaštitnim portalom.

      To se pravilo primjenjuje samo ako je konfiguriran proxy (na primjer, pravilom, korisnički na stranici chrome://settings ili proširenjima).

      Ako omogućite tu postavku, sve autentifikacijske stranice zaštitnog portala (tj., sve web-stranice koje se pokreću sa stranice za prijavu na zaštitnom portalu dok <ph name="PRODUCT_NAME" /> ne otkrije uspješnu internetsku vezu) prikazivat će se u zasebnom prozoru, zanemarujući sve postavke i ograničenja pravila za trenutačnog korisnika.

      Ako onemogućite tu postavku ili je ne postavite, sve autentifikacijske stranice zaštitnog portala prikazivat će se u (uobičajenoj) novoj kartici preglednika, na temelju trenutačnih korisničkih postavki proxyja.</translation>
<translation id="21394354835637379">Omogućuje vam da odredite URL-ove kojima je dopušteno instaliranje proširenja, aplikacija i tema.

          Počevši s preglednikom <ph name="PRODUCT_NAME" /> 21 instaliranje proširenja, aplikacija i korisničkih skripta iz izvora izvan okvira Chrome web-trgovine postalo je teže. Prije su korisnici mogli kliknuti vezu na *.crx datoteku i preglednik <ph name="PRODUCT_NAME" /> ponudio bi instaliranje datoteke nakon nekoliko upozorenja. Od preglednika <ph name="PRODUCT_NAME" /> 21 takve se datoteke moraju preuzeti i povući na stranicu postavki preglednika <ph name="PRODUCT_NAME" />. Ova postavka omogućuje određenim URL-ovima stari, jednostavniji tijek instalacije.

          Svaka stavka na tom popisu podudaran je uzorak stila proširenja (pogledajte https://developer.chrome.com/extensions/match_patterns). Korisnici će moći jednostavno instalirati stavke s bilo kojeg URL-a koji se podudara sa stavkom na tom popisu. Ti uzorci moraju dopustiti lokaciju *.crx datoteke kao i stranicu s koje se pokreće preuzimanje (tj. referalnu stranicu).

          <ph name="EXTENSION_INSTALL_BLACKLIST_POLICY_NAME" /> ima prednost nad tim pravilom. To znači da se proširenje na popisu zabranjenih proširenja neće instalirati čak ni ako dolazi s web-lokacije na tom popisu.</translation>
<translation id="214901426630414675">Ograniči način dvostranog ispisa</translation>
<translation id="2149330464730004005">Omogući ispis u boji</translation>
<translation id="2156132677421487971">Konfigurirajte pravila za <ph name="PRODUCT_NAME" />, značajku koja korisnicima omogućuje da sadržaj kartica, web-lokacija ili radne površine iz preglednika pošalju na udaljene zaslone i zvučne sustave.</translation>
<translation id="2166472654199325139">Nemoj filtrirati web-lokacije na temelju sadržaja za odrasle</translation>
<translation id="2168397434410358693">Odgoda neaktivnosti za vrijeme napajanja izmjeničnom strujom</translation>
<translation id="217013996107840632">Parametri naredbenog retka za prebacivanje iz zamjenskog preglednika.</translation>
<translation id="2170233653554726857">Omogući WPAD optimizaciju</translation>
<translation id="2176565653304920879">Kada se to pravilo postavi, automatsko otkrivanje vremenske zone odvijat će se na jedan od sljedećih način ovisno o vrijednosti postavke:

      Ako se pravilo postavi na TimezoneAutomaticDetectionUsersDecide, korisnici će moći upravljati automatskim otkrivanjem vremenske zone uobičajenim kontrolama na stranici chrome://settings.

      Ako se pravilo postavi na TimezoneAutomaticDetectionDisabled, kontrole automatskog otkrivanja vremenske zone na stranici chrome://settings bit će onemogućene. Automatsko otkrivanje vremenske zone bit će uvijek isključeno.

      Ako se pravilo postavi na TimezoneAutomaticDetectionIPOnly, kontrole za vremenske zone na stranici chrome://settings bit će onemogućene. Automatsko otkrivanje vremenske zone bit će uvijek uključeno. Otkrivanje vremenske zone utvrđivat će lokaciju samo na temelju IP adrese.

      Ako se pravilo postavi na TimezoneAutomaticDetectionSendWiFiAccessPoints, kontrole za vremenske zone na stranici chrome://settings bit će onemogućene. Automatsko otkrivanje vremenske zone bit će uvijek uključeno. Popis vidljivih Wi-Fi pristupnih točaka uvijek će se slati poslužitelju API-ja Geolocation radi preciznog otkrivanja vremenske zone.

      Ako se pravilo postavi na TimezoneAutomaticDetectionSendAllLocationInfo, kontrole za vremenske zone na stranici chrome://settings bit će onemogućene. Automatsko otkrivanje vremenske zone bit će uvijek uključeno. Podaci o lokaciji (na primjer Wi-Fi pristupne točke, dostupne bazne stanice, GPS) slat će se poslužitelju radi preciznog otkrivanja vremenske zone.

      Ako se to pravilo ne postavi, ponašat će se kao da je postavljeno pravilo TimezoneAutomaticDetectionUsersDecide.

      Postavljanje pravila SystemTimezone nadjačava ovo pravilo. U tom je slučaju automatsko otkrivanje vremenske zone potpuno onemogućeno.</translation>
<translation id="2178899310296064282">Primijeni barem umjereni Ograničeni način rada na YouTubeu</translation>
<translation id="2182291258410176649">Korisnik odlučuje hoće li omogućiti stvaranje sigurnosno kopiranje i vraćanje</translation>
<translation id="2183294522275408937">Ta postavka određuje koliko se često mora unijeti zaporka na zaključanom zaslonu za daljnju upotrebu brzog otključavanja. Ako je od zadnjeg unosa zaporke prošlo više vremena od onog koje je određeno tom postavkom, brzo otključavanje neće biti dostupno za otvaranje zaključanog zaslona. Ako se korisnik zadrži na zaključanom zaslonu dulje od tog razdoblja, zaporka će se tražiti kada korisnik sljedeći put unese pogrešan kôd ili ponovo otvori zaključani zaslon, ovisno o tome što se dogodi prije.

          Ako se ta postavka konfigurira, korisnici koji upotrebljavaju brzo otključavanje morat će unijeti zaporku na zaključanom zaslonu ovisno o toj postavci.

          Ako se ta postavka ne konfigurira, korisnici koji upotrebljavaju brzo otključavanje morat će svaki dan unijeti zaporku na zaključanom zaslonu.</translation>
<translation id="2194470398825717446">To je pravilo obustavljeno u verziji M61. Umjesto toga upotrijebite EcryptfsMigrationStrategy.

      Određuje kako se treba ponašati uređaj koji je isporučen s enkripcijom ecryptfs, a treba se prebaciti na enkripciju ext4.

      Ako to pravilo postavite na "DisallowArc", Android aplikacije bit će onemogućene za sve korisnike na uređaju (uključujući one koji već imaju enkripciju ext4) i korisnicima se neće nuditi prebacivanje s enkripcije ecryptfs na enkripciju ext4.

      Ako to pravilo postavite na "AllowMigration", korisnicima koji imaju početne direktorije s enkripcijom ecryptfs ponudit će se prebacivanje na enkripciju ext4 prema potrebi (trenutačno kada Android N postane dostupan na uređaju).

      To se pravilo ne primjenjuje na kiosk aplikacije – one se premještaju automatski. Ako se to pravilo ne postavi, uređaj će se ponašati kao da je odabrano "DisallowArc".</translation>
<translation id="2195032660890227692">To je pravilo uklonjeno iz sustava <ph name="PRODUCT_NAME" /> 68 i zamijenjeno pravilom <ph name="ARC_BR_POLICY_NAME" />.</translation>
<translation id="219720814106081560">Ako je to pravilo omogućeno ili nije konfigurirano (zadano), od korisnika će se
      tražiti pristup za snimanje videozapisa osim za URL-ove konfigurirane na popisu
      VideoCaptureAllowedUrls kojima će se pristup odobravati bez postavljanja upita.

      Kada je to pravilo onemogućeno, korisniku se nikad neće postaviti upit i
      snimanje će biti dostupno samo URL-ovima na popisu VideoCaptureAllowedUrls.

      To pravilo utječe na sve vrste videoulaza, a ne samo na ugrađenu kameru.</translation>
<translation id="2201555246697292490">Konfiguriraj popis dopuštenih za lokalno slanje poruka</translation>
<translation id="2204753382813641270">Kontroliraj automatsko skrivanje police</translation>
<translation id="2208976000652006649">Parametri za URL pretraživanja koji upotrebljava POST</translation>
<translation id="2214880135980649323">Kad se to pravilo postavi na omogućeno, proširenjima instaliranim prema pravilima organizacije dopuštena je upotreba Enterprise Hardware Platform API-ja.
      Kad se to pravilo postavi na onemogućeno ili se ne postavi, proširenjima nije dopuštena upotreba Enterprise Hardware Platform API-ja.
      To se pravilo primjenjuje i na proširenja komponenti kao što je proširenje Hangout Services.</translation>
<translation id="2223598546285729819">Zadana postavka obavijesti</translation>
<translation id="2231817271680715693">Uvoz povijesti pregledavanja iz zadanog preglednika pri prvom pokretanju</translation>
<translation id="2236488539271255289">Ne dopusti nijednoj web-lokaciji postavljanje lokalnih podataka</translation>
<translation id="2240879329269430151">Omogućuje da postavite smiju li web-lokacije prikazivati skočne prozore. Prikazivanje skočnih prozora može biti dopušteno za sve web-lokacije ili odbijeno za sve web-lokacije. Ako to pravilo nije postavljeno, upotrebljavat će se pravilo "BlockPopups", a korisnik će to moći promijeniti.</translation>
<translation id="2255326053989409609">Omogućavanje te postavke web-stranicama sprječava pristup grafičkom procesoru (GPU). To konkretno znači da web-stranice ne mogu pristupiti API-ju WebGL, a dodaci ne mogu upotrebljavati API Pepper 3D.

      Onemogućavanje ili nepostavljanje te postavke potencijalno dopušta web-stranicama upotrebu API-ja WebGL, a dodacima upotrebu API-ja Pepper 3D. Zadane postavke preglednika mogu svejedno zahtijevati prosljeđivanje argumenata naredbenog retka za upotrebu tih API-ja.

      Ako se pravilo HardwareAccelerationModeEnabled postavi na false, Disable3DAPIs se zanemaruje i to je ekvivalentno postavljanju pravila Disable3DAPIs na true.</translation>
<translation id="2258126710006312594">Dopusti korisnicima daljinskog pristupa prijenos datoteka na host/s hosta</translation>
<translation id="2265214338421787313">Ovo pravilo omogućuje administratoru da odredi da stranica može prikazivati skočne prozore tijekom zatvaranja.

      Kad je to pravilo omogućeno, stranice mogu prikazivati skočne prozore tijekom zatvaranja.

      Kad je to pravilo onemogućeno ili se ne postavi, stranice ne mogu prikazivati skočne prozore tijekom zatvaranja, u skladu sa specifikacijom (https://html.spec.whatwg.org/#apis-for-creating-and-navigating-browsing-contexts-by-name).

      To će se pravilo ukloniti u Chromeu 82.

      Pročitajte https://www.chromestatus.com/feature/5989473649164288</translation>
<translation id="2269319728625047531">Omogući prikaz pristanka na sinkronizaciju tijekom prijave</translation>
<translation id="2274864612594831715">To pravilo konfigurira omogućivanje virtualne tipkovnice kao uređaja za unos na OS-u Chrome. Korisnici ne mogu nadjačati to pravilo.

      Ako se pravilo postavi na istinito, virtualna zaslonska tipkovnica uvijek će biti omogućena.

      Ako se postavi na neistinito, virtualna zaslonska tipkovnica uvijek će biti onemogućena.

      Ako postavite to pravilo, korisnici ga ne mogu izmijeniti ili nadjačati, no i dalje će moći omogućiti/onemogućiti zaslonsku tipkovnicu za pristupačnost koja ima prednost pred virtualnom tipkovnicom kojom upravlja ovo pravilo. Pogledajte pravilo |VirtualKeyboardEnabled| za upravljanje zaslonskom tipkovnicom za pristupačnost.

      Ako se to pravilo ne postavi, zaslonska tipkovnica u početku je onemogućena, ali je korisnik u bilo kojem trenutku može omogućiti. Za odluku o tome kada će se prikazivati tipkovnica mogu se upotrebljavati i heuristička pravila.</translation>
<translation id="2292084646366244343">Proizvod <ph name="PRODUCT_NAME" /> može upotrebljavati Googleovu web-uslugu za ispravljanje pravopisnih pogrešaka. Ako je ta postavka omogućena, ta se usluga uvijek upotrebljava. Ako je ta postavka onemogućena, ta se usluga nikad ne upotrebljava.

      Provjera pravopisa još se uvijek može vršiti pomoću preuzetog rječnika; to pravilo upravlja samo upotrebom mrežne usluge.

      Ako ta postavka nije konfigurirana, korisnici mogu sami odlučiti hoće li se usluga provjere pravopisa upotrebljavati ili neće.</translation>
<translation id="2294382669900758280">Reprodukcija videozapisa u Android aplikacijama ne uzima se u obzir, čak i ako se to pravilo postavi na <ph name="TRUE" />.</translation>
<translation id="2299220924812062390">Odredi popis omogućenih dodataka</translation>
<translation id="2303795211377219696">Omogući Automatsko popunjavanje za kreditne kartice</translation>
<translation id="2309390639296060546">Zadana postavka zemljopisnog položaja</translation>
<translation id="2327252517317514801">Definira domene kojima je dopušten pristup G Suiteu</translation>
<translation id="2356878440219553005">Odredite pravilo za upravljanje napajanjem načina punjenja baterije.

          Dinamički upravljajte punjenjem baterije da biste smanjili istrošenost baterije uslijed opterećenja i produljili njezino trajanje.

          Ako je odabran prilagođeni način punjenja baterije, potrebno je odrediti pravila DeviceBatteryChargeCustomStartCharging i DeviceBatteryChargeCustomStopCharging.

          Ako se to pravilo postavi, primjenjivat će se način punjenja baterije ako to uređaj podržava.

          Ako se to pravilo ne postavi, a uređaj ga podržava, primjenjivat će se standardni način punjenja baterije i korisnik ga neće moći promijeniti.

          Napomena: <ph name="DEVICE_ADVANCED_BATTERY_CHARGE_MODE_ENABLED_NAME" /> nadjačava to pravilo ako se odredi prethodno.</translation>
<translation id="237494535617297575">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju web-lokacije koje ne smiju prikazivati obavijesti. Ako ovo pravilo nije postavljeno, upotrebljavat će se globalna zadana vrijednost za sve web-lokacije iz pravila "DefaultNotificationsSetting" ako je postavljeno, odnosno iz osobne konfiguracije korisnika ako nije.</translation>
<translation id="2386362615870139244">Dopusti blokiranja aktivacije zaslona</translation>
<translation id="2411817661175306360">Upozorenje o zaštiti zaporkom isključeno je</translation>
<translation id="2411919772666155530">Blokiranje obavijesti na ovim web-lokacijama</translation>
<translation id="2418507228189425036">Onemogućuje spremanje povijesti preglednika u pregledniku <ph name="PRODUCT_NAME" /> i korisnicima onemogućuje promjenu te postavke.

      Ako je postavka omogućena, povijest pregledavanja ne sprema se. Ta postavka onemogućuje i sinkroniziranje kartica.

      Ako se postavka onemogući ili se ne postavi, povijest pregledavanja se sprema.</translation>
<translation id="2426782419955104525">Omogućuje značajku Instant preglednika <ph name="PRODUCT_NAME" /> i onemogućuje korisnicima da mijenjaju tu postavku.

      Ako omogućite tu postavku, <ph name="PRODUCT_NAME" /> Instant je omogućen.

      Ako onemogućite tu postavku, <ph name="PRODUCT_NAME" /> Instant je onemogućen.

      Ako omogućite ili onemogućite tu postavku, korisnici je ne mogu promijeniti ili premostiti.

      Ako se ta postavka ne postavi, korisnici mogu upotrebljavati tu funkciju prema želji.

      Ta je postavka uklonjena iz verzije <ph name="PRODUCT_NAME" /> 29 i novijih verzija.</translation>
<translation id="2433412232489478893">To pravilo određuje je li korisniku dopuštena značajka mrežnog dijeljenja datoteka za <ph name="PRODUCT_NAME" />.

      Ako se pravilo ne konfigurira ili se postavi na True, korisnici će moći upotrebljavati mrežno dijeljenje datoteka.

      Ako se pravilo postavi na False, korisnici neće moći upotrebljavati mrežno dijeljenje datoteka.</translation>
<translation id="2438609638493026652">Omogućuje izvještavanje o ključnim događajima tijekom instalacije Android aplikacije na Googleu. Događaji se bilježe samo za aplikacije čija je instalacija pokrenuta putem pravila.

      Ako je pravilo postavljeno na "true", događaji će biti zabilježeni.
      Ako je pravilo postavljeno na "false" ili nije postavljeno uopće, događaji neće biti zabilježeni.</translation>
<translation id="244317009688098048">Omogućuje tipkovni prečac za izbjegavanje automatske prijave.

      Ako to pravilo nije postavljeno ili ako je postavljeno na točno, a račun na uređaju konfiguriran je za automatsku prijavu bez odgode, proizvod <ph name="PRODUCT_OS_NAME" /> primjenjivat će tipkovni prečac Ctrl + Alt + S za izbjegavanje automatske prijave i prikazivanje zaslona za prijavu.

      Ako je to pravilo postavljeno na netočno, automatska prijava bez odgode (ako je konfigurirana) ne može se izbjeći.</translation>
<translation id="2454228136871844693">Optimizirati za stabilnost.</translation>
<translation id="2463034609187171371">Omogući DHE pakete šifri u TLS-u</translation>
<translation id="2463365186486772703">Oznaka zemlje/jezika aplikacije</translation>
<translation id="2466131534462628618">Autentifikacija putem obaveznog portala zanemaruje proxy</translation>
<translation id="2471748297300970300">Ako se onemogući, sprječava pojavljivanje sigurnosnih upozorenja kad se Chrome pokrene s nekim potencijalno opasnim oznakama naredbenih redaka.

          Ako se omogući ili se ne postavi, sigurnosna se upozorenja prikazuju kad se neke oznake naredbenih redaka upotrijebe za pokretanje Chromea.

          Na Windowsima to je pravilo dostupno samo na instancama koje su pridružene domeni <ph name="MS_AD_NAME" /> ili instancama Windowsa 10 Pro ili Enterprise prijavljenim za upravljanje uređajima.</translation>
<translation id="2482676533225429905">Lokalno slanje poruka</translation>
<translation id="2483146640187052324">Predvidi mrežne radnje na bilo kojoj mrežnoj vezi</translation>
<translation id="2484208301968418871">Tim se pravilom kontrolira primjena filtra URL-ova za SafeSites.
      Taj se filtar koristi Google Safe Search API-jem da bi klasificirao URL-ove kao pornografske i nepornografske.

      Kada se to pravilo ne konfigurira ili se postavi na "Nemoj filtrirati web-lokacije na temelju sadržaja za odrasle", web-lokacije neće se filtrirati.

      Kada se to pravilo postavi na "Filtriraj vršne web-lokacije na temelju sadržaja za odrasle", filtrirat će se web-lokacije klasificirane kao pornografske.</translation>
<translation id="2486371469462493753">Onemogućuje provedbu zahtjeva Transparentnosti certifikata za navedene URL-ove.

      To pravilo omogućuje da se certifikati za nazive hostova na navedenim URL-ovima ne otkrivaju putem Transparentnosti certifikata. Tako se omogućuje nastavak upotrebe certifikata koji se inače ne bi smatrali pouzdanima jer nisu pravilno javno otkriveni, ali se otežava otkrivanje zloupotrijebljenih certifikata za te hostove.

      Uzorak URL-ova oblikovan je u skladu s uputama na stranici https://www.chromium.org/administrators/url-blacklist-filter-format. No s obzirom da su certifikati važeći za dani naziv hosta neovisno o shemi, priključku ili putu, u obzir se uzima samo dio URL-a s nazivom hosta. Zamjenski znakovi nisu podržani.

      Ako se to pravilo ne postavi, sa svim certifikatima koji se moraju otkriti putem Transparentnosti certifikata postupat će se kao da nisu pouzdani ako se ne otkriju u skladu s pravilom Transparentnost certifikata.</translation>
<translation id="2488010520405124654">Omogući odzivnu poruku za konfiguraciju mreže tijekom izvanmrežnog rada.

      Ako to pravilo nije postavljeno ili je postavljeno na točno, a račun na uređaju konfiguriran je za automatsku prijavu bez odgode i uređaj nema pristup internetu, sustav <ph name="PRODUCT_OS_NAME" /> prikazat će odzivnu poruku za konfiguraciju mreže.

      Ako je to pravilo postavljeno na netočno, umjesto odzivne poruke za konfiguraciju mreže prikazat će se poruka pogreške.</translation>
<translation id="2498238926436517902">Uvijek automatski sakrij policu</translation>
<translation id="2514328368635166290">Određuje URL ikone favorita zadanog davatelja usluga pretraživanja. Ovo je pravilo izborno. Ako nije postavljeno, za davatelja usluga pretraživanja neće biti prikazana nijedna ikona. Ovo se pravilo poštuje samo ako je omogućeno pravilo "DefaultSearchProviderEnabled".</translation>
<translation id="2516600974234263142">Omogućuje ispis na proizvodu <ph name="PRODUCT_NAME" /> i onemogućuje korisnicima promjenu ove postavke.

      Ako je ta postavka omogućena ili nije konfigurirana, korisnici mogu ispisivati.

      Ako je ta postavka onemogućena, korisnici ne mogu ispisivati iz proizvoda <ph name="PRODUCT_NAME" />. Ispis je onemogućen na izborniku francuskog ključa, proširenjima, aplikacijama jezika JavaScript itd. I dalje je omogućen ispis iz dodataka koji tijekom ispisa zaobilaze proizvod <ph name="PRODUCT_NAME" />. Primjerice, određene Flash aplikacije imaju na svojem kontekstom izborniku opciju ispisa, koja nije pokrivena ovim pravilom.</translation>
<translation id="2518231489509538392">Dopusti reprodukciju zvuka</translation>
<translation id="2521581787935130926">Prikaži prečac aplikacije u traci oznaka</translation>
<translation id="2529659024053332711">Omogućuje vam da odredite ponašanje prilikom pokretanja.

          Ako odaberete "Otvori web-stranicu nove kartice", pri pokretanju preglednika <ph name="PRODUCT_NAME" /> uvijek će se otvoriti web-stranica nove kartice.

          Ako odaberete "Vrati posljednju sesiju", ponovo će se otvoriti URL-ovi koji su bili otvoreni kada se <ph name="PRODUCT_NAME" /> posljednji put zatvorio i sesija pregledavanja vratit će se na isto mjesto.
          Odabirom te opcije onemogućuju se neke postavke koje se oslanjaju na sesije ili koje izvršavaju radnje pri izlazu (kao što su brisanje podataka o pregledavanju prilikom izlaza ili kolačića koji se odnose samo na sesije).

          Ako odaberete "Otvori popis URL-ova", otvorit će se popis ''URL-ovi koji se otvaraju prilikom pokretanja" kada korisnik pokrene <ph name="PRODUCT_NAME" />.

          Ako omogućite tu postavku, korisnici je neće moći promijeniti niti nadjačati u pregledniku <ph name="PRODUCT_NAME" />.

          Onemogućivanje postavke ima jednak učinak kao da je niste konfigurirali. Korisnik će je i dalje moći promijeniti u pregledniku <ph name="PRODUCT_NAME" />.

          Pravilo je dostupno samo na instancama Windowsa koje su pridružene domeni <ph name="MS_AD_NAME" /> ili instancama Windowsa 10 Pro ili Enterprise prijavljenim za upravljanje uređajima.</translation>
<translation id="2529880111512635313">Konfiguriranje popisa prisilno instaliranih aplikacija i proširenja</translation>
<translation id="253135976343875019">Odgoda upozorenja o neaktivnosti dok je uređaj priključen na struju</translation>
<translation id="2536525645274582300">Korisnik odlučuje hoće li omogućiti Googleove usluge lokacije</translation>
<translation id="254653220329944566">Omogućuje izvješćivanje u oblaku preglednika <ph name="PRODUCT_NAME" /></translation>
<translation id="2548572254685798999">Prijavi podatke Sigurnog pregledavanja</translation>
<translation id="2550593661567988768">Samo jednostrani ispis</translation>
<translation id="2552966063069741410">Vremenska zona</translation>
<translation id="2562339630163277285">Određuje URL tražilice koja se upotrebljava za davanje instant rezultata. URL treba sadržavati niz <ph name="SEARCH_TERM_MARKER" /> koji će se u trenutku postavljanja upita zamijeniti tekstom koji je korisnik dotad unio.

          To pravilo nije obavezno. Ako se ne postavi, rezultati instant pretraživanja neće se prikazivati.

          Googleov URL instant rezultata može se navesti kao: <ph name="GOOGLE_INSTANT_SEARCH_URL" />.

          To će se pravilo poštovati samo ako je omogućeno pravilo "DefaultSearchProviderEnabled".</translation>
<translation id="2569647487017692047">Ako se to pravilo postavi na False, <ph name="PRODUCT_OS_NAME" /> onemogućit će Bluetooth i korisnik ga neće moći omogućiti.

      Ako se to pravilo postavi na True ili se ne postavi, korisnik će moći omogućiti ili onemogućiti Bluetooth prema želji.

      Ako se to pravilo postavi, korisnik ga ne može promijeniti niti nadjačati.

      Nakon omogućivanja Bluetootha korisnik se mora odjaviti, pa ponovo prijaviti da bi promjene postale aktivne (taj postupak nije potreban kada se Bluetooth onemogućuje).</translation>
<translation id="2571066091915960923">Omogućuje ili onemogućuje proxy za kompresiju podataka i sprječava korisnike da promjene tu postavku.

      Ako omogućite ili onemogućite tu postavku, korisnici je ne mogu promijeniti niti premostiti.

      Ako se to pravilo ne postavi, korisnici će moći odlučivati hoće li upotrebljavati značajku proxyja za kompresiju podataka.</translation>
<translation id="257788512393330403">Zaporku treba unijeti svakih šest sati</translation>
<translation id="2586162458524426376">
      To se pravilo primjenjuje na zaslon za prijavu. Pogledajte i pravilo <ph name="ISOLATE_ORIGINS_POLICY_NAME" /> koje se primjenjuje na korisničku sesiju.
      Ako se to pravilo omogući, svaki izvor naveden na popisu odijeljenom zarezima izvodit će se u vlastitom procesu. Time će se također izolirati izvori navedeni prema poddomenama, npr. ako se navede https://example.com/, izolirat će se i https://foo.example.com/ kao dio web-lokacije https://example.com/.
      Ako se pravilo ne konfigurira ili se onemogući, za zaslon za prijavu koristit će se postavke izolacije web-lokacije zadane za platformu.
      </translation>
<translation id="2587719089023392205">Postavi <ph name="PRODUCT_NAME" /> kao zadani preglednik</translation>
<translation id="2592091433672667839">Trajanje neaktivnosti prije nego što se čuvar zaslona prikaže na zaslonu prijave u prodajnom načinu</translation>
<translation id="2592162121850992309">Ako se to pravilo postavi na true ili se ne postavi, hardversko će ubrzanje biti omogućeno ako se određena značajka GPU-a ne nalazi na popisu nedopuštenih.

      Ako se to pravilo postavi na false, hardversko ubrzanje neće biti omogućeno.</translation>
<translation id="2596260130957832043">Kontrolira je li omogućen NTLMv2.

          Sve novije verzije poslužitelja Samba i Windows podržavaju NTLMv2. To treba biti onemogućeno samo za kompatibilnost sa starijim verzijama i smanjuje sigurnost autentifikacije.

          Ako to pravilo nije postavljeno, zadana je vrijednost True i NTLMv2 je omogućen.</translation>
<translation id="26023406105317310">Konfiguriraj Kerberos račune</translation>
<translation id="2604182581880595781">Konfiguriranje pravila povezanih s mrežnim dijeljenjem datoteka.</translation>
<translation id="2623014935069176671">Pričekaj početnu aktivnost korisnika</translation>
<translation id="262740370354162807">Omogući slanje dokumenata na uslugu <ph name="CLOUD_PRINT_NAME" /></translation>
<translation id="2627554163382448569">Pruža konfiguracije za pisače tvrtki.

      To vam pravilo omogućuje da pružite konfiguracije pisača za <ph name="PRODUCT_OS_NAME" /> uređaje. Format je jednak kao za rječnik NativePrinters, osim što je potrebno dodatno polje "id" ili "guid" po pisaču za dopuštanje ili ograničavanje pisača.

      Datoteka ne smije biti veća od 5 MB i mora se kodirati u JSON-u. Prema procjeni, datoteka koja sadrži približno 21.000 pisača kodirat će se kao datoteka od 5 MB. Za potvrdu integriteta preuzimanja upotrebljava se kriptografsko raspršivanje.

      Datoteka se preuzima i predmemorira. Ponovo će se preuzeti svaki put kad se URL ili raspršivanje promijene.

      Ako se to pravilo postavi, <ph name="PRODUCT_OS_NAME" /> preuzet će datoteku za konfiguriranje pisača i učiniti pisače dostupnima u skladu s pravilima <ph name="BULK_PRINTERS_ACCESS_MODE" />, <ph name="BULK_PRINTERS_WHITELIST" /> i <ph name="BULK_PRINTERS_BLACKLIST" />.

      Ako postavite to pravilo, korisnici ga neće moći promijeniti niti nadjačati.

      To pravilo ne utječe na to mogu li korisnici konfigurirati pisače na pojedinačnim uređajima. Služi kao dodatno pravilo za konfiguraciju pisača koju vrše pojedinačni korisnici.
      </translation>
<translation id="2633084400146331575">Omogućavanje govornih povratnih informacija</translation>
<translation id="2646290749315461919">Omogućuje da postavite smiju li web-lokacije pratiti fizičku lokaciju korisnika. Praćenje fizičke lokacije korisnika može biti dopušteno prema zadanim postavkama, odbijeno prema zadanim postavkama ili se korisniku može postaviti upit svaki puta kada web-lokacija zahtijeva fizičku lokaciju. Ako ovo pravilo nije postavljeno, upotrebljavat će se pravilo "AskGeolocation", a korisnik će to moći promijeniti.</translation>
<translation id="2647069081229792812">Omogući ili onemogući uređivanje oznaka</translation>
<translation id="2649896281375932517">Odlučuju korisnici</translation>
<translation id="2650049181907741121">Radnja koja će se izvršiti kada korisnik spusti poklopac</translation>
<translation id="2655233147335439767">Određuje URL tražilice koja se upotrebljava za zadano pretraživanje. URL treba sadržavati niz "<ph name="SEARCH_TERM_MARKER" />" koji će se u trenutku upita zamijeniti pojmovima koje korisnik traži.

          Googleov URL pretraživanja može se navesti kao: <ph name="GOOGLE_SEARCH_URL" />.

          Ta se opcija mora postaviti kada je omogućeno pravilo "DefaultSearchProviderEnabled" i poštovat će se samo u tom slučaju.</translation>
<translation id="2659019163577049044">Ako je ova postavka omogućena, korisnicima će biti dopušteno postaviti svoje uređaje da sinkroniziraju SMS poruke na telefonima i Chromebookovima. Ako se dopusti ovo pravilo, korisnici moraju eksplicitno uključiti ovu značajku izvršavanjem uputa za postavljanje. Nakon izvršenja uputa za postavljanje korisnici će moći slati i primati SMS poruke na svojim Chromebookovima.

      Ako je postavka onemogućena, korisnicima neće biti dopušteno postaviti sinkronizaciju SMS-a.

      Ako se pravilo ne postavi, zadana postavka nije dopuštena korisnicima kojima se upravlja, a dopuštena je neupravljanim korisnicima.</translation>
<translation id="2660846099862559570">Nikad ne upotrebljavaj proxy</translation>
<translation id="2672012807430078509">Upravlja omogućivanjem NTLM-a kao autentifikacijskog protokola za SMB učitavanja</translation>
<translation id="267596348720209223">Određuje kodiranje znakova koje podržava davatelj usluga pretraživanja. Kodiranja su nazivi kodnih stranica poput UTF-8, GB2312 i ISO-8859-1. Isprobavaju se navedenim redoslijedom. Ovo je pravilo izborno. Ako nije postavljeno, upotrebljavat će se zadana stranica UTF-8. Ovo će se pravilo poštovati samo ako je omogućeno pravilo "DefaultSearchProviderEnabled".</translation>
<translation id="268577405881275241">Omogući značajku proxyja za kompresiju podataka</translation>
<translation id="2693108589792503178">Konfiguriranje URL-a za promjenu zaporke.</translation>
<translation id="2694143893026486692">Omogućeno je usidreno povećalo</translation>
<translation id="2706708761587205154">Dopusti ispis samo s PIN-om</translation>
<translation id="2710534340210290498">Ako se to pravilo postavi na false, korisnici neće moći zaključati zaslon (bit će moguća samo odjava s korisničke sesije). Ako se to pravilo postavi na true ili se ne postavi, korisnici koji su se autentificirali zaporkom moći će zaključati zaslon.</translation>
<translation id="2731627323327011390">Onemogući upotrebu <ph name="PRODUCT_OS_NAME" /> certifikata za ARC aplikacije</translation>
<translation id="2742843273354638707">Skrivanje aplikacije Chrome web-trgovine i veze u podnožju na web-stranici nove kartice i pokretača aplikacija za <ph name="PRODUCT_OS_NAME" />.

      Kada je to pravilo postavljeno na točno, ikone su skrivene.

      Kada je to pravilo postavljeno na netočno ili nije konfigurirano, ikone su vidljive.</translation>
<translation id="2744751866269053547">Registracija rukovatelja protokola</translation>
<translation id="2746016768603629042">Ovo je pravilo obustavljeno, umjesto njega upotrijebite DefaultJavaScriptSetting.

      Može se upotrijebiti za onemogućavanje JavaScripta na usluzi <ph name="PRODUCT_NAME" />.

      Ako je ova postavka onemogućena, web-stranice ne mogu upotrebljavati JavaScript i korisnik ne može promijeniti tu postavku.

      Ako je ova postavka omogućena ili nije postavljena, web-stranice mogu upotrebljavati JavaScript, no korisnik može promijeniti tu postavku.</translation>
<translation id="2753637905605932878">Ograniči raspon lokalnih UDP priključaka kojima se koristi WebRTC</translation>
<translation id="2757054304033424106">Vrste proširenja/aplikacija koje se smiju instalirati</translation>
<translation id="2758084448533744848">Određuje zadanu vremensku zonu koja će se upotrebljavati za uređaj. Ako se to pravilo postavi, korisnici uređaja ne mogu nadjačati navedenu vremensku zonu. Ako se navede nevažeća vrijednost, pravilo je još uvijek aktivirano i umjesto nje upotrebljava se "GMT". Ako se navede prazan niz, pravilo se zanemaruje.

      Ako se ovo pravilo ne upotrebljava, trenutačno aktivna vremenska zona ostat će u upotrebi, ali korisnici će je moći promijeniti.

      Na novim uređajima početna vremenska zona postavljena je na "SAD/Pacifik".

      Format vrijednosti slijedi nazive vremenskih zona u "Bazi podataka vremenskih zona IANA" (pogledajte "https://en.wikipedia.org/wiki/Tz_database"). Većina vremenskih zona naročito može biti označena kao "kontinent/veliki_grad" ili "ocean/veliki_grad".

      Postavljanjem tog pravila potpuno se onemogućuje automatsko određivanje vremenske zone prema lokaciji uređaja. Nadjačava se i pravilo SystemTimezoneAutomaticDetection.</translation>
<translation id="2759224876420453487">Kontroliraj ponašanje korisnika u sesiji višestrukih profila</translation>
<translation id="2761483219396643566">Odgoda upozorenja o neaktivnosti dok uređaj nije priključen na struju</translation>
<translation id="2762164719979766599">Navodi popis lokalnih računa na uređaju koji se prikazuje na zaslonu prijave.

      Svaki unos na popisu navodi identifikator, koji se upotrebljava interno da bi se razlikovali lokalni računi na uređaju.</translation>
<translation id="2769952903507981510">Konfiguriraj traženi naziv domene za hostove daljinskog pristupa</translation>
<translation id="2783078941107212091">Omogućite preporučivanje aplikacije u nultom stanju okvira za pretraživanje u pokretaču.

          Ako se to pravilo postavi na true, preporuke aplikacije mogu se prikazivati u pretraživanju nultog stanja.

          Ako se to pravilo postavi na false, preporuke aplikacije neće se prikazivati u pretraživanju nultog stanja.

          Ako postavite to pravilo, korisnici ga neće moći promijeniti ni nadjačati.

          Ako se to pravilo ne postavi, zadana postavka za upravljane uređaje bit će false.</translation>
<translation id="2787173078141616821">Prijavi informacije o statusu Androida</translation>
<translation id="2799297758492717491">Dopusti automatsku reprodukciju medija na popisu dopuštenih uzoraka URL-a</translation>
<translation id="2801155097555584385">Postavi prilagođeni početak punjenja baterije u postocima</translation>
<translation id="2801230735743888564">Dopusti korisnicima igranje skrivene igre s dinosaurom kada je uređaj izvan mreže.

      Ako se to pravilo postavi na "False", korisnici neće moći igrati skrivenu igru s dinosaurom kada uređaj nije povezan s mrežom. Ako se ta postavka postavi na "True", korisnici će moći igrati igru s dinosaurom. Ako se to pravilo ne postavi, korisnici neće moći igrati skrivenu igru s dinosaurom u prijavljenom OS-u Chrome, ali će je moći igrati u drugim okolnostima.</translation>
<translation id="2802085784857530815">Omogućuje vam da odredite mogu li korisnici pristupiti pisačima izvan tvrtke

      Ako se pravilo postavi na True ili se ne postavi, korisnici će moći dodavati i konfigurirati nativne pisače te ispisivati na njima.

      Ako se pravilo postavi na False, korisnici neće moći dodavati i konfigurirati nativne pisače. Neće moći ni ispisivati na prethodno konfiguriranim nativnim pisačima.
      </translation>
<translation id="2805707493867224476">Dopusti svim web-lokacijama prikazivanje skočnih prozora</translation>
<translation id="2808013382476173118">Omogućuje upotrebu STUN poslužitelja kada udaljeni klijenti pokušavaju uspostaviti vezu s ovim računalom.

          Ako je ova postavka omogućena, onda udaljeni klijenti mogu otkriti ovo računalo i povezati se s njime, čak i ako je odvojeno vatrozidom.

          Ako je ova postavka onemogućena, a odlazne UDP veze filtrirane su vatrozidom, onda će ovo računalo dopustiti samo veze s klijentskih računala unutar lokalne mreže.

          Ako ovo pravilo nije postavljeno, postavka će biti omogućena.</translation>
<translation id="2813281962735757923">Pravilo upravlja razdobljima tijekom kojih <ph name="PRODUCT_OS_NAME" /> uređaj ne smije automatski provjeravati ima li ažuriranja.
      Kad se to pravilo postavi na popis vremenskih intervala koji nije prazan:
      Uređaji neće moći automatski provjeravati ima li ažuriranja tijekom navedenih vremenskih intervala. To pravilo neće utjecati na uređaje koje je potrebno vratiti na prethodnu verziju ili koji su ispod minimalne verzije sustava <ph name="PRODUCT_OS_NAME" /> zbog mogućih sigurnosnih poteškoća. Osim toga, pravilo neće blokirati provjere ažuriranja koje zatraže korisnici ili administratori.
      Kad se to pravilo ne postavi ili ne sadrži vremenske intervale:
      Pravilo neće blokirati automatske provjere ažuriranja, no možda će ih blokirati druga pravila. Ta je značajka omogućena samo na Chrome uređajima koji su konfigurirani kao kiosci s automatskim pokretanjem. Ostali uređaji neće biti ograničeni tim pravilom.</translation>
<translation id="2823870601012066791">Lokacija Windows registra za <ph name="PRODUCT_OS_NAME" /> klijente:</translation>
<translation id="2824715612115726353">Omogući anonimni način</translation>
<translation id="2836621397261130126">Kontrolira poštuje li se odobrenje prema pravilima KDC-a kako bi se odlučilo hoće li se dodijeliti tiketi protokola <ph name="KERBEROS" />.

          Ako se pravilo postavi na true, HTTP autentifikacija poštuje odobrenje prema pravilima KDC-a, odnosno Chrome dodjeljuje vjerodajnice samo ako KDC postavi <ph name="OK_AS_DELEGATE" /> na tiketu usluge. Više informacija potražite na https://tools.ietf.org/html/rfc5896.html. Usluga također treba biti usklađena s pravilom "AuthNegotiateDelegateWhitelist".

          Ako se pravilo ne postavi ili se postavi na false, pravilo KDC-a zanemaruje se na podržanim platformama i poštuje se samo pravilo "AuthNegotiateDelegateWhitelist".

          Pravilo KDC-a uvijek se poštuje na Windowsima.</translation>
<translation id="283695852388224413">Ako se postavi to pravilo, primjenjuje se konfigurirana maksimalna duljina PIN-a. Vrijednost 0 ili manja znači da nema maksimalne duljine i u tom slučaju korisnik može postaviti PIN bilo koje duljine. Ako je ta postavka manja od <ph name="PIN_UNLOCK_MINIMUM_LENGTH_POLICY_NAME" />, ali veća od 0, maksimalna duljina jednaka je minimalnoj.

          Ako se pravilo ne postavi, maksimalna se duljina ne primjenjuje.</translation>
<translation id="2838830882081735096">Onemogući premještanje podataka i ARC</translation>
<translation id="2839294585867804686">Postavke mrežnog dijeljenja datoteka</translation>
<translation id="2840269525054388612">Određuje pisače koje korisnik može upotrebljavati.

      To se pravilo upotrebljava samo ako je pravilo <ph name="PRINTERS_WHITELIST" /> odabrano za <ph name="DEVICE_PRINTERS_ACCESS_MODE" />

      Ako se to pravilo upotrebljava, korisniku su dostupni samo pisači s ID-ovima podudarnim s vrijednostima u tom pravilu. ID-ovi se moraju podudarati s poljima "id" ili "guid" u datoteci navedenoj u pravilu <ph name="DEVICE_PRINTERS_POLICY" />.
      </translation>
<translation id="2842152347010310843">Određuje hoće li popis dopuštenih uzoraka URL-a koji se automatski reproduciraju uvijek biti omogućen.

      Ako je automatska reprodukcija omogućena, videozapisi se mogu automatski reproducirati (bez pristanka korisnika) s audiosadržajem u pregledniku <ph name="PRODUCT_NAME" />.

      Važeće specifikacije uzoraka URL-ova su:

      - [*.]domain.tld (podudara se sa domain.tld i svim poddomenama)

      - host (podudara se s točnim nazivom hosta)

      - scheme://host:port (podržane sheme: http,https)

      - scheme://[*.]domain.tld:port (podržane sheme: http,https)

      - file://path (put mora biti apsolutan i počinjati sa '/')

      - a.b.c.d (podudara se s točnom IPv4 ip adresom)

      - [a:b:c:d:e:f:g:h] (podudara se s točnom IPv6 ip adresom)

      Ako je pravilo AutoplayAllowed postavljeno na True, ovo pravilo neće imati učinka.

      Ako je pravilo AutoplayAllowed postavljeno na False, svi uzorci URL-a postavljeni u ovom pravilu i dalje će se moći reproducirati.

      Ako se <ph name="PRODUCT_NAME" /> izvodi, a pravilo se promijeni, pravilo će se primjenjivati samo na nove otvorene kartice. Zato će se neke kartice možda i dalje ponašati u skladu s prethodnim pravilom.</translation>
<translation id="284288632677954003">URL XML datoteke koja sadrži URL-ove koji nikada ne bi trebali pokrenuti promjenu preglednika.</translation>
<translation id="285480231336205327">Omogućavanje načina visokog kontrasta</translation>
<translation id="2854919890879212089">Određuje da <ph name="PRODUCT_NAME" /> u Pregledu ispisa upotrebljava zadani pisač sustava, a ne pisač koji je upotrijebljen zadnji put.

      Ako onemogućite tu postavku ili ne postavite nikakvu vrijednost, zadani će odredišni pisač u Pregledu ispisa biti pisač koji je upotrijebljen zadnji put.

      Ako omogućite tu postavku, u Pregledu ispisa upotrebljavat će se zadani pisač OS-a kao zadani odredišni pisač.</translation>
<translation id="285627849510728211">Postavi dnevno konfiguriranje naprednog načina punjenja baterije</translation>
<translation id="2856674246949497058">Vrati se na ciljnu verziju i ostani na njoj ako je verzija OS-a novija od ciljne. Tijekom postupka izvrši powerwash.</translation>
<translation id="2872961005593481000">Isključi</translation>
<translation id="2873651257716068683">Nadjačava veličinu stranice zadanog ispisa. Pravilo se zanemaruje ako veličina stranice nije dostupna.</translation>
<translation id="2874209944580848064">Napomena za uređaje <ph name="PRODUCT_OS_NAME" /> koji podržavaju Androidove aplikacije:</translation>
<translation id="2877225735001246144">Onemogući CNAME pretraživanje prilikom provjere Kerberos autentičnosti</translation>
<translation id="2890645751406497668">Automatski odobri ovim web-lokacijama da se povežu s USB uređajima s navedenim ID-jevima dobavljača i proizvoda.</translation>
<translation id="2892414556511568464">Ograničava način dvostranog ispisa. Nepostavljanje pravila i prazan skup smatraju se nepostojanjem ograničenja.</translation>
<translation id="2893546967669465276">Šalji zapisinike sustava poslužitelju za upravljanje</translation>
<translation id="2899002520262095963">Android aplikacije mogu upotrebljavati mrežne konfiguracije i CA certifikate postavljene putem tog pravila, no nemaju pristup nekim opcijama konfiguracije.</translation>
<translation id="290002216614278247">Omogućuje vam da zaključate sesiju korisnika na temelju vremena klijenta ili korisničke kvote za taj dan.

          |time_window_limit| određuje dnevni vremenski okvir u kojemu se sesija korisnika treba zaključati. Podržavamo samo jedno pravilo za svaki dan u tjednu, stoga veličina niza |entries| može varirati od nula do sedam. |starts_at| i |ends_at| početak su i kraj ograničenja vremenskog okvira, a kada je |ends_at| manji od |starts_at|, to znači da |time_limit_window| završava sljedeći dan. |last_updated_millis| vremenska je oznaka prema UTC-u za posljednje ažuriranje tog unosa, a šalje se u obliku niza jer vremenska oznaka ne bi stala u cijeli broj.

          |time_usage_limit| određuje dnevnu kvotu zaslona i kada je korisnik dosegne, sesija se korisnika zaključava. Postoji određeno svojstvo za svaki dan u tjednu, a ono se postavlja samo ako postoji aktivna kvota za taj dan. |usage_quota_mins| količina je vremena u kojemu se upravljani uređaj može upotrebljavati u jednom danu, a |reset_at| vrijeme je kada se kvota za upotrebu obnavlja. Zadana je vrijednost za |reset_at| ponoć ({'hour': 0, 'minute': 0}). |last_updated_millis| vremenska je oznaka prema UTC-u za vrijeme za posljednje ažuriranje tog unosa, a šalje se u obliku niza jer vremenska oznaka ne bi stala u cijeli broj.

          |overrides| služi za privremeno poništavanje jednog ili više prethodnih pravila.
          * Ako ni time_window_limit ni time_usage_limit nisu aktivni, za zaključavanje uređaja može se upotrijebiti |LOCK|.
          * |LOCK| privremeno zaključava sesiju korisnika dok ne počne sljedeći time_window_limit ili time_usage_limit.
          * |UNLOCK| otključava sesiju korisnika koja je zaključana funkcijom time_window_limit ili time_usage_limit.
          |created_time_millis| vremenska je oznaka prema UTC-u za izradu nadjačavanja, a šalje se u obliku niza jer vremenska oznaka ne bi stala u cijeli broj. Upotrebljava se kako bi se odredilo treba li se to nadjačavanje još primjenjivati. Ako je trenutačna značajka ograničenja aktivnog vremena (vremensko ograničenje upotrebe ili ograničenje vremenskog okvira) započela nakon što je nadjačavanje izrađeno, ne bi se trebala primjenjivati. Ne bi se trebala primjenjivati ni ako je nadjačavanje izrađeno prije posljednje promjene ograničenja time_window_limit ili time_usage_window.

          Moguće je poslati više nadjačavanja, a primijenit će se najnoviji važeći unos.</translation>
<translation id="2901725272378498025">Omogući sigurnosna upozorenja za oznake naredbenih redaka</translation>
<translation id="2905984450136807296">Trajanje predmemorije podataka za autentifikaciju</translation>
<translation id="2906874737073861391">Popis proširenja AppPack</translation>
<translation id="2907992746861405243">Određuje koji su pisači iz pravila <ph name="BULK_PRINTERS_POLICY" /> dostupni korisnicima.

      Određuje koje se pravilo za pristup upotrebljava za skupnu konfiguraciju pisača. Ako se odabere <ph name="PRINTERS_ALLOW_ALL" />, prikazuju se svi pisači. Ako se odabere <ph name="PRINTERS_BLACKLIST" />, <ph name="BULK_PRINTERS_BLACKLIST" /> upotrebljava se za ograničenje pristupa navedenim pisačima. Ako se odabere <ph name="PRINTERS_WHITELIST" />, <ph name="BULK_PRINTERS_WHITELIST" /> određuje samo one pisače koji se mogu odabrati.

      Ako se to pravilo ne postavi, pretpostavlja se da vrijedi <ph name="PRINTERS_ALLOW_ALL" />.
      </translation>
<translation id="2908277604670530363">Maksimalan broj istodobnih veza na proxy poslužitelju</translation>
<translation id="2952347049958405264">Ograničenja:</translation>
<translation id="2956777931324644324">To je pravilo ukinuto od verzije <ph name="PRODUCT_NAME" /> 36.

      Određuje hoće li proširenje TLS certifikata vezanih uz domenu biti omogućeno.

      Ta se postavka upotrebljava za omogućivanje proširenja TLS certifikata vezanih uz domenu za testiranje. Ta će se eksperimentalna postavka ukloniti.</translation>
<translation id="2957506574938329824">Nemoj dopustiti nijednoj web-lokaciji da traži pristup Bluetooth uređajima putem API-ja Web Bluetooth</translation>
<translation id="2957513448235202597">Vrsta računa za <ph name="HTTP_NEGOTIATE" /> autentifikaciju</translation>
<translation id="2959469725686993410">Uvijek šalji pristupne točke Wi-Fi mreže poslužitelju prilikom utvrđivanja vremenske zone</translation>
<translation id="2959898425599642200">Pravila zaobilaženja proxyja</translation>
<translation id="2960128438010718932">Raspored postupnog uvođenja za primjenu novog ažuriranja</translation>
<translation id="2960691910306063964">Omogući ili onemogući autentifikaciju bez PIN-a za hostove daljinskog pristupa</translation>
<translation id="2976002782221275500">Određuje koliko vremena treba proteći bez aktivnosti korisnika da bi se zaslon zatamnio tijekom rada s baterijskim napajanjem.

          Kada je postavljeno na vrijednost veću od nule, ovo pravilo određuje koliko vremena treba proteći u neaktivnosti prije nego što <ph name="PRODUCT_OS_NAME" /> zatamni zaslon.

          Kada je ovo pravilo postavljeno na nulu, <ph name="PRODUCT_OS_NAME" /> ne zatamnjuje zaslon tijekom neaktivnosti korisnika.

          Kada nije postavljeno, upotrebljava se zadano vrijeme.

          Vrijednost pravila treba navesti u milisekundama. Vrijednosti su ograničene na vrijeme kraće od odgode isključivanja zaslona i odgode neaktivnosti ili jednako tom vremenu (ako je postavljeno).</translation>
<translation id="2977997796833930843">To je pravilo obustavljeno i uklonit će se u budućnosti.

          To pravilo navodi zamjensku vrijednost za detaljnija pravila <ph name="IDLE_ACTION_AC_POLICY_NAME" /> i <ph name="IDLE_ACTION_BATTERY_POLICY_NAME" />. Ako se to pravilo postavi, njegova će se vrijednost upotrebljavati ako nije postavljeno odgovarajuće detaljnije pravilo.

          Ako se to pravilo ne postavi, ponašanje detaljnijih pravila ostat će nepromijenjeno.</translation>
<translation id="2987155890997901449">Omogući ARC</translation>
<translation id="2987227569419001736">Upravljanje upotrebom API-ja Web Bluetooth</translation>
<translation id="2990018289267778247">Ako se to pravilo postavi na true, opcije pristupačnosti uvijek se prikazuju na izborniku trake sustava.

          Ako se pravilo postavi na false, opcije pristupačnosti nikad se neće prikazivati na izborniku trake sustava.

          Ako postavite to pravilo, korisnici ga neće moći promijeniti ni nadjačati.

          Ako ne postavite to pravilo, opcije pristupačnosti neće se prikazivati na izborniku trake sustava, ali ih korisnik može prikazati putem stranice Postavke.

          Kada su omogućene značajke pristupačnosti (na drugi način, primjerice kombinacijom tipki), opcije pristupačnosti uvijek će se pojaviti na izborniku trake sustava.</translation>
<translation id="3011301228198307065">Konfigurira URL zadane početne stranice u pregledniku <ph name="PRODUCT_NAME" /> i korisnicima onemogućuje da ga promijene.

          Početna je stranica ona koja se otvara gumbom početnog zaslona. Stranicama koje se otvaraju prilikom pokretanja upravljaju pravila RestoreOnStartup.

          Za vrstu početne stranice možete postaviti URL koji navedete ovdje ili web-stranicu nove kartice. Ako odaberete web-stranicu nove kartice, ovo se pravilo ne primjenjuje.

          Ako omogućite tu postavku, korisnici neće moći promijeniti URL početne stranice u pregledniku <ph name="PRODUCT_NAME" />, ali će kao početnu stranicu moći odabrati web-stranicu nove kartice.

          Ako se to pravilo ne postavi, korisnik će moći samostalno odabrati početnu stranicu u slučaju da se ne postavi ni pravilo HomepageIsNewTabPage.

          URL mora imati standardnu shemu, na primjer "http://example.com" ili "https://example.com".

          Pravilo je dostupno samo na instancama Windowsa koje su pridružene domeni <ph name="MS_AD_NAME" /> ili instancama Windowsa 10 Pro ili Enterprise prijavljenim za upravljanje uređajima.</translation>
<translation id="3016255526521614822">Aplikacije za izradu bilježaka dopuštene na zaključanom zaslonu uređaja sa sustavom <ph name="PRODUCT_OS_NAME" /> stavi na popis dopuštenih</translation>
<translation id="3021562480854470924">Broj dopuštenih prijelaznih točaka za vraćanje sustava</translation>
<translation id="3023572080620427845">URL XML datoteke koja sadrži URL-ove koji se trebaju učitati u zamjenskom pregledniku.</translation>
<translation id="3030000825273123558">Omogući izvješće o metrici</translation>
<translation id="3033660238345063904">Ovdje možete navesti URL proxy poslužitelja.

          To će pravilo vrijediti samo ako odaberete ručne postavke proxyja pod stavkom "Odaberi način određivanja postavki proxy poslužitelja" i ako ne odredite pravilo <ph name="PROXY_SETTINGS_POLICY_NAME" />.

          Ne postavljajte to pravilo ako ste odabrali bilo koji drugi način za postavljanje pravila za proxy poslužitelje.

          Dodatne opcije i detaljne primjere možete pronaći ovdje:
          <ph name="PROXY_HELP_URL" />.</translation>
<translation id="3034580675120919256">Omogućuje da postavite smiju li web-lokacije pokretati JavaScript. Pokretanje JavaScripta može biti dopušteno za sve web-lokacije ili odbijeno za sve web-lokacije. Ako ovo pravilo nije postavljeno, upotrebljavat će se pravilo "AllowJavaScript", a korisnik će to moći promijeniti.</translation>
<translation id="3038323923255997294">Nastavi izvršavati ​​pozadinske aplikacije po zatvaranju usluge <ph name="PRODUCT_NAME" /></translation>
<translation id="3046192273793919231">Šalji mrežne pakete poslužitelju za upravljanje radi praćenja online statusa</translation>
<translation id="3047732214002457234">Odredi način na koji Chromeov alat za čišćenje šalje podatke Googleu</translation>
<translation id="304775240152542058">To pravilo određuje parametre naredbenog retka koji će se pokrenuti u zamjenskom pregledniku.

      Ako se pravilo ne postavi, samo se URL prosljeđuje kao parametar naredbenog retka.

      Ako se pravilo postavi na popis nizova, svaki se niz prosljeđuje zamjenskom pregledniku kao zasebni parametar naredbenog retka. U sustavu Windows parametri su spojeni razmacima. U sustavima Mac OS X i Linux parametar može sadržavati razmake, a da ga se i dalje tretira kao jedan parametar.

      Ako element sadrži ${url}, onda se zamjenjuje URL-om stranice koju je potrebno otvoriti.

      Ako nijedan element ne sadrži ${url}, URL se dodaje na kraj naredbenog retka.

      Varijable okruženja proširuju se. U sustavu Windows %ABC% zamjenjuje se vrijednošću varijable okruženja ABC. U sustavima Mac OS X i Linux ${ABC} zamjenjuje se vrijednošću varijable okruženja ABC.</translation>
<translation id="3048744057455266684">Ako je ovo pravilo postavljeno i ako URL pretraživanja predloženog u višenamjenskom okviru sadrži taj parametar u nizu upita ili identifikatoru fragmenta, prijedlog će prikazati pojmove za pretraživanje i pružatelja usluge pretraživanja umjesto neobrađenog URL-a pretraživanja.

          Pravilo nije obavezno. Ako nije postavljeno, neće se vršiti zamjena pojma za pretraživanje.

          Pravilo se primjenjuje samo ako je pravilo "DefaultSearchProviderEnabled" omogućeno.</translation>
<translation id="3053265701996417839">Microsoft Windows 7</translation>
<translation id="306887062252197004">Ovo pravilo omogućuje korisnicima značajke WebDriver da nadjačaju
      pravila koja mogu ometati njezin rad.

      To pravilo trenutačno onemogućuje pravila SitePerProcess i IsolateOrigins.

      Ako je to pravilo omogućeno, WebDriver će moći nadjačati nekompatibilna
      pravila.
      Ako je to pravilo onemogućeno ili nije konfigurirano, WebDriver neće moći
      nadjačati nekompatibilna pravila.</translation>
<translation id="3069958900488014740">Omogućuje isključivanje optimizacije WPAD-a (automatskog otkrivanja web-proxyja) u pregledniku <ph name="PRODUCT_NAME" />.

      Ako se to pravilo postavi na "False", optimizacija WPAD-a nije omogućena, pa <ph name="PRODUCT_NAME" /> dulje čeka WPAD poslužitelje temeljene na DNS-u. Ako se pravilo ne postavi ili ako se omogući, optimizacija WPAD-a omogućena je.

      Neovisno o tome hoće li se to pravilo postaviti i na koji način, korisnici ne mogu mijenjati postavku optimizacije WPAD-a.</translation>
<translation id="3072045631333522102">Čuvar zaslona koji će se upotrebljavati na zaslonu prijave u prodajnom načinu</translation>
<translation id="3072847235228302527">Postavi Uvjete pružanja usluge za lokalni račun na uređaju</translation>
<translation id="3077183141551274418">Omogućuje ili onemogućuje životne cikluse kartica</translation>
<translation id="3079417254871857650">Određuje radnju koja se treba poduzeti kada je početni direktorij korisnika izrađen pomoću enkripcije eCryptfs.

      Ako to pravilo postavite na "DisallowArc", Android aplikacije bit će onemogućene za korisnika i neće se izvršiti premještanje s enkripcije eCryptfs na ext4. Android aplikacijama neće se spriječiti pokretanje ako početni direktorij već ima enkripciju ext4.

      Ako to pravilo postavite na "Migrate", početni direktoriji s enkripcijom eCryptfs automatski će prijeći na enkripciju ext4 prilikom prijave bez traženja korisnikova pristanka.

      Ako to pravilo postavite na "Wipe", početni direktoriji s enkripcijom eCryptfs izbrisat će se prilikom prijave i umjesto njih izradit će se novi početni direktoriji s enkripcijom ext4. Upozorenje: time će se ukloniti svi lokalni podaci korisnika.

      Ako to pravilo postavite na "MinimalMigrate", početni direktoriji s enkripcijom eCryptfs izbrisat će se prilikom prijave i umjesto njih izradit će se novi početni direktoriji s enkripcijom ext4. No pokušat će se zadržati oznake za prijavu kako se korisnik ne bi morao ponovo prijavljivati. Upozorenje: time će se ukloniti svi lokalni podaci korisnika.

      Ako to pravilo postavite na opciju koja se više ne podržava ("AskUser" ili "AskForEcryptfsArcUsers"), to će se smatrati kao da ste odabrali opciju "Migrate".

      To se pravilo ne primjenjuje na korisnike kioska. Ako se pravilo ne postavi, uređaj će se ponašati kao da je odabrana opcija "DisallowArc".</translation>
<translation id="3086995894968271156">Konfiguriranje pravila Cast prijemnika u proizvodu <ph name="PRODUCT_NAME" />.</translation>
<translation id="3088796212846734853">Omogućuje vam postavljanje popisa uzoraka URL-ova koji navode web-lokacije kojima je dopušteno prikazivati slike.

          Ako se to pravilo ne postavi, za sve web-lokacije upotrebljavat će se globalna zadana vrijednost iz pravila "DefaultImagesSetting" ako je postavljeno, odnosno osobne konfiguracije korisnika ako nije.

          Napominjemo da je ovo pravilo prije bilo pogreškom omogućeno na Androidu, iako ta funkcija na Androidu nikad nije bila potpuno podržana.</translation>
<translation id="3091832372132789233">Puni bateriju za uređaje koji su prvenstveno spojeni na vanjski izvor napajanja.</translation>
<translation id="3096595567015595053">Popis omogućenih dodataka</translation>
<translation id="3101501961102569744">Odaberi način određivanja postavki proxy poslužitelja</translation>
<translation id="3101709781009526431">Datum i vrijeme</translation>
<translation id="3114411414586006215">To pravilo određuje popis web-lokacija koje nikad neće uzrokovati promjenu preglednika.

      Tom se popisu elementi mogu dodati i pomoću pravila <ph name="EXTERNAL_SITELIST_URL_POLICY_NAME" />.

      Ako se pravilo ne postavi, web-lokacije neće se dodavati na popis.

      Ako se pravilo postavi, svaka se stavka tretira kao pravilo. To je slično pravilu <ph name="URL_LIST_POLICY_NAME" />, samo što je logika je obrnuta: podudarna pravila neće otvoriti zamjenski preglednik.

      Za razliku od pravila <ph name="URL_LIST_POLICY_NAME" />, pravila se primjenjuju u oba smjera. To znači da kada je prisutan i omogućen dodatak Internet Explorera, ono također određuje treba li <ph name="IE_PRODUCT_NAME" /> otvoriti te URL-ove u pregledniku <ph name="PRODUCT_NAME" />.</translation>
<translation id="3117676313396757089">Upozorenje: DHE potpuno će se ukloniti iz preglednika <ph name="PRODUCT_NAME" /> nakon verzije 57 (oko ožujka 2017.) i ovo će pravilo tada prestati funkcionirati.

      Ako se to pravilo ne postavi ili se postavi na "False", DHE paketi šifri u TLS-u neće biti omogućeni. U protivnom se može postaviti na "True" radi omogućivanja DHE paketa šifri i održanja kompatibilnosti sa zastarjelim poslužiteljem. To je privremena mjera i poslužitelj se treba ponovo konfigurirati.

      Potiče se premještanje poslužitelja na ECDHE pakete šifri. Ako oni nisu dostupni, pomoću RSA razmjene ključeva provjerite je li omogućen paket šifri.</translation>
<translation id="3117706142826400449">Ako se pravilo onemogući, Chromeov alat za čišćenje neće pretraživati sustav radi pronalaženja i uklanjanja neželjenog softvera. Onemogućeno je i ručno pokretanje Chromeovog alata za čišćenje putem stranice chrome://settings/cleanup.

      Ako se pravilo omogući ili se ne postavi, Chromeov alat za čišćenje povremeno će tražiti neželjeni softver u sustavu i ako ga pronađe, korisniku će postaviti upit za uklanjanje. Omogućeno je i ručno aktiviranje Chromeovog alata za čišćenje putem stranice chrome://settings.

      Pravilo je dostupno samo na instancama Windowsa koje su pridružene domeni <ph name="MS_AD_NAME" /> ili instancama Windowsa 10 Pro ili Enterprise prijavljenim za upravljanje uređajima.</translation>
<translation id="3152425128389603870">Omogući i uključi Jedinstvenu radnu površinu prema zadanim postavkama</translation>
<translation id="3159375329008977062">Korisniku omogućuje izvoz/uvoz spremnika za Crostini putem korisničkog sučelja</translation>
<translation id="3165808775394012744">Ta su pravila uključena ovdje radi jednostavnijeg uklanjanja.</translation>
<translation id="316778957754360075">To se pravilo ne upotrebljava od verzije 29 sustava <ph name="PRODUCT_NAME" />. Preporučuje se da se pri postavljanju zbirki proširenja ili aplikacija koje hostira određena organizacija web-lokacija koja hostira CRX pakete uključi u pravilo ExtensionInstallSources te da se u pakete na web-stanici postave izravne veze za preuzimanje. Pokretač za tu web-stranicu može se izraditi pomoću pravila ExtensionInstallForcelist.</translation>
<translation id="3168968618972302728">Pravila povezana s autentifikacijom koju pruža Kerberos.</translation>
<translation id="3171369832001535378">Predložak mrežnog naziva hosta uređaja</translation>
<translation id="3172512016079904926">Omogućuje instalaciju hostova za lokalno slanje poruka na razini korisnika.

          Ako se ta postavka omogući, <ph name="PRODUCT_NAME" /> dopušta upotrebu hostova za lokalno slanje poruka instaliranih na korisničkoj razini.

          Ako se ta postavka onemogući, <ph name="PRODUCT_NAME" /> upotrebljavat će samo hostove za lokalno slanje poruka instalirane na razini sustava.

          Ako se ta postavka ne postavi, <ph name="PRODUCT_NAME" /> dopustit će upotrebu hostova za lokalno slanje poruka na razini korisnika.</translation>
<translation id="3177802893484440532">Zahtijevaj online OCSP/CRL provjere za lokalne pouzdane ustanove</translation>
<translation id="3185009703220253572">od verzije <ph name="SINCE_VERSION" /></translation>
<translation id="3187220842205194486">Android aplikacije ne mogu dobiti pristup korporacijskim ključevima. To pravilo nema utjecaja na njih.</translation>
<translation id="3205825995289802549">Maksimiziraj prvi prozor preglednika pri prvom pokretanju</translation>
<translation id="3211426942294667684">Postavke prijave putem preglednika</translation>
<translation id="3214164532079860003">Ako je omogućeno, ovo pravilo prisilno uvozi početnu stranicu iz trenutačno zadanog preglednika. Ako je onemogućeno, početna se stranica ne uvozi. Ako nije postavljeno, korisniku može biti postavljen upit želi li uvesti stranicu ili do uvoza može doći automatski.</translation>
<translation id="3219421230122020860">Dostupan je anoniman način rada</translation>
<translation id="3220624000494482595">Ako je kiosk aplikacija Android aplikacija, neće imati kontrolu nad <ph name="PRODUCT_OS_NAME" /> verzijom, čak i ako se to pravilo postavi na <ph name="TRUE" />.</translation>
<translation id="3236046242843493070">Obrasci URL-ova za dopuštanje instalacija proširenja, aplikacija i korisničkih skripti iz izvora</translation>
<translation id="3240609035816615922">Pravila za pristup konfiguraciji pisača.</translation>
<translation id="3240655340884151271">MAC adresa ugrađenog upravljača mrežnog sučelja priključne stanice</translation>
<translation id="3243309373265599239">Određuje koliko vremena treba proteći bez aktivnosti korisnika da bi se zaslon zatamnio tijekom napajanja izmjeničnom strujom.

          Kada je postavljeno na vrijednost veću od nule, ovo pravilo određuje koliko vremena treba proteći u neaktivnosti prije nego što <ph name="PRODUCT_OS_NAME" /> zatamni zaslon.

          Kada je ovo pravilo postavljeno na nulu, <ph name="PRODUCT_OS_NAME" /> ne zatamnjuje zaslon tijekom neaktivnosti korisnika.

          Kada nije postavljeno, upotrebljava se zadano vrijeme.

          Vrijednost pravila treba navesti u milisekundama. Vrijednosti su ograničene na vrijeme kraće od odgode isključivanja zaslona i odgode neaktivnosti ili jednako tom vremenu (ako je postavljeno).</translation>
<translation id="3251500716404598358">Konfigurira pravila za promjenu preglednika.

      Za otvaranje konfiguriranih web-lokacija automatski će se upotrebljavati neki drugi preglednik, a ne <ph name="PRODUCT_NAME" />.</translation>
<translation id="3264793472749429012">Kodiranja zadanog davatelja usluge pretraživanja</translation>
<translation id="3273221114520206906">Zadana postavka JavaScripta</translation>
<translation id="3284094172359247914">Upravljanje upotrebom API-ja WebUSB</translation>
<translation id="3288595667065905535">Kanal izdanja</translation>
<translation id="3292147213643666827">Omogućuje da se proizvod <ph name="PRODUCT_NAME" /> ponaša kao proxy između pisača iz oblaka <ph name="CLOUD_PRINT_NAME" /> i pisača iz starog sustava povezanih s računalom. Ako je ova postavka onemogućena ili nije konfigurirana, korisnici mogu omogućiti proxy ispisivanja na oblaku autentifikacijom putem svojih Google računa. Ako je ova postavka onemogućena, korisnici ne mogu omogućiti proxy, a računalu neće biti dopušteno dijeljenje pisača s oblakom <ph name="CLOUD_PRINT_NAME" />.</translation>
<translation id="3312206664202507568">Omogućuje stranicu na chrome://password-change na kojoj korisnici SAML-a mogu promijeniti svoje SAML zaporke unutar sesije kako bi SAML zaporka i zaporka zaključanog zaslona na uređaju ostale sinkronizirane.

      To pravilo omogućuje i prikaz obavijesti korisnicima SAML-a u slučaju skorog isteka njihovih SAML zaporki tako da ih mogu odmah promijeniti unutar sesije.
      No te će se obavijesti prikazati samo ako informacije o isteku zaporke uređaju pošalje davatelj identiteta za SAML tijekom postupka SAML prijave.

      Ako je to pravilo postavljeno, korisnik ga neće moći promijeniti ni nadjačati.</translation>
<translation id="3322771899429619102">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju web-lokacije koje smiju upotrebljavati generiranje ključeva. Ako je uzorak URL-ova u pravilu "KeygenBlockedForUrls", to nadjačava ove iznimke.

          Ako se to pravilo ne postavi, globalna zadana vrijednost upotrebljavat će se za sve web-lokacije iz pravila "DefaultKeygenSetting" ako je postavljeno, a u suprotnom iz korisnikove osobne konfiguracije.</translation>
<translation id="332771718998993005">Odredi naziv koji će se oglašavati kao odredište za <ph name="PRODUCT_NAME" />.

          Ako se to pravilo postavi na niz koji nije prazan, taj će se niz upotrebljavati kao naziv odredišta za <ph name="PRODUCT_NAME" />. U suprotnom će naziv odredišta biti naziv uređaja. Ako se to pravilo ne postavi, naziv odredišta bit će naziv uređaja i vlasnik uređaja (ili korisnik s domene koja upravlja uređajem) moći će ga promijeniti. Duljina naziva ograničena je na 24 znaka.</translation>
<translation id="3335468714959531450">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju web-lokacije koje smiju postavljati kolačiće.

         Ako se to pravilo ne postavi, upotrebljavat će se globalna zadana vrijednost za sve web-lokacije iz pravila "DefaultCookiesSetting" ako je postavljeno, odnosno iz osobne konfiguracije korisnika ako nije.

          Pogledajte i pravila "CookiesBlockedForUrls" i "CookiesSessionOnlyForUrls". Napominjemo da između tih triju pravila ne smiju postojati uzorci URL-ova u sukobu jer nije navedeno koje pravilo ima prednost.</translation>
<translation id="3373364525435227558">Postavlja jedan ili više preporučenih jezika za upravljane sesije, tako da korisnici mogu jednostavno odabrati neki od tih jezika.

      Korisnik može odabrati jezik i raspored tipkovnice prije pokretanja upravljane sesije. Svi jezici koje <ph name="PRODUCT_OS_NAME" /> podržava prema zadanim su postavkama poredani abecednim redom. Tim pravilom možete premjestiti skup preporučenih jezika na vrh popisa.

      Ako se to pravilo ne postavi, unaprijed će se odabrati trenutačni jezik korisničkog sučelja.

      Ako se pravilo postavi, preporučeni jezici premjestit će se na vrh popisa i bit će vidljivo odvojeni od ostalih jezika. Preporučeni jezici bit će navedeni redoslijedom kojim se pojavljuju u pravilu. Unaprijed će se odabrati prvi preporučeni jezik.

      Ako postoji više preporučenih jezika, pretpostavlja se da će korisnici htjeti odabrati neki od tih jezika. Odabir jezika i rasporeda tipkovnice bit će jasno istaknut prilikom pokretanja upravljane sesije. U protivnom će se pretpostaviti da većina korisnika želi koristiti unaprijed odabrani jezik. Odabir jezika i rasporeda tipkovnice neće biti tako istaknut prilikom pokretanja upravljane sesije.

      Kada se to pravilo postavi i omogući se automatska prijava (pogledajte pravila |DeviceLocalAccountAutoLoginId| i |DeviceLocalAccountAutoLoginDelay|), automatski pokrenuta upravljana sesija upotrebljavat će prvi preporučeni jezik i najpopularniji raspored tipkovnice koji odgovara tom jeziku.

      Unaprijed odabrani raspored tipkovnice uvijek će biti onaj koji je najpopularniji za unaprijed odabrani jezik.

      To se pravilo može postaviti samo kao preporučeno. Tim pravilom možete premjestiti skup preporučenih jezika na vrh popisa, ali korisnici za svoju sesiju uvijek mogu sami odabrati bilo koji jezik koji <ph name="PRODUCT_OS_NAME" /> podržava.
      </translation>
<translation id="3381968327636295719">Upotrijebi preglednik hosta prema zadanim postavkama</translation>
<translation id="3384115339826100753">Omogućite pravilo o upravljanju prebacivanjem napajanja radi uštede energije.

          Prebacivanje radi uštede energije pravilo je za uštedu energije kojim se minimizira upotreba izmjenične struje u razdobljima najveće potrošnje tijekom dana. Za svaki dan u tjednu može se postaviti vrijeme početka i završetka pokretanja načina prebacivanja napajanja radi uštede energije. U tom će se razdoblju sustav napajati putem baterije, čak i ako je priključen u izmjeničnu struju dok god je baterija iznad određenog praga. Nakon isteka vremena završetka sustav će se napajati iz utičnice ako je priključen u nju, no neće puniti bateriju. Nakon što nastupi vrijeme početka punjenja sustav će ponovo uobičajeno raditi na napajanju iz utičnice i ponovo će puniti bateriju.

          Ako se to pravilo postavi na true, a postavljeni su DevicePowerPeakShiftBatteryThreshold, DevicePowerPeakShiftDayConfig, prebacivanje napajanja radi uštede energije uvijek će biti omogućeno ako uređaj to podržava.

          Ako se pravilo postavi na false, prebacivanje napajanja radi uštede energije uvijek će biti onemogućeno.

          Ako postavite to pravilo, korisnici ga neće moći promijeniti ili nadjačati.

          Ako se to pravilo ne postavi, prebacivanje napajanja radi uštede energije bit će onemogućeno i korisnik ga neće moći omogućiti.</translation>
<translation id="3414260318408232239">Ako se to pravilo ne konfigurira, <ph name="PRODUCT_NAME" /> upotrebljava zadanu minimalnu verziju, a to je TLS 1.0.

      U suprotnom se može postaviti na jednu od sljedećih vrijednosti: "tls1", "tls1.1" ili "tls1.2". Kad se to pravilo postavi, <ph name="PRODUCT_NAME" /> neće upotrebljavati verzije SSL-a/TLS-a manje od navedene verzije. Vrijednost koja se ne prepozna ignorirat će se.</translation>
<translation id="34160070798637152">Upravlja mrežnom konfiguracijom na razini uređaja.</translation>
<translation id="3417418267404583991">Ako je to pravilo postavljeno na "istinito" ili ako nije konfigurirano, sustav <ph name="PRODUCT_OS_NAME" /> omogućit će prijave gostiju. Prijave gostiju predstavljaju sesije anonimnih korisnika i zaporka nije potrebna.

      Ako je to pravilo postavljeno na "lažno", sustav <ph name="PRODUCT_OS_NAME" /> neće dopustiti pokretanje gostujućih sesija.</translation>
<translation id="3418871497193485241">Primjenjuje minimalni Ograničeni način rada na YouTubeu i sprječava korisnike
      da odaberu način rada s manje ograničenja.

      Ako se ova postavka postavi na Strogo, strogi Ograničeni način rada na YouTubeu bit će uvijek aktivan.

      Ako se postavi na Umjereno, korisnik će samo moći odabrati umjereni
      ili strogi Ograničeni način rada na YouTubeu, ali neće moći onemogućiti
      Ograničeni način rada.

      Ako se ta postavka isključi ili se ne postavi neka vrijednost, <ph name="PRODUCT_NAME" /> neće primjenjivati Ograničeni način rada na YouTubeu. No vanjska pravila, primjerice YouTubeova pravila, i dalje mogu nametati Ograničeni način rada.</translation>
<translation id="3428247105888806363">Omogućavanje predviđanja mreže</translation>
<translation id="3432863169147125747">Upravlja postavkama ispisa.</translation>
<translation id="3434932177006334880">Ta se postavka zvala EnableWebBasedSignin prije Chromea 42 i više se uopće neće podržavati u Chromeu 43.

      Postavka je korisna za poslovne korisnike koji upotrebljavaju SSO rješenja koja još nisu kompatibilna s novim, ugrađenim tijekom prijave.
      Ako omogućite tu postavku, upotrebljavat će se stari tijek prijave putem weba.
      Ako onemogućite tu postavku ili je ne postavite, prema zadanoj postavci upotrebljavat će se novi, ugrađeni tijek prijave. Korisnici i dalje mogu omogućiti stari tijek prijave putem weba pomoću oznake naredbenog retka --enable-web-based-signin.

      Ta će se eksperimentalna postavka ukloniti kada ugrađena prijava bude u potpunosti podržavala sve SSO tijekove prijave.</translation>
<translation id="3437924696598384725">Dopusti korisniku da upravlja VPN vezama</translation>
<translation id="3459509316159669723">Ispis</translation>
<translation id="3460784402832014830">Određuje URL koji tražilica upotrebljava kako bi pružila web-stranicu nove kartice.

          To pravilo nije obavezno. Ako nije postavljeno, neće se pružati web-stranica nove kartice.

          To se pravilo poštuje samo ako je omogućeno pravilo "DefaultSearchProviderEnabled".</translation>
<translation id="3461279434465463233">Izvješćivanje o statusu napajanja</translation>
<translation id="346731943813722404">Pravilo određuje trebaju li odgode upravljanja potrošnjom energije i ograničenje duljine sesije početi teći tek nakon što se uoči prva aktivnost korisnika u sesiji.

          Ako se to pravilo postavi na istinito, odgode upravljanja potrošnjom energije i ograničenje duljine sesije neće početi teći dok se ne uoči prva aktivnost korisnika u sesiji.

          Ako se to pravilo postavi na neistinito ili se ne postavi, odgode upravljanja potrošnjom energije i ograničenje duljine sesije počinju teći odmah po početku sesije.</translation>
<translation id="3478024346823118645">Izbriši korisničke podatke nakon odjave</translation>
<translation id="3480961938508521469">Potpuno napuni bateriju standardnom brzinom.</translation>
<translation id="348495353354674884">Omogućavanje virtualne tipkovnice</translation>
<translation id="3487623755010328395">
        Ako se to pravilo postavi, usluga <ph name="PRODUCT_NAME" /> pokušat će se registrirati i primijeniti povezana pravila za oblak za sve profile.

        Vrijednost tog pravila token je za registraciju koji se može dobiti na konzoli Google Admina.</translation>
<translation id="3489247539215560634">Ako se ta postavka omogući, <ph name="PRODUCT_NAME" /> može zapamtiti zaporke korisnika i automatski ih unijeti prilikom sljedeće prijave na web-lokaciju.

          Ako se ta postavka onemogući, korisnici ne mogu spremati nove zaporke,
          no mogu upotrebljavati zaporke koje su ranije spremljene.

          Ako omogućite ili onemogućite tu postavku, korisnici neće moći promijeniti niti nadjačati tu postavku u pregledniku <ph name="PRODUCT_NAME" />. Ako se pravilo ne postavi, dopušteno je spremanje zaporki (ali ga korisnik može isključiti).</translation>
<translation id="3496296378755072552">Upravitelj zaporki</translation>
<translation id="3500732098526756068">Omogućuje vam da odredite okidač na temelju kojeg će zaštita zaporke prikazati upozorenje. Zaštita zaporke to upozorenje prikazuje korisnicima kada ponovo upotrijebe svoju zaštićenu zaporku na potencijalno sumnjivim web-lokacijama.

      Zaporke koje se trebaju zaštititi možete konfigurirati pomoću pravila "PasswordProtectionLoginURLs" i "PasswordProtectionChangePasswordURL".

      Ako se pravilo postavi na "PasswordProtectionWarningOff", upozorenje zaštite zaporke neće se prikazati.
      Ako se pravilo postavi na "PasswordProtectionWarningOnPasswordReuse", upozorenje zaštite zaporke prikazat će se kada korisnik ponovo upotrijebi svoju zaštićenu zaporku na web-lokaciji koja nije dopuštena.
      Ako se ptavilo postavi na "PasswordProtectionWarningOnPhishingReuse", upozorenje zaštite zaporke prikazat će se kada korisnik ponovo upotrijebi svoju zaštićenu zaporku na web-lokaciji za krađu identiteta.
      Ako se pravilo ne postavi, usluga zaštite zaporke štitit će samo zaporke za Google, no korisnik će moći promijeniti tu postavku.</translation>
<translation id="3502555714327823858">Dopusti sve dvostrane načine</translation>
<translation id="350443680860256679">Konfiguriraj ARC</translation>
<translation id="3504791027627803580">Određuje URL tražilice koja se upotrebljava za pretraživanje slika. Zahtjevi za pretraživanje slat će se pomoću GET metode. Ako je postavljeno pravilo "DefaultSearchProviderImageURLPostParams", zahtjevi za pretraživanje slika umjesto toga upotrebljavat će POST metodu.

          To je pravilo izborno. Ako nije postavljeno, neće se upotrijebiti nijedna slika.

          To se pravilo poštuje samo ako je omogućeno pravilo "DefaultSearchProviderEnabled".</translation>
<translation id="350797926066071931">Omogući Prevoditelj</translation>
<translation id="3513655665999652754">Quirks Server pruža konfiguracijske datoteke za hardver, primjerice
      profile ICC zaslona za kalibriranje monitora.

      Kad se to pravilo postavi na false, uređaj neće pokušavati
      kontaktirati Quirks Server radi preuzimanja konfiguracijskih datoteka.

      Ako se pravilo postavi na true ili se ne konfigurira, <ph name="PRODUCT_OS_NAME" /> automatski će kontaktirati Quirks Server i preuzeti konfiguracijske datoteke ako su dostupne i pohraniti ih na uređaj.  Pomoću tih se datoteka, na primjer, može poboljšati kvaliteta prikaza priključenih monitora.</translation>
<translation id="3524204464536655762">Ne dopuštaj nijednoj web-lokaciji da traži pristup USB uređajima putem API-ja WebUSB</translation>
<translation id="3526752951628474302">Samo jednobojni ispis</translation>
<translation id="3528000905991875314">Omogući alternativne stranice pogrešaka</translation>
<translation id="3545457887306538845">Omogućuje vam da kontrolirate gdje se mogu upotrebljavati Alati za razvojne programere.

      Ako se to pravilo postavi na DeveloperToolsDisallowedForForceInstalledExtensions" (vrijednost 0, što je zadano za poslovne korisnike), Alatima za razvojne programere i konzoli JavaScript može se pristupiti općenito, ali im se ne može pristupiti u kontekstu proširenja instaliranih prema pravilima organizacije.
      Ako se to pravilo postavi na "DeveloperToolsAllowed" (vrijednost 1, Alatima za razvojne programere i konzoli JavaScript može se pristupiti i može ih se upotrebljavati u svim kontekstima, uključujući kontekst proširenja instaliranih prema pravilima organizacije.
      Ako se to pravilo postavi na "DeveloperToolsDisallowed" (vrijednost 2), Alatima za razvojne programere neće se moći pristupiti, a elementi web-lokacije više se neće moći pregledavati. Onemogućit će se svi tipkovni prečaci i svi unosi izbornika ili kontekstnih izbornika za otvaranje Alata za razvojne programere ili konzole JavaScript:</translation>
<translation id="3547954654003013442">Proxy postavke</translation>
<translation id="3550875587920006460">Omogućuje postavljanje prilagođenog rasporeda za traženje ažuriranja. Primjenjuje se na sve korisnike i sva sučelja na uređaju. Kada se postavi, uređaj će provjeravati ima li ažuriranja prema tom rasporedu. Pravilo se mora ukloniti da bi se otkazala daljnja primjena rasporeda za traženje ažuriranja.</translation>
<translation id="355118380775352753">Web-lokacije koje se trebaju otvoriti u zamjenskom pregledniku</translation>
<translation id="3554984410014457319">Dopustite Google asistentu da osluškuje izraze za glasovnu aktivaciju.</translation>
<translation id="3557208865710006939">Prisilno omogućuje jezike provjere pravopisa. Jezici na popisu koji nisu prepoznati zanemarit će se.

      Ako omogućite to pravilo, provjera pravopisa bit će omogućena za navedene jezike, kao i za one jezike za koje korisnik omogući provjeru pravopisa.

      Ako to pravilo ne postavite ili ga onemogućite, korisnikove postavke provjere pravopisa neće se promijeniti.

      Ako se pravilo <ph name="SPELLCHECK_ENABLED_POLICY_NAME" /> postavi na false, neće se primjenjivati.

      Ako je jezik naveden i u ovom pravilu i u pravilu <ph name="SPELLCHECK_LANGUAGE_BLACKLIST_POLICY_NAME" />, prioritet će imati ovo pravilo i jezik za provjeru pravopisa bit će omogućen.

      Trenutačno su podržani sljedeći jezici: 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">Korisnici mogu konfigurirati kanal izdanja OS-a Chrome</translation>
<translation id="3575011234198230041">HTTP autentifikacija</translation>
<translation id="3577251398714997599">Postavke oglasa za web-lokacije s ometajućim oglasima</translation>
<translation id="357917253161699596">Omogući korisnicima upravljanje korisničkim certifikatima</translation>
<translation id="3583230441447348508">Navodi popis unaprijed konfiguriranih mrežnih dijeljenja datoteka.

      Svaka stavka na popisu pravila objekt je s dva člana: "share_url" i "mode". "share_url" treba biti URL dijeljenja, a "mode" treba biti "drop_down" ili "pre_mount". "drop_down" naznačuje da će se "share_url" dodati na padajući izbornik otkrivenih dijeljenja. "pre_mount" naznačuje da će se "share_url" učitati.</translation>
<translation id="3591527072193107424">Omogući značajku Podrška za stare preglednike.</translation>
<translation id="3591584750136265240">Konfiguriraj ponašanje autentifikacije tijekom prijave</translation>
<translation id="3627678165642179114">Omogući ili onemogući web-uslugu provjere pravopisa</translation>
<translation id="3628480121685794414">Omogući jednostrani ispis</translation>
<translation id="3631099945620529777">Ako se postavi na false, onemogućuje se gumb "Završi proces" u Upravitelju zadataka.

      Ako se postavi na true ili se ne konfigurira, korisnici mogu završavati postupke u Upravitelju zadataka.</translation>
<translation id="3643284063603988867">Omogući značajku "Zapamti zaporku"</translation>
<translation id="3646859102161347133">Postavljanje vrste povećala</translation>
<translation id="3653237928288822292">Ikona zadanog davatelja usluga pretraživanja</translation>
<translation id="3660510274595679517">
        Ako se to pravilo postavi na True, prijava za upravljanje u oblaku obavezna je i blokira postupak pokretanja Chromea ako ne uspije.

        Ako se pravilo ne postavi ili se postavi na False, prijava za upravljanje u oblaku nije obavezna i ne blokira postupak pokretanja Chromea ako ne uspije.

        To pravilo upotrebljava prijava za pravilo u oblaku strojnog opsega na radnoj površini i može ga postaviti Registry ili GPO u sustavu Windows, plist na Macu i JSON datoteka pravila na Linuxu.</translation>
<translation id="3660562134618097814">Prenesi kolačiće SAML IdP-a tijekom prijave</translation>
<translation id="3701121231485832347">Upravlja postavkama specifičnima za uređaje <ph name="PRODUCT_OS_NAME" /> kojima upravlja <ph name="MS_AD_NAME" />.</translation>
<translation id="3702518095257671450">Daljinsko atestiranje</translation>
<translation id="3702647575225525306"><ph name="POLICY_NAME" /> (Polje s jednim retkom obustavljeno je i uklonit će se. Počnite upotrebljavati tekstni okvir s više redaka u nastavku.)</translation>
<translation id="3709266154059827597">Konfiguriraj crnu listu instalacije proširenja</translation>
<translation id="3711895659073496551">Obustavi</translation>
<translation id="3715569262675717862">Autentifikacija na temelju korisničkih certifikata</translation>
<translation id="3736879847913515635">Omogućivanje dodavanja osobe u upravitelju korisnika</translation>
<translation id="3738723882663496016">U ovom se pravilu navodi licencni ključ <ph name="PLUGIN_VM_NAME" /> za ovaj uređaj.</translation>
<translation id="3748900290998155147">Određuje jesu li dopuštena zaključavanja aktivacije. Ta zaključavanja mogu tražiti proširenja putem API-ja proširenja za upravljanje napajanjem i ARC aplikacije.

          Ako se pravilo postavi na True ili se ne postavi, zaključavanja aktivacije primjenjivat će se za upravljanje napajanjem.

          Ako se pravilo postavi na False, zahtjevi za zaključavanje aktivacije zanemarivat će se.</translation>
<translation id="3750220015372671395">Blokiraj generiranje ključeva na ovim web-lokacijama</translation>
<translation id="375266612405883748">Ograničava raspon UDP priključaka koji upotrebljava host za daljinski pristup na ovom računalu.

          Ako se to pravilo ne postavi ili se postavi na prazan niz, host za daljinski pristup moći će upotrebljavati bilo koji dostupni priključak, osim ako se onemogući pravilo <ph name="REMOTE_ACCESS_HOST_FIREWALL_TRAVERSAL_POLICY_NAME" />, a u tom će slučaju host za daljinski pristup upotrebljavati UDP priključke u rasponu od 12400 do 12409.</translation>
<translation id="3756011779061588474">Blokiraj način rada razvojnog programera</translation>
<translation id="3758089716224084329">Omogućuje vam da odredite proxy poslužitelj kojim se koristi <ph name="PRODUCT_NAME" /> i onemogućuje korisnicima da mijenjaju postavke proxyja.

      Ako odaberete da se proxy poslužitelj nikad ne upotrebljava i da se veza uvijek uspostavlja izravno, sve se ostale opcije zanemaruju.

      Ako odaberete automatsko otkrivanje proxy poslužitelja, sve se ostale opcije zanemaruju.

      Detaljne primjere možete pronaći ovdje:
      <ph name="PROXY_HELP_URL" />.

      Ako omogućite tu postavku, <ph name="PRODUCT_NAME" /> i ARC aplikacije zanemarivat će sve opcije koje se odnose na proxy poslužitelj navedene u naredbenom retku.

      Ako se ta pravila ne postave, korisnici će moći sami odabrati postavke proxyja.</translation>
<translation id="3758249152301468420">Onemogući Razvojne alate</translation>
<translation id="3764248359515129699">Onemogućuje provedbu zahtjeva Transparentnosti certifikata za popis starih tijela za izdavanje certifikata.

      To pravilo omogućuje da se zahtjevi za otkrivanje Transparentnosti certifikata ne otkrivaju za lance certifikata koji sadrže certifikate s jednim od navedenih hashiranja za subjectPublicKeyInfo. To omogućuje da se certifikati koji se inače ne bi smatrali pouzdanima (jer nisu pravilno javno otkriveni) nastave upotrebljavati za hostove Enterprisea.

      Da bi se provedba Transparentnosti certifikata onemogućila kada se to pravilo postavi, mora se generirati hash za subjectPublicKeyInfo koji se pojavljuje u CA certifikatu koji se prepoznaje kao staro tijelo za izdavanje certifikata (CA). Stari CA jest CA koji jedan ili više operativnih sustava koje podržava <ph name="PRODUCT_NAME" /> smatraju pouzdanim prema zadanim postavkama, ali ga pouzdanim ne smatraju Projekt otvorenog izvornog koda za Android ili <ph name="PRODUCT_OS_NAME" />.

      Hash generiran za subjectPublicKeyInfo navodi se ulančavanjem naziva algoritma hashiranja, znaka "/" i Base64 kodiranja tog algoritma hashiranja primijenjenog na subjectPublicKeyInfo navedenog certifikata kodiranog DER-om. To Base64 kodiranje isti je format kao SPKI Fingerprint, kao što je definirano u RFC-u 7469, u odjeljku 2.4. Algoritmi hashiranja koji se ne prepoznaju ignoriraju se. Jedini podržani algoritam hashiranja trenutačno je "sha256".

      Ako se to pravilo ne postavi, sa svim certifikatima koji se moraju otkriti putem Transparentnosti certifikata postupat će se kao da nisu pouzdani ako se ne otkriju u skladu s pravilom Transparentnosti certifikata.</translation>
<translation id="3765260570442823273">Trajanje poruke upozorenja za odjavu u stanju mirovanja</translation>
<translation id="377044054160169374">Provedi intervenciju za zlonamjerni sadržaj</translation>
<translation id="3780152581321609624">Uključi nestandardni port u Kerberos SPN-u</translation>
<translation id="3780319008680229708">Ako se to pravilo postavi na "istinito", ikona Casta na alatnoj traci uvijek će se prikazivati na alatnoj traci ili u dodatnom izborniku te je korisnici neće moći ukloniti.

          Ako se pravilo postavi na "neistinito" ili se ne postavi, korisnici će moći prikvačiti ili ukloniti ikonu putem njezinog kontekstnog izbornika.

          Ako se pravilo "EnableMediaRouter" postavi na "neistinito", tada vrijednost tog pravila nema učinka i ikona na alatnoj traci neće se prikazivati.</translation>
<translation id="3788662722837364290">Postavke upravljanja napajanjem kada korisnik postane neaktivan</translation>
<translation id="3790085888761753785">Ako se ta postavka omogući, korisnici će se moći prijavljivati na svoj račun pomoću Smart Locka. To je manje strogo od uobičajenog ponašanja Smart Locka koje korisnicima omogućuje samo da otključaju zaslon.

      Ako se pravilo onemogući, korisnicima neće biti dopuštena upotreba prijave uz Smart Lock.

      Ako se ne postavi, ovo će pravilo prema zadanim postavkama biti onemogućeno za upravljane korisnike u poduzećima, a za neupravljane korisnike bit će omogućeno.</translation>
<translation id="379602782757302612">Omogućuje da odredite koja proširenja korisnici NE mogu instalirati. Prethodno instalirana proširenja koja stavite na popis zabranjenih bit će onemogućena i korisnici ih neće moći omogućiti. Kad se proširenje koje je onemogućeno zbog toga što se nalazi na popisu zabranjenih ukloni s tog popisa, automatski će biti ponovo omogućeno.

          Vrijednost "*" na popisu zabranjenih znači da nije dopušteno nijedno proširenje osim onih koja su izričito navedena na popisu dopuštenih.

          Ako to pravilo nije postavljeno, korisnik može instalirati bilo koje proširenje u <ph name="PRODUCT_NAME" />.</translation>
<translation id="3800626789999016379">Konfigurira direktorij koji će <ph name="PRODUCT_NAME" /> upotrebljavati za preuzimanje datoteka.

      Ako postavite to pravilo, preglednik <ph name="PRODUCT_NAME" /> upotrebljavat će navedeni direktorij bez obzira je li ga je korisnik naveo ili je označio okvir da se mjesto preuzimanja treba svaki put ponovo navesti.

      Popis varijabli koje se mogu upotrijebiti potražite na http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Ako se to pravilo ne postavi, upotrebljavat će se zadani direktorij za preuzimanja i korisnik će ga moći promijeniti.</translation>
<translation id="3805659594028420438">Omogući proširenje TLS certifikata vezanih uz domenu (zastarjelo)</translation>
<translation id="3808945828600697669">Odredi popis onemogućenih dodataka</translation>
<translation id="3811562426301733860">Dopusti oglase na svim web-lokacijama</translation>
<translation id="3816312845600780067">Omogući tipkovni prečac za izbjegavanje automatske prijave</translation>
<translation id="3820526221169548563">Omogućite značajku pristupačnosti tipkovnice na zaslonu.

          Ako je ovo pravilo postavljeno na istinito, tipkovnica na zaslonu uvijek će biti omogućena.

          Ako je ovo pravilo postavljeno na neistinito, tipkovnica na zaslonu uvijek će biti onemogućena.

          Ako postavite ovo pravilo, korisnici ga ne mogu promijeniti niti nadjačati.

          Ako ne postavite ovo pravilo, tipkovnica na zaslonu u početku je onemogućena, ali je korisnici mogu omogućiti u bilo kojem trenutku.</translation>
<translation id="382476126209906314">Konfiguriraj prefiks TalkGadget za hostove daljinskog pristupa</translation>
<translation id="3824972131618513497">Upravlja postavkama povezanima s upravljanjem napajanjem i ponovnim pokretanjem.</translation>
<translation id="3826475866868158882">Omogućene su Googleove usluge lokacije</translation>
<translation id="3831054243924627613">To pravilo određuje početno stanje sigurnosnog kopiranja i vraćanja podataka Androida.

      Ako se pravilo ne konfigurira ili se postavi na <ph name="BR_DISABLED" />, sigurnosno kopiranje i vraćanje podataka Androida izvorno je onemogućeno.

      Ako se pravilo postavi na <ph name="BR_ENABLED" />, sigurnosno kopiranje i vraćanje podataka Androida izvorno je omogućeno.

      Ako se pravilo postavi na <ph name="BR_UNDER_USER_CONTROL" />, korisnik treba odabrati hoće li upotrebljavati sigurnosno kopiranje i vraćanje podataka Androida. Ako korisnik omogući sigurnosno kopiranje i vraćanje, podaci Android aplikacija prenose se na Androidove poslužitelje za sigurnosne kopije i vraćaju s njih nakon ponovnog instaliranja kompatibilnih aplikacija.

      Napominjemo da to pravilo određuje stanje sigurnosnog kopiranja i vraćanja podataka Androida samo tijekom početnog postavljanja. Korisnik može kasnije u postavkama Androida uključiti ili isključiti sigurnosno kopiranje i vraćanje podataka Androida.</translation>
<translation id="3831376478177535007">Kada se ta postavka omogući, <ph name="PRODUCT_NAME" /> dopušta da se certifikati izdani u okviru Legacy PKI operacija tvrtke Symantec Corporation smatraju pouzdanima ako se inače mogu uspješno potvrditi i ulančavati s priznatim CA certifikatom.

      Napominjemo da ovo pravilo ovisi o tome hoće li operativni sustav još prepoznati certifikate Symantecove stare infrastrukture. Ako ažuriranje OS-a promijeni način na koji operativni sustav rukuje takvim certifikatima, to pravilo više neće imati utjecaja. Osim toga, to je pravilo predviđeno kao privremeno zaobilazno rješenje koje organizacijama omogućuje više vremena za prijelaz sa starih Symantecovih certifikata. To će se pravilo ukloniti u razdoblju oko 1. siječnja 2019.

      Ako se to pravilo ne postavi ili se postavi na netočno, <ph name="PRODUCT_NAME" /> pridržava se javno objavljenog rasporeda obustavljanja.

      Više pojedinosti o obustavljanju dostupno je na https://g.co/chrome/symantecpkicerts.</translation>
<translation id="383466854578875212">Omogućuje vam da odredite koji hostovi za lokalno slanje poruka neće biti podložni zabrani.

          Vrijednost "*" na popisu nedopuštenih znači da su svi hostovi za lokalno slanje poruka zabranjeni i da će se učitati samo hostovi za lokalno slanje poruka koji su navedeni na popisu dopuštenih.

          Prema zadanim postavkama svi su hostovi za lokalno slanje poruka dopušteni, ali ako su svi hostovi za lokalno slanje poruka prema pravilima zabranjeni, popis dopuštenih može se upotrijebiti za nadjačavanje tog pravila.</translation>
<translation id="3835692988507803626">Prisilno onemogući jezike provjere pravopisa</translation>
<translation id="3837424079837455272">To pravilo kontrolira mogu li se dodati novi korisnici u <ph name="PRODUCT_OS_NAME" />. Ne sprječava korisnike da se prijave na dodatne Google račune unutar Androida. Ako to želite spriječiti, konfigurirajte pravilo <ph name="ACCOUNT_TYPES_WITH_MANAGEMENT_DISABLED_CLOUDDPC_POLICY_NAME" /> za Android kao dio pravila <ph name="ARC_POLICY_POLICY_NAME" />.</translation>
<translation id="384743459174066962">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju web-lokacije koje ne smiju otvarati skočne prozore. Ako ovo pravilo nije postavljeno, upotrebljavat će se globalna zadana vrijednost za sve web-lokacije iz pravila "DefaultPopupsSetting" ako je postavljeno, odnosno iz osobne konfiguracije korisnika ako nije.</translation>
<translation id="3851039766298741586">Prijavljuje informacije o aktivnoj sesiji kioska, primjerice
      ID i verziju aplikacije.

      Ako se pravilo postavi na "false", informacije sesije kioska neće se
      prijavljivati. Ako se postavi na "true" ili se ne postavi, prijavljivat će se
      informacije sesije kioska.</translation>
<translation id="3858658082795336534">Dvostrani način zadanog ispisa</translation>
<translation id="3859780406608282662">Dodaje parametar dohvaćanju početne vrijednosti Varijacija u proizvodu <ph name="PRODUCT_OS_NAME" />.

      Ako je navedeno, dodat će parametar upita zvan "restrict" URL-u koji se upotrebljava za dohvaćanje početne vrijednosti Varijacije. Vrijednost parametra bit će vrijednost navedena u tom pravilu.

      Ako nije navedeno, neće mijenjati URL početne vrijednosti Varijacija.</translation>
<translation id="3863409707075047163">Minimalna omogućena verzija SSL-a</translation>
<translation id="3864020628639910082">Određuje URL tražilice koja se upotrebljava za davanje prijedloga pretraživanja. URL treba sadržavati niz "<ph name="SEARCH_TERM_MARKER" />" koji će se u trenutku upita zamijeniti tekstom koji je korisnik dotad unio.

          To pravilo nije obavezno. Ako se ne postavi, URL-ovi prijedloga neće se upotrebljavati.

          Googleov URL prijedloga može se navesti kao: <ph name="GOOGLE_SUGGEST_SEARCH_URL" />.

          To će se pravilo poštovati samo ako je omogućeno pravilo "DefaultSearchProviderEnabled".</translation>
<translation id="3864129983143201415">Konfiguriraj dopuštene jezike u korisničkoj sesiji</translation>
<translation id="3866249974567520381">Opis</translation>
<translation id="3868347814555911633">To je pravilo aktivno samo u prodajnom načinu.

      Navodi proširenja koja se automatski instaliraju za korisnike demo verzije, za uređaje u prodajnom načinu. Ta se proširenja spremaju na uređaj i mogu se instalirati izvanmrežno, nakon instalacije.

      Svaki unos popisa sadrži rječnik koji mora uključivati ID proširenja u polju "extension-id" i njegov URL za ažuriranje u polju "update-url".</translation>
<translation id="3874773863217952418">Omogući značajku Dodirnite za pretraživanje</translation>
<translation id="3877517141460819966">Integrirani način dvostruke autentifikacije</translation>
<translation id="3879208481373875102">Konfiguriranje popisa prisilno instaliranih web-aplikacija</translation>
<translation id="388237772682176890">To je pravilo obustavljeno u verziji M53 i uklonjeno u verziji M54 jer je uklonjena podrška za SPDY/3.1.

      Onemogućuje upotrebu protokola SPDY za uslugu <ph name="PRODUCT_NAME" />.

      Ako je to pravilo omogućeno, protokol SPDY neće biti dostupan na usluzi <ph name="PRODUCT_NAME" />.

      Onemogućivanjem tog pravila dopustit će se upotreba protokola SPDY.

      Ako se to pravilo ne postavi, SPDY će biti dostupan.</translation>
<translation id="3891357445869647828">Omogući JavaScript</translation>
<translation id="3895557476567727016">Konfigurira zadani direktorij koji će <ph name="PRODUCT_NAME" /> upotrebljavati za preuzimanje datoteka.

      Ako postavite to pravilo, ono će promijeniti zadani direktorij u koji <ph name="PRODUCT_NAME" /> preuzima datoteke. To pravilo nije obavezno, pa će korisnik moći promijeniti direktorij.

      Ako ne postavite to pravilo, <ph name="PRODUCT_NAME" /> upotrebljava svoj uobičajeni zadani direktorij (ovisno o platformi).

      Popis varijabli koje se mogu upotrebljavati potražite na stranici https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.</translation>
<translation id="3911737181201537215">To pravilo nema utjecaja na Androidovo bilježenje u zapisnike.</translation>
<translation id="391531815696899618">Onemogućuje sinkronizaciju Google diska u aplikaciji Datoteke za <ph name="PRODUCT_OS_NAME" /> kada je postavljeno na točno. U tom se slučaju nikakvi podaci ne prenose na Google disk.

          Ako nije postavljeno ili je postavljeno na netočno, korisnici će moći prenositi datoteke na Google disk.</translation>
<translation id="3915395663995367577">URL prema proxy .pac datoteci</translation>
<translation id="3920892052017026701">Postavite prilagođeni početak punjenja baterije u postocima.

          Baterija se počinje puniti kada istekne vrijednost prilagođenog početka punjenja baterije.

          Vrijednost pravila DeviceBatteryChargeCustomStartCharging mora biti manja od one u pravilu DeviceBatteryChargeCustomStopCharging.

          To se pravilo upotrebljava samo ako je pravilo DeviceBatteryChargeMode postavljeno na prilagođeno.

          Ako se pravilo ne konfigurira ili se ne postavi, primjenjivat će se standardni način punjenja baterije.</translation>
<translation id="3925377537407648234">Postavljanje razlučivosti zaslona i faktora skaliranja</translation>
<translation id="3939893074578116847">Slanje mrežnih paketa poslužitelju za upravljanje radi praćenja online statusa kako bi
      poslužitelj mogao otkriti je li uređaj offline.

      Ako se to pravilo postavi na True, slat će se mrežni paketi za praćenje (takozvani <ph name="HEARTBEATS_TERM" />).
      Ako se postavi na False ili se ne postavi, paketi se neće slati.</translation>
<translation id="3950239119790560549">Ograničenja vremena ažuriranja</translation>
<translation id="3956686688560604829">Koristi pravilo SiteList Internet Explorera za Podršku za stare preglednike.</translation>
<translation id="3958586912393694012">Dopusti upotrebu Smart Locka</translation>
<translation id="3963602271515417124">Ako je točno, daljinsko atestiranje dopušteno je za uređaj i certifikat će se automatski generirati i prenijeti na poslužitelj za upravljanje uređajem.

          Ako se postavi na netočno ili se ne postavi, certifikat se neće generirati i pozivi API-ju proširenja enterprise.platformKeys neće uspjeti.</translation>
<translation id="3964262920683972987">Konfiguriraj sliku pozadine na razini uređaja koja se prikazuje na zaslonu za prijavu ako se nijedan korisnik još nije prijavio na uređaj. Pravilo se postavlja tako da se navede URL s kojeg uređaj s OS-om Chrome može preuzeti sliku pozadine i kriptografsko hashiranje kojim se potvrđuje integritet preuzimanja. Slika mora biti u JPEG formatu i ne smije biti veća od 16 MB. URL-u se mora moći pristupiti bez autentifikacije. Slika pozadine preuzima se i sprema u predmemoriju. Ponovo će se preuzeti svaki put kada se URL ili hashiranje promijene.

      Ako se postavi pravilo za pozadinu uređaja, uređaj s OS-om Chrome preuzet će i koristiti sliku pozadine na zaslonu za prijavu ako se nijedan korisnik još nije prijavio na uređaj. Kad se korisnik prijavi, primjenjuje se njegovo pravilo za pozadinu.

      Ako se pravilo o pozadini za uređaj ne postavi, o prikazivanju pozadine odlučuje korisnikovo pravilo o pozadini, ako je postavljeno.</translation>
<translation id="3965339130942650562">Privremeni prekid do izvršavanja odjave korisnika u stanju mirovanja</translation>
<translation id="3973371701361892765">Nikada nemoj automatski sakriti policu</translation>
<translation id="3984028218719007910">Određuje hoće li sustav <ph name="PRODUCT_OS_NAME" /> zadržati lokalne podatke računa nakon odjave. Ako je to pravilo postavljeno na "istinito", sustav <ph name="PRODUCT_OS_NAME" /> ne zadržava trajne račune i svi podaci s korisnikove sesije bit će odbačeni nakon odjave. Ako je to pravilo postavljeno na "lažno" ili ako nije konfigurirano, uređaj će možda zadržavati (kriptirane) lokalne korisničke podatke.</translation>
<translation id="398475542699441679">Pravilo određuje hoće li se omogućiti Podrška za stare preglednike.

      Kad se to pravilo ne postavi ili se postavi na False, Chrome neće pokušati pokrenuti označene URL-ove u alternativnom pregledniku.

      Kad se to pravilo postavi na True, Chrome će pokušati pokrenuti neke URL-ove u alternativnom pregledniku (na primjer Internet Exploreru). Značajka se konfigurira pomoću pravila u grupi <ph name="LEGACY_BROWSER_SUPPORT_POLICY_GROUP" />.

      Ta je značajka zamjena za proširenje <ph name="LEGACY_BROWSER_SUPPORT_EXTENSION_NAME" />. Konfiguracija proširenja prenijet će se na tu značajku, no preporučuje se da umjesto toga upotrijebite Chromeova pravila. Time se osigurava bolja kompatibilnost ubuduće.</translation>
<translation id="3997519162482760140">URL-ovi koji će dobiti pristup uređajima za videosnimanje na SAML stranicama za prijavu</translation>
<translation id="4001275826058808087">IT administratori za poslovne uređaje pomoću te oznake mogu kontrolirati hoće li korisnici moći iskoristiti ponude registracijom OS-a Chrome.

      Ako je ovo pravilo postavljeno na istinito ili ako nije postavljeno, korisnici će moći iskoristiti ponude registracijom OS-a Chrome.

      Ako je pravilo postavljeno na neistinito, korisnici neće moći iskoristiti ponude.</translation>
<translation id="4008233182078913897">Određuje popis aplikacija i proširenja koji se instaliraju u pozadini
          bez interakcije s korisnikom i koje korisnik ne može deinstalirati
          ni onemogućiti. Sva dopuštenja koje
          aplikacije/proširenja zahtijevaju dodjeljuju se implicitno, bez interakcije
          s korisnikom, uključujući sva dodatna dopuštenja koja buduće verzije
          aplikacije/proširenja mogu zahtijevati. Osim toga, dopuštenja se dodjeljuju za API-je
          proširenja enterprise.deviceAttributes i enterprise.platformKeys. (Ta dva API-ja nisu dostupna za aplikacije/proširenja koji nisu
          prisilno instalirani.)

          To pravilo ima prednost pred pravilom <ph name="EXTENSION_INSTALL_BLACKLIST_POLICY_NAME" /> s kojim potencijalno može biti u sukobu. Ako se s popisa ukloni aplikacija ili proširenje koji su prethodno bili prisilno instalirani, <ph name="PRODUCT_NAME" /> automatski će ih deinstalirati.

          Za instance Windowsa koje nisu pridružene domeni <ph name="MS_AD_NAME" /> prisilna instalacija ograničena je na aplikacije i proširenja koji su navedeni u Chrome web-trgovini.

          Korisnici mogu izmijeniti izvorni kôd proširenja pomoću Alata za razvojne programere (zbog čega proširenje može prestati funkcionirati). Ako to predstavlja problem, postavite pravilo <ph name="DEVELOPER_TOOLS_POLICY_NAME" />.

          Svaka stavka pravila niz je koji sadrži ID proširenja i URL za "ažuriranje" odvojene točkom sa zarezom (<ph name="SEMICOLON" />). ID proširenja niz je od 32 slova koji se primjerice može pronaći na <ph name="CHROME_EXTENSIONS_LINK" /> u načinu rada razvojnog programera. URL za "ažuriranje", ako se navede, treba usmjeravati na XML dokument manifesta ažuriranja kako je opisano u dokumentu <ph name="LINK_TO_EXTENSION_DOC1" />. Prema zadanim postavkama, upotrebljava se URL za ažuriranje Chrome web-trgovine (koji je trenutačno "https://clients2.google.com/service/update2/crx"). URL za "ažuriranje" postavljen u ovom pravilu upotrebljava se samo za prvo instaliranje, dok će se za daljnja ažuriranja proširenja upotrebljavati URL ažuriranja naveden u manifestu proširenja. Napominjemo i to da je eksplicitno navođenje URL-a za "ažuriranje" bilo obavezno u verzijama preglednika <ph name="PRODUCT_NAME" /> zaključno s verzijom 67.

          Na primjer, <ph name="EXTENSION_POLICY_EXAMPLE" /> instalira proširenje s ID-jem <ph name="EXTENSION_ID_SAMPLE" /> sa standardnog URL-a za "ažuriranje" Chrome web-trgovine. Više informacija o hostingu proširenja potražite ovdje: <ph name="LINK_TO_EXTENSION_DOC2" />.

          Ako se to pravilo ne postavi, aplikacije ili proširenja neće se instalirati automatski i korisnik može deinstalirati bilo koju aplikaciju ili proširenje u pregledniku <ph name="PRODUCT_NAME" />.

          To se pravilo ne primjenjuje u anonimnom načinu.</translation>
<translation id="4008507541867797979">Ako se to pravilo postavi na True ili se ne konfigurira, sustav <ph name="PRODUCT_OS_NAME" /> na zaslonu za prijavu prikazivat će postojeće korisnike i omogućivati odabir korisnika.

      Ako se pravilo postavi na False, <ph name="PRODUCT_OS_NAME" /> neće prikazivati postojeće korisnike na zaslonu za prijavu. Prikazivat će se obični zaslon za prijavu (na kojem se unose korisnička e-adresa i zaporka ili telefon) ili SAML međuprostorni zaslon (ako se omogući pravilom <ph name="LOGIN_AUTHENTICATION_BEHAVIOR_POLICY_NAME" />) osim ako se konfigurira upravljana sesija. Ako se konfigurira upravljana sesija, prikazivat će se samo računi upravljane sesije od kojih je moguće odabrati jedan.

      To pravilo ne utječe na to hoće li se lokalni korisnički podaci zadržavati na uređaju.</translation>
<translation id="4010738624545340900">Omogućavanje pozivanja dijaloga za odabir datoteka</translation>
<translation id="4012737788880122133">Kada se pravilo postavi na True, onemogućuju se automatska ažuriranja.

      <ph name="PRODUCT_OS_NAME" /> uređaji automatski traže ažuriranja kada ta postavka nije konfigurirana ili je postavljena na False.

      Upozorenje: preporučuje se da automatska ažuriranja budu uvijek uključena da korisnici mogu primati ažuriranja softvera i važne sigurnosne ispravke. Isključivanje automatskih ažuriranja korisnike može izložiti opasnosti.</translation>
<translation id="4020682745012723568">Kolačići prenijeti na korisnikov profil nisu dostupni Android aplikacijama.</translation>
<translation id="402759845255257575">Nemoj dopustiti nijednoj web-lokaciji da pokreće JavaScript</translation>
<translation id="4027608872760987929">Omogući zadanog davatelja usluge pretraživanja</translation>
<translation id="4039085364173654945">Nadzire smije li podsadržaj treće strane na stranici prikazivati skočni dijaloški okvir HTTP Basic Auth. Obično je to onemogućeno radi obrane od krađe identiteta. Ako ovo pravilo nije postavljeno, to je onemogućeno i podsadržajima treće strane neće biti dopušteno prikazivanje skočnog dijaloškog okvira HTTP Basic Auth.</translation>
<translation id="4056910949759281379">Onemogući SPDY protokol</translation>
<translation id="408029843066770167">Dopusti upute Googleovoj usluzi za vrijeme</translation>
<translation id="408076456549153854">Omogući prijavu putem preglednika</translation>
<translation id="40853027210512570">Nadjačava pravila za odabir zadanog pisača za<ph name="PRODUCT_NAME" />.

      To pravilo određuje pravila za odabir zadanog pisača na proizvodu <ph name="PRODUCT_NAME" />, što se događa prvi put kad se funkcija ispisa koristi s profilom.

      Kad se to pravilo postavi, <ph name="PRODUCT_NAME" /> pokušat će pronaći pisač koji se podudara sa svim navedenim atributima i odabrati ga kao zadani. Odabire se prvi pronađeni pisač koji se podudara s pravilom. Ako podudaranje nije jedinstveno, može se odabrati bilo koji podudarni pisač, ovisno o redoslijedu otkrivanja pisača.

      Ako se pravilo ne postavi ili se podudarni pisač ne pronađe u okviru vremenskog ograničenja, upotrebljavat će se ugrađeni PDF pisač ili se neće odabrati nijedan ako PDF pisač nije dostupan.

      Pisači povezani s uslugom <ph name="CLOUD_PRINT_NAME" /> smatraju se vrstom <ph name="PRINTER_TYPE_CLOUD" />, dok su ostali pisači klasificirani kao vrsta <ph name="PRINTER_TYPE_LOCAL" />.
      Izostavljanje polja znači da su podudarne sve vrijednosti. Na primjer, ako se ne odredi povezivanje, Pregled ispisa pokrenut će otkrivanje svih vrsta pisača, kako lokalnih tako i onih u oblaku.
      Uzorci regularnih izraza moraju slijediti sintaksu JavaScript RegExp, a u podudaranjima se razlikuju mala i velika slova.</translation>
<translation id="4088589230932595924">Anoniman način rada prisilno je uključen</translation>
<translation id="4088983553732356374">Omogućuje vam da odredite je li web-lokacijama dopušteno postavljanje lokalnih podataka. Postavljanje lokalnih podataka može biti dopušteno za sve web-lokacije ili odbijeno za sve web-lokacije.

         Ako se pravilo postavi na "Zadrži kolačiće za vrijeme trajanja sesije", kolačići će se izbrisati po završetku sesije. Ako se <ph name="PRODUCT_NAME" /> izvodi u pozadini, sesija se možda neće završiti dok se ne zatvori posljednji prozor. Više informacija o konfiguriranju tog ponašanja potražite u pravilu "BackgroundModeEnabled".

          Ako se to pravilo ne postavi, koristit će se pravilo "AllowCookies" i korisnik će ga moći promijeniti.</translation>
<translation id="4103289232974211388">Preusmjeri na SAML IdP nakon korisnikove potvrde</translation>
<translation id="410478022164847452">Određuje koliko vremena treba proteći bez aktivnosti korisnika da bi se izvršila radnja neaktivnosti tijekom napajanja izmjeničnom strujom.

          Kada je pravilo postavljeno, određuje koliko vremena treba proteći u neaktivnosti prije nego što <ph name="PRODUCT_OS_NAME" /> pokrene radnju neaktivnosti, što se može konfigurirati zasebno.

          Kada pravilo nije postavljeno, upotrebljava se zadano vrijeme.

          Vrijednost pravila treba navesti u milisekundama.</translation>
<translation id="4105884561459127998">Konfigurira vrstu autentifikacije za SAML prijave.

      Kada se to pravilo ne postavi ili se postavi na zadano (vrijednost 0), ponašanje SAML prijava određeno je preglednikom ovisno o drugim čimbenicima. U najjednostavnijem slučaju autentifikacija korisnika i zaštita predmemoriranih podataka korisnika temelje se na zaporkama koje su korisnici unijeli ručno.

      Kada se to pravilo postavi na ClientCertificate (vrijednost 1), autentifikacija korisničkim certifikatom upotrebljava se za novo dodane korisnike koji se prijavljuju putem SAML-a. Za te se korisnike ne upotrebljavaju nikakve zaporke i njihovi se predmemorirani lokalni podaci štite pomoću odgovarajućih kriptografskih ključeva. Na primjer, ta postavka omogućuje konfiguriranje autentifikacije korisnika na temelju pametne kartice (napominjemo da se posredničke aplikacije za pametne kartice trebaju instalirati pomoću pravila DeviceLoginScreenExtensions).

      To se pravilo primjenjuje samo na korisnike koji se autentificiraju putem SAML-a.</translation>
<translation id="4105989332710272578">Onemogući provedbu Transparentnosti certifikata za popis URL-ova</translation>
<translation id="4121350739760194865">Sprječavanje prikaza promocija aplikacija na stranici Nova kartica</translation>
<translation id="412697421478384751">Omogući korisnicima da postave slabe PIN-ove za zaključan zaslon</translation>
<translation id="4138655880188755661">Vremensko ograničenje</translation>
<translation id="4144164749344898721">To pravilo kontrolira više postavki za strategiju upravljanja napajanjem kada korisnik postane neaktivan.

          Postoje četiri vrste radnji:
          * Zaslon će se zatamniti ako korisnik ostane neaktivan u razdoblju koje navodi |ScreenDim|.
          * Zaslon će se isključiti ako korisnik ostane neaktivan u razdoblju koje navodi |ScreenOff|.
          * Ako korisnik ostane neaktivan u razdoblju koje navodi |IdleWarning|, prikazat će se dijaloški okvir koji će upozoriti korisnika da će se poduzeti radnja u slučaju neaktivnosti. Poruka upozorenja prikazuje se samo ako je radnja u slučaju neaktivnosti odjava ili isključivanje.
          * Radnja koju navodi |IdleAction| poduzet će se ako korisnik ostane neaktivan u razdoblju koje navodi |Idle|.

          Za svaku od prethodno navedenih radnji vrijeme odgode do radnje u slučaju neaktivnosti treba navesti u milisekundama i postaviti na vrijednost veću od nule da bi se pokrenula odgovarajuća radnja. Ako se vrijeme odgode do radnje u slučaju neaktivnosti postavi na nulu, <ph name="PRODUCT_OS_NAME" /> neće poduzeti odgovarajuću radnju.

          Kada se vrijeme ne postavi, za svako od prethodno navedenih vremena odgode upotrebljava se zadana vrijednost.

          Napominjemo da vrijednosti za |ScreenDim| moraju biti manje od vrijednosti za |ScreenOff| ili jednake toj vrijednosti te da vrijednosti za |ScreenOff| i |IdleWarning| moraju biti manje od vrijednosti za |Idle| ili jednake toj vrijednosti.

          |IdleAction| može biti jedna od četiri moguće radnje:
          * |Suspend|
          * |Logout|
          * |Shutdown|
          * |DoNothing|

          Kada se |IdleAction| ne postavi, poduzima se zadana radnja, odnosno, obustavljanje.

          Postoje i zasebne postavke za izmjenično napajanje i bateriju.
          </translation>
<translation id="4150201353443180367">Zaslon</translation>
<translation id="4157003184375321727">Izvješće o verziji OS-a i opreme</translation>
<translation id="4157594634940419685">Dopusti pristup nativnim CUPS pisačima</translation>
<translation id="4160962198980004898">Izvor MAC adrese uređaja kada je na priključnoj stanici</translation>
<translation id="4163705126749612234">Konfigurira tražene nazive domena klijenta koji će se nametnuti klijentima daljinskog pristupa i onemogućuje korisnicima da to promijene.

          Ako se ta postavka omogući, s hostom se mogu povezati samo klijenti s navedenih domena.

          Ako se ta postavka onemogući ili se ne postavi, primjenjivat će se zadano pravilo za vrstu povezivanja. U slučaju daljinske pomoći to omogućuje klijentima s bilo koje domene da se povežu s hostom, dok je daljinski pristup u bilo kojem trenutku dostupan samo vlasniku hosta.

          Ta će postavka nadjačati postavku RemoteAccessHostClientDomain ako je prisutna.

          Pogledajte i RemoteAccessHostDomainList.</translation>
<translation id="4164601239783385546">Omogući značajku pristupačnosti "ljepljive tipke".

          Ako se to pravilo postavi na true, ljepljive tipke uvijek će biti omogućene.

          Ako se pravilo postavi na false, ljepljive tipke uvijek će biti onemogućene.

          Ako postavite to pravilo, korisnici ga neće moći promijeniti niti nadjačati.

          Ako se pravilo ne postavi, ljepljive tipke u početku su onemogućene, ali ih korisnici mogu omogućiti kad god žele.</translation>
<translation id="4171331498167688968">Ako je pravilo postavljeno na false, softver treće strane moći će ubaciti izvršni kôd u Chromeove procese. Ako pravilo nije postavljeno ili je postavljeno na true, softver treće strane neće moći ubaciti izvršni kôd u Chromeove procese.

      Neovisno o vrijednosti pravila, preglednik softveru treće strane trenutačno neće onemogućiti ubacivanje izvršnog koda u svoje procese na računalu koje je pridruženo domeni <ph name="MS_AD_NAME" />.</translation>
<translation id="4183229833636799228">Zadana postavka za dodatak <ph name="FLASH_PLUGIN_NAME" /></translation>
<translation id="4192388905594723944">URL za validaciju tokena za autentifikaciju klijenta za daljinski pristup</translation>
<translation id="4203389617541558220">Ograniči aktivno vrijeme uređaja određivanjem vremena za automatska ponovna pokretanja.

      Kada se to pravilo postavi, određuje duljinu aktivnog vremena uređaja nakon kojeg je određeno automatsko ponovno pokretanje.

      Kada se to pravilo ne postavi, aktivno vrijeme uređaja nije ograničeno.

      Ako postavite to pravilo, korisnici ga ne mogu promijeniti ili premostiti.

      Automatsko ponovno pokretanje određeno je za odabrano vrijeme, ali može se odgoditi na uređaju do 24 sata ako korisnik trenutačno upotrebljava uređaj.

      Napomena: trenutačno su automatska ponovna pokretanja omogućena samo dok se prikazuje zaslon za prijavu ili dok traje sesija aplikacije kioska. To će se u budućnosti promijeniti i pravilo će se primjenjivati uvijek, bez obzira na to je li neka određena vrsta sesije u tijeku ili nije.

      Vrijednost pravila treba navesti u sekundama. Zadana je najmanja vrijednost 3600 (jedan sat).</translation>
<translation id="4203879074082863035">Korisnicima se prikazuju samo pisači na popisu dopuštenih</translation>
<translation id="420512303455129789">Rječnik koji mapira URL-ove na Booleovu oznaku koja određuje hoće li pristup hostu biti dopušten (točno) ili blokiran (netočno).

          To je pravilo za internu upotrebu preglednika <ph name="PRODUCT_NAME" />.</translation>
<translation id="4224610387358583899">Vrijeme do zaključavanja zaslona</translation>
<translation id="423797045246308574">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju web-lokacije koje ne smiju upotrebljavati generiranje ključeva. Ako je uzorak URL-ova u pravilu "KeygenAllowedForUrls", ovo pravilo nadjačava te iznimke.

          Ako se to pravilo ne postavi, globalna zadana vrijednost upotrebljavat će se za sve web-lokacije iz pravila "DefaultKeygenSetting" ako je postavljeno, a u suprotnom iz korisnikove osobne konfiguracije.</translation>
<translation id="4238997902172035160">Konfigurira direktorij koji će <ph name="PRODUCT_NAME" /> upotrebljavati za spremanje roaming kopija profila.

      Ako postavite to pravilo, <ph name="PRODUCT_NAME" /> upotrebljavat će navedeni direktorij za spremanje roaming kopija profila ako je omogućeno pravilo <ph name="ROAMING_PROFILE_SUPPORT_ENABLED_POLICY_NAME" />. Ako se pravilo <ph name="ROAMING_PROFILE_SUPPORT_ENABLED_POLICY_NAME" /> onemogući ili ne postavi, vrijednost spremljena u tom pravilu neće se upotrebljavati.

      Na stranici https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables možete pronaći popis varijabli koje se mogu koristiti.

      Ako se pravilo ne postavi, koristit će se zadani put roaming profila.</translation>
<translation id="4239720644496144453">Za Android aplikacije ne upotrebljava se predmemorija. Ako više korisnika instalira istu Android aplikaciju, ta će se aplikacija preuzeti iznova za svakog korisnika.</translation>
<translation id="4243336580717651045">Omogućuje prikupljanje anonimiziranih podataka zaključano URL-om u pregledniku <ph name="PRODUCT_NAME" /> i korisnicima onemogućuje da promijene tu postavku.

      Prikupljanje anonimiziranih podataka zaključano URL-om Googleu šalje URL-ove stranica koje korisnik posjeti radi poboljšanja pretraživanja i pregledavanja.

      Ako omogućite to pravilo, prikupljanje anonimiziranih podataka zaključano URL-om stalno je aktivno.

      Ako onemogućite to pravilo, prikupljanje anonimiziranih podataka zaključano URL-om nikad nije aktivno.

      Ako se to pravilo ne postavi, prikupljanje anonimiziranih podataka zaključano URL-om bit će omogućeno, no korisnik će to moći promijeniti.</translation>
<translation id="4250680216510889253">Ne</translation>
<translation id="4261820385751181068">Oznaka zemlje/jezika za zaslon za prijavu na uređaju</translation>
<translation id="427220754384423013">Određuje pisače koje korisnik može upotrebljavati.

      To se pravilo upotrebljava samo ako je pravilo <ph name="PRINTERS_WHITELIST" /> odabrano za <ph name="BULK_PRINTERS_ACCESS_MODE" />.

      Ako se to pravilo upotrebljava, korisniku su dostupni samo pisači s ID-jevima podudarnim s vrijednostima u tom pravilu. ID-jevi se moraju podudarati s poljima "id" ili "guid" u datoteci navedenoj u pravilu <ph name="BULK_PRINTERS_POLICY" />.
      </translation>
<translation id="427632463972968153">Određuje parametre koji se upotrebljavaju prilikom pretraživanja slika pomoću POST metode. Sastoji se od zarezom odvojenih parova naziv/vrijednost. Ako je vrijednost parametar predloška, primjerice {imageThumbnail} u gornjem primjeru, zamijenit će se podacima stvarne minijature slike.

          To je pravilo izborno. Ako nije postavljeno, zahtjev za pretraživanje slika poslat će se pomoću GET metode.

          To se pravilo poštuje samo ako je omogućeno pravilo "DefaultSearchProviderEnabled".</translation>
<translation id="4285674129118156176">Omogućuje nepridruženim korisnicima da upotrebljavaju ARC</translation>
<translation id="4289903996435140853">Omogućuje postavljanje popisa URL-ova koji navode koje će web-lokacije automatski dobiti dopuštenje za pristup USB uređaju s navedenim ID-jem dobavljača i ID-jem proizvoda. Svaka stavka na popisu mora sadržavati uređaje i URL-ove da bi pravilo bilo važeće. Svaka stavka na uređaju može sadržavati polje ID-ja dobavljača i ID-ja proizvoda. Svaki izostavljeni ID smatra se zamjenskim znakom s jednom iznimkom, a ta je iznimka da se ID proizvoda ne može navesti, a da se ne navede i ID dobavljača. U suprotnom pravilo neće biti važeće i zanemarit će se.

        Model dopuštenja za USB upotrebljava URL web-lokacije koja šalje zahtjev ("URL koji šalje zahtjev") i URL vršnih web-lokacija u okviru ("URL koji se ugrađuje") kako bi se URL-u koji šalje zahtjev dopustio pristup USB uređaju. URL koji šalje zahtjev može se razlikovati od URL-a koji se ugrađuje ako se web-lokacija koja šalje zahtjev učitava u iframeu. Stoga, da bi se odredio URL koji šalje zahtjev i URL koji se ugrađuje, polje za "URL-ove" može sadržavati najviše dva niza URL-a razdvojena zarezom. Ako se odredi samo jedan URL, pristup će biti dopušten odgovarajućim USB uređajima kada se URL web-lokacije koja šalje zahtjev podudara s ovim URL-om, bez obzira na status ugrađivanja. URL-ovi u polju "URL-ovi" moraju biti važeći. U protivnom će se pravilo zanemariti.

        Ako se to pravilo ne postavi, za sve web-lokacije upotrebljavat će se globalna zadana vrijednost iz pravila "DefaultWebUsbGuardSetting" ako je to pravilo postavljeno, a ako nije, upotrebljavat će se korisnikova osobna konfiguracija.

        Uzorci URL-a u ovom pravilu ne bi trebali biti u sukobu s onima koji su konfigurirani pravilom WebUsbBlockedForUrls. Ako se pojavi sukob, ovo će pravilo imati prednost pred pravilima WebUsbBlockedForUrls i WebUsbAskForUrls.

        Vrijednosti za to pravilo i pravilo WebUsbAllowDevicesForUrls spajaju se.</translation>
<translation id="4298509794364745131">Navodi popis aplikacija koje se mogu omogućiti kao aplikacije za izradu bilježaka na zaključanom zaslonu uređaja sa sustavom <ph name="PRODUCT_OS_NAME" />.

      Ako je željena aplikacija za izradu bilježaka omogućena na zaključanom zaslonu, zaključani će zaslon sadržavati element korisničkog sučelja za pokretanje željene aplikacije.
      Kada se pokrene, aplikacija će moći izraditi prozor aplikacije na zaključanom zaslonu i podatkovne stavke (bilješke) u kontekstu zaključanog zaslona. Aplikacija će moći uvesti izrađene bilješke u sesiju primarnog korisnika kada se ta sesija otključa. Na zaključanom zaslonu trenutačno su podržane samo Chromeove aplikacije za izradu bilježaka.

      Ako se to pravilo postavi, korisnik će moći uključiti aplikaciju na zaključanom zaslonu samo ako se ID proširenja aplikacije nalazi na popisu vrijednosti tog pravila.
      Stoga će postavljanje tog pravila za prazan popis posve onemogućiti izradu bilježaka na zaključanom zaslonu.
      Napominjemo da prisutnost ID-a aplikacije u pravilima ne mora značiti da će korisnik moći omogućiti aplikaciju kao aplikaciju za izradu bilježaka na zaključanom zaslonu, na primjer na Chromeu 61 skup dostupnih aplikacija dodatno je ograničen platformom.

      Ako se to pravilo ne postavi, pravila neće nametati ograničenja za skup aplikacija koje korisnik može omogućiti na zaključanom zaslonu.</translation>
<translation id="4313767483634435271">MAC adresa označene priključne stanice uređaja</translation>
<translation id="4322842393287974810">Dopusti kiosk aplikaciji pokrenutoj automatski bez odgode da upravlja verzijom proizvoda <ph name="PRODUCT_OS_NAME" /></translation>
<translation id="4325690621216251241">Dodaj gumb za odjavu na programsku traku</translation>
<translation id="4332177773549877617">Zabilježite događaje za instalacije aplikacije za Android</translation>
<translation id="4335292026668105285">Određuje koliko vremena treba proći od zadnjeg korisničkog unosa nakon kojeg se prikazuje dijaloški okvir upozorenja dok je uređaj priključen u struju.

          Ako se postavi, to pravilo određuje koliko dugo korisnik treba biti neaktivan prije nego što <ph name="PRODUCT_OS_NAME" /> prikaže dijaloški okvir upozorenja kojim se korisnika obavještava da će se poduzeti radnja u slučaju neaktivnosti.

          Ako se pravilo ne postavi, ne prikazuje se dijaloški okvir upozorenja.

          Vrijednost pravila treba se navesti u milisekundama. Vrijednosti moraju biti kraće od vremena odgode do radnje u slučaju neaktivnosti ili jednake tom vremenu.

          Poruka upozorenja prikazuje se samo ako je radnja u slučaju neaktivnosti odjava ili isključivanje.</translation>
<translation id="4346674324214534449">Omogućuje vam da postavite hoće li se oglasi blokirati na web-lokacijama s ometajućim oglasima.

     Ako se to pravilo postavi na 2, oglasi će se blokirati na web-lokacijama s ometajućim oglasima.
      No to se ponašanje neće aktivirati ako se pravilo SafeBrowsingEnabled postavi na netočno.
      Ako se to pravilo postavi na 1, oglasi se neće blokirati na web-lokacijama s ometajućim oglasima.
      Ako se to pravilo ne postavi, upotrebljavat će se 2.</translation>
<translation id="4347908978527632940">Ako se pravilo postavi na "True" i korisnik je nadzirani korisnik, onda druge Androidove aplikacije mogu postaviti upit za korisnikova ograničenja za web putem davatelja sadržaja.

          Ako se pravilo postavi na "False" ili se ne postavi, onda davatelj sadržaja neće vraćati nikakve podatke.</translation>
<translation id="435461861920493948">Sadrži popis uzoraka koji se koriste za reguliranje vidljivosti računa u pregledniku <ph name="PRODUCT_NAME" />.

      Svaki Google račun na uređaju usporedit će se s uzorcima pohranjenim u ovom pravilu kako bi se odredila vidljivost računa u pregledniku <ph name="PRODUCT_NAME" />. Račun će biti vidljiv ako se njegov naziv podudara s bilo kojim uzorkom na popisu. U suprotnom će biti skriven.

      Upotrijebite zamjenski znak "*" za nulu ili više proizvoljnih znakova. Prespojni je znak "\", pa da biste dobili stvarni znak "*" ili "\", ispred njih stavite "\".

      Ako se to pravilo ne postavi, svi Google računi na uređaju bit će vidljivi u pregledniku <ph name="PRODUCT_NAME" />.</translation>
<translation id="4360826270668210664">Ako se to pravilo postavi, host daljinskog pristupa zahtijevat će od klijenata koji se autentificiraju pribavljanje autentifikacijske oznake s tog URL-a da bi se povezali. Pravilo se mora upotrebljavati zajedno s pravilom RemoteAccessHostTokenValidationUrl.

          Ta je značajka trenutačno onemogućena na poslužitelju.</translation>
<translation id="4363057787588706121">Dopusti spajanje pravila na popisu koja potječu iz različitih izvora</translation>
<translation id="436581050240847513">Izvješća o mrežnim sučeljima uređaja</translation>
<translation id="4372704773119750918">Ne dopusti poslovnom korisniku da bude dio višestrukog profila (primarnom ili sekundarnom)</translation>
<translation id="4377599627073874279">Dopusti svim web-lokacijama prikazivanje svih slika</translation>
<translation id="437791893267799639">Postavljanje pravila poništeno, onemogući premještanje podataka i ARC</translation>
<translation id="4389073105055031853">Dopusti korisnicima upravljanje svim certifikatima</translation>
<translation id="4389091865841123886">Konfiguriranje daljinskog atestiranja TPM mehanizmom.</translation>
<translation id="4408428864159735559">Popis unaprijed konfiguriranih mrežnih dijeljenja datoteka.</translation>
<translation id="4410236409016356088">Omogući usporavanje propusnosti mreže</translation>
<translation id="441217499641439905">Onemogući Google disk putem mobilne veze u aplikaciji Datoteke za <ph name="PRODUCT_OS_NAME" /></translation>
<translation id="4415603335307944578">Ako se to pravilo postavi na true ili se ne konfigurira, preglednik će ponovo prikazati stranicu dobrodošlice prilikom prvog pokretanja nakon nadogradnje OS-a.

      Ako se pravilo postavi na false, preglednik neće ponovo prikazati stranicu dobrodošlice prilikom prvog pokretanja nakon nadogradnje OS-a.</translation>
<translation id="4418726081189202489">Ako se to pravilo postavi na netočno, <ph name="PRODUCT_NAME" /> neće povremeno slati upite Googleovu poslužitelju radi dohvaćanja točne vremenske oznake. Ti će se upiti omogućiti ako se pravilo postavi na točno ili se ne postavi.</translation>
<translation id="4423597592074154136">Ručno određivanje proxy postavki</translation>
<translation id="4429220551923452215">Omogućuje ili onemogućuje prečace aplikacija u traci oznaka.

      Ako se to pravilo ne postavi, korisnik može odabrati hoće li prikazati prečace aplikacija u kontekstnom izborniku trake oznaka ili ih iz njega sakriti.

      Ako je to pravilo konfigurirano, korisnik ga ne može promijeniti, a prečac aplikacije prikazivat će se uvijek, odnosno nikad.</translation>
<translation id="4432762137771104529">Omogući prošireno izvješćivanje Sigurnog pregledavanja</translation>
<translation id="443454694385851356">Naslijeđeno (nije sigurno)</translation>
<translation id="443665821428652897">Izbriši podatke o web-lokacijama prilikom isključivanja preglednika (obustavljeno)</translation>
<translation id="4439132805807595336">Omogući uređaju da pokreće PluginVm.

      Ako se to pravilo postavi na False ili se ne postavi, <ph name="PLUGIN_VM_NAME" /> nije omogućen za uređaj. Ako se postavi na True, <ph name="PLUGIN_VM_NAME" /> omogućen je za uređaj ako je dopušten i drugim postavkama. <ph name="PLUGIN_VM_ALLOWED_POLICY_NAME" /> potrebno je postaviti na True i potrebno je postaviti <ph name="PLUGIN_VM_LICENSE_KEY_POLICY_NAME" /> i <ph name="PLUGIN_VM_IMAGE_POLICY_NAME" /> da bi se <ph name="PLUGIN_VM_NAME" /> mogao pokrenuti.</translation>
<translation id="4439336120285389675">Navedite popis zastarjelih značajki web-platformi kako biste ih privremeno ponovo omogućili.

      To pravilo pruža administratorima mogućnost ponovnog omogućivanja zastarjelih značajki web-platformi na ograničeno vrijeme. Značajke se identificiraju oznakom niza i one značajke koje odgovaraju oznakama koje se nalaze na popisu navedenom u tom pravilu omogućit će se ponovo.

      Ako se to pravilo ne postavi ili ako je popis prazan ili se ne podudara s jednom od podržanih oznaka niza, sve zastarjele značajke web-platformi ostat će onemogućene.

      Iako je pravilo podržano na prethodno navedenim platformama, značajka koju omogućuje može biti dostupna na manje platformi. Neke zastarjele značajke web-platformi ne mogu se ponovo omogućiti. Samo one koje su izričito navedene u nastavku mogu se ponovo omogućiti na ograničeno vrijeme koje se razlikuje od značajke do značajke. Općeniti oblik oznake niza bit će [Nazivzastarjeleznačajke]_EffectiveUntil[ggggmmdd]. Ako vas zanima, namjeru promjene značajke web-platforme možete pronaći na stranici https://bit.ly/blinkintents.
      </translation>
<translation id="4442582539341804154">Omogući zaključavanje kada uređaj prijeđe u stanje mirovanja ili se isključi</translation>
<translation id="4449469846627734399">Postavite dnevnu konfiguraciju za prebacivanje napajanja radi uštede energije</translation>
<translation id="4449545651113180484">Zakreni zaslon u smjeru kazaljke na satu 270 stupnjeva</translation>
<translation id="445270821089253489">Upravlja vrstom informacija o korisniku i uređaju o kojima se izvještava.</translation>
<translation id="4454820008017317557">Prikaži ikonu alatne trake za uslugu <ph name="PRODUCT_NAME" /></translation>
<translation id="4467952432486360968">Blokiraj kolačiće trećih strana</translation>
<translation id="4474167089968829729">Omogući spremanje zaporki u upravitelj zaporki</translation>
<translation id="4476769083125004742">Ako se to pravilo postavi na <ph name="BLOCK_GEOLOCATION_SETTING" />, Android aplikacije ne mogu pristupiti podacima o lokaciji. Ako to pravilo postavite na bilo koju drugu vrijednost ili ga ne postavite, korisniku se prikazuje upit o pristanku kada Android aplikacija želi pristupiti podacima o lokaciji.</translation>
<translation id="4480694116501920047">Nametni Sigurno pretraživanje</translation>
<translation id="4482640907922304445">Pokazuje gumb Početna na alatnoj traci proizvoda <ph name="PRODUCT_NAME" />. Ako omogućite ovu postavku, gumb Početna prikazivat će se uvijek. Ako onemogućite ovu postavku, gumb Početna neće se nikad prikazivati. Ako omogućite ili onemogućite ovu postavku, korisnici neće moći promijeniti ni poništiti ovu postavku u proizvodu <ph name="PRODUCT_NAME" />. Ako ovo pravilo nije postavljeno, korisnik će moći odabrati želi li da se prikazuje gumb Početna.</translation>
<translation id="4483649828988077221">Onemogući automatska ažuriranja</translation>
<translation id="4485425108474077672">Konfiguriraj URL stranice nove kartice</translation>
<translation id="4492287494009043413">Onemogući izradu snimki zaslona</translation>
<translation id="4494132853995232608">Wilco DTC</translation>
<translation id="449423975179525290">Konfigurirajte pravila koje se odnose na <ph name="PLUGIN_VM_NAME" />.</translation>
<translation id="450537894712826981">Konfigurira veličinu predmemorije koju će <ph name="PRODUCT_NAME" /> upotrebljavati za pohranu predmemoriranih medijskih datoteka na disku.

      Ako postavite ovo pravilo, <ph name="PRODUCT_NAME" /> upotrebljavat će ponuđenu veličinu predmemorije, bez obzira je li korisnik označio "--media-cache-size". Vrijednost navedena u ovom pravilu nije čvrsto postavljena granica, već prijedlog za sustav predmemoriranja; svaka vrijednost ispod nekoliko megabajta premala je i zaokružit će se na prihvatljivi minimum.

      Ako je vrijednost ovog pravila 0, upotrijebit će se zadana veličina predmemorije, ali je korisnik neće moći promijeniti.

      Ako ovo pravilo nije postavljeno, upotrijebit će se zadana veličina i korisnik će je moći nadjačati oznakom --media-cache-size.</translation>
<translation id="4508686775017063528">Ako se to pravilo postavi na "točno" ili se ne postavi, <ph name="PRODUCT_NAME" /> bit će omogućen i korisnici će ga moći pokrenuti putem izbornika aplikacije, kontekstnih izbornika na stranici, medijskih kontrola na web-lokacijama koje podržavaju Cast te ikone Casta na alatnoj traci (ako je prikazana).

          Ako se pravilo postavi na "netočno", <ph name="PRODUCT_NAME" /> bit će onemogućen.</translation>
<translation id="4515404363392014383">Omogući Sigurno pregledavanje za pouzdane izvore</translation>
<translation id="4518251772179446575">Pitaj kad web-lokacija želi pratiti fizičku lokaciju korisnika</translation>
<translation id="4519046672992331730">Omogućuje prijedloge pretraživanja u višenamjenskom okviru usluge <ph name="PRODUCT_NAME" /> i sprječava korisnike da promijene tu postavku.

      Ako omogućite ovu postavku, upotrebljavaju se prijedlozi pretraživanja.

      Ako onemogućite ovu postavku, prijedlozi pretraživanja nikad se ne upotrebljavaju.

      Ako omogućite ili onemogućite ovu postavku, korisnici neće moći promijeniti niti poništiti ovu postavku na usluzi <ph name="PRODUCT_NAME" />.

      Ako ovo pravilo nije postavljeno, bit će omogućeno, ali će ga korisnici moći promijeniti.</translation>
<translation id="4531706050939927436">Instaliranje Android aplikacija može se nametnuti s konzole Google Admina putem Google Playa. One ne upotrebljavaju to pravilo.</translation>
<translation id="4534500438517478692">Naziv ograničenja za Android:</translation>
<translation id="4541530620466526913">Lokalni računi na uređaju</translation>
<translation id="4543502256674577024">Postavke ažuriranja uređaja</translation>
<translation id="4554651132977135445">Način obrade povratne petlje korisničkog pravila</translation>
<translation id="4554841826517980623">To pravilo određuje treba li značajka mrežnog dijeljenja datoteka za <ph name="PRODUCT_NAME" /> upotrebljavati protokol <ph name="NETBIOS_PROTOCOL" /> za otkrivanje dijeljenja na mreži.
      Ako se to pravilo postavi na True, otkriće dijeljenja upotrebljavat će protokol <ph name="NETBIOS_PROTOCOL" /> za otkrivanje dijeljenja na mreži.
      Ako se to pravilo postavi na False, otkriće dijeljenja neće upotrebljavati protokol <ph name="NETBIOS_PROTOCOL" /> za otkrivanje dijeljenja.
      Ako pravilo nije postavljeno, zadano će biti onemogućeno za korisnike kojima upravlja tvrtka, a omogućeno za neupravljane korisnike.</translation>
<translation id="4555850956567117258">Omogući daljinsku ovjeru za korisnika</translation>
<translation id="4557134566541205630">URL web-stranice nove kartice zadanog davatelja usluge pretraživanja</translation>
<translation id="4567137030726189378">Dopusti upotrebu Alata za razvojne programere</translation>
<translation id="4578265298946081589">Ne pokreći ponovo nakon odjave korisnika.</translation>
<translation id="4578912515887794133">Ako se ta postavka omogući, host daljinskog pristupa uspoređuje ime lokalnog korisnika (s kojim je taj host povezan) i naziv Google računa koji je registriran kao vlasnik hosta (tj., "johndoe" ako je vlasnik hosta Google račun "johndoe@example.com").  Host daljinskog pristupa neće se pokrenuti ako se vlasnik hosta razlikuje od imena lokalnog korisnika s kojim je host povezan.  Pravilo RemoteAccessHostMatchUsername treba se upotrebljavati zajedno s pravilom RemoteAccessHostDomain kako bi se primijenilo i to da je Google račun vlasnika hosta povezan s određenom domenom (tj., "example.com").

          Ako se ta postavka onemogući ili ne postavi, host daljinskog pristupa može se povezati s bilo kojim lokalnim korisnikom.</translation>
<translation id="4591366717022345234">Pruži korisnicima međuverziju za brzi popravak</translation>
<translation id="4600786265870346112">Omogućivanje velikog pokazivača</translation>
<translation id="4604931264910482931">Konfiguriraj popis nedopuštenih za lokalno slanje poruka</translation>
<translation id="4617338332148204752">Preskoči provjeru metaoznaka u okviru <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="4625915093043961294">Konfiguriraj bijelu listu instalacije proširenja</translation>
<translation id="4632343302005518762">Dopusti proizvodu <ph name="PRODUCT_FRAME_NAME" /> rukovanje navedenim vrstama sadržaja</translation>
<translation id="4632566332417930481">Onemogući upotrebu Alata za razvojne programere na proširenjima instaliranim prema pravilima organizacije, dopusti upotrebu Alata za razvojne programere u drugim kontekstima</translation>
<translation id="4633786464238689684">Mijenja se zadano ponašanje tipki u skroz gornjem redu u funkcijske tipke.

          Ako se pravilo postavi na istinito, najgornji red tipki na tipkovnici prema zadanim će postavkama izvršavati naredbe funkcijskih tipki. Da bi se njihovo ponašanje vratilo na medijske tipke, potrebno je pritisnuti tipku za pretraživanje.

          Ako se pravilo postavi na neistinito ili se ne postavi, tipkovnica će izvršavati naredbe medijskih tipki prema zadanim postavkama, a naredbe funkcijskih tipki izvršavat će se ako se istovremeno drži tipka za pretraživanje.</translation>
<translation id="4639407427807680016">Nazivi hostova za lokalno slanje poruka koje treba izuzeti s popisa nedopuštenih</translation>
<translation id="4650759511838826572">Onemogući sheme URL protokola</translation>
<translation id="465099050592230505">URL web-trgovine tvrtke (obustavljeno)</translation>
<translation id="4661889655253181651">Postavke sadržaja omogućuju određivanje načina postupanja s određenim vrstama sadržaja (kao što su kolačići, slike i JavaScript).</translation>
<translation id="4665897631924472251">Postavke upravljanja proširenjima</translation>
<translation id="4668325077104657568">Zadana postavka slika</translation>
<translation id="4670865688564083639">Minimalno:</translation>
<translation id="4671708336564240458">Omogućuje vam da postavite hoće li se web-lokacijama s uvredljivim sadržajima onemogućiti otvaranje novih prozora i kartica.

      Ako se to pravilo postavi na True, web-lokacijama s uvredljivim sadržajima onemogućit će se otvaranje novih prozora i kartica.
      No to se ponašanje neće aktivirati ako se pravilo SafeBrowsingEnabled postavi na False.
      Ako se to pravilo postavi na False, web-lokacijama s uvredljivim sadržajima dopustit će se otvaranje novih prozora i kartica.
      Ako se to pravilo ne postavi, upotrebljavat će se True.</translation>
<translation id="467236746355332046">Podržane značajke:</translation>
<translation id="4674167212832291997">Prilagođava popis uzoraka URL-ova koje bi <ph name="PRODUCT_FRAME_NAME" /> uvijek trebao generirati.

          Ako se to pravilo ne postavi, zadani će se ispunjivač upotrebljavati za sve web-lokacije određene pravilom "ChromeFrameRendererSettings".

          Primjere uzoraka pogledajte na https://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="467449052039111439">Otvori popis URL-ova</translation>
<translation id="4674871290487541952">Dopusti nesigurne algoritme u provjerama integriteta za ažuriranja i instaliranja proširenja</translation>
<translation id="4680936297850947973">Obustavljeno u verziji M68. Umjesto toga upotrijebite DefaultPopupsSetting.

      Cijelo objašnjenje pročitajte na stranici https://www.chromestatus.com/features/5675755719622656.
      Ako se to pravilo omogući, web-lokacijama će se omogućiti istovremena navigacija i otvaranje novih prozora ili kartica.
      Ako se to pravilo onemogući ili se ne postavi, web-lokacijama će se onemogućiti istovremena navigacija i otvaranje novih prozora ili kartica.</translation>
<translation id="4680961954980851756">Omogući Automatsko popunjavanje</translation>
<translation id="4703402283970867140">Omogućite model pametnog zatamnjenja kako bi se produljilo vrijeme do zatamnjenja zaslona</translation>
<translation id="4722122254122249791">Omogući izolaciju web-lokacije za određene izvore</translation>
<translation id="4722399051042571387">Ako se postavi na False, korisnici neće moći postavljati PIN-ove koji su slabi ili ih je lako odgonetnuti.

          Primjeri slabih PIN-ova uključuju: PIN-ove koji se sastoje od jedne te iste znamenke (1111), PIN-ove u kojima se znamenke povećavaju za 1 (1234), PIN-ove u kojima se znamenke smanjuju za 1 (4321) i PIN-ove koji su previše česti.

          Prema zadanim postavkama korisnicima će se prikazivati upozorenje, a ne pogreška, ako se PIN smatra slabim.</translation>
<translation id="4723829699367336876">Omogući prijelaz vatrozida iz klijenta za daljinski pristup</translation>
<translation id="4725528134735324213">Omogući Androidovu uslugu sigurnosnog kopiranja</translation>
<translation id="4725801978265372736">Zahtijevaj podudaranje imena lokalnog korisnika i vlasnika hosta daljinskog pristupa</translation>
<translation id="4733471537137819387">Pravila koja se odnose na integriranu HTTP autentifikaciju.</translation>
<translation id="4744190513568488164">Poslužitelji koje <ph name="PRODUCT_NAME" /> može ovlastiti.

          Razdvojite više poslužitelja zarezima. Zamjenski su znakovi (*) dopušteni.

          Ako ne postavite ovo pravilo, <ph name="PRODUCT_NAME" /> neće dodijeliti vjerodajnice korisnika čak ni ako otkrije da je poslužitelj na intranetu.</translation>
<translation id="4752880493649142945">Klijentski certifikat za povezivanje s pravilom RemoteAccessHostTokenValidationUrl</translation>
<translation id="4757671984625088193">Ako se pravilo postavi na True ili se ne postavi, <ph name="PRODUCT_NAME" /> predlagat će stranice koje su povezane s trenutačnom stranicom.
      Ti se prijedlozi dohvaćaju daljinski s Googleovih poslužitelja.

      Ako se pravilo postavi na False, prijedlozi se neće dohvaćati ni prikazivati.</translation>
<translation id="4759650396863318477">Omogućuje postavljanje razdoblja u milisekundama tijekom kojeg će se prikazivati obavijesti o ponovnom pokretanju preglednika <ph name="PRODUCT_NAME" /> ili da je potrebno ponovo pokrenuti <ph name="PRODUCT_OS_NAME" /> radi primjene ažuriranja na čekanju.

      Tijekom tog će se vremena korisniku prikazivati ponavljajuća obavijest o potrebnom ažuriranju. Za <ph name="PRODUCT_OS_NAME" /> uređaje obavijest o ponovnom pokretanju prikazuje se na traci sustava u skladu s pravilom <ph name="RELAUNCH_HEADS_UP_PERIOD_POLICY_NAME" />. Za preglednike <ph name="PRODUCT_NAME" /> izbornik aplikacije mijenja se kada istekne trećina razdoblja obavijesti kako bi se naznačilo da je potrebno ponovno pokretanje. Boja te obavijesti mijenja se kada isteknu dvije trećine razdoblja i još jednom kada istekne cijelo razdoblje. Dodatne obavijesti omogućene pravilom <ph name="RELAUNCH_NOTIFICATION_POLICY_NAME" /> za preglednike imaju isti raspored.

      Ako se ne postavi, za <ph name="PRODUCT_OS_NAME" /> uređaje upotrebljava se zadano razdoblje od 345.600.000 milisekundi (četiri dana), a za <ph name="PRODUCT_NAME" /> zadano razdoblje od 604.800.000 milisekundi (jedan tjedan).</translation>
<translation id="4777805166623621364">
      Ova postavka, SitePerProcess, može se koristiti kako bi se korisnicima onemogućilo da se isključe iz zadanog ponašanja izolacije svih web-lokacija. Napominjemo da pravilo IsolateOrigins također može biti korisno za izolaciju dodatnih, preciznije određenih izvora.
      Ako se to pravilo omogući, korisnici se neće moći isključiti iz zadanog ponašanja pri kojem se svaka web-lokacija izvodi u svojem procesu.
      Ako se pravilo ne konfigurira ili se onemogući, korisnik će se moći isključiti iz izolacije web-lokacije
      (na primjer pomoću unosa "Disable site isolation" (Onemogući izolaciju web-lokacije) na stranici chrome://flags).  Ako se to pravilo postavi na onemogućeno i/ili ne konfigurira, ono ne isključuje izolaciju web-lokacije.
      Na proizvodu <ph name="PRODUCT_OS_NAME" /> do verzije 76 preporučuje se postaviti pravila za uređaje <ph name="DEVICE_LOGIN_SCREEN_SITE_PER_PROCESS_POLICY_NAME" /> na istu vrijednost. Ako se vrijednosti koje navode ta dva pravila ne podudaraju, može doći do kašnjenja prilikom pokretanja korisničke sesije dok se primjenjuje vrijednost koju navode korisnička pravila.

      NAPOMENA: to se pravilo ne primjenjuje na Androidu. Da biste omogućili SitePerProcess na Androidu, postavite pravilo SitePerProcessAndroid.
      </translation>
<translation id="4788252609789586009">Omogućuje značajku Automatsko popunjavanje na usluzi <ph name="PRODUCT_NAME" /> i omogućuje korisnicima automatsko unošenje podataka o kreditnim karticama u web-obrasce pomoću prethodno pohranjenih podataka.

      Ako se ta postavka onemogući, Automatsko popunjavanje nikada neće predlagati niti unositi podatke o kreditnim karticama niti će spremiti dodatne podatke o kreditnim karticama koje bi korisnik mogao unijeti tijekom pregledavanja weba.

      Ako se ta postavka omogući ili nema vrijednost, korisnik će moći kontrolirati Automatsko popunjavanje za kreditne kartice na korisničkom sučelju.</translation>
<translation id="4791031774429044540">Omogući značajku pristupačnosti velikog pokazivača.

          Ako se to pravilo postavi na točno, veliki će pokazivač uvijek biti omogućen.

          Ako se to pravilo postavi na netočno, veliki će pokazivač uvijek biti onemogućen.

          Ako postavite to pravilo, korisnici ga ne mogu promijeniti ili premostiti.

          Ako se to pravilo ne postavi, veliki će pokazivač u početku biti onemogućen, ali korisnici ga mogu omogućiti u bilo kojem trenutku.</translation>
<translation id="4802905909524200151">Konfiguriranje ponašanja ažuriranja <ph name="TPM_FIRMWARE_UPDATE_TPM" /> opreme</translation>
<translation id="4804828344300125154">Uvijek ponovo pokreni uređaj nakon odjave korisnika.</translation>
<translation id="4807950475297505572">Uklanjaju se korisnici koji najdulje nisu upotrebljavani dok se ne oslobodi dovoljno prostora</translation>
<translation id="4816674326202173458">Dopuštanje poslovnom korisniku da bude primarni i sekundarni (zadano ponašanje za korisnike kojima se ne upravlja)</translation>
<translation id="4826326557828204741">Radnja koja se poduzima kada se dosegne odgoda zbog neaktivnosti dok računalo pokreće baterija</translation>
<translation id="4832852360828533362">Izvješćivanje o korisniku i uređaju</translation>
<translation id="4834526953114077364">Uklanjaju se korisnici koji najdulje nisu upotrebljavani, a koji se nisu prijavili u prethodna 3 mjeseca dok se ne oslobodi dovoljno prostora</translation>
<translation id="4835622243021053389">Omogućite NTLMv2 autentifikaciju.</translation>
<translation id="4858735034935305895">Dopusti način punog zaslona</translation>
<translation id="4861767323695239729">Konfiguriraj dopuštene načine unosa u korisničkoj sesiji</translation>
<translation id="487460824085252184">Migrira automatski, bez traženja pristanka korisnika.</translation>
<translation id="4874982543810021567">Blokiraj WebUSB na ovim web-lokacijama</translation>
<translation id="4876805738539874299">Maksimalna verzija SSL-a omogućena</translation>
<translation id="4887274746092315609">Omogućuje stranicu za promjenu zaporke unutar sesije za korisnike SAML-a</translation>
<translation id="4897928009230106190">Određuje parametre koji se upotrebljavaju prilikom pretraživanja prijedloga pomoću POST metode. Sastoji se od zarezom odvojenih parova naziv/vrijednost. Ako je vrijednost parametar predloška, primjerice {searchTerms} u gornjem primjeru, zamijenit će se podacima stvarnih pojmova za pretraživanje.

          To je pravilo izborno. Ako nije postavljeno, zahtjev za predloženo pretraživanje poslat će se pomoću GET metode.

          To se pravilo poštuje samo ako je omogućeno pravilo "DefaultSearchProviderEnabled".</translation>
<translation id="489803897780524242">Parametar koji kontrolira položaj pojma za pretraživanje za zadanog pružatelja usluge pretraživanja</translation>
<translation id="4899708173828500852">Omogući Sigurno pregledavanje</translation>
<translation id="4899802251198446659">Omogućuje vam da odredite mogu li se videozapisi reproducirati automatski (bez korisnikova pristanka) s audiosadržajem u pregledniku <ph name="PRODUCT_NAME" />.

      Ako se ovo pravilo postavi na True, <ph name="PRODUCT_NAME" /> može automatski reproducirati medije.
      Ako se ovo pravilo postavi na False, <ph name="PRODUCT_NAME" /> ne može automatski reproducirati medije. Pravilo AutoplayWhitelist može se upotrijebiti za poništavanje ovog pravila za određene uzorke URL-a.
      Prema zadanim postavkama <ph name="PRODUCT_NAME" /> ne može automatski reproducirati medije. Pravilo AutoplayWhitelist može se upotrijebiti za poništavanje ovog pravila za određene uzorke URL-a.

      Ako se <ph name="PRODUCT_NAME" /> izvodi, a pravilo se promijeni, pravilo će se primjenjivati samo na nove 
otvorene kartice. Zato će se neke kartice možda i dalje ponašati u skladu s prethodnim pravilom.
      </translation>
<translation id="4906194810004762807">Brzina osvježavanja za pravilo uređaja</translation>
<translation id="4917385247580444890">Jak</translation>
<translation id="4923806312383904642">Dopusti WebDriveru da nadjača nekompatibilna pravila</translation>
<translation id="494613465159630803">Cast prijemnik</translation>
<translation id="494924690085329212">Ponovo pokreni nakon odjave korisnika ako je pokrenut Android.</translation>
<translation id="4962262530309732070">Ako se pravilo postavi na točno ili se ne konfigurira, <ph name="PRODUCT_NAME" /> dopustit će dodavanje osoba iz upravitelja korisnika.

      Ako se pravilo postavi na netočno, <ph name="PRODUCT_NAME" /> neće dopustiti izradu novih profila iz upravitelja profila.</translation>
<translation id="4970855112942626932">Onemogući prijavu putem preglednika</translation>
<translation id="4978405676361550165">Ako se postavi pravilo "OffHours", navedena pravila za uređaje zanemaruju se (upotreba zadanih postavki tih pravila) tijekom navedenih vremenskih intervala. Chrome ponovo primjenjuje pravila za uređaje na svaki događaj kada razdoblje "OffHours" započne ili završi. Korisnik će dobiti obavijest i morat će se odjaviti kada vrijeme za "OffHours" završi i kada se postavke pravila za uređaje promijene (odnosno kada je korisnik prijavljen računom koji nije dopušten).</translation>
<translation id="4980635395568992380">Vrste podataka:</translation>
<translation id="4983201894483989687">Dopusti pokretanje dodataka koji su zastarjeli</translation>
<translation id="4986560318567565414">Put do Chromea za prebacivanje iz zamjenskog preglednika.</translation>
<translation id="4988291787868618635">Radnja koja će se izvršiti kada nastupi odgoda neaktivnosti</translation>
<translation id="5034604678285451405">Postavite prag baterije (u postocima) za prebacivanje napajanja radi uštede energije.

          Ovo pravilo koristi se samo ako se DevicePowerPeakShiftEnabled postavi na true.

          Ako se pravilo ne konfigurira ili se ne postavi, prebacivanje napajanja radi uštede energije uvijek će biti onemogućeno.</translation>
<translation id="5047604665028708335">Dopusti pristup web-lokacijama izvan paketa sadržaja</translation>
<translation id="5052081091120171147">Ako je omogućeno, ovo pravilo prisilno uvozi povijest pregledavanja iz trenutačno zadanog preglednika. Ako je omogućeno, ovo pravilo također utječe na dijaloški okvir za uvoz. Ako je onemogućeno, povijest pregledavanja se ne uvozi. Ako nije postavljeno, korisniku može biti postavljen upit želi li uvesti povijest pregledavanja ili do uvoza može doći automatski.</translation>
<translation id="5055312535952606505">Konfigurira postavke proxyja za <ph name="PRODUCT_NAME" />. Te postavke proxyja bit će dostupne i za ARC aplikacije.

          Ako omogućite tu postavku, <ph name="PRODUCT_NAME" /> i ARC aplikacije zanemarivat će sve opcije koje se odnose na proxy poslužitelj navedene u naredbenom retku.

          Ako se to pravilo ne postavi, korisnici će moći sami odabrati postavke proxyja.

          Ako se postavi, pravilo <ph name="PROXY_SETTINGS_POLICY_NAME" /> nadjačat će bilo koje pojedinačno pravilo <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" /> i <ph name="PROXY_SERVER_MODE_POLICY_NAME" />.

          Polje <ph name="PROXY_MODE_PROXY_SETTINGS_FIELD" /> omogućuje vam da odredite proxy poslužitelj kojim se koristi <ph name="PRODUCT_NAME" /> i onemogućuje korisnicima da mijenjaju postavke proxyja.

          Polje <ph name="PROXY_PAC_URL_PROXY_SETTINGS_FIELD" /> URL je za .pac datoteku proxy poslužitelja.

          Polje <ph name="PROXY_SERVER_PROXY_SETTINGS_FIELD" /> URL je proxy poslužitelja.

          Polje <ph name="PROXY_BYPASS_LIST_PROXY_SETTINGS_FIELD" /> popis je proxy hostova koje će <ph name="PRODUCT_NAME" /> zaobilaziti.

          Polje <ph name="PROXY_SERVER_MODE_PROXY_SETTINGS_FIELD" /> obustavljeno je u korist polja "ProxyMode". Omogućuje vam da odredite proxy poslužitelj kojim se koristi <ph name="PRODUCT_NAME" /> i onemogućuje korisnicima da mijenjaju postavke proxyja.

          Ako za "ProxyMode" odaberete vrijednost "direct", proxy poslužitelj nikad se neće upotrebljavati, a sva će se ostala polja zanemariti.

          Ako za "ProxyMode" odaberete vrijednost "system", upotrebljavat će se proxy poslužitelji sustava, a sva će se ostala polja zanemariti.

          Ako za "ProxyMode" odaberete vrijednost "auto_detect", sva će se ostala polja zanemariti.

          Ako za "ProxyMode" odaberete vrijednost "fixed_server", upotrebljavat će se polja "ProxyServer" i "ProxyBypassList".

          Ako za "ProxyMode" odaberete vrijednost "pac_script", upotrebljavat će se polja "ProxyPacUrl" i "ProxyBypassList".</translation>
<translation id="5056708224511062314">Povećalo je onemogućeno</translation>
<translation id="5058573563327660283">Odaberi strategiju kojom se oslobađa prostor na disku tijekom automatskog čišćenja (obustavljeno)</translation>
<translation id="5067143124345820993">Popis korisnika kojima je dopuštena prijava</translation>
<translation id="5075834892754086022">Ako se postavi to pravilo, primjenjuje se konfigurirana minimalna
          duljina PIN-a. (Apsolutna minimalna duljina PIN-a iznosi 1. Vrijednosti manje od 1
          tretiraju se kao 1.)

          Ako se pravilo ne postavi, primjenjuje se minimalna duljina PIN-a od
          šest znakova. To je preporučeni minimum.</translation>
<translation id="5076274878326940940">Omogućuje upotrebu zadanog davatelja usluge pretraživanja.

          Ako omogućite tu postavku, zadano se pretraživanje izvodi kada korisnik u višenamjenski okvir unese tekst koji nije URL.

          Upotrebu zadanog davatelja usluge pretraživanja možete odrediti postavljanjem preostalih pravila za zadano pretraživanje. Ako se ona ne postave, korisnik može odabrati zadanog davatelja usluge pretraživanja.

          Ako onemogućite tu postavku, pretraživanje se neće izvoditi kada korisnik u višenamjenski okvir unese tekst koji nije URL.

          Ako omogućite ili onemogućite tu postavku, korisnici neće moći promijeniti niti nadjačati tu postavku u pregledniku <ph name="PRODUCT_NAME" />.

          Ako se pravilo ne postavi, zadani je davatelj usluge pretraživanja omogućen, a korisnik će moći postaviti popis davatelja usluge pretraživanja.

          Pravilo je dostupno samo na instancama Windowsa koje su pridružene domeni <ph name="MS_AD_NAME" /> ili instancama Windowsa 10 Pro ili Enterprise prijavljenim za upravljanje uređajima.</translation>
<translation id="5085647276663819155">Onemogući pregled ispisa</translation>
<translation id="5090209345759901501">Proširi postavku Flash sadržaja na sav sadržaj</translation>
<translation id="5090791951240382356">Dopusti spajanje pravila rječnika koja potječu iz različitih izvora</translation>
<translation id="5093540029655764852">Određuje stopu (u danima) po kojoj klijent mijenja zaporku računa na računalu. Klijent tu zaporku generira nasumično i korisnik je ne može vidjeti.

      Zaporke računa na računalu trebale bi se jednako redovito mijenjati kao i korisničke. Ako se to pravilo onemogući ili postavi na veliki broj dana, to može negativno utjecati na sigurnost jer potencijalnim napadačima daje više vremena za pronalaženje zaporke računa uređaja i njezinu upotrebu.

      Ako se pravilo ne postavi, zaporka računa na računalu mijenja se svakih 30 dana.

      Ako se pravilo postavi na 0, promjena zaporke računa na računalu onemogućena je.

      Zaporke mogu biti i starije od navedenog broja dana ako je klijent bio offline dulje vrijeme.</translation>
<translation id="510196893779239086">To pravilo određuje hoće li se Chrome potpuno zatvoriti kada se posljednja kartica prebaci u drugi preglednik.

      Ako se pravilo ne postavi ili se postavi na True, Chrome će zadržati barem jednu otvorenu karticu nakon prebacivanja na zamjenski preglednik.

      Ako se pravilo postavi na False, Chrome će zatvoriti karticu nakon prebacivanja na zamjenski preglednik, čak i ako je to bila posljednja kartica. Chrome će se tako u potpunosti zatvoriti.</translation>
<translation id="5102203758995933166">Omogućuje primjenu mrežne konfiguracije za svakog korisnika na <ph name="PRODUCT_OS_NAME" /> uređaju. Mrežna je konfiguracija niz u formatu JSON, kao što je definirano formatom Open Network Configuration.</translation>
<translation id="5105313908130842249">Odgoda zaključavanja zaslona za vrijeme baterijskog napajanja</translation>
<translation id="5108031557082757679">Onemogućeni pisači za uređaje tvrtke</translation>
<translation id="5124368997194894978">Omogući pokretanje na izmjeničnom napajanju</translation>
<translation id="5131211790949066746">Omogućuje spajanje pravila <ph name="EXTENSION_INSTALL_BLACKLIST_POLICY_NAME" />, <ph name="EXTENSION_INSTALL_WHITELIST_POLICY_NAME" /> i <ph name="EXTENSION_INSTALL_FORCELIST_POLICY_NAME" /> za popise za instaliranje proširenja.

      Ako omogućite tu postavku, vrijednosti iz pravila za platformu uređaja, pravila za oblak uređaja i pravila za korisničku platformu spajaju se u jedan popis i upotrebljavaju kao cjelina umjesto da se upotrebljavaju samo vrijednosti iz jednog izvora s najvišim prioritetom.

      Ako onemogućite tu postavku ili je ne postavite, uzimaju se samo unosi s popisa iz izvora najvišeg prioriteta, a svi se ostali izvori prikazuju kao sukobi, no zanemaruju se.</translation>
<translation id="5141670636904227950">Postavljanje zadane vrste povećala na "omogućeno" na zaslonu za prijavu</translation>
<translation id="5142301680741828703">Uvijek prikaži sljedeće URL obrasce u okviru <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="5148753489738115745">Omogućuje vam da odredite dodatne parametre koji se upotrebljavaju kada <ph name="PRODUCT_FRAME_NAME" /> pokreće uslugu <ph name="PRODUCT_NAME" />.

          Ako se to pravilo ne postavi, upotrebljavat će se zadani naredbeni redak.</translation>
<translation id="5152787786897382519">Chromium i Google Chrome imaju neke grupe međusobno ovisnih pravila koja omogućuju upravljanje značajkom. Te su skupine predstavljene sljedećim grupama pravila. S obzirom da pravila mogu imati više izvora, primjenjuju se samo vrijednosti koje potječu iz izvora pravila najvišeg prioriteta. Vrijednosti koje potječu iz izvora nižeg prioriteta u istoj grupi zanemarit će se. Redoslijed prioriteta definiran je u pravilu <ph name="POLICY_PRIORITY_DOC_URL" />.</translation>
<translation id="5159469559091666409">Učestalost slanja mrežnih paketa za praćenje u milisekundama.

      Ako se to pravilo ne postavi, zadani interval iznosi 3 minute. Minimalni
      je interval 30 sekundi, a maksimalni 24 sata, a vrijednosti izvan raspona
      svest će se na taj raspon.</translation>
<translation id="5163002264923337812">Omogući staru prijavu na temelju weba</translation>
<translation id="5168529971295111207">To je pravilo obustavljeno. Umjesto njega upotrijebite ProxyMode.

          Omogućuje vam da odredite proxy poslužitelj kojim se koristi <ph name="PRODUCT_NAME" /> i onemogućuje korisnicima da mijenjaju postavke proxyja.

          To se pravilo primjenjuje samo ako se ne navede pravilo <ph name="PROXY_SETTINGS_POLICY_NAME" />.

          Ako odaberete da se proxy poslužitelj nikad ne upotrebljava i da se veza uvijek uspostavlja izravno, sve se ostale opcije zanemaruju.

          Ako odaberete upotrebu proxy postavki sustava ili automatsko otkrivanje proxy poslužitelja, sve se ostale opcije zanemaruju.

          Ako odaberete ručne postavke proxy poslužitelja, dodatne opcije možete navesti pod stavkama "Adresa ili URL proxy poslužitelja", 'URL za .pac datoteku proxy poslužitelja" i "Popis pravila o zaobilaženju proxyja odvojenih zarezima". ARC aplikacije upotrebljavat će samo HTTP proxy poslužitelj s najvišim prioritetom.

          Detaljne primjere možete pronaći ovdje:
          <ph name="PROXY_HELP_URL" />.

          Ako omogućite tu postavku, <ph name="PRODUCT_NAME" /> zanemarivat će sve opcije koje se odnose na proxy poslužitelj navedene u naredbenom retku.

          Ako se to pravilo ne postavi, korisnici će moći sami odabrati postavke proxyja.</translation>
<translation id="5182055907976889880">Konfiguracija Google diska u proizvodu <ph name="PRODUCT_OS_NAME" />.</translation>
<translation id="5183383917553127163">Omogućuje određivanje proširenja koja ne podliježu crnoj listi.

          Vrijednost * na crnoj listi znači da su sva proširenja na crnoj listi i da korisnici mogu instalirati samo proširenja koja su na bijeloj listi.

          Prema zadanim postavkama sva su proširenja na bijeloj listi, no ako su sva proširenja prema pravilu na crnoj listi, bijela lista može se upotrebljavati za poništavanje tog pravila.</translation>
<translation id="519247340330463721">Konfiguriranje pravila povezanih sa Sigurnim pregledavanjem.</translation>
<translation id="5192837635164433517">Omogućuje upotrebu zamjenskih stranica pogrešaka koje su ugrađene u proizvod <ph name="PRODUCT_NAME" /> (poput "Stranica nije pronađena") te sprječava korisnike da promijene tu postavku. Ako omogućite ovu postavku, upotrebljavat će se zamjenske stranice pogrešaka. Ako onemogućite ovu postavku, zamjenske stranice pogrešaka neće se nikada upotrebljavati. Ako omogućite ili onemogućite ovu postavku, korisnici neće moći promijeniti niti poništiti ovu postavku u proizvodu <ph name="PRODUCT_NAME" />. Ako pravilo nije postavljeno, to će biti omogućeno, ali korisnik će to moći promijeniti.</translation>
<translation id="5196805177499964601">Blokiranje načina rada razvojnog programera.

      Ako se to pravilo postavi na točno, <ph name="PRODUCT_OS_NAME" /> sprječava pokretanje uređaja u načinu rada razvojnog programera. Sustav će odbiti pokretanje i prikazati zaslon pogreške kada je način rada razvojnog programera uključen.

      Ako se to pravilo ne postavi ili se postavi na lažno, način rada razvojnog programera bit će dostupan za uređaj.</translation>
<translation id="520403427390290017">Značajka životnih ciklusa kartica rasterećuje procesor, a time i memoriju povezanu s izvođenjem kartica koje se dulje nisu koristile tako što ih najprije priguši, zatim zamrzne i konačno odbaci.

      Ako se to pravilo postavi na False, životni su ciklusi kartica onemogućeni i sve se kartice izvode na uobičajen način.

      Ako se to pravilo postavi na True ili se ne navede, životni su ciklusi kartica omogućeni.</translation>
<translation id="5207823059027350538">Konfigurira zadani URL web-stranice nove kartice i sprječava korisnike da ga promijene.

          Web-stranica nove kartice stranica je koja se otvara pri otvaranju novih kartica (uključujući one koje se otvaraju u novim prozorima).

          To pravilo ne određuje stranice koje se otvaraju prilikom pokretanja. Te se stranice određuju pravilima <ph name="RESTORE_ON_STARTUP_POLICY_NAME" />. No ovo pravilo utječe na početnu odnosno polaznu stranicu ako se postavi da one otvaraju web-stranice nove kartice.

          Ako se pravilo ne postavi ili se ostavi prazno, upotrebljavat će se zadana web-stranica nove kartice.

          Pravilo je dostupno samo na instancama Windowsa koje su pridružene domeni <ph name="MS_AD_NAME" /> ili instancama Windowsa 10 Pro ili Enterprise prijavljenim za upravljanje uređajima.</translation>
<translation id="5208240613060747912">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju web-lokacije koje ne smiju prikazivati obavijesti. Ako ovo pravilo nije postavljeno, upotrebljavat će se globalna zadana vrijednost za sve web-lokacije iz pravila "DefaultNotificationsSetting" ako je postavljeno, odnosno iz osobne konfiguracije korisnika ako nije.</translation>
<translation id="5213038356678567351">Web-lokacije koje nikad ne pokreću promjenu preglednika.</translation>
<translation id="5219844027738217407">Za Android aplikacije to pravilo utječe samo na mikrofon. Kada se to pravilo postavi na True, mikrofon je isključen za sve Android aplikacije, bez iznimke.</translation>
<translation id="5221394278852982313">Omogućuje postavljanje popisa URL-ova koji navode koje će web-lokacije automatski dobiti dopuštenje za pristup USB uređaju s navedenim ID-jem dobavljača i ID-jem proizvoda. Svaka stavka na popisu mora sadržavati uređaje i URL-ove da bi pravilo bilo važeće. Svaka stavka na uređaju može sadržavati polje ID-ja dobavljača i ID-ja proizvoda. Svaki izostavljeni ID smatra se zamjenskim znakom s jednom iznimkom, a ta je iznimka da se ID proizvoda ne može navesti, a da se ne navede i ID dobavljača. U suprotnom pravilo neće biti važeće i zanemarit će se.

        Model dopuštenja za USB upotrebljava URL web-lokacije koja šalje zahtjev ("URL koji šalje zahtjev") i URL vršnih web-lokacija u okviru ("URL koji se ugrađuje") kako bi se URL-u koji šalje zahtjev dopustio pristup USB uređaju. URL koji šalje zahtjev može se razlikovati od URL-a koji se ugrađuje ako se web-lokacija koja šalje zahtjev učitava u iframeu. Stoga, da bi se odredio URL koji šalje zahtjev i URL koji se ugrađuje, polje za "URL-ove" može sadržavati najviše dva niza URL-a razdvojena zarezom. Ako se odredi samo jedan URL, pristup će biti dopušten odgovarajućim USB uređajima kada se URL web-lokacije koja šalje zahtjev podudara s ovim URL-om, bez obzira na status ugrađivanja. URL-ovi u polju "URL-ovi" moraju biti važeći. U protivnom će se pravilo zanemariti.

        Ako se to pravilo ne postavi, za sve web-lokacije upotrebljavat će se globalna zadana vrijednost iz pravila "DefaultWebUsbGuardSetting" ako je to pravilo postavljeno, a ako nije, upotrebljavat će se korisnikova osobna konfiguracija.

        Uzorci URL-a u ovom pravilu ne bi trebali biti u sukobu s onima koji su konfigurirani pravilom WebUsbBlockedForUrls. Ako se pojavi sukob, ovo će pravilo imati prednost pred pravilima WebUsbBlockedForUrls i WebUsbAskForUrls.

        Vrijednosti za to pravilo i pravilo DeviceWebUsbAllowDevicesForUrls spajaju se.</translation>
<translation id="5228316810085661003">Odgoda automatske prijave lokalnog računa na uređaju.

      To se pravilo ne primjenjuje ako se ne postavi pravilo |DeviceLocalAccountAutoLoginId|. U protivnom:

      Ako se to pravilo postavi, njime se određuje količina vremena bez aktivnosti korisnika koje treba proći prije automatske prijave na lokalni račun na uređaju koji je određen pravilom |DeviceLocalAccountAutoLoginId|.

      Ako se to pravilo ne postavi, kao vrijeme čekanja upotrebljavat će se 0 milisekundi.

      To se pravilo određuje u milisekundama.</translation>
<translation id="523505283826916779">Postavke pristupačnosti</translation>
<translation id="5236882091572996759">Ako se to pravilo postavi na true ili se ne postavi, korisnik se neće smatrati neaktivnim tijekom reprodukcije audiozapisa. Time se sprječava odgoda neaktivnosti i izvršavanje radnji neaktivnosti. No nakon isteka konfiguriranog vremena čekanja zaslon će se zatamniti, isključiti i zaključati neovisno o aktivnosti audiozapisa.

          Ako se pravilo postavi na false, korisnik se može smatrati neaktivnim bez obzira na aktivnost audiozapisa.</translation>
<translation id="5246700266104954355">To je pravilo obustavljeno. Za upravljanje dostupnošću dodatka Flash upotrijebite pravilo <ph name="DEFAULT_PLUGINS_SETTING_POLICY_NAME" />, a pomoću pravila <ph name="ALWAYS_OPEN_PDF_EXTERNALLY_POLICY_NAME" /> odredite trebaju li se PDF datoteke otvarati u integriranom pregledniku za PDF.

      Određuje popis dodataka koji su omogućeni u pregledniku <ph name="PRODUCT_NAME" /> i sprječava korisnike da promijene tu postavku.

      Za podudaranje nizova proizvoljnih znakova mogu se koristiti zamjenski znakovi "*" i "?". "*" odgovara proizvoljnom broju znakova, a "?" određuje opcijski pojedinačni znak, odnosno odgovara znakovima nula ili jedan. "\" je prespojni znak, tako da za podudaranje s pravim znakovima "*", "?" ili "\" možete ispred njih staviti znak "\".

      Navedeni se popis dodataka uvijek upotrebljava u pregledniku <ph name="PRODUCT_NAME" /> ako su dodaci instalirani. Dodaci su označeni kao omogućeni na stranici "about:plugins" i korisnici ih ne mogu onemogućiti.

      To pravilo nadjačava pravila DisabledPlugins i DisabledPluginsExceptions.

      Ako se pravilo ne postavi, korisnik može onemogućiti bilo koji dodatak koji je instaliran na sustavu.</translation>
<translation id="5247006254130721952">Blokiraj opasna preuzimanja</translation>
<translation id="5248863213023520115">Postavlja vrste enkripcije koje su dopuštene kada se od <ph name="MS_AD_NAME" /> poslužitelja zahtijeva Kerberos ulaznica.

      Ako se to pravilo postavi na "Sve", dopuštene su vrste enkripcije AES "aes256-cts-hmac-sha1-96" i "aes128-cts-hmac-sha1-96", kao i vrsta RC4 enkripcije "rc4-hmac". AES enkripcija ima prednost ako poslužitelj podržava obje vrste. RC4 ne smatra se sigurnom enkripcijom i poslužitelj bi se po mogućnosti trebao ponovo konfigurirati tako da podržava AES.

      Ako se pravilo postavi na "Jako" ili se ne postavi, dopuštene su samo vrste AES enkripcije.

      Ako se pravilo postavi na "Naslijeđeno", dopuštena je samo RC4 enkripcija. Ta opcija nije sigurna i potrebna je samo u vrlo specifičnim okolnostima.

      Pročitajte i https://wiki.samba.org/index.php/Samba_4.6_Features_added/changed#Kerberos_client_encryption_types.</translation>
<translation id="5249453807420671499">Korisnici mogu dodati Kerberos račune</translation>
<translation id="5255162913209987122">Može se preporučiti</translation>
<translation id="527237119693897329">Omogućuje vam da odredite koji se hostovi za lokalno slanje poruka ne bi smjeli učitavati.

          Vrijednost "*" na popisu nedopuštenih znači da su svi hostovi za lokalno slanje poruka zabranjeni, osim u slučaju kada su izričito navedeni na popisu dopuštenih.

          Ako se to pravilo ne postavi, usluga <ph name="PRODUCT_NAME" /> učitat će sve instalirane hostove za lokalno slanje poruka.</translation>
<translation id="5272684451155669299">Ako se postavi na True, korisnik može upotrebljavati hardver na Chrome uređajima za daljinsko atestiranje identiteta CA-u privatnosti putem API-ja <ph name="ENTERPRISE_PLATFORM_KEYS_API" /> pomoću funkcije <ph name="CHALLENGE_USER_KEY_FUNCTION" />.

          Ako se postavi na False ili ako se ne postavi, pozivi API-ju vratit će kôd pogreške.</translation>
<translation id="5277806246014825877">Omogućuje tom korisniku da pokrene Crostini.

      Ako se to pravilo postavi na False, Crostini neće biti omogućen za korisnika.
      Ako se postavi na True ili se ne postavi, Crostini će biti omogućen za korisnika pod uvjetom da to dopuštaju i druge postavke.
      Sva tri pravila, VirtualMachinesAllowed, CrostiniAllowed i DeviceUnaffiliatedCrostiniAllowed, moraju se postaviti na True kada se primjenjuju na dopuštanje pokretanja Crostinija.
      Ako se to pravilo promijeni na False, primjenjuje se na pokretanje novih spremnika za Crostini, ali ne isključuje one koji su već pokrenuti.</translation>
<translation id="5283457834853986457">Onemogućuje alat za traženje dodataka (obustavljen)</translation>
<translation id="5288772341821359899">Ako se to pravilo postavi, raspon UDP priključaka kojima se koristi WebRTC ograničen je na navedeni interval priključaka (krajnje točke uključene).

      Ako se pravilo ne postavi ili se postavi na prazni niz ili nevažeći raspon priključaka, WebRTC može upotrebljavati bilo koji dostupni lokalni UDP priključak.</translation>
<translation id="5290940294294002042">Odredite popis dodataka koje korisnik može omogućiti ili onemogućiti</translation>
<translation id="5306186200045823863">Omogući pouzdanost naslijeđene infrastrukture javnog ključa tvrtke Symantec Corporation</translation>
<translation id="5307432759655324440">Pristupačnost anonimnog načina rada</translation>
<translation id="5318185076587284965">Omogući hostu za daljinski pristup upotrebu relejnih poslužitelja</translation>
<translation id="5323128137188992869">Dopusti emitiranje sadržaja na uređaj pomoću usluge <ph name="PRODUCT_NAME" />.

          Ako se to pravilo postavi na False, korisnici neće moći emitirati sadržaj na svom uređaju. Ako se pravilo postavi na True, korisnici će moći emitirati sadržaj. Ako se pravilo ne postavi, korisnici neće moći emitirati sadržaj na registrirane uređaje s OS-om Chrome, ali će moći emitirati na neregistrirane uređaje.</translation>
<translation id="5329007337159326804">Upozorenje: pravilo o maksimalnoj verziji TLS-a u potpunosti će se ukloniti iz proizvoda <ph name="PRODUCT_NAME" /> oko verzije 75 (oko lipnja 2019.).

      Ako se to pravilo ne konfigurira, <ph name="PRODUCT_NAME" /> upotrebljava zadanu maksimalnu verziju.

      U suprotnom se može postaviti na jednu od sljedećih vrijednosti: "tls1.2" ili "tls1.3". Kad se pravilo postavi, <ph name="PRODUCT_NAME" /> neće upotrebljavati verzije SSL-a/TLS-a veće od navedene verzije. Vrijednost koja se ne prepozna ignorirat će se.</translation>
<translation id="5330684698007383292">Dopusti proizvodu <ph name="PRODUCT_FRAME_NAME" /> rukovanje sljedećim vrstama sadržaja</translation>
<translation id="5331746669335642668">Pravila oblaka za <ph name="PRODUCT_NAME" /> nadjačavaju pravila platforme.</translation>
<translation id="5365476955714838841">Parametri naredbenog retka za zamjenski preglednik.</translation>
<translation id="5365946944967967336">Prikaži gumb Početna na alatnoj traci</translation>
<translation id="5366745336748853475">Omogućuje vam da navedete popis uzoraka URL-ova koji određuju web-lokacije za koje je certifikat klijenta automatski odabran na zaslonu za prijavu u okviru koji hostira SAML protok, ako web-lokacija zahtijeva certifikat. Primjer upotrebe je konfiguracija certifikata za cijeli uređaj koji će se pojaviti za SAML IdP.

      Vrijednost mora biti polje JSON rječnika u nizovima. Svaki rječnik mora biti u obliku { "pattern": "$URL_PATTERN", "filter" : $FILTER }, pri čemu je $URL_PATTERN uzorak postavke sadržaja. $FILTER ograničava između kojih će klijentskih certifikata preglednik automatski birati. Neovisno o filtru, birat će se samo certifikati koji se podudaraju sa zahtjevom poslužitelja za certifikat. Ako je $FILTER u obliku { "ISSUER": { "CN": "$ISSUER_CN" } }, dodatno se biraju samo klijentski certifikati koje izdaje certifikat koji ima CommonName $ISSUER_CN. Ako je $FILTER prazan rječnik {}, odabir klijentskih certifikata nije dodatno ograničen.

      Ako se to pravilo ne postavi, neće biti automatskog odabira ni za jednu web-lokaciju.</translation>
<translation id="5366977351895725771">Ako je postavljeno na netočno, korisnik neće moći izrađivati nadzirane korisnike. Postojeći nadzirani korisnici i dalje će biti dostupni.

          Ako je postavljeno na točno ili nije konfigurirano, korisnik može izrađivati nadzirane korisnike i upravljati njima.</translation>
<translation id="5369937289900051171">Samo ispis u boji</translation>
<translation id="5370279767682621504">Omogući podršku za HTTP/0.9 na priključcima koji nisu zadani</translation>
<translation id="5378985487213287085">Omogućuje da postavite smiju li web-lokacije prikazivati obavijesti radne površine. Prikazivanje obavijesti radne površine može biti dopušteno prema zadanim postavkama, odbijeno prema zadanim postavkama ili korisnik može primiti upit svaki put kad web-lokacija želi prikazati obavijest radne površine. Ako to pravilo nije postavljeno, upotrebljavat će se pravilo "AskNotifications", a korisnik će to moći promijeniti.</translation>
<translation id="538108065117008131">Dopusti da <ph name="PRODUCT_FRAME_NAME" /> rukuje sljedećim vrstama sadržaja.</translation>
<translation id="5391388690191341203">Lokalni račun na uređaju za automatsku prijavu</translation>
<translation id="5392172595902933844">Informacije o statusu Androida šalju se
      poslužitelju.

      Ako se to pravilo postavi na False ili se ne postavi, informacije o statusu neće se prijavljivati.
      Ako se postavi na True, te će se informacije prijavljivati.

      To se pravilo primjenjuje samo ako su omogućene Androidove aplikacije.</translation>
<translation id="5395271912574071439">Omogućuje skrivanje hostova za daljinski pristup dok traje povezivanje.

          Ako je ova postavka omogućena, tada se onemogućuju fizički ulazni i izlazni uređaji hosta dok je daljinsko povezivanje u tijeku.

          Ako je ta postavka onemogućena ili nije postavljena, tada u interakciju s hostom mogu stupati lokalni i udaljeni korisnici kada se on dijeli.</translation>
<translation id="5396049152026347991">Dopusti korisniku da upravlja VPN vezama.

      Ako se to pravilo postavi na False, onemogućena su sva korisnička sučelja proizvoda <ph name="PRODUCT_NAME" /> koja bi korisniku omogućila da prekine vezu ili izmijeni VPN veze.

      Ako se pravilo ne postavi ili se postavi na True, korisnici mogu prekinuti vezu ili izmijeniti VPN veze kao i obično.

      Ako se VPN veza uspostavi putem VPN aplikacije, to pravilo ne utječe na korisničko sučelje u toj aplikaciji. Korisnik bi stoga i dalje mogao upotrebljavati tu aplikaciju za izmjenu VPN veze.

      To bi se pravilo trebalo upotrebljavati zajedno sa značajkom "Uvijek uključena VPN mreža" koja administratoru omogućuje da odredi hoće li se VPN veza uspostaviti prilikom pokretanja.</translation>
<translation id="5405289061476885481">Konfigurira koji su rasporedi tipkovnice dopušteni na zaslonu za prijavu za <ph name="PRODUCT_OS_NAME" />.

      Ako se to pravilo postavi na popis identifikatora načina unosa, zadani načini unosa bit će dostupni na zaslonu za prijavu. Prvi zadani način unosa bit će odabran unaprijed. Kad je korisnički modul aktiviran na zaslonu za prijavu, uz načine unosa zadane ovim pravilom bit će dostupan i način unosa koji je korisnik zadnji upotrebljavao. Ako se to pravilo ne postavi, načini unosa na zaslonu za prijavu izvest će se iz jezika na kojem se prikazuje zaslon za prijavu. Zanemarit će se vrijednosti koje nisu važeći identifikatori načina unosa.</translation>
<translation id="5412057811596122582">Ako je to pravilo omogućeno ili nije konfigurirano (zadano), od korisnika će se
      tražiti pristup za snimanje audiozapisa osim za URL-ove konfigurirane na popisu
      AudioCaptureAllowedUrls kojima će se pristup odobravati bez postavljanja upita.

      Kada je to pravilo onemogućeno, korisniku se nikad neće postaviti upit i
      snimanje će biti dostupno samo URL-ovima na popisu AudioCaptureAllowedUrls.

      To pravilo utječe na sve vrste audioulaza, a ne samo na ugrađeni mikrofon.</translation>
<translation id="5422643441807528365">Licencni ključ <ph name="PLUGIN_VM_NAME" /></translation>
<translation id="5423001109873148185">Ako je omogućeno, ovo pravilo prisilno uvozi tražilice iz trenutačno zadanog preglednika. Ako je omogućeno, ovo pravilo također utječe na dijaloški okvir za uvoz. Ako je onemogućeno, zadana se tražilica ne uvozi. Ako nije postavljeno, korisniku može biti postavljen upit želi li uvesti tražilicu ili do uvoza može doći automatski.</translation>
<translation id="5423197884968724595">Naziv ograničenja za Android WebView:</translation>
<translation id="5424147596523390018">Dopusti sve načine boje</translation>
<translation id="5427003226809696696">Ovim pravilima kontrolira se treba li se prozor preglednika otvarati pri pokretanju sesije.

          Ako su ova pravila omogućena, prozor preglednika neće se otvarati.

          Ako su ova pravila onemogućena ili nisu postavljena, prozoru preglednika dopušteno je otvaranje. Imajte na umu da se prozor preglednika možda neće otvoriti zbog drugih pravila ili oznaka naredbenog retka.</translation>
<translation id="5427879482805712214">To pravilo omogućuje vam da konfigurirate sliku avatara koji predstavlja korisnika na zaslonu za prijavu. Pravilo se postavlja tako da se navede URL s kojeg <ph name="PRODUCT_OS_NAME" /> može preuzeti sliku avatara i kriptografsko hashiranje kojim se potvrđuje integritet preuzimanja. Slika mora biti u JPEG formatu i ne smije biti veća od 512 KB. URL-u se mora moći pristupiti bez autentifikacije.

      Slika avatara preuzima se i sprema u predmemoriju. Ponovo će se preuzeti svaki put kada se URL ili hashiranje promijene.

      Ako se to pravilo postavi, <ph name="PRODUCT_OS_NAME" /> preuzet će i koristiti sliku avatara.

      Ako postavite to pravilo, korisnici ga neće moći promijeniti ni nadjačati.

      Ako se pravilo ne postavi, korisnik može odabrati sliku avatara koja će ga predstavljati na zaslonu za prijavu.</translation>
<translation id="5432219358069697932">To pravilo omogućuje vam da konfigurirate sliku pozadine koja se prikazuje na radnoj površini i pozadini zaslona za prijavu korisnika. Pravilo se postavlja tako da se navede URL s kojeg <ph name="PRODUCT_OS_NAME" /> može preuzeti sliku pozadine i kriptografsko hashiranje kojim se potvrđuje integritet preuzimanja. Slika mora biti u JPEG formatu i ne smije biti veća od 16 MB. URL-u se mora moći pristupiti bez autentifikacije.

      Slika pozadine preuzima se i sprema u predmemoriju. Ponovo će se preuzeti svaki put kada se URL ili hashiranje promijene.

      Ako se to pravilo postavi, <ph name="PRODUCT_OS_NAME" /> preuzet će i koristiti sliku pozadine.

      Ako postavite to pravilo, korisnici ga neće moći promijeniti ni nadjačati.

      Ako se pravilo ne postavi, korisnik može odabrati sliku koja će se prikazivati na radnoj površini i pozadini zaslona za prijavu.</translation>
<translation id="5437733496511628148">Omogućavanjem te postavke sprječava se da elementi web-stranice koji ne pripadaju domeni prikazanoj u adresnoj traci preglednika postavljaju kolačiće.

      Onemogućavanjem te postavke dopušta se postavljanje kolačića elementima web-stranica koji ne pripadaju domeni prikazanoj u adresnoj traci preglednika te se sprječava da korisnici promijene tu postavku.

      Ako se pravilo ne postavi, kolačići trećih strana bit će omogućeni, ali će korisnici to moći promijeniti.</translation>
<translation id="5442026853063570579">To pravilo kontrolira i pristup Opcijama za razvojne programere Androida. Ako to pravilo postavite na "DeveloperToolsDisallowed" (vrijednost 2), korisnici ne mogu pristupiti Opcijama za razvojne programere. Ako to pravilo postavite na neku drugu vrijednost ili ga ne postavite, korisnici mogu pristupiti Opcijama za razvojne programere tako što će sedam puta dodirnuti broj međuverzije u aplikaciji postavki Androida.</translation>
<translation id="544342220587994947">Omogućuje vam da navedete popis uzoraka URL-ova koji određuju web-lokacije za koje <ph name="PRODUCT_NAME" /> treba automatski odabirati klijentski certifikat ako web-lokacija zahtijeva certifikat.

          Vrijednost mora biti polje JSON rječnika u nizovima. Svaki rječnik mora biti u obliku { "pattern": "$URL_PATTERN", "filter" : $FILTER }, pri čemu je $URL_PATTERN uzorak postavke sadržaja. $FILTER ograničava između kojih će klijentskih certifikata preglednik automatski birati. Neovisno o filtru, birat će se samo certifikati koji se podudaraju sa zahtjevom poslužitelja za certifikat. Na primjer, ako je $FILTER u obliku { "ISSUER": { "CN": "$ISSUER_CN" } }, dodatno se biraju samo klijentski certifikati koje izdaje certifikat koji ima CommonName $ISSUER_CN. Ako $FILTER sadrži odjeljak "ISSUER" i "SUBJECT", klijentski certifikat mora ispunjavati oba uvjeta da bi se mogao odabrati. Ako $FILTER navodi organizaciju ("O"), certifikat mora imati najmanje jednu organizaciju koja se podudara s navedenom vrijednosti da bi se mogao odabrati. Ako $FILTER navodi organizacijsku jedinicu ("OU"), certifikat mora imati najmanje jednu organizacijsku jedinicu koja se podudara s navedenom vrijednosti da bi se mogao odabrati. Ako je $FILTER prazan rječnik {}, odabir klijentskih certifikata nije dodatno ograničen.

          Ako se to pravilo ne postavi, neće biti automatskog odabira ni za jednu web-lokaciju.</translation>
<translation id="5447306928176905178">Omogući prijavljivanje informacija o memoriji (ukupna veličina JS-a) na stranici (zastarjelo)</translation>
<translation id="5457065417344056871">Omogućivanje načina rada za goste u pregledniku</translation>
<translation id="5457924070961220141">Omogućuje konfiguriranje zadanog HTML prikazivača kada je instaliran okvir <ph name="PRODUCT_FRAME_NAME" />. Ako ovo pravilo nije postavljeno, zadana je postavka da prikazivanje obavlja preglednik hosta, ali to po izboru možete poništiti i postaviti da okvir <ph name="PRODUCT_FRAME_NAME" /> prikazuje HTML stranice prema zadanim postavkama.</translation>
<translation id="5458584148602890023">Omogućivanje prebacivanja napajanja radi uštede energije</translation>
<translation id="5464816904705580310">Konfiguriranje postavki za upravljane korisnike.</translation>
<translation id="546726650689747237">Odgoda zatamnjenja zaslona za vrijeme napajanja izmjeničnom strujom</translation>
<translation id="5469143988693423708">Korisniku omogućuje pokretanje Crostinija</translation>
<translation id="5469825884154817306">Blokiraj slike na ovim web-lokacijama</translation>
<translation id="5472668698895343595">To pravilo određuje popis web-lokacija koje se trebaju otvoriti u zamjenskom pregledniku.

      Tom se popisu mogu dodati i elementi pomoću pravila <ph name="USE_IE_SITELIST_POLICY_NAME" /> i <ph name="EXTERNAL_SITELIST_URL_POLICY_NAME" />.

      Ako se pravilo ne postavi, web-lokacije neće se dodavati na popis.

      Ako se pravilo postavi, svaka se stavka tretira kao pravilo za otvaranje u zamjenskom pregledniku. <ph name="PRODUCT_NAME" /> na temelju tih pravila odlučuje treba li se neki URL otvoriti u zamjenskom pregledniku.

      Kada je prisutan i omogućen dodatak Internet Explorera, Internet Explorer vraća se na preglednik <ph name="PRODUCT_NAME" /> ako se pravila ne podudaraju.

      Ako su pravila proturječna, <ph name="PRODUCT_NAME" /> upotrebljava najodređenije pravilo.</translation>
<translation id="5475361623548884387">Omogući ispis</translation>
<translation id="547601067149622666">Nemojte dopustiti oglase na web-lokacijama s ometajućim oglasima</translation>
<translation id="5483065054530244863">Dopusti certifikate s SHA-1 potpisom koje izdaju lokalne pouzdane ustanove</translation>
<translation id="5483777239978559943">To je pravilo obustavljeno. Za upravljanje dostupnošću dodatka Flash upotrijebite pravilo <ph name="DEFAULT_PLUGINS_SETTING_POLICY_NAME" />, a pomoću pravila <ph name="ALWAYS_OPEN_PDF_EXTERNALLY_POLICY_NAME" /> odredite hoće li se za otvaranje PDF datoteka upotrebljavati integrirani preglednik za PDF.

      Određuje popis dodataka koje korisnik može omogućiti ili onemogućiti u pregledniku <ph name="PRODUCT_NAME" />.

      Zamjenski znakovi "*" i "?" mogu se upotrebljavati za podudaranje nizova proizvoljnih znakova. "*" odgovara proizvoljnom broju znakova, a "?" određuje opcijski pojedinačni znak, odnosno odgovara znakovima nula ili jedan. "\" je prespojni znak, tako da za podudaranje s pravim znakovima "*", "?" ili "\" možete ispred njih staviti znak "\".

      Ako omogućite tu postavku, u pregledniku <ph name="PRODUCT_NAME" /> može se upotrebljavati navedeni popis dodataka. Korisnici ih mogu omogućiti ili onemogućiti u stavci "about:plugins", čak i ako se dodatak podudara s uzorkom na popisu "DisabledPlugins". Korisnici također mogu omogućiti i onemogućiti dodatke koji se ne podudaraju s nijednim uzorkom na popisima "DisabledPlugins", "DisabledPluginsExceptions" i "EnabledPlugins".

      To pravilo služi za omogućavanje strogog zabranjivanja dodataka u slučajevima kad popis "DisabledPlugins" sadrži unose sa zamjenskim znakovima kao što su "onemogući sve dodatke '*'" ili "onemogući sve Java dodatke '*Java*'", dok administrator želi omogućiti neke određene verzije kao što je "IcedTea Java 2.3". Te određene verzije moguće je navesti u ovom pravilu.

      Imajte na umu da je potrebno izuzeti i naziv dodatka i naziv grupe dodataka. Svaka grupa dodataka prikazana je u zasebnom odjeljku u about:plugins, a svaki odjeljak može imati jedan dodatak ili više njih. Na primjer, dodatak "Shockwave Flash" pripada grupi "Adobe Flash Player", a oba naziva moraju imati svoje podudaranje na popisu iznimki ako se taj dodatak planira izuzeti s popisa nedopuštenih.

      Ako se pravilo ne postavi, svaki dodatak koji odgovara uzorcima u "DisabledPlugins" bit će onemogućen i zaključan, a korisnik ga neće moći omogućiti.</translation>
<translation id="5499375345075963939">To je pravilo aktivno samo u prodajnom načinu.

      Kada je vrijednost tog pravila postavljena i nije 0, trenutačno prijavljeni korisnik demo verzije automatski će biti odjavljen nakon isteka razdoblja neaktivnosti određenog trajanja.

      Vrijednost pravila treba odrediti u milisekundama.</translation>
<translation id="5508307164752647432">Omogući funkciju Kerberos</translation>
<translation id="5511702823008968136">Omogući traku Knjižne oznake</translation>
<translation id="5512418063782665071">URL početne stranice</translation>
<translation id="551639594034811656">Pravilom se definira popis postotaka kojim će se definirati udio <ph name="PRODUCT_OS_NAME" /> uređaja u organizacijskoj jedinici za dnevno ažuriranje počevši od dana otkrivanja ažuriranja. Vrijeme otkrivanja kasnije je od vremena objavljivanja ažuriranja jer nakon objavljivanja ažuriranja može proći neko vrijeme dok uređaj ne potraži ažuriranja.

      Svaki par (dan, postotak) sadrži postotak flote koji se treba ažurirati za određeni broj dana od vremena otkrivanja ažuriranja. Na primjer, ako su parovi [(4, 40), (10, 70), (15, 100)], to znači da se 40% flote treba ažurirati u roku od četiri dana od otkrivanja ažuriranja, 70% treba se ažurirati u roku od 10 dana i tako dalje.

      Ako se za ovo pravilo definira vrijednost, ažuriranja će zanemariti pravilo <ph name="DEVICE_UPDATE_SCATTER_FACTOR_POLICY_NAME" /> i slijediti ovo pravilo.

      Ako je popis prazan, neće biti postupnog uvođenja i ažuriranja će se primijeniti prema drugim pravilima za uređaje.

      Pravilo se ne primjenjuje na prebacivanje kanala.</translation>
<translation id="5526701598901867718">Sve (nije sigurno)</translation>
<translation id="5529037166721644841">Određuje vrijeme u milisekundama tijekom kojeg se od usluge upravljanja uređajima traže podaci o korisničkim pravilima.

      Postavljanje ovog pravila nadjačava zadanu vrijednost od 3 sata. Valjane vrijednosti za ovo pravilo u rasponu su od 1800000 (30 minuta) do 86400000 (1 dan). Sve vrijednosti koje nisu u ovom rasponu prebacit će se u odgovarajuće granice.

      Ako ne postavite to pravilo, <ph name="PRODUCT_OS_NAME" /> upotrebljavat će zadanu vrijednost od 3 sata.

      Ako platforma podržava obavijesti o pravilima, odgoda osvježavanja postavit će se na 24 sata (sve zadane postavke i vrijednost ovog pravila zanemarit će se) jer se očekuje da će obavijesti o pravilima automatski nametnuti osvježavanje nakon svake promjene pravila, zbog čega su češća osvježavanja nepotrebna.</translation>
<translation id="5530347722229944744">Blokiraj potencijalno opasna preuzimanja</translation>
<translation id="5535973522252703021">Bijela lista Kerberos poslužitelja za ovlašćivanje</translation>
<translation id="554903022911579950">Kerberos</translation>
<translation id="555077880566103058">Dopusti svim web-lokacijama pokretanje dodatka <ph name="FLASH_PLUGIN_NAME" /></translation>
<translation id="5559079916187891399">To pravilo nema utjecaja na Android aplikacije.</translation>
<translation id="5560039246134246593">Dodavanje parametra dohvaćanju vrijednosti varijacija u proizvodu <ph name="PRODUCT_NAME" />.

      Ako je naveden, parametar upita pod nazivom "restrict" dodat će se URL-u za dohvaćanje vrijednosti varijacija. Vrijednost parametra bit će vrijednost navedena u ovom pravilu.

      Ako nije naveden, URL vrijednosti varijacija neće se izmijeniti.</translation>
<translation id="5561811616825571914">Automatski odabir klijentskih certifikata za te web-lokacije na zaslonu za prijavu</translation>
<translation id="5565178130821694365">Zaporku treba unijeti svaka dva dana (48 sati)</translation>
<translation id="5566210228171064229">Dopusti ispis s PIN-om i bez njega</translation>
<translation id="556865034069957245">To pravilo upravlja dostupnošću prikaza preko cijelog u kojem su svi elementi korisničkog sučelja preglednika <ph name="PRODUCT_NAME" /> skriveni, a vidljiv je samo web-sadržaj.

      Ako se to pravilo postavi na true ili se ne konfigurira, korisnici, aplikacije i proširenja s odgovarajućim dopuštenjima mogu pristupiti prikazu preko cijelog zaslona.

      Ako se pravilo postavi na false, nijedan korisnik, aplikacija ili proširenje ne mogu pristupiti prikazu preko cijelog zaslona.

      Kad je onemogućen prikaz preko cijelog zaslona, način kioska nije dostupan ni na jednoj platformi osim za <ph name="PRODUCT_OS_NAME" />.</translation>
<translation id="556941986578702361">Kontroliraj automatsko skrivanje police proizvoda <ph name="PRODUCT_OS_NAME" />.

      Ako je ta polica postavljena na "AlwaysAutoHideShelf", polica će uvijek biti automatski skrivena.

      Ako je ta polica postavljena na "NeverAutoHideShelf", polica se nikada automatski ne skriva.

      Ako postavite to pravilo, korisnici ga ne mogu promijeniti niti prebrisati.

      Ako pravilo nije postavljeno, korisnici mogu birati treba li se polica automatski skrivati.</translation>
<translation id="557360560705413259">Kada se ta postavka omogući, <ph name="PRODUCT_NAME" /> upotrebljava commonName certifikata poslužitelja za pronalaženje podudarnosti s nazivom poslužitelja ako certifikatu nedostaje proširenje subjectAlternativeName pod uvjetom da uspješno potvrdi lokalno instalirane CA certifikate i poveže s njima.

      Napominjemo da se to ne preporučuje jer može omogućiti zaobilaženje proširenja nameConstraints koje ograničava nazive hostova za koje određeni certifikat može biti ovlašten.

      Ako se to pravilo ne postavi ili se postavi na False, certifikati poslužitelja kojima nedostaje proširenje subjectAlternativeName s nazivom DNS-a ili IP adresom neće se smatrati pouzdanima.</translation>
<translation id="5578571772998293651">Dopušta povratne informacije korisnika.
        Ako se pravilo postavi na false, korisnici ne mogu slati Googleu povratne informacije.

        Ako se pravilo ne postavi ili se postavi na true, korisnici mogu poslati Googleu povratne informacije tako da otvore Izbornik -&gt; Pomoć -&gt; Prijava poteškoće ili pomoću kombinacije tipaka.</translation>
<translation id="5581292529942108810">Konfigurira pravila povezana s Chromeovim proširenjem za prijavljivanje.

      To se pravilo primjenjuje samo kada je omogućeno pravilo <ph name="CHROME_REPORTING_EXTENSION_NAME" />, a računalo je prijavljeno tokenom <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="5583806683960333345">Ako se ta postavka omogući, korisnici će moći upotrebljavati Automatsko modemsko povezivanje koje im omogućuje da dijele mobilne podatke svojeg Google telefona s uređajem.

      Ako se ta postavka onemogući, korisnicima neće biti dopuštena upotreba Automatskog modemskog povezivanja.

      Ako se ne postavi, to će pravilo prema zadanim postavkama biti onemogućeno za upravljane korisnike u organizacijama, a za neupravljane korisnike bit će omogućeno.</translation>
<translation id="5584132346604748282">Kontrola Googleovih usluga lokacije na Androidu</translation>
<translation id="5586942249556966598">Ne radi ništa</translation>
<translation id="5590494712401018042">Određuje postotak za skaliranje odgode zatamnjivanja zaslona kada je uređaj u prezentacijskom načinu.

          Ako se to pravilo postavi, ono određuje postotak za skaliranje odgode zatamnjivanja zaslona kada je uređaj u prezentacijskom načinu. Kada se odgoda zatamnjivanja zaslona skalira, odgode isključivanja zaslona, zaključavanja zaslona i mirovanja podešavaju se kako bi se zadržali isti vremenski odmaci za odgodu zatamnjivanja zaslona koji su izvorno konfigurirani.

          Ako se to pravilo ne postavi, upotrebljava se zadani faktor skaliranja.

          To se pravilo primjenjuje samo ako je onemogućeno pravilo <ph name="POWER_SMART_DIM_ENABLED_POLICY_NAME" />. U suprotnom se to pravilo zanemaruje jer se odgoda zatamnjivanja zaslona određuje modelom strojnog učenja.

          Faktor skaliranja mora biti 100% ili više. Vrijednosti uslijed kojih bi odgoda zatamnjivanja zaslona u prezentacijskom načinu bila kraća od regularne odgode zatamnjivanja zaslona nisu dopuštene.</translation>
<translation id="5592242031005200087">
      Ako je pravilo omogućeno, svaki od navedenih izvora na popisu odijeljenom zarezima izvodit će se u vlastitom procesu. Time će se također izolirati izvori navedeni prema poddomenama. Na primjer, ako se navede https://example.com/, izolirat će se i https://foo.example.com/ kao dio web-lokacije https://example.com/.
      Ako se pravilo onemogući, neće doći do izričite izolacije web-lokacije i radne verzije IsolateOriginsAndroid i SitePerProcessAndroid bit će onemogućene. Korisnici će i dalje moći ručno omogućiti IsolateOrigins putem oznake naredbenog retka.
      Ako se pravilo ne konfigurira, korisnici će moći izmijeniti tu postavku.

      NAPOMENA: izolacija web-lokacija na Androidu u eksperimentalnoj je fazi. Podrška će se s vremenom poboljšati, ali trenutačno može doći do problema pri izvedbi.

      NAPOMENA: ovo pravilo primjenjuje se samo na Chrome na Androidu koji se izvodi na uređajima koji moraju imati više od 1 GB RAM-a. Za primjenu pravila na drugim platformama upotrijebite IsolateOrigins.
      </translation>
<translation id="5599461642204007579">Postavke upravljanja za <ph name="MS_AD_NAME" /></translation>
<translation id="5610104657949692379">Ako se postavi, to pravilo određuje koju će radnju <ph name="PRODUCT_OS_NAME" /> izvršiti kada korisnik nije aktivan tijekom razdoblja zadanog odgodom neaktivnosti koja se može konfigurirati zasebno.

          Ako se pravilo ne postavi, poduzima se zadana radnja, a to je obustava.

          Ako je radnja obustava, moguće je zasebno konfigurirati hoće li <ph name="PRODUCT_OS_NAME" /> zaključati zaslon prije obustavljanja.</translation>
<translation id="5618398258385745432">Povezana postavka upotrijebljena je prije uvođenja ponovne autentifikacije za prikaz zaporki. Od tada ta postavka pa ni ovo pravilo nisu utjecali na ponašanje Chromea. Trenutačno ponašanje Chromea sada je isto kao da se tim pravilom onemogućuje prikaz čitljivog teksta zaporki na stranici postavki upravitelja zaporki. To znači da stranica postavki sadrži samo rezervirano mjesto, a Chrome će prikazati zaporku tek kad korisnik klikne "Prikaži" (i izvrši ponovnu autentifikaciju ako je primjenjivo). Izvorni opis pravila naveden je u nastavku.

          Upravlja time može li korisnik prikazati zaporke čitljivim tekstom u upravitelju zaporki.

          Ako onemogućite tu postavku, upravitelj zaporki ne dopušta prikaz spremljenih zaporki čitljivim tekstom u prozoru upravitelja zaporki.

          Ako omogućite tu postavku ili ne postavite pravilo, korisnicima se zaporke u upravitelju zaporki prikazuju čitljivim tekstom.</translation>
<translation id="5620392548325769024">Omogući prikaz stranice dobrodošlice prilikom prvog pokretanja preglednika nakon nadogradnje OS-a</translation>
<translation id="5630352020869108293">Vrati posljednju sesiju</translation>
<translation id="5643906875497889108">Određuje vrste aplikacija/proširenja koje se smiju instalirati i ograničava pristup vremenu izvođenja.

          Ta postavka navodi popis dopuštenih vrsta proširenja/aplikacija koje se mogu instalirati u pregledniku <ph name="PRODUCT_NAME" /> i hostova s kojima mogu stupati u interakciju. Vrijednost je popis nizova od kojih svaki treba biti jedno od sljedećeg: "extension", "theme", "user_script", "hosted_app", "legacy_packaged_app" i "platform_app". Više informacija o pojedinoj vrsti možete pronaći u dokumentaciji proširenja za <ph name="PRODUCT_NAME" />.

          Napominjemo da to pravilo utječe i na prisilnu instalaciju proširenja i aplikacija putem pravila ExtensionInstallForcelist.

          Ako se ta postavka konfigurira, proširenja/aplikacije čija vrsta nije navedena na popisu neće se instalirati.

          Ako se postavka ne konfigurira, neće se primjenjivati ograničenja u vezi s prihvatljivim vrstama proširenja/aplikacija.

          Upotreba više ID-jeva odvojenih zarezima prije verzije 75 nije podržana i preskočit će se. Ostatak pravila i dalje će se primjenjivati.</translation>
<translation id="5645779841392247734">Dopusti kolačiće na ovim web-lokacijama</translation>
<translation id="5689430183304951538">Veličina stranice zadanog ispisa</translation>
<translation id="5693469654327063861">Dopusti premještanje podataka</translation>
<translation id="5694594914843889579">Kada se to pravilo postavi na True, vanjska pohrana neće biti dostupna u pregledniku datoteka.

      To pravilo utječe na sve vrste medija za pohranu, na primjer USB flash pogone, vanjske tvrde diskove, SD i ostale memorijske kartice, optičku pohranu itd. Ne utječe na unutarnju pohranu, pa se i dalje može pristupati datotekama spremljenima u mapu Preuzimanja. To pravilo ne utječe ni na Google disk.

      Ako se ta postavka onemogući ili ako se ne konfigurira, korisnici na svojem uređaju mogu upotrebljavati sve podržane vrste vanjske pohrane.</translation>
<translation id="5697306356229823047">Izvješće o korisnicima uređaja</translation>
<translation id="5699487516670033016">Određuje trajanje predmemorije podataka za autentifikaciju (u satima). Predmemorija se upotrebljava za bržu prijavu. Sadrži općenite podatke (naziv radne grupe itd.) o povezanim područjima, tj. područjima koje područje računala smatra pouzdanima. U predmemoriju ne spremaju se podaci o korisniku i podaci za nepovezana područja. Ponovnim pokretanjem uređaja briše se predmemorija.

      Ako se pravilo ne postavi, predmemorirani podaci mogu se ponovo upotrijebiti u trajanju od 73 sata.

      Ako se pravilo postavi na 0, predmemoriranje podataka za autentifikaciju nije uključeno. To može znatno usporiti prijavu pridruženih korisnika jer se podaci o području moraju dohvaćati pri svakoj prijavi.

      Napominjemo da se podaci o području spremaju u predmemoriju čak i za kratkotrajne korisnike. Predmemorija se treba isključiti ako se želi spriječiti praćenje područja kratkotrajnih korisnika.</translation>
<translation id="570062449808736508">Kada je to pravilo postavljeno na niz koji nije prazan, web-prikaz će čitati ograničenja za URL-ove davatelja sadržaja s određenim nazivom nadležnog tijela.</translation>
<translation id="5701714006401683963">Ako se to pravilo postavi na False, upravljana gostujuća sesija ponašat će se kako je dokumentirano na stranici https://support.google.com/chrome/a/answer/3017014 – standardna "Javna sesija".

      Ako se to pravilo postavi na True ili se ne postavi, upravljana gostujuća sesija poprimit će ponašanje "Upravljane sesije" koja uklanja mnoga ograničenja uspostavljena za regularne "Javne sesije".

      Ako se pravilo postavi, korisnik ga ne može promijeniti niti nadjačati.</translation>
<translation id="5708969689202733975">Konfiguriraj dopuštene načine brzog otključavanja</translation>
<translation id="5711016543513883877">
      Ako se to pravilo omogući, svaki od navedenih izvora na
      popisu odijeljenom zarezima izvodit će se u vlastitom procesu. Time će se također izolirati
      izvori navedeni prema poddomenama. Na primjer, ako se navede https://example.com/,
      izolirat će se i https://foo.example.com/ kao dio web-lokacije
      https://example.com/.
      Ako se pravilo ne konfigurira ili se onemogući, korisnik će moći promijeniti tu postavku.

      NAPOMENA: To se pravilo ne primjenjuje na Androidu. Da biste omogućili IsolateOrigins na Androidu, postavite pravilo IsolateOriginsAndroid.
      </translation>
<translation id="572155275267014074">Postavke Androida</translation>
<translation id="5722934961007828462">Kada je ta postavka omogućena, <ph name="PRODUCT_NAME" /> uvijek vrši provjeru opoziva za certifikate poslužitelja koji uspješno potvrđuju lokalno instalirane CA certifikate kojima su potpisani.

      Ako <ph name="PRODUCT_NAME" /> ne može dobiti informaciju o statusu opoziva, s takvim će se certifikatima postupati kao da su opozvani (tzv. "hard-fail").

      Ako to pravilo nije postavljeno ili je postavljeno kao netočno, tada će <ph name="PRODUCT_NAME" /> upotrijebiti postojeće mrežne postavke provjere opoziva.</translation>
<translation id="5728154254076636808">Omogućuje izradu roaming kopija podataka <ph name="PRODUCT_NAME" /> profila</translation>
<translation id="5732972008943405952">Uvoz podataka za automatsko popunjavanje obrazaca iz zadanog preglednika pri prvom pokretanju</translation>
<translation id="5741810844420698449">Ako se to pravilo postavi, ono određuje radnju koju će <ph name="PRODUCT_OS_NAME" /> poduzeti kada korisnik zatvori poklopac uređaja.

          Ako se pravilo ne postavi, poduzima se zadana radnja, a to je obustava.

          Ako je radnja obustava, moguće je zasebno konfigurirati hoće li <ph name="PRODUCT_OS_NAME" /> zaključati zaslon prije obustavljanja.</translation>
<translation id="5765780083710877561">Opis:</translation>
<translation id="5770738360657678870">Razvojni kanal (možda je nestabilan)</translation>
<translation id="5774856474228476867">URL zadanog davatelja usluge pretraživanja</translation>
<translation id="5775235485119094648">Baterija se puni dok je u fiksnom rasponu.</translation>
<translation id="5776485039795852974">Pitaj kad god web-lokacija želi prikazati obavijesti radne površine</translation>
<translation id="5781412041848781654">Određuje koja se GSSAPI knjižnica treba upotrebljavati za HTTP autentifikaciju. Možete postaviti samo naziv knjižnice ili cijeli put.

          Ako se ne navede nijedna postavka, <ph name="PRODUCT_NAME" /> upotrebljava zadani naziv knjižnice.</translation>
<translation id="5781806558783210276">Određuje koliko vremena treba proteći bez aktivnosti korisnika da bi se izvršila radnja neaktivnosti tijekom baterijskog napajanja.

          Kada je pravilo postavljeno, određuje koliko vremena treba proteći u neaktivnosti prije nego što <ph name="PRODUCT_OS_NAME" /> pokrene radnju neaktivnosti, što se može konfigurirati zasebno.

          Kada pravilo nije postavljeno, upotrebljava se zadano vrijeme.

          Vrijednost pravila treba navesti u milisekundama.</translation>
<translation id="5783009211970309878">Ispiši zaglavlja i podnožja</translation>
<translation id="5809210507920527553">Upravlja postavkama za Linuxov spremnik (Crostini).</translation>
<translation id="5809728392451418079">Postavlja naziv za prikaz za lokalne račune uređaja</translation>
<translation id="5814301096961727113">Postavljanje zadanog stanja izgovaranja povratnih informacija na zaslonu za prijavu</translation>
<translation id="5815129011704381141">Automatsko ponovno pokretanje nakon ažuriranja</translation>
<translation id="5815353477778354428">Konfigurira direktorij koji će <ph name="PRODUCT_FRAME_NAME" /> upotrebljavati za pohranjivanje korisničkih podataka.

      Ako postavite to pravilo, <ph name="PRODUCT_FRAME_NAME" /> upotrebljavat će navedeni direktorij.

      Popis varijabli koje se mogu upotrijebiti potražite na http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Ako se ta postavka ne postavi, upotrebljavat će se zadani direktorij profila.</translation>
<translation id="5826047473100157858">Određuje može li korisnik otvarati stranice u anonimnom načinu u proizvodu <ph name="PRODUCT_NAME" />. Ako je odabrano "Enabled" (omogućeno) ili pravilo nije postavljeno, stranice se mogu otvarati u anonimnom načinu. Ako je odabrano "Disabled" (onemogućeno), stranice se ne mogu otvarati u anonimnom načinu. Ako je odabrano "Forced" (prisilno), stranice se mogu otvarati SAMO u anonimnom načinu.</translation>
<translation id="582857022372205358">Omogući dvostrani ispis po kraćem rubu</translation>
<translation id="583091600226586337">
      Ako je to pravilo omogućeno, od korisnika će se prije preuzimanja tražiti da odredi gdje će svaka datoteka biti spremljena.
      Ako je pravilo onemogućeno, preuzimanja će započeti odmah, a korisnik neće dobiti upit gdje treba spremiti datoteku.
      Ako pravilo nije konfigurirano, korisnik će moći promijeniti tu postavku.
      </translation>
<translation id="5832274826894536455">Obustavljena pravila</translation>
<translation id="5835124959204887277">Određuje URL-ove i domene za koje se neće prikazivati upit kada se od sigurnosnih ključeva zatraže certifikati za ovjeru. Osim toga, sigurnosnom ključu bit će poslan signal koji pokazuje da se pojedina ovjera može upotrebljavati. Bez toga, korisnicima će se u Chromeu 65+ prikazati upit kada web-lokacije zatraže ovjeru sigurnosnih ključeva.

      URL-ovi (primjerice https://example.com/some/path) bit će odgovarajući samo kao ID-ovi aplikacija za U2F. Domene (primjerice example.com) bit će odgovarajuće samo kao RP ID-ovi za mrežnu provjeru autentičnosti. Znači, kako bi se obuhvatili API-ji i za U2F i za mrežnu provjeru autentičnosti za određenu web-lokaciju, moraju biti navedeni i URL i domena ID-a aplikacije.</translation>
<translation id="5836064773277134605">Ograniči raspon UDP priključaka koji upotrebljava host za daljinski pristup</translation>
<translation id="5861856285460256766">Konfiguracija koda za roditeljski pristup</translation>
<translation id="5862253018042179045">Postavi zadano stanje značajke pristupačnosti izgovaranja povratnih informacija na zaslonu za prijavu.

          Ako se to pravilo postavi na točno, izgovaranje povratnih informacija bit će omogućeno dok se prikazuje zaslon za prijavu.

          Ako se to pravilo postavi na netočno, izgovaranje povratnih informacija bit će onemogućeno dok se prikazuje zaslon za prijavu.

          Ako postavite to pravilo, korisnici ga mogu privremeno premostiti omogućujući ili onemogućujući izgovaranje povratnih informacija. Međutim, korisnički odabir nije trajan i zadana se vrijednost vraća svaki put kada se zaslon za prijavu prikaže iznova ili ako taj zaslon miruje jednu minutu.

          Ako se to pravilo ne postavi, izgovaranje povratnih informacija onemogućeno je pri prvom prikazivanju zaslona za prijavu. Korisnici mogu omogućiti ili onemogućiti izgovaranje povratnih informacija u bilo kojem trenutku, a status te značajke na zaslonu za prijavu zadržat će se i za sljedeće korisnike.</translation>
<translation id="5868414965372171132">Mrežna konfiguracija na razini korisnika</translation>
<translation id="5879014913445067283">Upravlja otkrićem mrežnog dijeljenja datoteka putem <ph name="NETBIOS_NAME" /></translation>
<translation id="5882345429632338713">Odgoda prije pokretanja zamjenskog preglednika (milisekunde)</translation>
<translation id="5883015257301027298">Zadana postavka kolačića</translation>
<translation id="5887414688706570295">Konfigurira prefiks za TalkGadget koji će upotrebljavati hostovi daljinskog pristupa i sprječava korisnike da ga mijenjaju.

          Ako je naveden, taj se prefiks stavlja ispred temeljnog naziva za TalkGadget kako bi nastao puni naziv domene za TalkGadget. Temeljni je naziv domene za TalkGadget ".talkgadget.google.com".

          Ako je ta postavka omogućena, hostovi će upotrebljavati prilagođeni naziv domene kada pristupaju TalkGadgetu umjesto zadanog naziva domene.

          Ako je ta postavka onemogućena ili ako nije postavljena, zadani naziv domene TalkGadget ("chromoting-host.talkgadget.google.com") upotrebljavat će se za sve hostove.

          Ta postavka pravila ne utječe na klijente daljinskog pristupa. Oni će uvijek upotrebljavati "chromoting-client.talkgadget.google.com" za pristup TalkGadgetu.</translation>
<translation id="5893553533827140852">Ako je ta postavka omogućena, zahtjevi autentifikacije "gnubby" proslijedit će se putem proxyja vezom udaljenog hosta.

          Ako je ta postavka onemogućena ili nije konfigurirana, zahtjevi autentifikacije "gnubby" neće se prosljeđivati putem proxyja.</translation>
<translation id="5897913798715600338">Napuni bateriju pomoću tehnologije brzog punjenja.</translation>
<translation id="5898486742390981550">Kada je prijavljeno više korisnika, samo primarni korisnik može upotrebljavati Android aplikacije.</translation>
<translation id="5901427587865226597">Samo dvostrani ispis</translation>
<translation id="5903898512448364160">
      Ako se pravilo postavi na true, pravilo oblaka imat će prednost u slučaju sukoba s pravilom platforme.
      Ako se pravilo postavi na false ili se ne konfigurira, pravilo platforme imat će prednost ako je u sukobu pravilom oblaka.

      To je pravilo dostupno samo kao obavezno pravilo platforme računala i utječe samo na pravila oblaka koja se odnose na računalo.
      </translation>
<translation id="5905473632148429217">Omogući online OCSP/CRL provjere</translation>
<translation id="5906199912611534122">Dopušta omogućivanje ili onemogućivanje usporavanja mreže.
      Primjenjuje se na sve korisnike i sva sučelja na uređaju. Kada se postavi,
      usporavanje traje dok se ne isključi tim pravilom.

      Ako se postavi na False, nema usporavanja.
      Ako se postavi na True, sustav se usporava da bi se postigle pružene stope prijenosa i preuzimanja (u kbit/s).</translation>
<translation id="591088232153082363">Adaptivno punjenje baterije na temelju uzorka potrošnje baterije.</translation>
<translation id="5921713479449475707">Dopusti preuzimanja automatskog ažuriranja putem HTTP-a</translation>
<translation id="5921888683953999946">Postavi zadano stanje značajke pristupačnosti velikog pokazivača na zaslonu za prijavu.

          Ako se to pravilo postavi na točno, veliki će pokazivač biti omogućen dok se prikazuje zaslon za prijavu.

          Ako se to pravilo postavi na netočno, veliki će pokazivač biti onemogućen dok se prikazuje zaslon za prijavu.

          Ako postavite to pravilo, korisnici ga mogu privremeno premostiti omogućujući ili onemogućujući veliki pokazivač. Međutim, korisnički odabir nije trajan i zadana se vrijednost vraća svaki put kada se zaslon za prijavu prikaže iznova ili ako taj zaslon miruje jednu minutu.

          Ako se to pravilo ne postavi, veliki je pokazivač onemogućen pri prvom prikazivanju zaslona za prijavu. Korisnici mogu omogućiti ili onemogućiti veliki pokazivač u bilo kojem trenutku, a njegov status na zaslonu za prijavu zadržat će se i za sljedeće korisnike.</translation>
<translation id="5929855945144989709">Dopusti uređajima pokretanje virtualnih računala na OS-u Chrome</translation>
<translation id="5932767795525445337">To se pravilo može koristiti i za prikvačivanje Android aplikacija.</translation>
<translation id="5936622343001856595">Nameće da se upiti u Google web-pretraživanju provode s aktiviranom funkcijom Sigurno pretraživanje te sprječava korisnike da promijene tu postavku.

      Ako omogućite tu postavku, Sigurno pretraživanje uvijek će biti aktivno u Google pretraživanju.

      Ako onemogućite tu postavku ili ne odredite njenu vrijednost, Sigurno pretraživanje u Google pretraživanju neće biti primijenjeno.</translation>
<translation id="5946082169633555022">Beta kanal</translation>
<translation id="5946329690214660966">Postavi prilagođeni raspored za traženje ažuriranja</translation>
<translation id="5950205771952201658">Budući da "soft-fail", mrežne provjere opoziva ne pružaju učinkovitu zaštitu sigurnosti, onemogućuju se prema zadanim postavkama u pregledniku <ph name="PRODUCT_NAME" /> verzije 19 i novijih verzija. Postavljanjem tog pravila na točno prethodno se ponašanje vraća i izvršit će se mrežne provjere OCSP/CRL.

      Ako to pravilo nije postavljeno ili je postavljeno na netočno, <ph name="PRODUCT_NAME" /> neće vršiti mrežne provjere opoziva u pregledniku <ph name="PRODUCT_NAME" /> 19 i novijim verzijama.</translation>
<translation id="5961137303188584693">MAC adresa ugrađenog upravljača mrežnog sučelja uređaja</translation>
<translation id="5966615072639944554">Proširenja koja smiju upotrebljavati API za daljinsku ovjeru</translation>
<translation id="5983708779415553259">Zadano ponašanje za web-lokacije koje nisu ni u jednom paketu sadržaja</translation>
<translation id="5997543603646547632">Upotrijebi sat s 24-satnim prikazom prema zadanim postavkama</translation>
<translation id="5997846976342452720">Određuje treba li onemogućiti alat za traženje dodataka (obustavljen)</translation>
<translation id="5998198091336830580">To je pravilo dio sljedeće atomske grupe (primjenjuju se samo pravila iz izvora najvišeg prioriteta u grupi):</translation>
<translation id="6017568866726630990">Prikaži dijalog ispisa iz sustava umjesto pretpregleda ispisa.

      Kada je omogućena ta postavka, proizvod <ph name="PRODUCT_NAME" /> otvorit će dijalog ispisa iz sustava umjesto ugrađenog pretpregleda ispisa kada korisnik zatraži ispis stranice.

      Ako to pravilo nije postavljeno ili je postavljeno na netočno, naredbe ispisa pokreću zaslon pretpregleda ispisa.</translation>
<translation id="6022948604095165524">Radnja prilikom pokretanja</translation>
<translation id="602728333950205286">Instant URL zadanog davatelja usluge pretraživanja</translation>
<translation id="603410445099326293">Parametri URL-a za prijedloge koji upotrebljava POST</translation>
<translation id="6034341625190551415">Upravlja javnom sesijom i vrstama računa za kiosk.</translation>
<translation id="6034603289689965535">Omogućuje stranici da prikazuje skočne prozore tijekom unloadinga</translation>
<translation id="6036523166753287175">Omogući prijelaz vatrozida iz hosta za daljinski pristup</translation>
<translation id="605475635122964053">Ograničava način ispisa s PIN-om. Ako se pravilo ne postavi, smatra se da nema ograničenja. Pravilo se zanemaruje ako način nije dostupan. Značajka ispisa s PIN-om omogućena je samo za pisače koji upotrebljavaju protokole IPPS, USB ili IPP putem USB-a </translation>
<translation id="6070667616071269965">Rasporedi tipkovnice za zaslon za prijavu na uređaju</translation>
<translation id="6074963268421707432">Nemoj dopustiti nijednoj web-lokaciji da prikazuje obavijesti radne površine</translation>
<translation id="6074964551275531965">Postavi razdoblje za obavijesti o ažuriranjima</translation>
<translation id="6076099373507468537">Definira popis USB uređaja za koje je dopušteno odvajanje od upravljačkog programa jezgre radi upotrebe putem API-ja chrome.usb izravno unutar web-aplikacije. Unosi su parovi identifikatora dobavljača i identifikatora proizvoda USB uređaja, a služe za prepoznavanje određenog hardvera.

      Ako se pravilo ne konfigurira, popis uklonjivih USB uređaja ostaje prazan.</translation>
<translation id="6083631234867522991">Windows (Windows klijenti):</translation>
<translation id="608788685013546076">Postavite prag baterije (u postocima) za prebacivanje napajanja radi uštede energije</translation>
<translation id="6089679180657323464">Upravlja postavkama Wilco kontrolera za dijagnostiku i telemetriju.</translation>
<translation id="6091233616732024397">Nametni korisnicima prijavu radi upotrebe preglednika</translation>
<translation id="6093156968240188330">Dopusti udaljenim korisnicima da interakciju s privilegiranim prozorima u sesijama daljinske pomoći</translation>
<translation id="6095999036251797924">Navodi koliko vremena treba proteći od posljednjeg korisničkog unosa da bi se zaslon zaključao dok radi na izmjeničnom napajanju ili bateriji.

          Kada je vrijeme postavljeno na vrijednost veću od nule, predstavlja koliko vremena korisnik mora mirovati da bi <ph name="PRODUCT_OS_NAME" /> zaključao zaslon.

          Kada je vrijeme postavljeno na nulu, <ph name="PRODUCT_OS_NAME" /> ne zaključava zaslon kada korisnik postane neaktivan.

          Kada se vrijeme ne postavi, upotrebljava se zadano vrijeme.

          Preporučeni način zaključavanja zaslona u mirovanju jest omogućiti zaključavanje zaslona u obustavljenom načinu i obustaviti <ph name="PRODUCT_OS_NAME" /> nakon vremena do ulaska u stanje mirovanja. To bi se pravilo trebalo upotrebljavati samo kada bi do zaključavanja zaslona trebalo dolaziti značajno prije nego do obustavljanja ili kada obustavljanje u mirovanju uopće nije poželjno.

          Vrijednost pravila treba navesti u milisekundama. Vrijednosti se ograničavaju kako bi bile kraće od vremena do ulaska u stanje mirovanja.</translation>
<translation id="6097601282776163274">Omogući prikupljanje anonimiziranih podataka zaključano URL-om</translation>
<translation id="6099853574908182288">Način boje zadanog ispisa</translation>
<translation id="6107642964266628393">Upravlja načinom i vremenom primjene ažuriranja Chrome OS-a.</translation>
<translation id="6111936128861357925">Dopuštanje skrivene igre s dinosaurom</translation>
<translation id="6114416803310251055">neodobreno</translation>
<translation id="6133088669883929098">Dopusti svim web-lokacijama da upotrebljavaju generiranje ključeva</translation>
<translation id="6136537398661737682">To pravilo određuje početno stanje Googleovih usluga lokacije.

      Ako se pravilo ne konfigurira ili se postavi na <ph name="GLS_DISABLED" />, Googleove usluge lokacije izvorno su onemogućene.

      Ako se pravilo postavi na <ph name="GLS_ENABLED" />, Googleove usluge lokacije izvorno su omogućene.

      Ako se pravilo postavi na <ph name="GLS_UNDER_USER_CONTROL" />, korisnik treba odabrati hoće li upotrebljavati Googleove usluge lokacije. To će omogućiti Android aplikacijama postavljanje upita za lokaciju uređaja, kao i slanje anonimnih podataka o lokaciji Googleu.

      Napominjemo da to pravilo određuje stanje Googleovih usluga lokacije samo tijekom početnog postavljanja. Korisnik može kasnije u postavkama Androida uključiti ili isključiti Googleove usluge lokacije.

      Napominjemo da će se to pravilo zanemariti, a Googleove usluge lokacije onemogućiti ako se <ph name="DEFAULT_GEOLOCATION_SETTING_POLICY_NAME" /> postavi na <ph name="BLOCK_GEOLOCATION_SETTING" />.</translation>
<translation id="6141402445226505817">Uvijek upotrebljavaj približno otkrivanje vremenske zone</translation>
<translation id="6145799962557135888">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju web-lokacije koje ne smiju pokretati JavaScript. Ako to pravilo nije postavljeno, upotrebljavat će se globalna zadana vrijednost za sve web-lokacije iz pravila "DefaultJavaScriptSetting", ako je postavljeno, odnosno iz osobne konfiguracije korisnika, ako nije.</translation>
<translation id="614662973812186053">To pravilo kontrolira i prikupljanje podataka o upotrebi i dijagnostici na Androidu.</translation>
<translation id="6153048425064249648">Ovo pravilo upravlja izvješćivanjem u oblaku preglednika <ph name="PRODUCT_NAME" /> koje prenosi informacije o radu tog preglednika na konzolu Google Admina.

      Kad se to pravilo ne postavi ili se postavi na False, podaci se ne prikupljaju niti se prenose.
      Kad se to pravilo postavi na True, podaci se prikupljaju i prenose na konzolu Google Admina.
      Da biste upravljali time koji se podaci prenose, upotrijebite pravila u grupi Chromeovo proširenje za prijavljivanje.

      To je pravilo učinkovito samo kad je računalo prijavljeno pomoću pravila <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.

      To pravilo prisilno instalira <ph name="CHROME_REPORTING_EXTENSION_NAME" /> radi izvješćivanja i nadjačava sva pravila proširenja povezana s tim proširenjem.</translation>
<translation id="6155247658847899816">Ako se to pravilo postavi, za razlučivost i faktor skaliranja svakog
      zaslona postavljaju se određene vrijednosti. Postavke vanjskog zaslona
      postavljaju se za sve povezane vanjske zaslone.

      Vrijednosti za "external_width" i "external_height" trebaju biti izražene u
      pikselima. Vrijednosti za "external_scale_percentage" i
      "internal_scale_percentage" trebaju biti izražene u postotcima.

      Ako se "external_use_native" postavi na True, pravilo će zanemariti vrijednosti za
      "external_height" i "external_width" te postaviti razlučivost vanjskih
      zaslona na njihovu prirodnu razlučivost.

      Ako se "external_use_native" postavi na False ili nije ponuđeno, a
      nije ponuđeno ni "external_height" ili "external_width", pravilo ne
      utječe na postavke vanjskih zaslona. Ako neki zaslon ne podržava
      određenu razlučivost ili faktor skaliranja, pravilo se neće primijeniti na taj
      zaslon.

      Ako je oznaka "recommended" postavljena na True, korisnici mogu promijeniti
      razlučivost i faktor skaliranja bilo kojeg zaslona na stranici postavki nakon prijave, 
      no vrijednost pravila nadjačat će njihove postavke prilikom sljedećeg ponovnog pokretanja.
      Ako je oznaka "recommended" postavljena na False ili nije postavljena, korisnici
      ne mogu promijeniti postavke zaslona.</translation>
<translation id="6155936611791017817">Postavljanje zadanog stanja velikog pokazivača na zaslonu za prijavu</translation>
<translation id="6157537876488211233">Popis pravila zaobilaženja proxyja odvojenih zarezima</translation>
<translation id="6158324314836466367">Naziv web-trgovine tvrtke (obustavljeno)</translation>
<translation id="6158817306788002298">Ovdje možete navesti URL za .pac datoteku proxy poslužitelja.

          To će pravilo vrijediti samo ako odaberete ručne postavke proxyja pod stavkom "Odaberi način određivanja postavki proxy poslužitelja" i ako ne odredite pravilo <ph name="PROXY_SETTINGS_POLICY_NAME" />.

          Ne postavljajte to pravilo ako ste odabrali bilo koji drugi način za postavljanje pravila za proxy poslužitelje.

          Detaljne primjere možete pronaći ovdje:
          <ph name="PROXY_HELP_URL" />.</translation>
<translation id="6178075938488052838">Pravilo određuje tko može pokrenuti sesiju sustava <ph name="PRODUCT_OS_NAME" />. Ono ne sprječava korisnike da se prijave na dodatne Google račune unutar Androida. Ako to želite spriječiti, konfigurirajte pravilo <ph name="ACCOUNT_TYPES_WITH_MANAGEMENT_DISABLED_CLOUDDPC_POLICY_NAME" /> za Android kao dio pravila <ph name="ARC_POLICY_POLICY_NAME" />.</translation>
<translation id="6181608880636987460">Omogućuje vam postavljanje popisa uzoraka URL-ova koji navode web-lokacije kojima nije dopušteno pokretanje dodatka <ph name="FLASH_PLUGIN_NAME" />.

          Ako se to pravilo ne postavi, za sve web-lokacije upotrebljavat će se globalna zadana vrijednost iz pravila "DefaultPluginsSetting", ako je to pravilo postavljeno, ili vrijednost iz korisnikove osobne konfiguracije.</translation>
<translation id="6190022522129724693">Zadana postavka skočnih prozora</translation>
<translation id="6190367314942602985">Prijavljuj informacije za identifikaciju korisnika</translation>
<translation id="6197453924249895891">Dodjeljuje pristup korporacijskim ključevima za proširenja.

      Ključevi su namijenjeni korporacijskoj upotrebi ako su generirani chrome.enterprise.platformKeys API-jem na upravljanom računu. Ključevi uvezeni ili generirani na neki drugi način nisu namijenjeni korporacijskoj upotrebi.

      Pristup ključevima za korporacijsku upotrebu određen je isključivo ovim pravilom. Korisnik ne može ni dodijeliti ni povući pristup korporacijskim ključevima za proširenja.

      Prema zadanim postavkama proširenje ne može upotrebljavati ključ za korporacijsku upotrebu, što je ekvivalentno postavljanju pravila allowCorporateKeyUsage na neistinito za određeno proširenje.

      Samo ako se allowCorporateKeyUsage postavi na istinito za određeno proširenje, ono može upotrebljavati ključ bilo koje platforme označen za korporacijsku upotrebu za potpisivanje arbitrarnih podataka. To bi se dopuštenje trebalo odobriti samo ako proširenje pouzdano može zaštititi pristup ključu od napadača.</translation>
<translation id="6208896993204286313">Prijavljuj informacije o pravilima za <ph name="PRODUCT_NAME" /></translation>
<translation id="6210259502936598222">Prijavljuj informacije o OS-u i verziji preglednika <ph name="PRODUCT_NAME" /></translation>
<translation id="6210610748361191729">Ako se pravilo postavi na False, izvoz/uvoz korisničkog sučelja neće biti dostupno korisnicima. Međutim i dalje je moguće upotrebljavati naredbe 'lxc' izravno u virtualno računalo kako bi se izvezle i uvezle slike spremnika.</translation>
<translation id="6211428344788340116">Generira izvješće o vremenima aktivnosti uređaja.

      Ako se ta postavka ne postavi ili se postavi na istinito, registrirani uređaji izvješćivat će o razdobljima aktivnosti korisnika na uređaju. Ako se postavka postavi na neistinito, vremena aktivnosti uređaja neće se bilježiti niti će se o njima izvješćivati.</translation>
<translation id="6212868225782276239">Prikazani su svi pisači osim onih na popisu zabranjenih.</translation>
<translation id="6219965209794245435">Ako je omogućeno, to pravilo nameće uvoz podataka za automatsko popunjavanje obrazaca iz prethodnog zadanog preglednika, a utječe i na dijaloški okvir za uvoz.

      Ako je onemogućeno, ti se podaci ne uvoze.

      Ako se ne postavi, korisnik može dobiti upit želi li uvesti podatke ili uvoz može biti automatski.</translation>
<translation id="6221175752766085998">Dopusti certifikate koje izdaju lokalne pouzdane ustanove bez proširenja subjectAlternativeName</translation>
<translation id="6224304369267200483">URL-ovima/domenama automatski je dopuštena izravna ovjera sigurnosnih ključeva</translation>
<translation id="6233173491898450179">Postavi imenik za preuzimanje</translation>
<translation id="6244210204546589761">URL-ovi koji se otvaraju prilikom pokretanja</translation>
<translation id="6255387031094435995">Omogućuje spajanje odabranih pravila istog opsega i razine kada potječu iz različitih izvora.

        Ako za pravilo na popisu postoji sukob između dva izvora, vrijednosti će se spojiti u novi popis pravila pod uvjetom da su izvori istog opsega i razine.

        Ako za pravilo na popisu postoji sukob između dva izvora, ali i između njihovih opsega i/ili razine, primijenit će se pravilo najvišeg prioriteta.

        Ako postoji sukob između izvora, opsega i/ili razine za pravilo koje nije navedeno na popisu, primijenit će se pravilo najvišeg prioriteta.</translation>
<translation id="6258193603492867656">Određuje treba li generirani Kerberos SPN uključivati nestandardni priključak. Ako omogućite ovu postavku, a bude unesen nestandardni priključak (tj. priključak koji nije 80 ili 443), on će biti uključen u generirani Kerberos SPN. Ako onemogućite ovu postavku ili ju ne postavite, generirani Kerberos SPN neće uključivati priključak ni u kojem slučaju.</translation>
<translation id="6261643884958898336">Prijavljuj informacije za identifikaciju računala</translation>
<translation id="6281043242780654992">Konfigurira pravila za lokalno slanje poruka. Zabranjeni hostovi za lokalno slanje poruka bit će dopušteni samo ako se nalaze na popisu dopuštenih.</translation>
<translation id="6282799760374509080">Omogući ili onemogući snimanje zvuka</translation>
<translation id="6284362063448764300">TLS 1.1</translation>
<translation id="6310223829319187614">Omogući samodovršavanje naziva domene tijekom prijave korisnika</translation>
<translation id="6315673513957120120">Chrome prikazuje stranicu upozorenja kada korisnici dođu do web-lokacija koje sadrže pogreške SSL-a. Prema zadanim postavkama ili kada se to pravilo postavi na "True", korisnicima je dopušteno klikanjem proći stranice upozorenja.
      Ako se pravilo postavi na "False", korisnici neće moći klikanjem proći stranice upozorenja.</translation>
<translation id="6319198883324703402">Postavi vrijeme prve obavijesti o ponovnom pokretanju za korisnika</translation>
<translation id="6352543686437322588">Lokalni račun na uređaju koji se treba automatski prijaviti nakon odgode.

      Ako se to pravilo postavi, navedena sesija automatski će se prijaviti nakon što na zaslonu za prijavu istekne vrijeme bez interakcije s korisnikom. Lokalni račun na uređaju mora se prethodno konfigurirati (pogledajte pravilo |DeviceLocalAccounts|).

      Ako se to pravilo ne postavi, neće biti automatske prijave.</translation>
<translation id="6353901068939575220">Određuje parametre koji se upotrebljavaju prilikom pretraživanja URL-ova pomoću POST metode. Sastoji se od zarezom odvojenih parova naziv/vrijednost. Ako je vrijednost parametar predloška, primjerice {searchTerms} u gornjem primjeru, zamijenit će se podacima stvarnih pojmova za pretraživanje.

          To je pravilo izborno. Ako nije postavljeno, poslat će se zahtjev za pretraživanje pomoću GET metode.

          To se pravilo poštuje samo ako je omogućeno pravilo "DefaultSearchProviderEnabled".</translation>
<translation id="6368011194414932347">Konfiguriraj URL početne stranice</translation>
<translation id="6368403635025849609">Omogući JavaScript na ovim web-lokacijama</translation>
<translation id="6376659517206731212">Može biti obavezno</translation>
<translation id="6377355597423503887">To je pravilo obustavljeno i umjesto njega možete upotrijebiti BrowserSignin.

      Korisniku omogućuje prijavu na preglednik <ph name="PRODUCT_NAME" />.

      Ako postavite to pravilo, možete konfigurirati je li korisniku dopuštena prijava na <ph name="PRODUCT_NAME" />. Ako pravilo postavite na "False", aplikacije i proširenja koje upotrebljavaju API chrome.identity prestat će funkcionirati, pa je zato bolje upotrijebiti pravilo SyncDisabled.</translation>
<translation id="6378076389057087301">Odredi utječe li zvučna aktivnost na upravljanje napajanjem</translation>
<translation id="637934607141010488">Generira popis korisnika uređaja koji su se nedavno prijavili.

      Ako se pravilo postavi na neistinito, izvješća o korisnicima neće se generirati.</translation>
<translation id="6394350458541421998">To se pravilo ne upotrebljava od verzije 29 sustava <ph name="PRODUCT_OS_NAME" />. Umjesto toga upotrijebite pravilo PresentationScreenDimDelayScale.</translation>
<translation id="6401669939808766804">Odjavi korisnika</translation>
<translation id="6406448383934634215">Ako za radnju pri pokretanju odaberete "Otvori popis URL-ova", moći ćete odrediti popis URL-ova koji se otvaraju. Ako se pravilo ne postavi, prilikom pokretanja neće se otvoriti nijedan URL.

          To se pravilo primjenjuje samo ako je pravilo "RestoreOnStartup" postavljeno na "RestoreOnStartupIsURLs".

          Pravilo je dostupno samo na instancama Windowsa koje su pridružene domeni <ph name="MS_AD_NAME" /> ili instancama Windowsa 10 Pro ili Enterprise prijavljenim za upravljanje uređajima.</translation>
<translation id="6417265370957905582">Google asistent</translation>
<translation id="6426205278746959912">Android aplikacijama ne može se nametnuti upotreba proxyja. Podskup postavki proxyja dostupan je Android aplikacijama i one ga mogu primjenjivati prema želji:

          Ako odaberete da se proxy poslužitelj ne upotrebljava nikad, Android aplikacije dobivaju informaciju da nije konfiguriran nijedan proxy.

          Ako odaberete da se upotrebljavaju postavke proxyja sustava ili proxy fiksnog poslužitelja, Android aplikacijama pružaju se adresa i priključak http proxy poslužitelja.

          Ako odaberete automatsko otkrivanje proxy poslužitelja, URL skripte "http://wpad/wpad.dat" pruža se Android aplikacijama. Ne upotrebljava se nijedan drugi dio protokola za automatsko otkrivanje proxyja.

          Ako odaberete .pac skriptu proxyja, URL skripte pruža se Android aplikacijama.</translation>
<translation id="6430366557948788869">Chromeovo proširenje za prijavljivanje</translation>
<translation id="6440051664870270040">Dopusti web-lokacijama istovremenu navigaciju i otvaranje skočnih prozora</translation>
<translation id="6447948611083700881">Sigurnosno kopiranje i vraćanje su onemogućeni</translation>
<translation id="6449476513004303784">Onemogući korisnicima upravljanje certifikatima</translation>
<translation id="645425387487868471">Omogući nametanje prijave za preglednik <ph name="PRODUCT_NAME" /></translation>
<translation id="6464074037294098618">Omogući Automatsko popunjavanje za adrese</translation>
<translation id="6467613372414922590">Dopusti hostove za lokalno slanje poruka na razini korisnika (instaliranih bez administratorskih dopuštenja)</translation>
<translation id="6468980648680553776">To je pravilo obustavljeno. Umjesto njega upotrijebite RemoteAccessHostClientDomainList.</translation>
<translation id="6473623140202114570">Konfiguriranje popisa domena na kojima Sigurno pregledavanje neće prikazivati upozorenja.</translation>
<translation id="6488627892044759800">Konfigurira vrstu zadane početne stranice u pregledniku <ph name="PRODUCT_NAME" /> i korisnicima onemogućuje promjenu postavki početne stranice. Početna stranica može se postaviti na URL koji navedete ili web-stranicu nove kartice.

          Ako omogućite tu postavku, za početnu se stranicu uvijek koristi web-stranica nove kartice i zanemaruje se lokacija URL-a početne stranice.

          Ako onemogućite tu postavku, početna stranica korisnika nikad neće biti web-stranica nove kartice osim ako se njezin URL postavi na "chrome://newtab".

          Ako omogućite ili onemogućite tu postavku, korisnici neće moći promijeniti vrstu početne stranice u pregledniku <ph name="PRODUCT_NAME" />.

          Ako ne postavite to pravilo, korisnik će moći samostalno odabrati hoće li početna stranica biti web-stranica nove kartice.

          Pravilo je dostupno samo na instancama Windowsa koje su pridružene domeni <ph name="MS_AD_NAME" /> ili instancama Windowsa 10 Pro ili Enterprise prijavljenim za upravljanje uređajima.</translation>
<translation id="6491139795995924304">Omogući Bluetooth na uređaju</translation>
<translation id="6491872498385040936">To je pravilo obustavljeno. Umjesto njega možete upotrijebiti pravilo <ph name="FORCE_YOUTUBE_RESTRICT_POLICY_NAME" /> koje ga nadjačava i koje omogućuje preciznije prilagođavanje.

      Nameće umjereni Ograničeni način rada na YouTubeu i sprječava korisnike da promijene tu postavku.

      Ako se omogući ta postavka, uvijek će se primjenjivati barem umjereni Ograničeni način rada na YouTubeu.

      Ako se ta postavka onemogući ili se ne postavi vrijednost, <ph name="PRODUCT_NAME" /> neće primjenjivati Ograničeni način rada na YouTubeu. No vanjska pravila, primjerice YouTubeova pravila, i dalje mogu nametati Ograničeni način rada.</translation>
<translation id="6495328383950074966">Konfiguriranje popisa domena koje će Sigurno pregledavanje smatrati pouzdanima. To znači sljedeće:
      Sigurno pregledavanje neće tražiti opasne resurse (npr. krađu identiteta, zlonamjerni ili neželjeni softver) ako njihovi URL-ovi odgovaraju tim domenama.
      Usluga zaštite preuzimanja koju pruža Sigurno pregledavanje neće provjeravati preuzimanja hostirana na tim domenama.
      Usluga za zaštitu zaporke koju pruža Sigurno pregledavanje neće provjeravati je li ponovno upotrijebljena zaporka ako se URL stranice podudara s tim domenama.

      Ako se ta postavka omogući, Sigurno pregledavanje smatrat će te domene pouzdanima.
      Ako se ta postavka onemogući ili se ne postavi, na sve će se resurse primjenjivati zadana zaštita Sigurnog pregledavanja.
      Pravilo je dostupno samo na instancama Windowsa koje su pridružene domeni <ph name="MS_AD_NAME" /> ili instancama Windowsa 10 Pro ili Enterprise prijavljenim za upravljanje uređajima.</translation>
<translation id="6515357889978918016"><ph name="PLUGIN_VM_NAME" /> slika</translation>
<translation id="6520802717075138474">Uvoz tražilica iz zadanog preglednika pri prvom pokretanju</translation>
<translation id="6525955212636890608">Ako omogućite ovu postavku, pokrenut će se sav Flash sadržaj ugrađen na web-lokacijama s postavkom za dopuštanje Flasha u postavkama sadržaja – bilo da ju je postavio korisnik ili je postavljena pravilom tvrtke – uključujući sadržaj iz drugih izvora ili manji sadržaj.

      Da biste odredili koje web-lokacije mogu pokretati Flash, pogledajte pravila "DefaultPluginsSetting", "PluginsAllowedForUrls" i "PluginsBlockedForUrls".

      Ako je ta postavka onemogućena ili nije postavljena, postoji mogućnost da će Flash sadržaj iz drugih izvora ili manji sadržaj biti blokiran.</translation>
<translation id="6532769014584932288">Dopusti zaključavanja aktivacije</translation>
<translation id="653608967792832033">Određuje koliko vremena treba proteći bez aktivnosti korisnika da bi se zaslon zaključao tijekom rada s baterijskim napajanjem.

          Kada je postavljeno na vrijednost veću od nule, ovo pravilo određuje koliko vremena treba proteći u neaktivnosti prije nego što <ph name="PRODUCT_OS_NAME" /> zaključa zaslon.

          Kada je ovo pravilo postavljeno na nulu, <ph name="PRODUCT_OS_NAME" /> ne zaključava zaslon tijekom neaktivnosti korisnika.

          Kada nije postavljeno, upotrebljava se zadano vrijeme.

          Preporučen je način za zaključavanje zaslona tijekom neaktivnosti omogućiti zaključavanje zaslona tijekom obustavljanja i postaviti <ph name="PRODUCT_OS_NAME" /> na obustavljanje nakon razdoblja neaktivnosti. Ovo bi se pravilo trebalo upotrebljavati samo kada bi do zaključavanja zaslona trebalo doći puno prije obustavljanja ili kada obustavljanje u razdoblju neaktivnosti uopće nije poželjno.

          Vrijednost pravila treba navesti u milisekundama. Vrijednosti su ograničene na vrijeme kraće od odgode neaktivnosti.</translation>
<translation id="6536600139108165863">Automatsko ponovno pokretanje nakon isključivanja uređaja</translation>
<translation id="6539246272469751178">To pravilo nema utjecaja na Android aplikacije. One uvijek upotrebljavaju zadani direktorij za preuzimanja i ne mogu pristupiti nijednoj datoteci koju je sustav <ph name="PRODUCT_OS_NAME" /> preuzeo u direktorij za preuzimanje koji nije zadan.</translation>
<translation id="654303922206238013">Strategija premještanja za ecryptfs</translation>
<translation id="6544897973797372144">Ako je to pravilo postavljeno na True, a pravilo ChromeOsReleaseChannel nije određeno, korisnicima domene koja se prijavljuje bit će dopušteno da mijenjaju kanal izdanja na uređaju. Ako je to pravilo postavljeno na False, uređaj će biti zaključan na posljednji postavljeni kanal.

      Pravilo ChromeOsReleaseChannel premostit će kanal koji je odabrao korisnik, ali ako je kanal određen pravilom stabilniji od kanala instaliranog na uređaj, kanal će se promijeniti samo nakon što verzija stabilnijeg kanala dosegne viši broj verzije od verzije koja je instalirana na uređaj.</translation>
<translation id="6553143066970470539">Postotak svjetline zaslona</translation>
<translation id="6559057113164934677">Ne dopuštaj nijednoj web-lokaciji pristupanje kameri i mikrofonu</translation>
<translation id="6561396069801924653">Prikaži opcije pristupačnosti u izborniku palete sustava</translation>
<translation id="6563458316362153786">Omogućivanje Brzog prijelaza 802.11r</translation>
<translation id="6565312346072273043">Na zaslonu za prijavu postavite zadano stanje značajke pristupačnosti tipkovnice na zaslonu.

          Ako je ovo pravilo postavljeno na istinito, tipkovnica na zaslonu bit će omogućena kad se prikaže zaslon za prijavu.

          Ako je ovo pravilo postavljeno na neistinito, tipkovnica na zaslonu bit će onemogućena kad se prikaže zaslon za prijavu.

          Ako postavite ovo pravilo, korisnici ga mogu privremeno nadjačati tako što će omogućiti ili onemogućiti tipkovnicu na zaslonu. No, korisnikov odabir nije trajan i zadana se postavka vraća svaki put kad se ponovo prikaže zaslon za prijavu ili kad je korisnik neaktivan 1 minutu na zaslonu za prijavu.

          Ako ne postavite to pravilo, tipkovnica na zaslonu onemogućena je prilikom prvog prikazivanja zaslona za prijavu. Korisnici mogu omogućiti ili onemogućiti tipkovnicu na zaslonu u bilo kojem trenutku i njen status na zaslonu za prijavu zadržava se među korisnicima.</translation>
<translation id="6570691255874112762">Pravilo određuje može li korisnik uvesti i ukloniti certifikate putem Upravitelja certifikata.

      Ako se to pravilo postavi na "Dopusti korisnicima upravljanje svim certifikatima" ili se ne postavi, korisnici će moći upravljati certifikatima.

      Ako se pravilo postavi na "Dopusti korisnicima upravljanje korisničkim certifikatima", korisnici će moći upravljati korisničkim certifikatima, ali ne i svim certifikatima uređaja.

      Ako se pravilo postavi na "Onemogući korisnicima upravljanje certifikatima", korisnici neće moći upravljati certifikatima, već će ih moći samo prikazati.</translation>
<translation id="6573305661369899995">Postavi vanjski izvor ograničenja URL-ova</translation>
<translation id="6583851521569686409">Konfigurira popis pisača.

      To pravilo omogućuje administratorima da navedu konfiguracije pisača za
      korisnike.

      <ph name="PRINTER_DISPLAY_NAME" /> i <ph name="PRINTER_DESCRIPTION" /> nizovi su slobodnog oblika koji se mogu prilagoditi radi lakšeg odabira pisača. <ph name="PRINTER_MANUFACTURER" /> i <ph name="PRINTER_MODEL" /> krajnjim korisnicima omogućuju da lakše prepoznaju pisač tako što navode proizvođača i modela pisača. <ph name="PRINTER_URI" /> treba biti adresa kojoj se može pristupiti s računala klijenta, uključujući <ph name="URI_SCHEME" />, <ph name="URI_PORT" /> i <ph name="URI_QUEUE" />. <ph name="PRINTER_UUID" /> nije obavezan. Ako se navede, služi za uklanjanje duplikata <ph name="ZEROCONF_DISCOVERY" /> pisača.

      <ph name="PRINTER_EFFECTIVE_MODEL" /> treba sadržavati naziv pisača ili se <ph name="PRINTER_AUTOCONF" /> treba postaviti na true. Pisači s oba ta svojstva ili bez ijednog od tih svojstava zanemarit će se.

      Postavljanje pisača dovršava se po prvoj upotrebi pisača.  PPD-ovi će se preuzeti tek prilikom upotrebe pisača.  Nakon toga često korišteni PPD-ovi spremit će se u predmemoriju.

      To pravilo ne utječe na mogućnost korisnika da konfiguriraju pisače na pojedinačnim uređajima.  Ono služi kao dodatno pravilo za konfiguraciju pisača pojedinačnih korisnika.

      Za uređaje kojima upravlja Active Directory to pravilo podržava proširivanje naziva uređaja <ph name="MACHINE_NAME_VARIABLE" /> na naziv uređaja Active Directoryja ili njegov podniz. Na primjer, ako naziv uređaja glasi <ph name="MACHINE_NAME_EXAMPLE" />, onda će se <ph name="MACHINE_NAME_VARIABLE_EXAMPLE" /> zamijeniti s četiri znaka iza šestog položaja, tj. <ph name="MACHINE_NAME_PART_EXAMPLE" />. Položaj se temelji na nuli.
      </translation>
<translation id="6598235178374410284">Slika avatara korisnika</translation>
<translation id="6603004149426829878">Uvijek šalji sve dostupne signale lokacije poslužitelju prilikom utvrđivanja vremenske zone</translation>
<translation id="6628120204569232711">Izvješćivanje o statusu pohrane</translation>
<translation id="6628646143828354685">Omogućuje vam da odredite smiju li web-lokacije dobivati pristup Bluetooth uređajima u blizini. Pristup se može potpuno blokirati ili se može tražiti dopuštenje korisnika svaki put kad neka web-lokacija želi pristupiti Bluetooth uređajima u blizini.

          Ako se pravilo ne postavi, upotrebljavat će se vrijednost "3" i korisnik će to moći promijeniti.</translation>
<translation id="663685822663765995">Ograniči način boje ispisa</translation>
<translation id="6641981670621198190">Onemogući podršku za API-je 3D grafike</translation>
<translation id="6646056064606561298">Omogućite pravilo o upravljanju pokretanjem na izmjeničnom napajanju.

          Pokretanje na izmjeničnom napajanju omogućuje sustavu da se automatski pokrene iz isključenog stanja ili mirovanja kad je uređaj priključen u utičnicu.

          Ako se to pravilo postavi na true, pokretanje na izmjeničnom napajanju uvijek će biti omogućeno ako uređaj to podržava.

          Ako se pravilo postavi na false, pokretanje na izmjeničnom napajanju uvijek će biti onemogućeno.

          Ako postavite to pravilo, korisnici ga neće moći promijeniti ili nadjačati.

          Ako se to pravilo ne postavi, pokretanje na izmjeničnom napajanju bit će onemogućeno i korisnik ga neće moći omogućiti.</translation>
<translation id="6647965994887675196">Ako je postavljeno na točno, mogu se izrađivati i upotrebljavati nadzirani korisnici.

          Ako je postavljeno na netočno ili nije konfigurirano, izrada i prijava nadziranih korisnika bit će onemogućena. Svi postojeći nadzirani korisnici bit će skriveni.

          NAPOMENA: zadano se ponašanje za potrošačke i poslovne uređaje razlikuje: na potrošačkim su uređajima nadzirani korisnici omogućeni prema zadanim postavkama, a na poslovnim su uređajima onemogućeni prema zadanim postavkama.</translation>
<translation id="6649397154027560979">Pravilo je obustavljeno, upotrijebite URLBlacklist.

      Onemogućuje navedene sheme protokola na usluzi <ph name="PRODUCT_NAME" />.

      URL-ovi koji upotrebljavaju shemu s tog popisa neće se učitati i nisu dostupni navigacijom.

      Ako se to pravilo ne postavi ili ako je popis prazan, sve će sheme biti dostupne na usluzi <ph name="PRODUCT_NAME" />.</translation>
<translation id="6652197835259177259">Postavke lokalno upravljanih korisnika</translation>
<translation id="6658245400435704251">Određuje do koliko sekundi uređaj može nasumično odgađati preuzimanje ažuriranja od trenutka kad je ažuriranje prvi put poslano na poslužitelj. Uređaj može dio tog vremena čekati u smislu stvarnog proteka vremena, a preostalo vrijeme u smislu broja provjera ažuriranja. U bilo kojem slučaju, gornja granica raspršivanja konstantan je iznos vremena tako da uređaj nikad ne može zauvijek zapeti čekajući ažuriranje.</translation>
<translation id="6665670272107384733">Odredi koliko često korisnik mora unijeti zaporku za upotrebu brzog otključavanja</translation>
<translation id="6681229465468164801">Omogućuje vam postavljanje popisa uzoraka URL-ova koji navode web-lokacije kojima se sprječava da od korisnika traže dopuštenje za pristup USB uređaju.

          Ako se to pravilo ne postavi, za sve će se web-lokacije upotrebljavati globalna zadana vrijednost iz pravila "DefaultWebUsbGuardSetting", ako je postavljeno, ili vrijednost iz osobne korisnikove konfiguracije.

          Uzorci URL-ova u ovom pravilu ne smiju biti u sukobu s uzorcima konfiguriranim u pravilu "WebUsbBlockedForUrls". Ako za URL postoje podudaranja u oba pravila, nije određeno koje će od njih imati prednost.</translation>
<translation id="6689792153960219308">Izvješćivanje o statusu hardvera</translation>
<translation id="6698632841807204978">Omogući jednobojni ispis</translation>
<translation id="6699880231565102694">Omogući autentifikaciju s dva čimbenika za hostove daljinskog pristupa</translation>
<translation id="6731757988219967594">Filtriraj vršne web-lokacije (ali ne ugrađene iframeove) na temelju sadržaja za odrasle</translation>
<translation id="6734521799274931721">Određuje dostupnost mrežnog dijeljenja datoteka za OS Chrome</translation>
<translation id="6735701345096330595">Nametni omogućivanje provjere pravopisa za jezike</translation>
<translation id="673699536430961464">Ova postavka korisnicima omogućuje promjenu Google računa unutar područja sadržaja u prozoru preglednika nakon što se prijave na svojem <ph name="PRODUCT_OS_NAME" /> uređaju.

      Ako je ovo pravilo postavljeno na False, neće biti dopušteno standardno prijavljivanje na drugi račun iz područja sadržaja preglednika.

      Ako ovo pravilo nije postavljeno ili je postavljeno na True, upotrebljavat će se zadano ponašanje: prijavljivanje na drugi račun iz područja sadržaja preglednika bit će dopušteno, osim za podređene račune za koje će biti blokirano za područje sadržaja koje nije anonimno.

      U slučaju da prijavljivanje na drugi račun ne treba biti dopušteno u anonimnom načinu, razmislite o blokiranju tog načina rada pomoću pravila IncognitoModeAvailability.

      Napominjemo da će korisnici moći pristupiti Googleovim uslugama bez autentifikacije ako blokiraju kolačiće.</translation>
<translation id="6757438632136860443">Omogućuje vam postavljanje popisa uzoraka URL-ova koji navode web-lokacije kojima je dopušteno pokretanje dodatka <ph name="FLASH_PLUGIN_NAME" />.

          Ako se to pravilo ne postavi, za sve web-lokacije upotrebljavat će se globalna zadana vrijednost iz pravila "DefaultPluginsSetting", ako je to pravilo postavljeno, ili vrijednost iz korisnikove osobne konfiguracije.</translation>
<translation id="6757613329154374267">Omogućeno je sigurnosno kopiranje i vraćanje podataka</translation>
<translation id="6762235610019366960">Omogućuje vam da upravljate prikazivanjem promotivnog i/ili obrazovnog sadržaja na cijeloj kartici na usluzi <ph name="PRODUCT_NAME" />.

      Ako se ne konfigurira ili se omogući (postavi na True), <ph name="PRODUCT_NAME" /> korisnicima može prikazivati sadržaj na cijeloj kartici radi pružanja informacija o proizvodima.

      Ako se onemogući (postavi na False), <ph name="PRODUCT_NAME" /> korisnicima neće prikazivati sadržaj na cijeloj stranici radi pružanja informacija o proizvodima.

      Ta postavka upravlja prikazivanjem stranica dobrodošlice koje korisnicima pomažu da se prijave na <ph name="PRODUCT_NAME" /> i odaberu ga kao zadani preglednik ili ih na neki drugi način informiraju o značajkama proizvoda.</translation>
<translation id="6766216162565713893">Dopusti web-lokacijama da traže dopuštenje korisnika za pristup Bluetooth uređajima u blizini</translation>
<translation id="6770454900105963262">Izvješćivanje o informacijama o aktivnim sesijama kioska</translation>
<translation id="6786747875388722282">Proširenja</translation>
<translation id="6786967369487349613">Postavljanje direktorija roaming profila</translation>
<translation id="6795485990775913659">Dopusti ispis samo bez PIN-a</translation>
<translation id="6810445994095397827">Blok JavaScript na ovim web-lokacijama</translation>
<translation id="6813263547126514821">Uključivanje i isključivanje</translation>
<translation id="681446116407619279">Podržane sheme autentifikacije</translation>
<translation id="6816212867679667972">Odredite naziv hosta uređaja koji se upotrebljava u DHCP zahtjevima.

      Ako se to pravilo postavi na niz koji nije prazan, taj će se niz upotrebljavati kao naziv hosta uređaja tijekom DHCP zahtjeva.

      Niz može sadržavati varijable ${ASSET_ID}, ${SERIAL_NUM}, ${MAC_ADDR} i ${MACHINE_NAME} koje bi bile zamijenjene vrijednostima na uređaju prije njegove upotrebe za naziv hosta. Dobivena zamjena treba biti valjani naziv hosta (prema RFC 1035, odjeljak 3.1).

      Ako se to pravilo ne postavi ili vrijednost nakon zamjene nije valjani naziv hosta, u DHCP zahtjevu neće biti postavljen naziv hosta. </translation>
<translation id="6833988859168635883">Polazna stranica, početna stranica i web-stranica nove kartice</translation>
<translation id="6835883744948188639">Prikaži korisniku ponavljajuću obavijest o preporučenom ponovnom pokretanju</translation>
<translation id="6837480141980366278">Kontrolira primjenjuje li se ugrađeni DNS klijent u pregledniku <ph name="PRODUCT_NAME" />.

      Ako se pravilo postavi na True, upotrebljavat će se ugrađeni DNS klijent.

      Ako se pravilo postavi na False, ugrađeni DNS klijent nikad se neće upotrebljavati.

      Ako se to pravilo ne postavi, ugrađeni DNS klijent bit će omogućen prema zadanim postavkama na MacOS-u, Androidu (ako nisu omogućeni ni Privatni DNS ni VPN) i OS-u Chrome, a korisnici će moći promijeniti postavku upotrebe ugrađenog DNS klijenta uređivanjem oznaka na stranici chrome://flags ili navođenjem oznake naredbenog retka.</translation>
<translation id="6843296367238757293">Pravilo je zastarjelo. Njegova se upotreba ne preporučuje. Pročitajte više na https://support.google.com/chrome/a/answer/7643500</translation>
<translation id="684856667300805181">To je pravilo uklonjeno iz sustava <ph name="PRODUCT_NAME" /> 68 i zamijenjeno pravilom <ph name="ARC_GLS_POLICY_NAME" />.</translation>
<translation id="6856743875250214792">To je pravilo zastarjelo i uklonjeno u M66 budući da se upotrebljavalo samo za interno testiranje i predstavlja sigurnosni rizik.

      Određuje oznake koje se trebaju primijeniti na <ph name="PRODUCT_NAME" /> prilikom pokretanja. Navedene oznake primjenjuju se samo na zaslonu za prijavu. Oznake postavljene ovim pravilom ne primjenjuju se na korisničke sesije.</translation>
<translation id="685769593149966548">Primijeni strogi Ograničeni način rada za YouTube</translation>
<translation id="6857824281777105940">To pravilo određuje hoće li se prijavljivati podaci Sigurnog pregledavanja, uključujući broj upozorenja Sigurnog pregledavanja i broj klikova zanemarivanja upozorenja Sigurnog pregledavanja.

      Ako se pravilo ne postavi ili se postavi na True, prikupljaju se podaci Sigurnog pregledavanja.
      Ako se pravilo postavi na False, ne prikupljaju se podaci Sigurnog pregledavanja.

      To se pravilo primjenjuje samo kada je omogućeno proširenje <ph name="CHROME_REPORTING_EXTENSION_NAME" />, a računalo je prijavljeno tokenom <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="686079137349561371">Microsoft Windows 7 ili novije verzije</translation>
<translation id="687046793986382807">To se pravilo više ne primjenjuje od verzije 35 proizvoda <ph name="PRODUCT_NAME" />.

      Neovisno o vrijednosti opcije, informacije o memoriji prijavljuju se za stranicu, ali se prijavljene veličine kvantiziraju, a stopa ažuriranja ograničena je iz sigurnosnih razloga. Za dobivanje preciznih podataka u stvarnom vremenu upotrijebite alate kao što je Telemetrija.</translation>
<translation id="6894178810167845842">URL stranice nove kartice</translation>
<translation id="6899705656741990703">Automatski detektiraj proxy postavke</translation>
<translation id="6903814433019432303">To je pravilo aktivno samo u prodajnom načinu.

      Određuje set URL-ova za učitavanje kada se pokrene demonstracijska sesija. To će pravilo premostiti sve druge mehanizme za postavljanje početnog URL-a, pa se može primijeniti samo na sesiju koja nije povezana s određenim korisnikom.</translation>
<translation id="6908640907898649429">Konfigurira zadanog davatelja usluge pretraživanja. Možete odrediti zadanog davatelja usluge pretraživanja koji će korisnik upotrebljavati ili onemogućiti zadano pretraživanje.</translation>
<translation id="6913068954484253496">Dopusti da se <ph name="PRODUCT_NAME" /> povezuje s uređajima za emitiranje na svim IP adresama.</translation>
<translation id="6915442654606973733">Omogući značajku pristupačnosti izgovaranja povratnih informacija.

          Ako se to pravilo postavi na točno, izgovaranje povratnih informacija uvijek će biti omogućeno.

          Ako se to pravilo postavi na netočno, izgovaranje povratnih informacija uvijek će biti onemogućeno.

          Ako postavite to pravilo, korisnici ga ne mogu promijeniti ili premostiti.

          Ako se to pravilo ne postavi, izgovaranje povratnih informacija u početku je onemogućeno, ali korisnik ga može omogućiti u bilo kojem trenutku.</translation>
<translation id="6916507170737609563">
      Možda biste trebali pogledati postavke pravila IsolateOriginsAndroid da biste iskoristili prednosti obiju značajki, izolacije i ograničenog utjecaja za korisnike koristeći IsolateOriginsAndroid s popisom web-lokacija koje želite izolirati. Ova postavka, SitePerProcessAndroid, izolira sve web-lokacije.
      Ako je pravilo omogućeno, svaka će se web-lokacija izvoditi u svojem procesu.
      Ako je pravilo onemogućeno, neće doći do eksplicitne izolacije web-lokacije i radne verzije pravila IsolateOriginsAndroid i SitePerProcessAndroid bit će 
onemogućene. Korisnici će još uvijek moći ručno omogućiti SitePerProcess.
      Ako to pravilo nije konfigurirano, korisnik će moći izmijeniti tu postavku.

      NAPOMENA: izolacija web-lokacija na Androidu je eksperimentalna. Podrška će se s vremenom poboljšati, ali trenutačno može uzrokovati probleme s izvedbom.

      NAPOMENA: ovo pravilo primjenjuje se samo na Chrome na Androidu koji se izvodi na uređajima koji moraju imati više od 1 GB RAM-a. Da bi se pravilo primijenilo na druge platforme, upotrijebite SitePerProcess.
      </translation>
<translation id="6922884955650325312">Blokiraj dodatak <ph name="FLASH_PLUGIN_NAME" /></translation>
<translation id="6923366716660828830">Određuje naziv zadanog davatelja usluga pretraživanja. Ako naziv ostane prazan ili nije postavljen, upotrebljavat će se naziv hosta određen URL-om pretraživanja. Ovo će pravilo biti uzeto u obzir samo ako je omogućeno pravilo "DefaultSearchProviderEnabled".</translation>
<translation id="6924223708804692571">Prisilno onemogućuje jezike provjere pravopisa. Jezici na popisu koji nisu prepoznati zanemarit će se.

      Ako omogućite to pravilo, za navedene jezike neće biti omogućena provjera pravopisa. Za jezike koji nisu navedeni na popisu korisnik će moći omogućiti ili onemogućiti provjeru pravopisa.

      Ako to pravilo ne postavite ili ga onemogućite, korisnikove postavke provjere pravopisa neće se promijeniti.

      Ako se pravilo <ph name="SPELLCHECK_ENABLED_POLICY_NAME" /> postavi na false, neće se primjenjivati.

      Ako je jezik naveden i u ovom pravilu i u pravilu <ph name="SPELLCHECK_LANGUAGE_POLICY_NAME" />, prioritet će imati potonje pravilo i jezik za provjeru pravopisa bit će omogućen.

      Trenutačno su podržani sljedeći jezici: 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">Omogući dvostrani ispis po dužem rubu</translation>
<translation id="6931242315485576290">Onemogući sinkronizaciju podataka s Googleom</translation>
<translation id="6936894225179401731">Određuje maksimalni broj simultanih veza proxy poslužitelja.

      Neki proxy poslužitelji ne mogu imati velik broj istodobnih veza po klijentu, a to se može riješiti postavljanjem ovog pravila na nižu vrijednost.

      Vrijednost ovog pravila treba biti niža od 100 i viša od 6, a zadana je vrijednost 32.

      Poznato je da neke web-aplikacije zauzimaju brojne veze uz GET-ove na čekanju pa snižavanje vrijednosti ispod 32 može dovesti do mrežnog čekanja za preglednik ako je otvoreno previše takvih web-aplikacija. Smanjivanje ispod zadane vrijednosti činite na vlastiti rizik.

      Ako to pravilo nije postavljeno, upotrebljavat će se zadana vrijednost, a to je 32.</translation>
<translation id="6943577887654905793">Naziv Mac/Linux preferencije:</translation>
<translation id="6944167205014013774">Informacije o upotrebi Linux aplikacija šalju se
      poslužitelju.

      Ako se to pravilo postavi na False ili se ne postavi, informacije o upotrebi
      neće se prijavljivati. Ako se postavi na True, te će se informacije prijavljivati.

      To se pravilo primjenjuje samo ako je omogućena podrška za Linux aplikacije.</translation>
<translation id="69525503251220566">Značajka pretraživanja po slici koja pruža parametre za zadanog davatelja usluge pretraživanja</translation>
<translation id="6953102253399571439">Omogući ispis s PIN-om prema zadanim postavkama</translation>
<translation id="6956272732789158625">Nemoj dopustiti nijednoj web-lokaciji da upotrebljava generiranje ključeva</translation>
<translation id="6965859329738616662">Navodi se je li dopušten model pametnog zatamnjenja kako bi se produljilo vrijeme do zatamnjenja zaslona.

      Prije nego što se zaslon zatamni, model pametnog zatamnjenja procjenjuje treba li odgoditi zatamnjenje zaslona. Ako model pametnog zatamnjenja odgodi zatamnjenje zaslona, on učinkovito produljuje vrijeme dok zaslon ne bude zatamnjen. U tom se slučaju isključivanje zaslona, zaključavanje zaslona i odgode  mirovanja prilagođavaju kako bi zadržale jednaku udaljenost od odgode zatamnjenja zaslona kako je izvorno konfigurirano.
      Ako je ovo pravilo postavljeno na True ili nije postavljeno, bit će omogućen model pametnog zatamnjenja te će biti dopušteno produljiti vrijeme dok zaslon ne bude zatamnjen. Ako je ovo pravilo postavljeno na False, model pametnog zatamnjenja neće utjecati na zatamnjenje zaslona.</translation>
<translation id="6967394885063085697">Omogućite pravilo za upravljanje napajanjem za napredni način punjenja baterije.

          Napredni način punjenja baterije omogućuje korisniku da maksimizira performanse baterije. U naprednom načinu punjenja sustav će upotrebljavati standardni algoritam punjenja i druge tehnike izvan radnih sati radi maksimiziranja performansi baterije. Tijekom radnih sati upotrebljavat će se ekspresno punjenje. Ekspresno punjenje omogućuje veću brzinu punjenja, tako da je i baterija brže potpuno napunjena. Vrijeme najintenzivnije upotrebe sustava za svaki se dan navodi u obliku vremena početka i trajanja.

          Ako se to pravilo postavi na true i postavljeno je pravilo DeviceAdvancedBatteryChargeModeDayConfig, napredni način punjenja baterije uvijek će biti omogućen ako uređaj to podržava.

          Ako se to pravilo postavi na false, napredni način punjenja baterije uvijek će biti onemogućen.

          Ako postavite to pravilo, korisnici ga neće moći promijeniti ni nadjačati.

          Ako se to pravilo ne postavi, napredni način punjenja baterije bit će onemogućen i korisnik ga neće moći omogućiti.</translation>
<translation id="6972540544240464302">Odaberite konfiguraciju alata za zakazivanje zadataka</translation>
<translation id="6979158407327259162">Google disk</translation>
<translation id="6994082778848658360">Određuje način na koji se hardver s ugrađenim sigurnosnim elementom može upotrebljavati za pružanje dvostruke autentifikacije ako je kompatibilan s ovom značajkom. Tipka za uključivanje/isključivanje uređaja upotrebljava se za otkrivanje korisnikove fizičke prisutnosti.

      Ako se odabere "Onemogućeno", dvostruka se autentifikacija ne upotrebljava.

      Ako se odabere "U2F", integrirana dvostruka autentifikacija ponašat će se u skladu sa specifikacijom za FIDO U2F.

      Ako se odabere "U2F_EXTENDED", integrirana dvostruka autentifikacija pružat će funkcije U2F i neka proširenja za pojedinačno atestiranje.</translation>
<translation id="7003334574344702284">Ako je omogućeno, ovo pravilo prisilno uvozi spremljene zaporke iz prethodno zadanog preglednika. Ako je omogućeno, ovo pravilo također utječe na dijaloški okvir za uvoz. Ako je onemogućeno, spremljene se zaporke ne uvoze. Ako nije postavljeno, korisniku može biti postavljen upit želi li uvesti zaporke ili do uvoza može doći automatski.</translation>
<translation id="7003746348783715221">Postavke za <ph name="PRODUCT_NAME" /></translation>
<translation id="7007671350884342624">Konfigurira direktorij koji će <ph name="PRODUCT_NAME" /> koristiti za pohranu podataka korisnika.

      Ako postavite to pravilo, taj će direktorij <ph name="PRODUCT_NAME" /> upotrebljavati bez obzira na to je li korisnik naveo oznaku "--user-data-dir". Kako bi se spriječio gubitak podataka ili druge neočekivane pogreške, pravilo se ne smije postaviti na korijenski direktorij ili direktorij jedinice koji se koristi u druge svrhe jer njegovim sadržajem upravlja <ph name="PRODUCT_NAME" />.

      Na stranici https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables možete pronaći popis mogućih varijabli.

      Ako se pravilo ne postavi, koristit će se zadani put profila i korisnik će ga moći nadjačati oznakom naredbenog retka "--user-data-dir".</translation>
<translation id="7027785306666625591">Konfigurirajte upravljanje napajanjem za <ph name="PRODUCT_OS_NAME" />.

      Ova vam pravila omogućuju da konfigurirate kako će se <ph name="PRODUCT_OS_NAME" /> ponašati kad korisnik ne bude aktivan određeno vrijeme.</translation>
<translation id="7040229947030068419">Primjer vrijednosti:</translation>
<translation id="7044883996351280650">Kontrola usluge sigurnosnog kopiranja i vraćanja na Androidu</translation>
<translation id="7049373494483449255">Omogućuje proizvodu <ph name="PRODUCT_NAME" /> slanje dokumenata na uslugu <ph name="CLOUD_PRINT_NAME" /> za ispis. NAPOMENA: To se odnosi samo na podršku usluge <ph name="CLOUD_PRINT_NAME" /> u proizvodu <ph name="PRODUCT_NAME" />. To ne sprječava korisnike da poslove ispisa šalju na web-lokacije. Ako je ova postavka omogućena ili nije konfigurirana, korisnici mogu ispisivati putem usluge <ph name="CLOUD_PRINT_NAME" /> iz dijaloškog okvira za ispis u proizvodu <ph name="PRODUCT_NAME" />. Ako je ova postavka onemogućena, korisnici ne mogu ispisivati putem usluge <ph name="CLOUD_PRINT_NAME" /> iz dijaloškog okvira za ispis u proizvodu <ph name="PRODUCT_NAME" /></translation>
<translation id="7053678646221257043">Ako je omogućeno, ovo pravilo prisilno uvozi knjižne oznake iz trenutačno zadanog preglednika. Ako je omogućeno, ovo pravilo također utječe na dijaloški okvir za uvoz. Ako je onemogućeno, nijedna knjižna oznaka neće biti uvezena. Ako nije postavljeno, korisniku može biti postavljen upit želi li uvesti oznake ili do uvoza može doći automatski.</translation>
<translation id="7063895219334505671">Dopusti skočne prozore na ovim web-lokacijama</translation>
<translation id="706568410943497889">
      Ako je pravilo postavljeno na True, proizvod <ph name="PRODUCT_NAME" /> ima dopuštenje prikupljati zapisnike događaja WebRTC s Googleovih usluga (npr. Google Meet) i prenijeti te zapisnike na Google.

      Ako se pravilo postavi na False ili se ne postavi, <ph name="PRODUCT_NAME" /> ne smije prikupljati niti prenositi takve zapisnike.

      Ti zapisnici sadrže dijagnostičke podatke kao što su vrijeme i veličina poslanih i primljenih RTP paketa, povratne informacije o zagušenju na mreži i medapodatke o vremenu i kvaliteti zvučnih i videozapisa. Ti podaci pomažu pri otklanjanju pogrešaka kod audio i videopoziva na Chromeu, kao što su poteškoće s procjenom propusnosti itd. Zapisnici ne sadrže audio ili videosadržaje poziva.

      Ta kolekcija podataka može se pokrenuti samo pomoću Googleovih web-usluga, kao što su Hangouts ili Google Meet.

      Ti zapisnici mogu se putem ID-ja sesije povezati s drugim zapisnicima koje je prikupila sama Googleova usluga; to je namijenjeno lakšem otklanjanju pogrešaka.
      </translation>
<translation id="706669471845501145">Dopusti web-lokaciji prikazivanje obavijesti radne površine</translation>
<translation id="7068108874199666656">Omogućuje primjenu mrežne konfiguracije za sve korisnike <ph name="PRODUCT_OS_NAME" /> uređaja. Mrežna je konfiguracija niz u formatu JSON, kao što je definirano formatom Open Network Configuration.</translation>
<translation id="7070525176564511548">Zaporku treba unijeti svaki tjedan (168 sati)</translation>
<translation id="7072208053150563108">Stopa promjene zaporke računala</translation>
<translation id="7079519252486108041">Blokiraj skočne prozore na ovim web-lokacijama</translation>
<translation id="7085803328069945025">Omogućuje vam postavljanje popisa uzoraka URL-ova koji navode web-lokacije kojima je dopušteno da od korisnika traže dopuštenje za pristup USB uređaju.

          Ako se to pravilo ne postavi, za sve web-lokacije upotrebljavat će se globalna zadana vrijednost iz pravila "DefaultWebUsbGuardSetting", ako je postavljeno, ili vrijednost iz korisnikove osobne konfiguracije.

          Uzorci URL-ova u ovom pravilu ne smiju biti u sukobu s uzorcima konfiguriranim u pravilu "WebUsbBlockedForUrls". Ako za URL postoje podudaranja u oba pravila, nije određeno koje će od njih imati prednost.</translation>
<translation id="7086677522575756117">Određuje postotak za skaliranje odgode zatamnjivanja zaslona kada se uoči aktivnost korisnika dok je zaslon zatamnjen ili ubrzo nakon što se zaslon isključi.

          Ako se to pravilo postavi, ono određuje postotak za skaliranje odgode zatamnjivanja zaslona kada se uoči aktivnost korisnika dok je zaslon zatamnjen ili ubrzo nakon što se zaslon isključi. Kada se odgoda zatamnjivanja skalira, odgode isključivanja zaslona, zaključavanja zaslona i mirovanja podešavaju se kako bi se zadržali isti vremenski odmaci za odgodu zatamnjivanja zaslona koji su izvorno konfigurirani.

          Ako se to pravilo ne postavi, upotrebljava se zadani faktor skaliranja.

          To se pravilo primjenjuje samo ako je onemogućeno pravilo <ph name="POWER_SMART_DIM_ENABLED_POLICY_NAME" />. U suprotnom se to pravilo zanemaruje jer se odgoda zatamnjivanja zaslona određuje modelom strojnog učenja.

          Faktor skaliranja mora biti 100% ili više.</translation>
<translation id="710003290625031750">Proširen opis sheme:</translation>
<translation id="7106631983877564505">Omogući zaključavanje kada uređaji <ph name="PRODUCT_OS_NAME" /> prijeđu u stanje mirovanja ili se isključe.

      Ako omogućite tu postavku, korisnici će morati unijeti zaporku za otključavanje uređaja u stanju mirovanja.

      Ako onemogućite tu postavku, korisnici neće morati unijeti zaporku za otključavanje uređaja u stanju mirovanja.

      Ako omogućite ili onemogućite tu postavku, korisnici je ne mogu promijeniti ni nadjačati.

      Ako ne postavite to pravilo, korisnici mogu odabrati žele li unositi zaporku za otključavanje uređaja.</translation>
<translation id="7107148737865880402">Omogućite pravilo za upravljanje dijeljenjem USB napajanja.

          Neki uređaji imaju određeni USB priključak označen ikonom munje ili baterije koji se mogu upotrebljavati za punjenje uređaja, primjerice mobilnog telefona, pomoću baterije sustava. To pravilo utječe na ponašanje punjenja na tom priključku dok je sustav u načinu mirovanja ili isključen. To pravilo ne utječe na ostale USB priključke ni na ponašanje punjenja dok je sustav u aktivnom načinu.

          Kada je sustav u aktivnom načinu, USB priključak uvijek omogućuje napajanje.

          Ako se to pravilo postavi na true, a uređaj je u načinu mirovanja, USB priključak napajat će se dok je uređaj priključen na punjač ili ako je razina baterija viša od 50%. Inače se neće napajati.

          Ako se to pravilo postavi na true, a uređaj je isključen, USB priključak napajat će se dok je uređaj priključen na punjač. Inače se neće napajati.

          Ako se to pravilo ne postavi, pravilo će biti omogućeno i korisnik ga neće moći onemogućiti.</translation>
<translation id="7115494316187648452">Određuje je li proces preglednika <ph name="PRODUCT_NAME" /> pokrenut prilikom prijave u OS i nastavlja li raditi nakon što se zatvori posljednji prozor preglednika, uslijed čega pozadinske aplikacije i trenutačna sesija pregledavanja mogu ostati aktivne, uključujući kolačiće sesije. Za pozadinski proces prikazuje se ikona na traci sustava putem koje ga se može zatvoriti u bilo kojem trenutku.

      Ako se to pravilo postavi na "točno", pozadinski je način omogućen i korisnik ne može njime upravljati u postavkama preglednika.

      Ako se pravilo postavi na "netočno", pozadinski je način onemogućen i korisnik ne može upravljati njime u postavkama preglednika.

      Ako se pravilo ne postavi, pozadinski je način početno onemogućen i korisnik može upravljati njime u postavkama preglednika.</translation>
<translation id="7123160381479171745">Definira popis korisnika kojima je dopuštena prijava na uređaj. Unosi su u obliku <ph name="USER_WHITELIST_ENTRY_FORMAT" />, primjerice <ph name="USER_WHITELIST_ENTRY_EXAMPLE" />. Da biste slučajnim korisnicima dopustili pristup domeni, upotrijebite unose u obliku <ph name="USER_WHITELIST_ENTRY_WILDCARD" />.

      Ako se to pravilo ne konfigurira, nema ograničenja za prijavu korisnika. Napominjemo da je za izradu novih korisnika još uvijek potrebna odgovarajuća konfiguracija pravila <ph name="DEVICE_ALLOW_NEW_USERS_POLICY_NAME" />.</translation>
<translation id="7126716959063786004">Omogući završavanje postupaka u Upravitelju zadataka</translation>
<translation id="7127892035367404455">Vraćanje na ciljnu verziju</translation>
<translation id="713121532817834879">To je pravilo URL koji usmjerava na XML datoteku u istom formatu kao i pravilo <ph name="IEEM_SITELIST_POLICY" /> u Internet Exploreru. Ono učitava pravila iz XML datoteke i pritom ih ne dijeli s Internet Explorerom.

      Pravila u toj XML datoteci primjenjuju se na isti način kao i pravilo <ph name="GREYLIST_POLICY_NAME" />. To znači da ta pravila onemogućuju pregledniku <ph name="PRODUCT_NAME" /> otvaranje nekog drugog preglednika, kao i drugom pregledniku da otvori preglednik <ph name="PRODUCT_NAME" />.

      Ako se to pravilo ne postavi ili se ne postavi na važeći URL, <ph name="PRODUCT_NAME" /> neće ga upotrebljavati kao izvor pravila koja ne pokreću promjenu preglednika.

      Ako se to pravilo postavi na važeći URL, <ph name="PRODUCT_NAME" /> s tog će URL-a preuzeti popis web-lokacija i primijeniti pravila kao da su konfigurirana pravilom <ph name="SITELIST_POLICY_NAME" />.

      Više informacija o pravilu <ph name="IEEM_SITELIST_POLICY" /> dostupno je na stranici: https://docs.microsoft.com/internet-explorer/ie11-deploy-guide/what-is-enterprise-mode</translation>
<translation id="7132877481099023201">URL-ovi koji će dobiti pristup uređajima za videosnimanje bez postavljanja upita</translation>
<translation id="7138678301420049075">Ostalo</translation>
<translation id="7140629953254369759">Upućuje <ph name="PRODUCT_OS_NAME" /> na korištenje konfiguracije alata za zakazivanje zadataka koji se prepoznaje po navedenom imenu.

      Ovo pravilo može se postaviti na "zaštita" i "izvedba", čime se odabiru konfiguracije alata za zakazivanje zadataka koji su ugođeni za stabilnost odnosno maksimalnu izvedbu.

      Ako se pravilo ne postavi, korisnik sam može odlučivati.</translation>
<translation id="7145335384492396213">Zadani način ispisa s PIN-om</translation>
<translation id="7158064522994309072">To pravilo određuje naredbu koja se treba upotrijebiti za otvaranje URL-ova u zamjenskom pregledniku.

      Ako se pravilo ne postavi, upotrebljava se zadana postavka platforme: Internet Explorer za Windows odnosno Safari za Mac OS X. Na Linuxu zamjenski se preglednik neće pokrenuti ako to pravilo nije postavljeno.

      Ako se pravilo postavi na ${ie}, ${firefox}, ${safari} ili ${opera}, pokrenut će se odgovarajući preglednik ako je instaliran. ${ie} dostupan je samo u sustavu Windows, a ${safari} je dostupan samo u sustavima Windows i Mac OS X.

      Ako se pravilo postavi na put datoteke, ta će se datoteka upotrebljavati kao izvršna datoteka.</translation>
<translation id="7167436895080860385">Omogući korisnicima prikazivanje zaporki u upravitelju zaporki (zastarjelo)</translation>
<translation id="7173856672248996428">Kratkotrajni profil</translation>
<translation id="717630378807352957">Dopušta sve pisače iz konfiguracijske datoteke.</translation>
<translation id="7176721759719212761">Određuje jesu li dopuštena zaključavanja aktivacije. Ta zaključavanja mogu tražiti proširenja putem API-ja proširenja za upravljanje napajanjem i ARC aplikacije.

          Ako se pravilo postavi na True ili se ne postavi, zaključavanja aktivacije primjenjivat će se za upravljanje napajanjem, osim ako je pravilo AllowWakeLocks postavljeno na False.

          Ako se ovo pravilo postavi na False, zahtjevi za zaključavanje aktivacije zaslona spustit će se na razinu zahtjeva sustava za zaključavanje aktivacije.</translation>
<translation id="7177857088692019405">Brzo otključavanje</translation>
<translation id="7185078796915954712">TLS 1.3</translation>
<translation id="718956142899066210">Dopuštene vrste veza za ažuriranja</translation>
<translation id="7194407337890404814">Naziv zadanog davatelja usluge pretraživanja</translation>
<translation id="7199304109870655950">Konfigurira opcije daljinskog pristupa na hostu Udaljene radne površine Chrome.

      Host Udaljene radne površine Chrome nativna je usluga koja se izvodi na ciljnom računalu s kojim se korisnik može povezati pomoću aplikacije Udaljena radna površina Chrome.  Nativna je usluga pakirana i izvršava se zasebno od preglednika <ph name="PRODUCT_NAME" />.

      Ta se pravila zanemaruju ako host Udaljene
      radne površine Chrome nije instaliran.</translation>
<translation id="7202925763179776247">Dopusti ograničenja za preuzimanja</translation>
<translation id="7207095846245296855">Nametni Google sigurno pretraživanje</translation>
<translation id="7211368186050418507">Nikad ne otkrivaj vremensku zonu automatski</translation>
<translation id="7216442368414164495">Omogućivanje korisnicima da se uključe u prošireno izvješćivanje Sigurnog pregledavanja</translation>
<translation id="7221822638060296742">Omogućuje vam da odredite je li web-lokacijama dopušteno automatski pokretati dodatak <ph name="FLASH_PLUGIN_NAME" />. Automatsko pokretanje dodatka <ph name="FLASH_PLUGIN_NAME" /> može biti dopušteno za sve web-lokacije ili odbijeno za sve web-lokacije.

          Opcija "klikni za reprodukciju" omogućuje pokretanje dodatka <ph name="FLASH_PLUGIN_NAME" />, no korisnik mora kliknuti rezervirano mjesto da bi pokrenuo njegovo izvršavanje.

          Automatska reprodukcija dopuštena je samo za domene koje su izričito navedene u pravilu <ph name="PLUGINS_ALLOWED_FOR_URLS_POLICY_NAME" />. Ako želite omogućiti automatsku reprodukciju za sve web-lokacije, razmislite o dodavanju http://* i https://* na taj popis.

          Ako se to pravilo ne postavi, korisnik će tu postavku moći promijeniti ručno.</translation>
<translation id="7222749588229362483">Omogućuje spajanje odabranih pravila istog opsega i razine kada potječu iz različitih izvora.

        Spajanje se sastoji od spajanja ključeva prve razine rječnika iz svakog izvora. U slučaju sukoba među ključevima primijenit će se ključ koji potječe iz izvora najvišeg prioriteta.

        Ako za pravilo na popisu postoji sukob između dva izvora, vrijednosti će se spojiti u novi rječnik pravila pod uvjetom da su izvori istog opsega i razine.

        Ako za pravilo na popisu postoji sukob između dva izvora, ali i između njihovih opsega i/ili razine, primijenit će se pravilo najvišeg prioriteta.

        Ako postoji sukob između izvora, opsega i/ili razine za pravilo koje nije navedeno na popisu, primijenit će se pravilo najvišeg prioriteta.</translation>
<translation id="7229975860249300121">Sadrži regularni izraz koji se upotrebljava za određivanje Google računa koji se mogu postaviti kao primarni računi preglednika <ph name="PRODUCT_NAME" /> (to je račun koji se odabire prilikom tijeka uključivanja sinkronizacije).

      Prikazuje se odgovarajuća pogreška ako se korisnik pokuša prijaviti korisničkim imenom koje se ne podudara s uzorkom.

      Ako se pravilo ne postavi ili se ostavi prazno, korisnik može postaviti bilo koji Google račun kao primarni račun u pregledniku <ph name="PRODUCT_NAME" />.</translation>
<translation id="723103540848640830">Postavi minimalnu dužinu PIN-a za zaključan zaslon</translation>
<translation id="7232816984286843471">Ako se to pravilo postavi na False, nepridruženim korisnicima neće biti dopuštena upotreba Crostinija.

      Ako se to pravilo ne postavi ili se postavi na True, svim će korisnicima biti dopuštena upotreba Crostinija pod uvjetom da to dopuštaju i druge postavke.
      Sva tri pravila, VirtualMachinesAllowed, CrostiniAllowed i DeviceUnaffiliatedCrostiniAllowed, moraju se postaviti na True kada se primjenjuju na dopuštanje pokretanja Crostinija.
      Ako se to pravilo promijeni na False, primjenjuje se na pokretanje novih spremnika za Crostini, ali ne isključuje one koji su već pokrenuti.</translation>
<translation id="7234280155140786597">Nazivi zabranjenih hostova za lokalno slanje poruka (ili "*" za sve)</translation>
<translation id="7236775576470542603">Postavi zadanu vrstu povećala koje je omogućeno na zaslonu za prijavu.

          Ako se to pravilo postavi, ono upravlja vrstom povećala koje je omogućeno dok se zaslon za prijavu prikazuje. Postavljanjem tog pravila na vrijednost "Ništa" povećalo se onemogućuje.

          Ako postavite to pravilo, korisnici ga mogu privremeno premostiti omogućujući ili onemogućujući povećalo. Međutim, korisnički odabir nije trajan i zadana se vrijednost vraća svaki put kada se zaslon za prijavu prikaže iznova ili ako taj zaslon miruje jednu minutu.

          Ako se to pravilo ne postavi, povećalo je onemogućeno pri prvom prikazivanju zaslona za prijavu. Korisnici mogu omogućiti ili onemogućiti povećalo u bilo kojem trenutku, a njegov status na zaslonu za prijavu zadržat će se i za sljedeće korisnike.</translation>
<translation id="7249828445670652637">Omogući <ph name="PRODUCT_OS_NAME" /> CA certifikate za ARC aplikacije</translation>
<translation id="7252681704926980614">Korisničko ime i naziv datoteke šalju se poslužitelju nativnih pisača sa svakim zadatkom ispisa. Prema zadanim se postavkama ne šalju.

      Postavljanjem tog pravila na True onemogućuju se i pisači koji upotrebljavaju druge protokole osim IPPS, USB ili IPP putem USB-a jer se korisničko ime i naziv datoteke ne smiju otvoreno slati putem mreže.</translation>
<translation id="7258823566580374486">Omogući skrivanje hosta za daljinski pristup</translation>
<translation id="7260204423892780600">Određuje postavke za Google asistenta.</translation>
<translation id="7260277299188117560">Omogućeno je automatsko ažuriranje p2p</translation>
<translation id="7261252191178797385">Slika pozadine uređaja</translation>
<translation id="7264704483008663819">To je pravilo obustavljeno u verziji M68. Umjesto njega upotrijebite DeveloperToolsAvailability.

      Onemogućuje Alate za razvojne programere i konzolu JavaScript.

      Ako omogućite tu postavku, više neće biti moguće pristupiti Alatima za razvojne programere i više se neće moći provjeravati elementi web-lokacija. Onemogućit će se svi tipkovni prečaci i stavke izbornika ili kontekstnih izbornika za otvaranje Alata za razvojne programere ili konzole JavaScript.

      Ako se ta opcija onemogući ili ne postavi, korisnik može upotrebljavati Alate za razvojne programere i konzolu JavaScript.

      Ako se postavi pravilo DeveloperToolsAvailability, zanemaruje se vrijednost pravila DeveloperToolsDisabled.</translation>
<translation id="7266471712301230894">To je pravilo uklonjeno od verzije 64 sustava <ph name="PRODUCT_NAME" />.

      Automatsko pretraživanje i instalacija dodataka koji nedostaju nisu više podržani.</translation>
<translation id="7267809745244694722">Medijske tipke postavi kao zadane funkcijske tipke</translation>
<translation id="7271085005502526897">Uvoz početne stranice iz zadanog preglednika pri prvom pokretanju</translation>
<translation id="7273823081800296768">Ako je ta postavka omogućena ili nije konfigurirana, tada korisnici mogu odabrati hoće li upariti klijente i hostove u trenutku povezivanja tako da ne moraju svaki put unositi PIN.

          Ako je ta postavka onemogućena, ta značajka neće biti dostupna.</translation>
<translation id="7274077256421167535">Omogući dijeljenje USB napajanja</translation>
<translation id="7275334191706090484">Upravljane oznake</translation>
<translation id="7291084543582732020">Ako omogućite tu postavku, korisnicima će biti dopuštena upotreba Smart Locka pod uvjetom da su ispunjeni zahtjevi značajke.

      Ako onemogućite tu postavku, korisnici neće moći upotrebljavati Smart Lock.

      Ako se ne postavi, to će pravilo prema zadanim postavkama biti onemogućeno za upravljane korisnike u organizacijama, a za neupravljane korisnike bit će omogućeno.</translation>
<translation id="7295019613773647480">Omogući nadzirane korisnike</translation>
<translation id="7301543427086558500">Navodi popis zamjenskih URL-ova koji se mogu upotrijebiti za izvlačenje pojmova pretraživanja iz tražilice. URL-ovi trebaju sadržavati niz <ph name="SEARCH_TERM_MARKER" />, koji će se upotrijebiti za izvlačenje pojmova pretraživanja.

          Ovo pravilo nije obavezno. Ako nije postavljeno, za izvlačenje pojmova pretraživanja neće se upotrebljavati zamjenski URL-ovi.

          Ovo se pravilo primjenjuje samo ako je omogućeno pravilo 'DefaultSearchProviderEnabled'.</translation>
<translation id="7302043767260300182">Odgoda zaključavanja zaslona za vrijeme napajanja izmjeničnom strujom</translation>
<translation id="7311458740754205918">Ako se ovo pravilo postavi na istinito ili se ne postavi, web-stranica nove kartice može prikazivati preporuke sadržaja na temelju korisnikove povijesti pretraživanja, interesa ili lokacije.

      Ako se postavi na neistinito, automatski generirani prijedlozi sadržaja neće se prikazivati na web-stranici nove kartice.</translation>
<translation id="7313793931637495417">Pravilo određuje hoće li se prijavljivati informacije o verziji, kao što su verzija OS-a, platforma OS-a, arhitektura OS-a, verzija preglednika <ph name="PRODUCT_NAME" /> i kanal preglednika <ph name="PRODUCT_NAME" />. 

      Ako se to pravilo ne postavi ili se postavi na True, prikupljaju se informacije o verziji.
      Ako se pravilo postavi na False, ne prikupljaju se informacije o verziji.

      To se pravilo primjenjuje samo kada je omogućeno pravilo <ph name="CHROME_REPORTING_EXTENSION_NAME" />, a računalo je prijavljeno tokenom <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="7323896582714668701">Dodatni parametri naredbenog retka za uslugu <ph name="PRODUCT_NAME" /></translation>
<translation id="7326394567531622570">Slično pravilu Wipe (vrijednost 2), no pokušava zadržati oznake za prijavu kako se korisnik ne bi morao ponovo prijavljivati.</translation>
<translation id="7329842439428490522">Određuje koliko vremena treba proteći bez aktivnosti korisnika da bi se zaslon isključio tijekom baterijskog napajanja.

          Kada je postavljeno na vrijednost veću od nule, ovo pravilo određuje koliko vremena treba proteći u neaktivnosti prije nego što <ph name="PRODUCT_OS_NAME" /> isključi zaslon.

          Kada je ovo pravilo postavljeno na nulu, <ph name="PRODUCT_OS_NAME" /> ne isključuje zaslon tijekom neaktivnosti korisnika.

          Kada nije postavljeno, upotrebljava se zadano vrijeme.

          Vrijednost pravila treba navesti u milisekundama. Vrijednosti su ograničene na vrijeme kraće od odgode neaktivnosti ili jednako tom vremenu.</translation>
<translation id="7329968046053403405">Određuje vrstu računa za račune koje pruža Androidova aplikacija za autentifikaciju koja podržava <ph name="HTTP_NEGOTIATE" /> autentifikaciju (npr., autentifikaciju Kerberos). Te informacije pruža dobavljač aplikacije za autentifikaciju. Više informacija potražite na https://goo.gl/hajyfN.

          Ako se ne navede nijedna postavka, na Androidu nije omogućena <ph name="HTTP_NEGOTIATE" /> autentifikacija.</translation>
<translation id="7331962793961469250">Kada je postavljeno na "true" (točno), promocije za aplikacije Chrome web-trgovine neće se pojavljivati na stranici Nova kartica. Ako se ova opcija postavi na "false" (netočno) ili se ne postavi uopće, promocije za aplikacije Chrome web-trgovine prikazivat će se na stranici Nova kartica</translation>
<translation id="7332963785317884918">Pravilo je zastarjelo. Sustav <ph name="PRODUCT_OS_NAME" /> uvijek će upotrebljavati strategiju čišćenja "RemoveLRU".

      Upravlja ponašanjem automatskog čišćenja na uređajima <ph name="PRODUCT_OS_NAME" />. Automatsko čišćenje pokreće se kada količina slobodnog prostora na disku dosegne kritičnu razinu kako bi se oslobodio prostor na disku.

      Ako se to pravilo postavi na "RemoveLRU", automatsko čišćenje uklanjat će korisnike s uređaja počevši od onog koji se najdulje nije prijavljivao, sve dok ne bude dovoljno prostora.

      Ako se to pravilo postavi na "RemoveLRUIfDormant", automatsko čišćenje uklanjat će korisnike koji se nisu prijavili najmanje 3 mjeseca počevši od onog koji se najdulje nije prijavljivao, sve dok ne bude dovoljno prostora.

      Ako se to pravilo ne postavi, automatsko čišćenje upotrebljava zadanu ugrađenu strategiju. Ta je strategija trenutačno "RemoveLRUIfDormant".</translation>
<translation id="7336785017449297672">Upravlja postavkama sata i vremenske zone.</translation>
<translation id="7336878834592315572">Zadrži kolačiće za vrijeme trajanja sesije</translation>
<translation id="7339315111520512972">Nametni pokretanje koda za umrežavanje u procesu preglednika</translation>
<translation id="7340034977315324840">Izvješće o vremenima aktivnosti uređaja</translation>
<translation id="7343497214039883642">Datoteka za konfiguraciju pisača tvrtke za uređaje</translation>
<translation id="735902178936442460">Pravilo određuje hoće li se prijavljivati informacije koje se mogu upotrijebiti za identifikaciju računala, kao što su naziv računala i mrežne adrese.

      Ako se to pravilo ne postavi ili se postavi na True, prikupljaju se informacije koje se mogu upotrijebiti za identifikaciju računala.
      Ako se pravilo postavi na False, ne prikupljaju se informacije koje se mogu upotrijebiti za identifikaciju računala.

      To se pravilo primjenjuje samo kada je omogućeno pravilo <ph name="CHROME_REPORTING_EXTENSION_NAME" />, a računalo je prijavljeno tokenom <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="7359307926583593395">
      To se pravilo primjenjuje na zaslon za prijavu. Pogledajte i pravilo <ph name="SITE_PER_PROCESS_POLICY_NAME" /> koje se primjenjuje na korisničku sesiju. Preporučuje se postaviti oba pravila na istu vrijednost. Ako se vrijednosti ne podudaraju, može doći do kašnjenja prilikom pokretanja korisničke sesije dok se primjenjuje vrijednost navedena korisničkim pravilima.
      </translation>
<translation id="737655323154569539">Ograničava veličinu stranice ispisa. Nepostavljanje pravila i prazan skup smatraju se nepostojanjem ograničenja.</translation>
<translation id="7389872682701720082">Ako omogućite tu postavku, dodaci koji nisu zastarjeli uvijek će se pokretati.

      Ako postavku onemogućite ili je ne postavite, od korisnika će se tražiti dopuštenje za pokretanje dodataka koji zahtijevaju autorizaciju. Ti dodaci mogu predstavljati sigurnosni rizik.</translation>
<translation id="7417972229667085380">Postotak za skaliranje odgode u stanju mirovanja u načinu prezentacije (obustavljeno)</translation>
<translation id="7421483919690710988">Postavite veličinu predmemorije medijskog diska u bajtovima</translation>
<translation id="7424751532654212117">Popis iznimki popisa onemogućenih dodataka</translation>
<translation id="7426112309807051726">Određuje treba li se onemogućiti <ph name="TLS_FALSE_START" /> optimizacija. Iz povijesnih razloga to se pravilo zove DisableSSLRecordSplitting.

      Ako se to pravilo ne postavi ili se postavi na "False", omogućit će se <ph name="TLS_FALSE_START" />. Ako se postavi na "True", neće se omogućiti <ph name="TLS_FALSE_START" />.</translation>
<translation id="7433714841194914373">Omogući Instant</translation>
<translation id="7434202861148928348">Konfiguriraj tražene nazive domena za klijente daljinskog pristupa</translation>
<translation id="7443616896860707393">Zahtjevi za Cross-origin HTTP Basic Auth</translation>
<translation id="7454519673779830548">Dodaje unaprijed unesene Kerberos račune. Ako se vjerodajnice za Kerberos podudaraju s vjerodajnicama za prijavu, račun se može konfigurirati da ponovo koristi vjerodajnice za prijavu tako da se za korisničko ime navede "${{LOGIN_EMAIL}}", a za zaporku "${{PASSWORD}}" kako bi se Kerberosov tiket mogao dohvatiti automatski osim ako je konfigurirana dvostruka autentifikacija. Korisnici ne mogu izmijeniti račune dodane tim pravilom.

          Ako se to pravilo omogući, popis računa definiranih pravilom dodaje se u postavke Kerberos računa.

          Ako se to pravilo onemogući ili ne postavi, u postavke Kerberos računa ne dodaje se nijedan račun i uklanjaju se svi računi prethodno dodani tim pravilom. Korisnici još uvijek mogu dodavati račune ručno ako je omogućeno pravilo "Korisnici mogu dodati Kerberos račune".</translation>
<translation id="7458437477941640506">Nemoj se vratiti na ciljnu verziju ako je verzija OS-a novija od ciljne. Ažuriranja su također onemogućena.</translation>
<translation id="7464991223784276288">Ograničavanje kolačića iz podudarnih URL-ova na trenutačnu sesiju</translation>
<translation id="7469554574977894907">Omogući prijedloge pretraživanja</translation>
<translation id="7485481791539008776">Zadana pravila za odabir pisača</translation>
<translation id="7485730741952775732">Ako se to pravilo postavi, host daljinskog pristupa taj će URL koristiti za provjeru autentifikacijskih tokena od klijenata daljinskog pristupa radi prihvaćanja povezivanja. Mora se upotrebljavati zajedno s pravilom RemoteAccessHostTokenUrl.

          Ta je značajka trenutačno onemogućena na poslužitelju.</translation>
<translation id="749556411189861380">Generira izvješće o verziji OS-a i opreme registriranih uređaja.

      Ako se ta postavka ne postavi ili se postavi na istinito, registrirani uređaji periodički će izvješćivati o verziji OS-a i opreme. Ako se postavka postavi na neistinito, izvješće s informacijama o verziji neće se generirati.</translation>
<translation id="7498946151094347510">Određuje pisače koje korisnik ne može upotrebljavati.

      To se pravilo upotrebljava samo ako je pravilo <ph name="PRINTERS_BLACKLIST" /> odabrano za <ph name="DEVICE_PRINTERS_ACCESS_MODE" />.

      Ako se to pravilo upotrebljava, korisniku se pružaju svi pisači osim pisača s ID-jevima navedenima u pravilu. ID-jevi se moraju podudarati s poljima "id" ili "guid" u datoteci navedenoj u pravilu <ph name="DEVICE_PRINTERS_POLICY" />.
      </translation>
<translation id="7506269062143646163">Omogući podršku za Potpisanu HTTP razmjenu (SXG).

          Ako se to pravilo ne postavi ili se omogući, Google Chrome prihvaćat će web-sadržaje koji se poslužuju kao potpisane HTTP razmjene.

          Ako se pravilo onemogući, potpisane HTTP razmjene ne mogu se učitati.</translation>
<translation id="7511361072385293666">Ako se to pravilo postavi na "istinito" ili ako se ne postavi, dopuštena je upotreba QUIC protokola na proizvodu <ph name="PRODUCT_NAME" />.
      Ako se postavi na "neistinito", upotreba QUIC protokola nije dopuštena.</translation>
<translation id="7517845714620372896">Određuje postotak svjetline zaslona.
          Ako se to pravilo postavi, početna svjetlina zaslona prilagođena je u skladu s vrijednošću pravila, ali je korisnik može naknadno promijeniti. Značajke automatske svjetline onemogućene su.
          Ako se pravilo ne postavi, nema utjecaja na korisničke kontrole zaslona i automatsku svjetlinu.
          Vrijednosti pravila trebaju se navesti u postocima u rasponu od 0 do 100.</translation>
<translation id="7517846421386644905">Omogućuju administratoru da odredi hoće li Wilco kontroler za dijagnostiku i telemetriju (DTC) prikupljati, obrađivati i prijavljivati telemetrijske i dijagnostičke podatke.

      Ako se to pravilo postavi na False ili se ne postavi, DTC je isključen i ne može prikupljati, obrađivati i prijavljivati telemetrijske i dijagnostičke podatke s uređaja.
      Ako je na određenom uređaju Wilco DTC dostupan, a pravilo se postavi na True, uključeno je prikupljanje, obrada i prijavljivanje telemetrijskih i dijagnostičkih podataka.</translation>
<translation id="7519251620064708155">Dopusti generiranje ključeva na ovim web-lokacijama</translation>
<translation id="7529100000224450960">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju web-lokacije kojima je dopušteno otvaranje skočnih prozora. Ako ovo pravilo nije postavljeno, upotrebljavat će se globalna zadana vrijednost za sve web-lokacije iz pravila "DefaultPopupsSetting" ako je postavljeno, odnosno iz osobne konfiguracije korisnika ako nije.</translation>
<translation id="7529144158022474049">Čimbenik raspršivanja automatskog ažuriranja</translation>
<translation id="7534199150025803530">To pravilo nema utjecaja na Android aplikaciju Google disk. Ako želite spriječiti upotrebu Google diska putem mobilnih veza, onemogućite instaliranje Android aplikacije Google disk.</translation>
<translation id="7540622499178214923">Dopusti Wilco kontroler za dijagnostiku i telemetriju</translation>
<translation id="7547549430720182663">Spoji</translation>
<translation id="7553535237300701827">Kada je to pravilo postavljeno, tijek autentifikacije prilikom prijave odvijat će se na jedan od sljedećih načina ovisno o vrijednosti te postavke:

      Ako je postavljeno na GAIA-u, prijava će se odvijati uobičajenim GAIA-inim tijekom autentifikacije.

      Ako je postavljeno na SAML_INTERSTITIAL, prijava će prikazati međuprostorni zaslon koji korisniku nudi da nastavi s autentifikacijom putem SAML IdP-a domene za prijavu uređaja ili da se vrati na uobičajen GAIA-in tijek prijave.</translation>
<translation id="755951849901630953">Omogućuje ažuriranja komponenti za sve komponente u pregledniku <ph name="PRODUCT_NAME" /> kada se pravilo ne postavi ili se postavi na True.

      Ako se postavi na False, ažuriranje je komponenti onemogućeno. No neke su komponente izuzete od tog pravila i dalje će se ažurirati, a to su komponente koje ne sadrže izvršni kôd, koje bitno ne mijenjaju ponašanje preglednika ili koje su važne za sigurnost.
      Primjeri takvih komponenti uključuju popise opozvanih certifikata i podatke Sigurnog pregledavanja.
      Više informacija o Sigurnom pregledavanju potražite na stranici https://developers.google.com/safe-browsing.</translation>
<translation id="7566878661979235378">Vrsta autentifikacije za SAML prijavu</translation>
<translation id="757395965347379751">Kada je ta postavka omogućena, <ph name="PRODUCT_NAME" /> dopušta certifikate s SHA-1 potpisom ako se uspješno ovjere i povežu s lokalno instaliranim CA certifikatima.

      Napominjemo da to pravilo ovisi o tome dopušta li snop za potvrdu certifikata operativnog sustava SHA-1 potpise. Ako se ažuriranjem OS-a promijeni njegovo rukovanje SHA-1 certifikatima, to pravilo možda više neće imati utjecaja. Nadalje, to je pravilo predviđeno kao privremeno rješenje kako bi organizacije imale više vremena za napuštanje algoritma SHA-1. Pravilo će se ukloniti 1. siječnja 2019. ili oko tog datuma.

      Ako se to pravilo ne postavi ili se postavi na False, <ph name="PRODUCT_NAME" /> slijedi javno najavljeni raspored ukidanja algoritma SHA-1.</translation>
<translation id="7578049687634719313">Pravilo određuje vrijeme čekanja prije pokretanja zamjenskog preglednika, u milisekundama.

      Ako se to pravilo ne postavi ili se postavi na 0, nakon pomicanja na označeni URL on se odmah otvara u zamjenskom pregledniku.

      Kada se to pravilo postavi na neki broj, Chrome će prikazati poruku na toliko milisekunda, a zatim će otvoriti zamjenski preglednik.</translation>
<translation id="7593523670408385997">Konfigurira veličinu predmemorije koju će <ph name="PRODUCT_NAME" /> upotrebljavati za pohranu predmemoriranih datoteka na disku.

      Ako postavite ovo pravilo, <ph name="PRODUCT_NAME" /> upotrebljavat će ponuđenu veličinu predmemorije, bez obzira je li korisnik označio "--disk-cache-size". Vrijednost navedena u ovom pravilu nije čvrsto postavljena granica, već prijedlog za sustav predmemoriranja; svaka vrijednost ispod nekoliko megabajta premala je i zaokružit će se na prihvatljivi minimum.

      Ako je vrijednost ovog pravila 0, upotrijebit će se zadana veličina predmemorije, ali je korisnik neće moći promijeniti.

      Ako ovo pravilo nije postavljeno, upotrijebit će se zadana veličina i korisnik će je moći nadjačati oznakom --disk-cache-size.</translation>
<translation id="759389052790680884">Postavite prilagođeno zaustavljanje punjenja baterije u postocima.

          Baterija se prestaje puniti kada dosegne vrijednost prilagođenog zaustavljanja punjenja baterije.

          Vrijednost pravila DeviceBatteryChargeCustomStartCharging mora biti manja od one u pravilu DeviceBatteryChargeCustomStopCharging.

          To se pravilo upotrebljava samo ako je pravilo DeviceBatteryChargeMode postavljeno na prilagođeno.

          Ako se pravilo ne konfigurira ili se ne postavi, primjenjivat će se standardni način punjenja baterije.</translation>
<translation id="759957074386651883">Postavke Sigurnog pregledavanja</translation>
<translation id="7604169113182304895">Android aplikacije mogu poštovati taj popis dobrovoljno. Na to ih ne možete natjerati.</translation>
<translation id="7612157962821894603">Oznake na razini sustava primijenit će se prilikom pokretanja preglednika <ph name="PRODUCT_NAME" /></translation>
<translation id="7614663184588396421">Popis onemogućenih shema protokola</translation>
<translation id="7617319494457709698">To pravilo određuje dopuštena proširenja za upotrebu funkcije <ph name="CHALLENGE_USER_KEY_FUNCTION" /> API-ja <ph name="ENTERPRISE_PLATFORM_KEYS_API" /> za daljinsko atestiranje. Proširenja se moraju dodati na taj popis da bi upotrebljavala taj API.

          Ako proširenje nije na popisu ili ako popis nije postavljen, poziv API-ju vratit će kôd pogreške.</translation>
<translation id="7620869951155758729">Ovo pravilo navodi konfiguraciju koja se upotrebljava za generiranje i potvrđivanje koda za roditeljski pristup.

      |current_config| uvijek se upotrebljava za generiranje pristupnog koda i treba se upotrebljavati za potvrđivanje pristupnog koda samo kad ga nije moguće potvrditi pomoću |future_config|.
      |future_config| primarna je konfiguracija koje se upotrebljava za potvrđivanje pristupnog koda.
      |old_configs| trebaju se upotrebljavati za potvrđivanje pristupnog koda samo kad ga nije moguće potvrditi pomoću |future_config| i |current_config|.

      Predviđeni je način upotrebe ovog pravila postupno izmjenjivati konfiguraciju pristupnog koda. Nova se konfiguracija uvijek stavlja u |future_config|, a postojeća
      vrijednost istovremeno se premješta u |current_config|. Prethodne vrijednosti za |current_config| premještaju se u |old_configs| i uklanjanju nakon završetka ciklusa izmjene.

      Ovo se pravilo primjenjuje samo na korisnika koji je dijete.
      Kad se to pravilo postavi, kôd za roditeljski pristup može se potvrditi na djetetovom uređaju.
      Kad se to pravilo ne postavi, nije moguće potvrditi kôd za roditeljski pristup na djetetovom uređaju.</translation>
<translation id="7625444193696794922">Određuje kanal za izdavanje na koji bi ovaj uređaj trebao biti priključen.</translation>
<translation id="7632724434767231364">Naziv GSSAPI biblioteke</translation>
<translation id="7635471475589566552">Konfigurira oznaku zemlje/jezika aplikacije u proizvodu <ph name="PRODUCT_NAME" /> i sprječava korisnike da promijene oznaku zemlje/jezika. Ako omogućite ovu postavku, <ph name="PRODUCT_NAME" /> upotrebljavat će navedenu oznaku zemlje/jezika. Ako konfigurirana oznaka zemlje/jezika nije podržana, upotrebljavat će se "en-US". Ako je ova postavka onemogućena ili nije postavljena, <ph name="PRODUCT_NAME" /> upotrebljavat će oznaku zemlje/jezika koju odredi korisnik (ako je konfigurirana), oznaku zemlje/jezika sustava ili standardnu oznaku zemlje/jezika "en-US".</translation>
<translation id="7641363659597330616">Konfigurira vrste preuzimanja koje će <ph name="PRODUCT_NAME" /> potpuno blokirati, bez omogućivanja korisnicima da nadjačaju sigurnosnu odluku.

      Ako postavite to pravilo, preglednik <ph name="PRODUCT_NAME" /> spriječit će određene vrste preuzimanja i neće dopustiti da korisnici zaobiđu sigurnosna upozorenja.

      Kada se odabere opcija "Blokiraj opasna preuzimanja", dopuštena su sva preuzimanja osim onih koja imaju upozorenja Sigurnog pregledavanja.

      Kada se odabere opcija "Blokiraj potencijalno opasna preuzimanja", dopuštena su sva preuzimanja osim onih koja imaju upozorenja Sigurnog pregledavanja o potencijalno opasnim preuzimanjima.

      Kada se odabere opcija "Blokiraj sva preuzimanja", blokiraju se sva preuzimanja.

      Kada se to pravilo ne postavi (ili se odabere opcija "Nema posebnih ograničenja"), preuzimanja će prolaziti kroz uobičajena sigurnosna ograničenja na temelju rezultata analize Sigurnog pregledavanja.

      Napominjemo da se ta ograničenja primjenjuju na preuzimanja aktivirana iz sadržaja web-stranice, kao i putem opcije kontekstnog izbornika "Preuzmi vezu...". Ta se ograničenja ne primjenjuju na spremanje ili preuzimanje trenutačno prikazane stranice ni na spremanje u obliku PDF-a u opcijama ispisa.

      Više informacija o Sigurnom pregledavanju potražite na stranici https://developers.google.com/safe-browsing.</translation>
<translation id="7643883929273267746">Ograniči račune koji su vidljivi u pregledniku <ph name="PRODUCT_NAME" /></translation>
<translation id="7644825865811580663">Ako se to pravilo postavi na true, <ph name="PRODUCT_NAME" /> bezuvjetno će maksimizirati prvi prozor koji se prikazuje prilikom prvog pokretanja.
      Ako se pravilo postavi na false ili se ne konfigurira, odluka o maksimiziranju prvog prozora temeljit će se na veličini zaslona.</translation>
<translation id="7651739109954974365">Utvrđuje treba li roaming podataka biti omogućen za uređaj. Ako je to pravilo postavljeno na "istinito", roaming podataka bit će dopušten. Ako to pravilo nije konfigurirano ili je postavljeno na "lažno", roaming podataka neće biti dostupan.</translation>
<translation id="7657261947024629645">Optimizirati za izvedbu.</translation>
<translation id="7673194325208122247">Razdoblje (milisekunde)</translation>
<translation id="7676708657861783864">Kolačići koje postavljaju stranice koje odgovaraju tim uzorcima URL-ova bit će ograničeni na trenutačnu sesiju, odnosno bit će izbrisani nakon zatvaranja preglednika.

          Za URL-ove koji nisu obuhvaćeni ovdje navedenim uzorcima i za sve URL-ove za koje to pravilo nije postavljeno upotrebljavat će se globalna zadana vrijednost iz pravila "DefaultCookiesSetting" ako je postavljeno, odnosno iz osobne konfiguracije korisnika ako nije.

          Ako je <ph name="PRODUCT_NAME" /> pokrenut u "pozadinskom načinu", sesija se možda neće završiti kada se zatvori posljednji prozor, već će ostati aktivna dok se ne zatvori preglednik. Više informacija o konfiguriranju tog ponašanja potražite u pravilu "BackgroundModeEnabled".

          Pogledajte i pravila "CookiesAllowedForUrls" i "CookiesBlockedForUrls". Napominjemo da između tih triju pravila ne smiju postojati uzorci URL-ova u sukobu jer nije navedeno koje pravilo ima prednost.

          Ako je pravilo "RestoreOnStartup" postavljeno na vraćanje URL-ova iz prethodnih sesija, ovo se pravilo neće poštovati i za te će se web-lokacije kolačići trajno pohranjivati.</translation>
<translation id="7683777542468165012">Dinamičko osvježavanje pravila</translation>
<translation id="7687943045976362719">Ako se to pravilo postavi, navedenim vrstama sadržaja rukovat će <ph name="PRODUCT_FRAME_NAME" />.

          Ako se to pravilo ne postavi, za sve web-lokacije upotrebljavat će se zadani ispunjivač. (Zadani ispunjivač može se konfigurirati pomoću pravila <ph name="CHROME_FRAME_RENDERER_SETTINGS_POLICY_NAME" />.)</translation>
<translation id="7694245791806617022">Upravlja time je li značajka "Zapamti zaporku" omogućena u dijaloškom okviru za autentifikaciju koju pruža Kerberos. Zaporke se pohranjuju kriptirane na disku, a dostupne su samo demonu sustava Kerberos i tijekom korisničke sesije.

          Ako se to pravilo omogući ili ne postavi, korisnici mogu odlučiti hoće li se zaporke Kerberosa zapamtiti kako ih se više ne bi trebalo unositi. Kerberosov tiket dohvaća se automatski osim ako je potrebna dodatna autentifikacija (dvostruka autentifikacija).

          Ako se to pravilo onemogući, zaporke se ne pamte i sve se prethodno pohranjene zaporke uklanjaju. Korisnici moraju unijeti zaporku svaki put kad je potrebna provjera autentičnosti u sustavu Kerberos. Ovisno o postavkama poslužitelja vremenski intervali u kojima se to događa obično se kreću od svakih osam sati do nekoliko mjeseci.</translation>
<translation id="7694807474048279351">Odredi vrijeme automatskog ponovnog pokretanja nakon primjene ažuriranja sustava <ph name="PRODUCT_OS_NAME" />.

      Kada se to pravilo postavi na točno, određuje se vrijeme automatskog ponovnog pokretanja kada se primijeni ažuriranje sustava <ph name="PRODUCT_OS_NAME" /> za čije je dovršavanje potrebno ponovno pokretanje. Ponovno je pokretanje postavljeno na trenutak dovršavanja ažuriranja, ali može se odgoditi na uređaju do 24 sata ako korisnik trenutačno upotrebljava taj uređaj.

      Kada se to pravilo postavi na netočno, nakon primjene ažuriranja sustava <ph name="PRODUCT_OS_NAME" /> ne određuje se vrijeme automatskog ponovnog pokretanja. Postupak ažuriranja dovršava se kada korisnik sljedeći put ponovo pokrene uređaj.

      Ako postavite to pravilo, korisnici ga ne mogu promijeniti ili premostiti.

      Napomena: trenutačno su automatska ponovna pokretanja omogućena samo dok se prikazuje zaslon za prijavu ili dok traje sesija aplikacije kioska. To će se u budućnosti promijeniti i pravilo će se primjenjivati uvijek, bez obzira na to je li neka određena vrsta sesije u tijeku ili nije.</translation>
<translation id="7701341006446125684">Postavljanje veličine predmemorije aplikacija i proširenja (u bajtovima)</translation>
<translation id="7709537117200051035">Rječnik koji mapira nazive hostova na Booleovu oznaku koja određuje hoće li pristup hostu biti dopušten (točno) ili blokiran (netočno).

          To je pravilo za internu upotrebu preglednika <ph name="PRODUCT_NAME" />.</translation>
<translation id="7712109699186360774">Pitaj svaki put kada web-lokacija želi pristupiti kameri i/ili mikrofonu</translation>
<translation id="7713608076604149344">Ograničenja za preuzimanja</translation>
<translation id="7715711044277116530">Postotak za skaliranje odgode zatamnjenja zaslona u načinu prezentacije</translation>
<translation id="7716781462866245042">Postavite dnevno konfiguriranje naprednog načina punjenja baterije.

          To se pravilo upotrebljava samo ako se DeviceAdvanceBatteryChargeModeEnabled postavi na true.

          Ako se pravilo ne konfigurira ili se ne postavi, napredni način punjenja baterije uvijek će biti onemogućen.

          Napomena: <ph name="CHARGE_START_TIME_FIELD_NAME" /> mora biti manje od <ph name="CHARGE_END_TIME_FIELD_NAME" />.

          Napomena: dopuštene vrijednosti za polje <ph name="MINUTE_FIELD_NAME" /> u <ph name="CHARGE_START_TIME_FIELD_NAME" /> i <ph name="CHARGE_END_TIME_FIELD_NAME" /> jesu 0, 15, 30, 45.</translation>
<translation id="7717938661004793600">Konfiguriranje značajki pristupačnosti proizvoda <ph name="PRODUCT_OS_NAME" />.</translation>
<translation id="7747447585227954402">Dopusti uređajima da upotrebljavaju <ph name="PLUGIN_VM_NAME" /> na proizvodu <ph name="PRODUCT_OS_NAME" /></translation>
<translation id="7749402620209366169">Omogućuje autentifikaciju s dva čimbenika za hostove daljinskog pristupa umjesto PIN-a koji određuje korisnik.

          Ako je ta postavka omogućena, korisnici moraju unijeti važeći kôd s dva čimbenika kada pristupaju hostu.

          Ako je ta postavka onemogućena ili ako nije postavljena, autentifikacija s dva čimbenika neće biti omogućena i upotrebljavat će se zadani postupak s PIN-om koji određuje korisnik.</translation>
<translation id="7750991880413385988">Otvori stranicu Nova kartica</translation>
<translation id="7754704193130578113">Pitaj gdje spremiti svaku datoteku prije preuzimanja</translation>
<translation id="7761446981238915769">Konfiguriranje popisa instaliranih aplikacija na zaslonu za prijavu</translation>
<translation id="7763479091692861127"> Vrste veza putem kojih su dopuštena ažuriranja OS-a. Ažuriranja OS-a zbog svoje veličine potencijalno jako opterećuju vezu i mogu uzrokovati dodatne troškove. Stoga prema zadanim postavkama nisu omogućena za vrste veza koje se smatraju skupima, a to su trenutačno WiMax, Bluetooth i mobilne veze.

      Prepoznati identifikatori vrste veze jesu "ethernet", "wifi", "wimax", "bluetooth" i "mobilna".</translation>
<translation id="7763614521440615342">Prikaz prijedloga sadržaja na web-stranici nove kartice</translation>
<translation id="7765879851993224640">Dopusti upotrebu Smart Locka za prijavu.</translation>
<translation id="7772346342637974431">Određuje koliko vremena treba proći od zadnjeg korisničkog unosa nakon kojeg se prikazuje dijaloški okvir upozorenja kada uređaj nije priključen u struju.

          Ako se postavi, to pravilo određuje koliko dugo korisnik treba biti neaktivan prije nego što <ph name="PRODUCT_OS_NAME" /> prikaže dijaloški okvir upozorenja kojim se korisnika obavještava da će se poduzeti radnja u slučaju neaktivnosti.

          Ako se pravilo ne postavi, ne prikazuje se dijaloški okvir upozorenja.

          Vrijednost pravila treba se navesti u milisekundama. Vrijednosti moraju biti kraće od vremena odgode do radnje u slučaju neaktivnosti ili jednake tom vremenu.

          Poruka upozorenja prikazuje se samo ako je radnja u slučaju neaktivnosti odjava ili isključivanje.</translation>
<translation id="7774768074957326919">Upotrijebi proxy postavke sustava</translation>
<translation id="7777535871204167559">Postupaj s vanjskim uređajima za pohranu kao da su samo za čitanje</translation>
<translation id="7788511847830146438">Po profilu</translation>
<translation id="780603170519840350">Onemogućuje provedbu zahtjeva Transparentnosti certifikata za popis hashiranja za subjectPublicKeyInfo.

      To pravilo omogućuje da se zahtjevi za otkrivanje Transparentnosti certifikata ne otkrivaju za lance certifikata koji sadrže certifikate s jednim od navedenih hashiranja za subjectPublicKeyInfo. To omogućuje da se certifikati koji se inače ne bi smatrali pouzdanima (jer nisu pravilno javno otkriveni) nastave upotrebljavati za hostove Enterprisea.

      Da bi se provedba Transparentnosti certifikata onemogućila kada se to pravilo postavi, mora se ispuniti jedan od sljedećih uvjeta:
      1. Hashiranje je generirano za subjectPublicKeyInfo certifikata poslužitelja.
      2. Hashiranje je generirano za subjectPublicKeyInfo koji se pojavljuje u CA certifikatu u lancu certifikata, CA certifikat ograničen je proširenjem X.509v3 nameConstraints, jedna ili više stavki directoryName nameConstraints prisutne su u permittedSubtrees i directoryName sadrži atribut organizationName.
      3. Hashiranje je generirano za subjectPublicKeyInfo koji se pojavljuje u CA certifikatu u lancu certifikata, CA certifikat ima jedan ili više atributa organizationName u predmetu certifikata i certifikat poslužitelja sadrži isti broj atributa organizationName istim redoslijedom i s vrijednostima identičnim bajt za bajt.

      Hash generiran za subjectPublicKeyInfo navodi se ulančavanjem naziva algoritma hashiranja, znaka "/" i Base64 kodiranja tog algoritma hashiranja primijenjenog na subjectPublicKeyInfo navedenog certifikata kodiranog DER-om. To Base64 kodiranje isti je format kao SPKI Fingerprint, kao što je definirano u RFC-u 7469, u odjeljku 2.4. Algoritmi hashiranja koji se ne prepoznaju ignoriraju se. Jedini podržani algoritam hashiranja trenutačno je "sha256".

      Ako se to pravilo ne postavi, sa svim certifikatima koji se moraju otkriti putem Transparentnosti certifikata postupat će se kao da nisu pouzdani ako se ne otkriju u skladu s pravilom Transparentnosti certifikata.</translation>
<translation id="7818131573217430250">Postavljanje zadanog stanja načina visokog kontrasta na zaslonu za prijavu</translation>
<translation id="7822837118545582721">Kada se to pravilo postavi na True, korisnici ne mogu ništa zapisivati na vanjske uređaje za pohranu.

      Ako se ta postavka postavi na False ili se ne konfigurira, korisnici mogu izrađivati i izmjenjivati datoteke na vanjskim uređajima za pohranu na kojima se može fizički zapisivati.

      ExternalStorageDisabled ima prednost pred ovim pravilom. Ako se ExternalStorageDisabled postavi na True, onda je pristup vanjskoj pohrani potpuno onemogućen, a ovo se pravilo stoga zanemaruje.

      Dinamičko osvježavanje tog pravila podržano je u verziji M56 i kasnijim verzijama.</translation>
<translation id="7831595031698917016">Određuje maksimalnu odgodu u milisekundama od primitka poništenja valjanosti pravila do dohvaćanja novog pravila s usluge upravljanja uređajem.

      Postavljanjem tog pravila poništava se zadana vrijednost od 5000 milisekundi. Važeće vrijednosti za to pravilo u rasponu su od 1000 (1 sekunde) do 300000 (5 minuta). Sve vrijednosti koje nisu u tom rasponu bit će prilagođene odgovarajućoj granici.

      Ako se to pravilo ne postavi, <ph name="PRODUCT_NAME" /> upotrebljavat će zadanu vrijednost od 5000 milisekundi.</translation>
<translation id="7841880500990419427">Minimalna verzija TLS-a za pričuvnu upotrebu</translation>
<translation id="7858404742201086014">Ako omogućite tu postavku, zastarjeli se dodaci upotrebljavaju kao uobičajeni dodaci.

      Ako omogućite tu postavku, zastarjeli dodaci neće se upotrebljavati i od korisnika se neće tražiti dopuštenje za njihovo pokretanje.

      Ako se ta postavka ne postavi, od korisnika će se tražiti dopuštenje za pokretanje zastarjelih dodataka.</translation>
<translation id="787125417158068494">Ako se postavi na SyncDisabled ili se ne konfigurira, <ph name="PRODUCT_OS_NAME" /> certifikati nisu dostupni za ARC aplikacije.

      Ako se postavi na CopyCaCerts, svi CA certifikati instalirani u ONC uz <ph name="WEB_TRUSTED_BIT" /> dostupni su za ARC aplikacije.</translation>
<translation id="7882585827992171421">To je pravilo aktivno samo u prodajnom načinu.

      Određuje ID proširenja koje će se upotrebljavati kao čuvar zaslona na zaslonu prijave. To proširenje mora biti dijelom paketa AppPack koji se konfigurira za ovu domenu pravilom DeviceAppPack.</translation>
<translation id="7882857838942884046">Onemogućivanje Google sinkronizacije uzrokovat će nepravilno funkcioniranje izrade sigurnosnih kopija i vraćanja na Androidu.</translation>
<translation id="7882890448959833986">Spriječi upozorenje o nepodržanom OS-u</translation>
<translation id="7889788745439330797">Upravlja time mogu li korisnici dodati Kerberos račune.

          Ako se to pravilo omogući ili ne postavi, korisnici mogu dodati Kerberos račune putem postavki Kerberos računa na stranici postavki za Osobe. Korisnici imaju potpunu kontrolu nad računima koje su dodali i mogu ih izmijeniti ili ukloniti.

          Ako se pravilo onemogući, korisnici ne mogu dodati Kerberos račune. Računi se mogu dodati samo pravilom "Konfiguriraj Kerberos račune". To je učinkovit način zaključavanja računa.</translation>
<translation id="7895553628261067384">Daljinski pristup</translation>
<translation id="7902255855035461275">Uzorci na tom popisu usporedit će se sa sigurnosnim izvorištem
      URL-a koji šalje zahtjev. Ako se pronađe podudaranje, pristup uređajima
      za snimanje videozapisa dopuštat će se bez upita.

      NAPOMENA: do verzije 45 to je pravilo bilo podržano samo u načinu kioska.</translation>
<translation id="7912255076272890813">Konfiguriraj dopuštene vrste aplikacija/proširenja</translation>
<translation id="7922358664346625612">Zadrži otvorenu posljednju karticu u Chromeu.</translation>
<translation id="793134539373873765">Određuje hoće li se p2p upotrebljavati za podatke ažuriranja OS-a. Ako je postavljeno na Točno, uređaji će dijeliti i pokušati konzumirati podatke ažuriranja na LAN-u potencijalno smanjujući potrošnju internetske propusnosti i zagušenje. Ako podaci ažuriranja nisu dostupni na LAN-u, uređaj će prijeći na preuzimanje s poslužitelja ažuriranja. Ako je postavljeno na Netočno ili nije konfigurirano, p2p se neće upotrebljavati.</translation>
<translation id="7933141401888114454">Omogući izradu nadziranih korisnika</translation>
<translation id="793473937901685727">Postavi dostupnost certifikata za ARC aplikacije</translation>
<translation id="7937491150792971922">Spoji pravila za popise za instaliranje proširenja iz više izvora</translation>
<translation id="7937766917976512374">Omogući ili onemogući snimanje videozapisa</translation>
<translation id="7941975817681987555">Ne predviđaj mrežne radnje ni na jednoj mrežnoj vezi</translation>
<translation id="7952007677054834789">Konfigurirajte stranice koje se učitavaju prilikom pokretanja, zadanu početnu stranicu i zadanu stranicu nove kartice u pregledniku <ph name="PRODUCT_NAME" /> i spriječite korisnike da ih promijene.

      Korisničke postavke početne stranice potpuno su zaključane samo ako odaberete početnu stranicu kao web-stranicu nove kartice ili je postavite kao URL i navedete URL početne stranice. Ako ne navedete URL početne stranice, korisnik će svejedno moći postaviti početnu stranicu na web-stranicu nove kartice tako da navede "chrome://newtab".

      Pravilo "URL-ovi za otvaranje prilikom pokretanja" zanemaruje se ako ne odaberete "Otvori popis URL-ova" u odjeljku "Radnje prilikom pokretanja".</translation>
<translation id="7952958573604504839">To je pravilo obustavljeno u verziji M48 u korist pravila <ph name="NETWORK_PREDICTION_OPTIONS_POLICY_NAME" />, a uklonjeno je u verziji M54.

      Omogućuje predviđanje mreže u pregledniku <ph name="PRODUCT_NAME" /> i onemogućuje korisnicima da promijene tu postavku.

      Time se ne kontrolira samo pretpreuzimanje DNS-a, već i TCP i SSL pretpovezivanje i pretprikaz web-stranica. Naziv pravila odnosi se na pretpreuzimanje DNS-a iz povijesnih razloga.

      Ako omogućite ili onemogućite tu postavku, korisnici je neće moći promijeniti ni nadjačati u pregledniku <ph name="PRODUCT_NAME" />.

      Ako se pravilo ne postavi, ono će biti omogućeno, ali će ga korisnici moći promijeniti.</translation>
<translation id="7953256619080733119">Hostovi ručnih iznimaka upravljanih korisnika</translation>
<translation id="7958537754689366707">Zaporku treba unijeti svakih dvanaest sati</translation>
<translation id="7961779417826583251">Onemogući provedbu Transparentnosti certifikata za popis starih tijela za izdavanje certifikata</translation>
<translation id="7974114691960514888">Ovo pravilo više se ne podržava. Omogućuje upotrebu STUN i relejnih poslužitelja prilikom povezivanja s udaljenim klijentom. Ako je ova postavka omogućena, onda ovo računalo može otkriti udaljena računala hostove i povezati se s njima, čak i ako su odvojena vatrozidom. Ako je ova postavka onemogućena, a izlazne UDP veze filtrirane su vatrozidom, onda se ovo računalo može jedino povezati s računalima hostovima unutar lokalne mreže.</translation>
<translation id="7976157349247117979">Naziv odredišta za <ph name="PRODUCT_NAME" /></translation>
<translation id="7980227303582973781">Nema posebnih ograničenja</translation>
<translation id="7985242821674907985"><ph name="PRODUCT_NAME" /></translation>
<translation id="798856998567564266">Ako omogućite tu postavku, oznake se mogu dodavati, uklanjati ili mijenjati. To je zadana postavka čak i ako se ne postavi pravilo.

      Ako onemogućite tu postavku, oznake se neće moći dodavati, uklanjati ni mijenjati. Postojeće oznake i dalje su dostupne.</translation>
<translation id="7992136759457836904">Omogućuje vam da odredite je li virtualnim računalima dopušteno pokretanje na OS-u Chrome.

      Ako se to pravilo postavi na True, uređaju je dopušteno pokretanje virtualnih računala.
      Ako se pravilo postavi na False, uređaju nije dopušteno pokretanje virtualnih računala.
      Sva tri pravila, VirtualMachinesAllowed, CrostiniAllowed i DeviceUnaffiliatedCrostiniAllowed, moraju se postaviti na True kada se primjenjuju na dopuštanje pokretanja Crostinija.
      Kada se to pravilo promijeni na False, primjenjuje se na pokretanje novih virtualnih računala, ali ne isključuje već pokrenuta virtualna računala.
      Kada to pravilo nije postavljeno na upravljanom uređaju, uređaju nije dopušteno pokretanje virtualnih računala.
      Neupravljanim je uređajima dopušteno pokretanje virtualnih računala.</translation>
<translation id="8001701200415781021">Ograniči Google račune kojima je dopušteno da se postave kao primarni računi u pregledniku <ph name="PRODUCT_NAME" /></translation>
<translation id="8009554972280451023">Ako omogućite tu postavku, postavke pohranjene u <ph name="PRODUCT_NAME" /> profilima kao što su oznake, podaci za automatsko popunjavanje, zaporke itd. također će se bilježiti u datoteku pohranjenu u mapu korisničkog profila na Roamingu ili na lokaciju koju je odredio administrator pomoću pravila <ph name="ROAMING_PROFILE_LOCATION_POLICY_NAME" />. Omogućivanjem tog pravila onemogućuje se sinkronizacija u oblaku.

      Ako se to pravilo onemogući ili ne postavi, upotrebljavat će se samo uobičajeni lokalni profili.

      Pravilo <ph name="SYNC_DISABLED_POLICY_NAME" /> onemogućuje svu sinkronizaciju podataka nadjačavajući <ph name="ROAMING_PROFILE_SUPPORT_ENABLED_POLICY_NAME" />.</translation>
<translation id="802147957407376460">Zakreni zaslon 0 stupnjeva</translation>
<translation id="8033913082323846868">Ovo pravilo obustavljeno je u M70 te umjesto njega upotrebljavajte AutofillAddressEnabled i AutofillCreditCardEnabled.

      Omogućuje značajku <ph name="PRODUCT_NAME" /> Automatskog popunjavanja i dopušta korisnicima da samostalno popune web-obrasce služeći se prethodno pohranjenim informacijama kao što su adresa ili podaci o kreditnoj kartici.

      Ako onemogućite ovu postavku, značajka Automatskog popunjavanja neće biti dostupna korisnicima.

      Ako omogućite ovu postavku ili ako ne postavite vrijednost, značajku Automatskog popunjavanja i dalje će kontrolirati korisnik. To im omogućuje konfiguraciju profila Automatskog popunjavanja te uključivanje ili isključivanje značajke Automatskog popunjavanja po vlastitom nahođenju.</translation>
<translation id="8044493735196713914">Izvješće načina pokretanja uređaja</translation>
<translation id="8050080920415773384">Nativni ispis</translation>
<translation id="8053580360728293758">Nadjačava način boje zadanog ispisa. Pravilo se zanemaruje ako način nije dostupan.</translation>
<translation id="8059164285174960932">URL na kojem bi klijenti za daljinski pristup trebali dobiti token za autentifikaciju</translation>
<translation id="806523868782250975">Konfigurira popis upravljanih oznaka.

      Pravilo obuhvaća popis oznaka u kojem je svaka oznaka rječnik s ključevima "<ph name="NAME" />" i "<ph name="URL_LABEL" />" koji nose naziv i cilj oznake. Moguće je konfigurirati podmapu tako da se definira oznaka bez ključa "<ph name="URL_LABEL" />", ali s dodatnim ključem "<ph name="CHILDREN" />" koji i sam sadrži popis oznaka kako je gore definirano (od kojih neke opet mogu biti mape). <ph name="PRODUCT_NAME" /> dopunjuje nepotpune URL-ove kao da su poslani putem višenamjenskog okvira, npr. "<ph name="GOOGLE_COM" />" postaje "<ph name="HTTPS_GOOGLE_COM" />".

      Te se oznake spremaju u mapu koju korisnik ne može izmijeniti (ali je može sakriti s trake oznaka). Zadani naziv mape glasi "Upravljane oznake", ali naziv se može prilagoditi tako da se popisu oznaka doda rječnik s ključem "<ph name="TOPLEVEL_NAME" />" čija je vrijednost željeni naziv mape.

      Upravljane oznake ne sinkroniziraju se s korisničkim računom i proširenja ih ne mogu mijenjati.</translation>
<translation id="8078366200175825572">Omogućuje postavljanje popisa uzoraka URL-ova koji određuju web-lokacije koje ne smiju postavljati kolačiće.

          Ako ovo pravilo nije postavljeno, upotrebljavat će se globalna zadana vrijednost za sve web-lokacije iz pravila "DefaultCookiesSetting" ako je postavljeno, odnosno iz osobne konfiguracije korisnika ako nije.

          Pogledajte i pravila "CookiesAllowedForUrls" i "CookiesSessionOnlyForUrls". Napominjemo da između tih triju pravila ne smiju postojati uzorci URL-ova u sukobu jer nije navedeno koje pravilo ima prednost.</translation>
<translation id="8099880303030573137">Odgoda neaktivnosti za vrijeme baterijskog napajanja</translation>
<translation id="8101381354936029836">Atomska grupa pravila:</translation>
<translation id="8102913158860568230">Zadana postavka za medijski stream</translation>
<translation id="8104186956182795918">Omogućuje da postavite smiju li web-lokacije prikazivati slike. Prikazivanje slika može biti dopušteno za sve web-lokacije ili odbijeno za sve web-lokacije.

          Ako se ovo pravilo ne postavi, upotrebljavat će se pravilo "AllowImages", a korisnici će to moći promijeniti.

          Napominjemo da je ovo pravilo prije bilo pogreškom omogućeno na Androidu, iako ta funkcija na Androidu nikad nije bila potpuno podržana.</translation>
<translation id="8104962233214241919">Automatski odabir certifikata klijenta za ove web-lokacije</translation>
<translation id="8112122435099806139">Određuje oblik sata koji će se upotrebljavati za uređaj.

      To pravilo konfigurira oblik sata koji će se upotrebljavati na zaslonu za prijavu i biti zadan za korisnike sesije. Korisnici još uvijek mogu nadjačati oblik sata za svoje račune.

      Ako se to pravilo postavi na istinito, uređaj će upotrebljavati 24-satni oblik. Ako se postavi na neistinito, uređaj će upotrebljavati 12-satni oblik.

      Ako se to pravilo ne postavi, uređaj će prema zadanom upotrebljavati 24-satni oblik sata.</translation>
<translation id="8113421140338762630">Omogućuje vam da postavite razdoblje, u milisekundama, između prve obavijesti da se <ph name="PRODUCT_OS_NAME" /> uređaj mora ponovo pokrenuti kako bi se primijenilo ažuriranje na čekanju i kraja razdoblja određenog pravilom <ph name="RELAUNCH_NOTIFICATION_PERIOD_POLICY_NAME" />.

      Ako se ne postavi, zadano razdoblje od 86.400.000 milisekundi (jedan dan) koristi se za <ph name="PRODUCT_OS_NAME" /> uređaje.</translation>
<translation id="8114382167597081590">Ne primjenjuj Ograničeni način rada na YouTubeu</translation>
<translation id="8118665053362250806">Postavi veličinu predmemorije medijskog diska</translation>
<translation id="8124468781472887384">Pravila za pristup konfiguraciji pisača za uređaje.</translation>
<translation id="8135937294926049787">Određuje koliko vremena treba proteći bez aktivnosti korisnika da bi se zaslon isključio tijekom napajanja izmjeničnom strujom.

          Kada je postavljeno na vrijednost veću od nule, ovo pravilo određuje koliko vremena treba proteći u neaktivnosti prije nego što <ph name="PRODUCT_OS_NAME" /> isključi zaslon.

          Kada je ovo pravilo postavljeno na nulu, <ph name="PRODUCT_OS_NAME" /> ne isključuje zaslon tijekom neaktivnosti korisnika.

          Kada nije postavljeno, upotrebljava se zadano vrijeme.

          Vrijednost pravila treba navesti u milisekundama. Vrijednosti su ograničene na vrijeme kraće od odgode neaktivnosti ili jednako tom vremenu.</translation>
<translation id="8138009212169037227">Pravilo određuje hoće li se prijavljivati podaci pravila i vrijeme dohvaćanja pravila.

      Ako se pravilo ne postavi ili se postavi na True, prikupljaju se podaci pravila i vrijeme dohvaćanja pravila.
      Ako se pravilo postavi na False, ne prikupljaju se podaci pravila ni vrijeme dohvaćanja pravila.

      To se pravilo primjenjuje samo kada je omogućeno pravilo <ph name="CHROME_REPORTING_EXTENSION_NAME" />, a računalo je prijavljeno tokenom <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="8140204717286305802">Generira popis mrežnih sučelja s njihovim vrstama i adresama hardvera koji prijavljuje poslužitelju.

      Ako se pravilo postavi na neistinito, popis sučelja neće se generirati.</translation>
<translation id="8141795997560411818">To pravilo ne sprječava korisnika da upotrebljava Android aplikaciju Google disk. Ako želite spriječiti pristup Google disku, onemogućite instaliranje Android aplikacije Google disk.</translation>
<translation id="8142894094385450823">Postavi preporučene jezike za upravljanu sesiju</translation>
<translation id="8146727383888924340">Dopusti korisnicima da iskoriste ponude tijekom registracije OS-a Chrome</translation>
<translation id="8148785525797916822">Sprječava upozorenje koje se prikazuje kada se <ph name="PRODUCT_NAME" /> izvodi na računalima ili operativnim sustavima koji više nisu podržani.</translation>
<translation id="8148901634826284024">Omogući značajku pristupačnosti načina visokog kontrasta.

          Ako se to pravilo postavi na točno, način visokog kontrasta uvijek će biti omogućen.

          Ako se to pravilo postavi na netočno, način visokog kontrasta uvijek će biti onemogućen.

          Ako postavite to pravilo, korisnici ga ne mogu promijeniti ili premostiti.

          Ako se to pravilo ne postavi, način visokog kontrasta u početku će biti onemogućen, ali korisnik ga može omogućiti u bilo kojem trenutku.</translation>
<translation id="815061180603915310">Ako se postavi na omogućeno, to pravilo prisilno prebacuje profil na jednokratni način rada. Ako je to pravilo navedeno kao pravilo OS-a (npr. GPO u sustavu Windows), primjenjivat će se na svaki profil u sustavu. Ako je postavljeno kao pravilo za oblak, primjenjivat će se samo na profil koji se prijavi upravljanim računom.

      U tom načinu podaci profila ostaju na disku samo onoliko dugo koliko traje sesija korisnika. Značajke kao što su povijest preglednika, proširenja i njihovi podaci, web-podaci, primjerice kolačići i baze podataka na webu, ne čuvaju se nakon zatvaranja preglednika. No pravilo ne sprječava korisnika da ručno preuzme bilo koje podatke na disk te spremi ili ispiše stranice.

      Ako je korisnik omogućio sinkronizaciju, svi ti podaci sačuvat će se na njegovom profilu za sinkronizaciju isto kao i s normalnim profilima. Anonimni način također je dostupan ako nije izričito onemogućen pravilom.

      Ako se pravilo postavi na onemogućeno ili se ne postavi, prijava vodi na normalne profile.</translation>
<translation id="8158758865057576716">Omogućuje izradu roaming kopija podataka <ph name="PRODUCT_NAME" /> profila.</translation>
<translation id="8172676363520748127">Ako je omogućeno, snimke zaslona ne mogu se snimati tipkovnim prečacima ili API-jima proširenja.

      Ako je onemogućeno ili nije određeno, izrada snimki zaslona dopuštena je.</translation>
<translation id="817455428376641507">Omogućuje pristup navedenim URL-ovima kao iznimkama s popisa zabranjenih URL-ova.

      Pogledajte opis pravila o popisu zabranjenih URL-ova za opis formata unosa na tom popisu.

      Ovo se pravilo može upotrijebiti za otvaranje iznimaka s ograničavajućih popisa nedopuštenih stavki. Primjerice, "*" može biti zabranjen kako bi se blokirali svi zahtjevi i to se pravilo može upotrebljavati za omogućavanje pristupa ograničenom popisu URL-ova. Može se upotrijebiti za otvaranje iznimaka za određene sheme, poddomene drugih domena, priključke ili specifične putanje.

      Najodređeniji filtar odredit će je li URL blokiran ili dopušten. Popis dopuštenih stavki ima prednost pred popisom nedopuštenih.

      Pravilo je ograničeno na 1000 unosa; svi se daljnji unosi zanemaruju.

      Ako to pravilo nije postavljeno, na popisu nedopuštenih stavki u pravilu 'URLBlacklist' neće biti iznimaka.</translation>
<translation id="8176035528522326671">Dopuštanje poslovnom korisniku da bude samo primarni korisnik višestrukih profila (zadano ponašanje za korisnike kojima upravlja tvrtka)</translation>
<translation id="8183108371184777472">Spriječi otvaranje prozora preglednika</translation>
<translation id="8186911565834244165">Dopusti povratne informacije korisnika</translation>
<translation id="8214600119442850823">Konfigurira upravitelja zaporki.</translation>
<translation id="8217516105848565518">To je pravilo obustavljeno. Umjesto njega upotrijebite RemoteAccessHostDomainList.</translation>
<translation id="8244171102276095471">Omogući RC4 pakete šifri u TLS-u</translation>
<translation id="8244525275280476362">Maksimalna odgoda dohvaćanja nakon poništavanja valjanosti pravila</translation>
<translation id="8256688113167012935">Kontrolira naziv računa koji prikazuje proizvod <ph name="PRODUCT_OS_NAME" /> na zaslonu prijave za odgovarajući lokalni račun na uređaju.

      Ako je to pravilo postavljeno, zaslon prijave upotrijebit će navedeni niz u alatu za odabir prijave prema slici s odgovarajućeg lokalnog računa uređaja.

      Ako pravilo nije postavljeno, proizvod <ph name="PRODUCT_OS_NAME" /> upotrijebit će ID računa e-pošte lokalnog računa uređaja kao naziv za prikaz na zaslonu prijave.

      Ovo se pravilo zanemaruje za redovite korisničke račune.</translation>
<translation id="8259375588339409826">Chromium i Google Chrome podržavaju isti skup pravila. Napominjemo da ovaj dokument može sadržavati neobjavljena pravila (to jest, unos "podržano na" odnosi se na neobjavljene verzije proizvoda <ph name="PRODUCT_NAME" />) podložna promjeni ili uklanjanju bez prethodne najave i za koja se ne pružaju nikakva jamstva, što znači da nema jamstava ni za sigurnost ni privatnost.

Ta su pravila namijenjena isključivo konfiguriranju instanci preglednika <ph name="PRODUCT_NAME" /> za unutarnju upotrebu u vašoj organizaciji. Upotreba tih pravila izvan vaše organizacije (na primjer u javno distribuiranom programu) smatra se zlonamjernim softverom, pa će je Google i dobavljači antivirusnih programa vjerojatno označiti kao takvu.

Te se postavke ne moraju konfigurirati ručno! Jednostavne predloške za Windows, Mac i Linux možete preuzeti na web-lokaciji <ph name="POLICY_TEMPLATE_DOWNLOAD_URL" />.

Za sustav Windows preporučuje se konfiguriranje pravila putem GPO-a, iako se pružanje pravila putem registra i dalje podržava za instance Windowsa pridružene domeni <ph name="MS_AD_NAME" />.</translation>
<translation id="8259592978873597235">Ako se pravilo postavi na true ili se ne postavi, korisnik se ne smatra neaktivnim tijekom reprodukcije videozapisa. Time se sprječava odgoda neaktivnosti te zatamnjivanja, isključivanja i zaključavanja zaslona, kao i izvršavanje odgovarajućih radnji.

          Ako se pravilo postavi na false, korisnik se može smatrati neaktivnim bez obzira na aktivnost videozapisa.</translation>
<translation id="8274603902181597201">Briše početni direktorij korisnika za ecryptfs i započinje novi ext4-šifrirani početni direktorij.</translation>
<translation id="8285435910062771358">Omogućeno je povećalo cijelog zaslona</translation>
<translation id="8288199156259560552">Omogući Googleovu uslugu lokacije na Androidu</translation>
<translation id="8292322992383748446">Izvješćivanje o statistici hardvera za SoC komponente.

      Ako se to pravilo postavi na False, neće biti izvješća o statistici.
      Ako se postavi na True ili se ne postavi, izvješćivat će se o statistici.</translation>
<translation id="8294750666104911727">Stranice čija je vrijednost X-UA-Compatible postavljena na chrome=1 uobičajeno će se generirati u okviru <ph name="PRODUCT_FRAME_NAME" /> bez obzira na pravilo "ChromeFrameRendererSettings".

          Ako omogućite tu postavku, na stranicama se neće tražiti metaoznake.

          Ako onemogućite tu postavku, na stranicama će se tražiti metaoznake.

          Ako se to pravilo ne postavi, na stranicama će se tražiti metaoznake.</translation>
<translation id="8300455783946254851">Onemogućuje sinkronizaciju Google diska u aplikaciji Datoteke za <ph name="PRODUCT_OS_NAME" /> prilikom upotrebe mobilne veze kada je postavljeno na točno. U tom slučaju podaci se sinkroniziraju s Google diskom prilikom povezanosti putem Wi-Fija ili Etherneta.

          Ako nije postavljeno ili je postavljeno na netočno, korisnici će moći prenositi datoteke na Google disk mobilnim vezama.</translation>
<translation id="8300992833374611099">Kontroliraj gdje se mogu upotrebljavati Alati za razvojne programere</translation>
<translation id="8306117673860983372">Postavke prijave</translation>
<translation id="8312129124898414409">Omogućuje vam da postavite smiju li web-lokacije upotrebljavati generiranje ključeva. Generiranje ključeva može se dopustiti za sve web-lokacije ili odbiti za sve web-lokacije.

          Ako se to pravilo ne postavi, upotrebljavat će se "BlockKeygen" i korisnik će to moći promijeniti.</translation>
<translation id="8320149248919453401">Način punjenja baterije</translation>
<translation id="8329984337216493753">To je pravilo aktivno samo u prodajnom načinu.

      Kada je pravilo "DeviceIdleLogoutTimeout" navedeno, to pravilo određuje trajanje okvira za upozorenje s odbrojavanjem koji se prikazuje korisniku prije nego što se izvrši odjava.

      Vrijednost pravila trebala bi biti navedena u milisekundama.</translation>
<translation id="8331479227794770304">Omogući ljepljive tipke</translation>
<translation id="8339420913453596618">Dvostruka autentifikacija onemogućena</translation>
<translation id="8344454543174932833">Uvoz oznaka iz zadanog preglednika pri prvom pokretanju</translation>
<translation id="8357681633047935212">Ograniči duljinu korisničke sesije</translation>
<translation id="8359734107661430198">Omogući ExampleDeprecatedFeature API do 2008/09/02</translation>
<translation id="8367209241899435947">Omogući Chromeov alat za čišćenje u sustavu Windows</translation>
<translation id="8369602308428138533">Odgoda isključivanja zaslona za vrijeme napajanja izmjeničnom strujom</translation>
<translation id="8371178326720637170">Omogućuje upravljanim proširenjima da upotrebljavaju Enterprise Hardware Platform API</translation>
<translation id="8374747520743832795">Izvješćivanje o identifikatorima i statistici hardvera u vezi s napajanjem.

      Ako se to pravilo postavi na False, neće biti izvješća o statistici.
      Ako se postavi na True ili se ne postavi, izvješćivat će se o statistici.</translation>
<translation id="8380490658357556620">Omogućuje upotrebu relejnih poslužitelja kada udaljeni klijenti pokušavaju uspostaviti vezu s ovim računalom.

          Ako se ta postavka omogući, udaljeni klijenti mogu upotrebljavati relejne poslužitelje za povezivanje s ovim računalom kada izravna veza nije dostupna (primjerice, zbog ograničenja vatrozida).

          Ako se onemogući pravilo <ph name="REMOTE_ACCESS_HOST_FIREWALL_TRAVERSAL_POLICY_NAME" />, ovo će se pravilo zanemariti.

          Ako se pravilo ne postavi, postavka će se omogućiti.</translation>
<translation id="8382184662529825177">Omogući upotrebu daljinske ovjere za zaštitu sadržaja za uređaj</translation>
<translation id="838870586332499308">Omogući roaming podataka</translation>
<translation id="8390049129576938611">Onemogućuje interni preglednik PDF-ova na usluzi <ph name="PRODUCT_NAME" />. Tretira ga kao preuzimanje i omogućuje uređaju da otvara PDF datoteke zadanom aplikacijom.

      Ako se to pravilo ne postavi ili se onemogući, a korisnik nije onemogućio dodatak za PDF-ove, za otvaranje PDF datoteka upotrebljavat će se dodatak za PDF-ove.</translation>
<translation id="8395749934754392549">Upravlja postavkama za Android spremnik (ARC) i Android aplikacije.</translation>
<translation id="8396145449084377015">To pravilo određuje hoće li se učitavati pravila iz pravila SiteList Internet Explorera.

      Ako se pravilo ne postavi ili se postavi na False, <ph name="PRODUCT_NAME" /> neće upotrebljavati pravilo <ph name="IEEM_SITELIST_POLICY" /> Internet Explorera kao izvor pravila za promjenu preglednika.

      Ako se pravilo postavi na True, <ph name="PRODUCT_NAME" /> potražit će URL popisa web-lokacija u pravilu <ph name="IEEM_SITELIST_POLICY" /> Internet Explorera. Nakon toga <ph name="PRODUCT_NAME" /> preuzet će popis web-lokacija s tog URL-a i primijeniti pravila kao da su konfigurirana pravilom <ph name="SITELIST_POLICY_NAME" />.

      Više informacija o pravilu <ph name="IEEM_SITELIST_POLICY" /> Internet Explorera dostupno je na https://docs.microsoft.com/internet-explorer/ie11-deploy-guide/what-is-enterprise-mode</translation>
<translation id="8402079500086185021">Uvijek otvaraj PDF datoteke vanjski</translation>
<translation id="8417305981081876834">Postavi maksimalnu dužinu PIN-a za zaključan zaslon</translation>
<translation id="841977920223099909">Okidač upozorenja o zaštiti zaporkom</translation>
<translation id="8424255554404582727">Postavi zadano zakretanje zaslona koje će se primjenjivati nakon svakog ponovnog pokretanja</translation>
<translation id="8426231401662877819">Zakreni zaslon u smjeru kazaljke na satu 90 stupnjeva</translation>
<translation id="8433186206711564395">Postavke mreže</translation>
<translation id="8433423491036718210">Konfiguriranje popisa URL-ova za prijavu u organizacijama na kojima usluga zaštite zaporkom treba spremiti otisak prsta kao zaporku.</translation>
<translation id="8451988835943702790">Upotrijebi web-stranicu nove kartice kao početnu stranicu</translation>
<translation id="8459216513698220096">Određuje obrađuju li se korisnička pravila s GPO-a računala i na koji način.

      Ako se pravilo postavi na "Zadano" ili se ne postavi, korisnička se pravila očitavaju samo s GPO-ova korisnika (GPO-ovi računala zanemaruju se).

      Ako se pravilo postavi na "Spoji", korisnička pravila u korisničkim GPO-ovima spajaju se s korisničkim pravilima u GPO-ovima računala (GPO-ovi računala imaju prednost).

      Ako se pravilo postavki na "Zamijeni", korisnička pravila u GPO-ovima korisnika zamjenjuju se korisničkim pravilima u GPO-ovima računala (GPO-ovi korisnika zanemaruju se).</translation>
<translation id="8465065632133292531">Parametri za URL usluge Instant koji upotrebljava POST</translation>
<translation id="8465746466645315861">Ako se to pravilo ne postavi, korisnik može omogućiti ili onemogućiti provjeru pravopisa u postavkama jezika.

      Ako se pravilo postavi na true, provjera pravopisa je omogućena i korisnik je ne može onemogućiti. Na sustavima <ph name="MS_WIN_NAME" />, <ph name="PRODUCT_OS_NAME" /> i <ph name="LINUX_OS_NAME" /> jezici provjere pravopisa mogu se pojedinačno uključiti ili isključiti kako bi korisnik ipak mogao onemogućiti provjeru pravopisa isključivanjem svih jezika provjere pravopisa. Da bi se to izbjeglo, možete upotrijebiti pravilo <ph name="SPELLCHECK_LANGUAGE_POLICY_NAME" /> za prisilno omogućivanje određenih jezika provjere pravopisa.

      Ako se to pravilo postavi na false, provjera pravopisa je onemogućena i korisnik je ne može omogućiti. Pravila <ph name="SPELLCHECK_LANGUAGE_POLICY_NAME" /> i <ph name="SPELLCHECK_LANGUAGE_BLACKLIST_POLICY_NAME" /> ne primjenjuju se ako je pravilo postavljeno na false.
      </translation>
<translation id="847472800012384958">Ne dopusti web-lokacijama prikazivanje skočnih prozora</translation>
<translation id="8477885780684655676">TLS 1.0</translation>
<translation id="8483004350080020634">Uklanja osjetljive dijelove https:// URL-ova koji se odnose na privatnost i sigurnost prije nego što se URL-ovi proslijede PAC skriptama (Proxy Auto Config) kojima se <ph name="PRODUCT_NAME" /> koristi tijekom razrješavanja proxyja.

      Kad se postavi na True, sigurnosna je značajka omogućena, a iz https://
      URL-ova uklanjaju se osjetljivi dijelovi prije slanja URL-ova na PAC skriptu.
      PAC skripta na taj način ne može vidjeti podatke koji se obično štite
      kriptiranim kanalom (kao što su put i upit URL-a).

      Kad se to pravilo postavi na False, ta je sigurnosna značajka onemogućena
      i PAC skriptama implicitno se dopušta prikaz svih komponenti https:// URL-a.
      To se primjenjuje na sve PAC skripte bez obzira na porijeklo (uključujući
      one dohvaćene u nezaštićenom prijenosu ili one koje su na nesiguran način
      otkrivene putem WPAD-a).

      Zadana je postavka True (omogućena sigurnosna značajka).

      Preporučena je postavka True. Na False bi se trebala postaviti
      jedino ako uzrokuje problem s kompatibilnošću s postojećim PAC skriptama.

      To će se pravilo ukloniti u verziji M75.</translation>
<translation id="8484458986062090479">Prilagođava popis uzoraka URL-ova koje bi preglednik hosta trebao uvijek generirati.

          Ako se to pravilo ne postavi, zadani će se ispunjivač upotrebljavati za sve web-lokacije određene pravilom "ChromeFrameRendererSettings".

          Primjere uzoraka pogledajte na https://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="8489964335640955763">PluginVm</translation>
<translation id="8493645415242333585">Onemogući pohranjivanje povijesti preglednika</translation>
<translation id="8499172469244085141">Zadane postavke (korisnici ih mogu prebrisati)</translation>
<translation id="849962487677588458">To se pravilo ukida, a njegovo je uklanjanje predviđeno u Chromeu 78, bez pružanja zamjenskog pravila.

      Pravilo omogućuje HTTP/0.9 na svim priključcima osim 80 za HTTP i 443 za HTTPS.

      To je pravilo onemogućeno prema zadanim postavkama i ako se omogući, korisnici će biti izloženi sigurnosnoj poteškoći https://crbug.com/600352.

      Tim se pravilom želi pružiti mogućnost organizacijama za premještanje postojećih poslužitelja s protokola HTTP/0.9 i uklonit će se u budućnosti.

      Ako se to pravilo ne postavi, HTTP/0.9 onemogućit će se na priključcima koji nisu zadani.</translation>
<translation id="8507835864888987300">Postavlja ciljnu verziju za Automatska ažuriranja.

      Određuje prefiks ciljne verzije na koju bi se <ph name="PRODUCT_OS_NAME" /> trebao ažurirati. Ako je verzija na uređaju starija od navedenog prefiksa, ažurirat će se na najnoviju verziju s navedenim prefiksom. Ako uređaj već ima noviju verziju, učinak će ovisiti o vrijednosti postavljenoj u pravilu <ph name="DEVICE_ROLLBACK_TO_TARGET_VERSION_POLICY_NAME" />. Format prefiksa funkcionira prema komponentama kao što je prikazano u sljedećem primjeru:

      "" (ili nije konfigurirano): ažuriranje na najnoviju dostupnu verziju.
      "1412.": ažuriranje na bilo koju verziju podređenu verziji 1412 (npr. 1412.24.34 ili 1412.60.2)
      "1412.2.": ažuriranje na bilo koju verziju podređenu verziji 1412.2 (npr. 1412.2.34 ili 1412.2.2)
      "1412.24.34": ažuriranje samo na tu konkretnu verziju.

      Upozorenje: ne preporučuje se konfigurirati ograničenja verzije jer korisnici tako možda neće primati ažuriranja softvera i važne sigurnosne ispravke. Ograničavanje ažuriranja na određeni prefiks verzije korisnike može izložiti opasnosti.</translation>
<translation id="8519264904050090490">URL-ovi ručnih iznimaka upravljanih korisnika</translation>
<translation id="8525526490824335042">Linuxov spremnik</translation>
<translation id="8538235451413605457">Konfigurira zahtjev za minimalnu dopuštenu verziju preglednika <ph name="PRODUCT_NAME" />. Verzije u nastavku smatraju se zastarjelima i uređaj ne bi dopustio korisniku prijavu dok se OS ne ažurira.
      Ako trenutačne verzije postanu zastarjele tijekom sesije, korisnik će se prisilno odjaviti.

      Ako se to pravilo ne postavi, ograničenja se ne primjenjuju i korisnik se može prijaviti bez obzira na verziju preglednika <ph name="PRODUCT_NAME" />.

      Pojam "verzija" može se odnositi na točnu verziju, na primjer "61.0.3163.120" ili prefiks verzije, na primjer "61.0".  </translation>
<translation id="8544375438507658205">Zadani alat za prikazivanje HTML-a za <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="8544465954173828789">Dopusti sinkronizaciju SMS poruka s telefona na Chromebook.</translation>
<translation id="8548832052135586762">Postavlja ispis na samo u boji, samo jednobojni ili određuje da nema ograničenja načina boje. Ako se pravilo ne postavi, smatra se da nema ograničenja.</translation>
<translation id="8549772397068118889">Upozori kada se posjećuju web-lokacije izvan paketa sadržaja</translation>
<translation id="8566729013138025202">Određuje skup pravila koja će se prenijeti na vrijeme izvođenja ARC-a. Vrijednost mora biti važeći JSON.

      To se pravilo može koristiti da bi se konfiguriralo koje će se Android aplikacije automatski instalirati na uređaj.

      Da biste prikvačili aplikacije na pokretač, pogledajte PinnedLauncherApps.</translation>
<translation id="8566842294717252664">Skrivanje web-trgovine na web-stranici nove kartice i pokretaču aplikacija</translation>
<translation id="8569734380847633643">
          Ako se pravilo postavi na false, <ph name="PRODUCT_OS_NAME" /> onemogućit će Wi-Fi i korisnici ga neće moći ponovo omogućiti.
          Ako se pravilo postavi na true ili se ne postavi, korisnici će moći omogućiti ili onemogućiti Wi-Fi prema želji.</translation>
<translation id="857369585509260201">To je pravilo obustavljeno i umjesto njega možete upotrijebiti BrowserSignin.

      Ako se to pravilo postavi na True, korisnik se mora prijaviti na <ph name="PRODUCT_NAME" /> svojim profilom da bi mogao upotrebljavati taj preglednik. Zadana vrijednost za BrowserGuestModeEnabled postavit će se na False. Napominjemo da će nakon omogućivanja tog pravila postojeći neprijavljeni profili biti zaključani i neće im biti moguće pristupiti. Više informacija možete pronaći u članku centra za pomoć.

      Ako se to pravilo postavi na False ili se ne konfigurira, korisnik može upotrebljavati preglednik bez prijave na <ph name="PRODUCT_NAME" />.</translation>
<translation id="8586528890725660268">Određuje pisače koje korisnik ne može upotrebljavati.

      To se pravilo upotrebljava samo ako je pravilo <ph name="PRINTERS_BLACKLIST" /> odabrano za <ph name="BULK_PRINTERS_ACCESS_MODE" />.

      Ako se to pravilo upotrebljava, korisniku se pružaju svi pisači osim pisača s ID-jevima navedenima u pravilu. ID-jevi se moraju podudarati s poljima "id" ili "guid" u datoteci navedenoj u pravilu <ph name="BULK_PRINTERS_POLICY" />.
      </translation>
<translation id="8587229956764455752">Dopusti stvaranje novih korisničkih računa</translation>
<translation id="8598350264853261122">Ako se to pravilo postavi na False, nepridruženim korisnicima neće biti dopuštena upotreba ARC-a.

      Ako se pravilo ne postavi ili se postavi na True, svim će korisnicima biti dopuštena upotreba ARC-a (osim ako je ARC onemogućen na drugi način).

      Promjene pravila primjenjuju se samo kada se ARC ne izvodi, primjerice prilikom pokretanja OS Chromea.</translation>
<translation id="8615400197788843468">Omogućuje <ph name="PRODUCT_NAME" /> značajku ograničene prijave u G Suiteu i korisnicima onemogućuje da promijene te postavku.

      Ako definirate tu postavku, korisnik će moći pristupiti Googleovim
      aplikacijama samo pomoću računa s domena koje navedete (da biste
      dopustili gmail.com/googlemail.com račune, na popis domena trebate dodati
      "consumer_accounts" (bez navodnika)).

      Ta će postavka korisniku spriječiti da se prijavi i doda sekundarni račun na
      upravljanom uređaju na kojem je potrebna Google autentifikacija ako taj
      račun ne pripada prethodno navedenom popisu dopuštenih domena.

      Ako se ta postavka ostavi prazna ili se ne konfigurira, korisnik će moći
      pristupati G Suiteu bilo kojim računom.

      To pravilo uzrokuje da se svim HTTP i HTTPS zahtjevima za sve google.com
      domene dodaje zaglavlje X-GoogApps-Allowed-Domains kako je opisano na
      https://support.google.com/a/answer/1668854.


      Tu postavku korisnici ne mogu promijeniti niti nadjačati.</translation>
<translation id="8631434304112909927">do verzije <ph name="UNTIL_VERSION" /></translation>
<translation id="8649763579836720255">Uređaji s OS-om Chrome mogu upotrebljavati daljinsku ovjeru (potvrđeni pristup) kako bi dobili certifikat koji izdaje tijelo za izdavanje certifikata OS-a Chrome koje potvrđuje da uređaj ispunjava uvjete za reprodukciju zaštićenog sadržaja. Taj proces uključuje slanje informacija o potvrdi hardvera tijelu za izdavanje certifikata OS-a Chrome koje jedinstveno identificira uređaj.

          Ako je ta postavka netočna, uređaj neće upotrebljavati daljinsku ovjeru za zaštitu sadržaja i uređaj možda neće moći reproducirati zaštićeni sadržaj.

          Ako je ta postavka točna ili ako nije postavljena, daljinska ovjera može se upotrebljavati za zaštitu sadržaja.</translation>
<translation id="8650974590712548439">Lokacija Windows registra za Windows klijente:</translation>
<translation id="8654286232573430130">Određuje koji poslužitelji trebaju biti stavljeni na popis dopuštenih za integriranu autentifikaciju. Integrirana autentifikacija omogućena je samo kada <ph name="PRODUCT_NAME" /> primi zahtjev za autentifikaciju od proxyja ili poslužitelja koji se nalazi na tom popisu.

          Razdvojite više poslužitelja zarezima. Zamjenski su znakovi (*) dopušteni.

          Ako ne postavite ovo pravilo, <ph name="PRODUCT_NAME" /> pokušat će otkriti je li poslužitelj na intranetu te će jedino tada odgovoriti na IWA zahtjeve. Ako otkrije da se radi o poslužitelju na internetu, <ph name="PRODUCT_NAME" /> zanemarit će njegove IWA zahtjeve.</translation>
<translation id="8661297125441579970">Onemogući premještanje podataka i ARC.</translation>
<translation id="8672321184841719703">Ciljna verzija automatskog ažuriranja</translation>
<translation id="867410340948518937">U2F (univerzalna dvostruka autentifikacija)</translation>
<translation id="8685024486845674965">Upozorenje o zaštiti zaporkom aktivira se ponovnom upotrebom zaporke</translation>
<translation id="8693243869659262736">Upotreba ugrađenog DNS klijenta</translation>
<translation id="8698286761337647563">Broj dana za prethodno obavještavanje korisnika SAML-a prije isteka zaporke</translation>
<translation id="8703488928438047864">Izvješćivanje o statusu ploče</translation>
<translation id="8703872185032220081">Postavite dnevnu konfiguraciju prebacivanja napajanja radi uštede energije.

          Ovo pravilo koristi se samo ako se DevicePowerPeakShiftEnabled postavi na true.

          Ako se pravilo ne konfigurira ili se ne postavi, prebacivanje napajanja radi uštede energije uvijek će biti onemogućeno.

          Napomena: dozvoljene vrijednosti za polje <ph name="MINUTE_FIELD_NAME" /> u polju <ph name="START_TIME_FIELD_NAME" />, <ph name="END_TIME_FIELD_NAME" /> i <ph name="CHARGE_START_TIME_FIELD_NAME" /> su 0, 15, 30, 45.</translation>
<translation id="8704831857353097849">Popis onemogućenih dodataka</translation>
<translation id="8711086062295757690">Određuje ključnu riječ koja je prečac u višenamjenskom okviru za pokretanje usluge pretraživanja ovog davatelja usluga. Ovo je pravilo izborno. Ako nije postavljeno, nijedna ključna riječ neće aktivirati davatelja usluga pretraživanja. Ovo se pravilo uzima u obzir samo ako je omogućeno pravilo "DefaultSearchProviderEnabled".</translation>
<translation id="8733448613597049197">Omogućuje prošireno izvješćivanje Sigurnog pregledavanja za <ph name="PRODUCT_NAME" /> i onemogućuje korisnicima da promijene tu postavku.

      Prošireno izvješćivanje šalje neke podatke o sustavu i sadržaj stranice Googleovim poslužiteljima radi otkrivanja opasnih aplikacija i web-lokacija.

      Ako se postavi na True, izvješća će se izrađivati i slati kada god to bude potrebno (na primjer kada se prikaže međuprostorno sigurnosno upozorenje).

      Ako se pravilo postavi na False, izvješća se neće slati.

      Ako se pravilo postavi na True ili False, korisnik neće moći izmijeniti postavku.

      Ako se pravilo ne postavi, korisnik će moći promijeniti postavku i odlučiti hoće li slati izvješća.

      Više informacija o Sigurnom pregledavanju potražite na stranici https://developers.google.com/safe-browsing.</translation>
<translation id="8736538322216687231">Primijeni minimalni Ograničeni način rada na YouTubeu</translation>
<translation id="8749370016497832113">Omogućuje brisanje povijesti preglednika i preuzimanja u pregledniku <ph name="PRODUCT_NAME" /> te sprječava korisnike da promijene tu postavku.

      Uzmite u obzir da čak i kada je onemogućeno ovo pravilo, čuvanje povijesti pregledavanja i preuzimanja nije zajamčeno: korisnici možda mogu izravno urediti ili izbrisati datoteke baze podataka povijesti, a preglednik također može u bilo kojem trenutku arhivirati neke ili sve stavke povijesti ili im ukinuti rok trajanja.

      Ako je ova postavka omogućena ili nije postavljena, povijest pregledavanja i preuzimanja može se izbrisati.

      Ako je ova postavka onemogućena, povijest pregledavanja i preuzimanja nije moguće izbrisati.</translation>
<translation id="8757552286070680084">Konfiguracija Wilco DTC-a</translation>
<translation id="8758831693895931466">Omogući obaveznu prijavu za upravljanje u oblaku</translation>
<translation id="8759829385824155666">Dopuštene vrste enkripcije Kerberos</translation>
<translation id="8764119899999036911">Određuje temelji li se generirani Kerberos SPN na kanonskom DNS imenu ili unesenom izvornom imenu. Ako omogućite ovu postavku, CNAME pretraživanje bit će preskočeno, a upotrijebit će se uneseni naziv poslužitelja. Ako onemogućite ovu postavku ili ju ne postavite, kanonski naziv poslužitelja bit će utvrđen putem CNAME pretraživanja.</translation>
<translation id="8764477907716150749">To je pravilo za internu upotrebu preglednika <ph name="PRODUCT_NAME" />.</translation>
<translation id="8798099450830957504">Zadano</translation>
<translation id="8800453707696044281">Postavi prilagođeno zaustavljanje punjenja baterije u postocima</translation>
<translation id="8801680448782904838">Obavijesti korisnika o obaveznom ili preporučenom ponovnom pokretanju preglednika ili uređaja</translation>
<translation id="8818173863808665831">Prijavljuje geografsku lokaciju uređaja.

      Ako se to pravilo ne postavi ili ako se postavi na lažno, lokacija se neće prijavljivati.</translation>
<translation id="8818768076343557335">Predviđaj mrežne radnje na svim mrežama osim mobilnim.
          (Zastarjelo u verziji 50, uklonjeno u verziji 52. Ako se u verzijama nakon 52. postavi vrijednost 1, njome će se postupati kao da je 0 – predviđanje mrežnih radnji na svim mrežnim vezama.)</translation>
<translation id="8825782996899863372">Upozorenje o zaštiti zaporkom aktivira se ponovnom upotrebom zaporke na stranici za krađu identiteta</translation>
<translation id="8833109046074170275">Autentifikacija zadanim GAIA-inim tijekom</translation>
<translation id="8838303810937202360"><ph name="PRODUCT_OS_NAME" /> predmemorira aplikacije i proširenja kako bi ih moglo instalirati više korisnika jednog uređaja radi izbjegavanja ponovnog preuzimanja za svakog korisnika.
      Ako se to pravilo ne konfigurira ili je vrijednost niža od 1 MB, <ph name="PRODUCT_OS_NAME" /> upotrebljava zadanu veličinu predmemoriranja.</translation>
<translation id="8851325571441692315">Omogućuje vam da odredite proxy poslužitelj kojim se koristi <ph name="PRODUCT_NAME" /> i onemogućuje korisnicima da mijenjaju postavke proxyja.

          To se pravilo primjenjuje samo ako se ne postavi pravilo <ph name="PROXY_SETTINGS_POLICY_NAME" />.

          Ako odaberete da se proxy poslužitelj nikad ne upotrebljava i da se veza uvijek uspostavlja izravno, sve se ostale opcije zanemaruju.

          Ako odaberete upotrebu proxy postavki sustava, sve se ostale opcije zanemaruju.

          Ako odaberete automatsko otkrivanje proxy poslužitelja, sve se ostale opcije zanemaruju.

          Ako odaberete fiksni način proxy poslužitelja, dodatne opcije možete odrediti pod stavkama "Adresa ili URL proxy poslužitelja" ili "Popis pravila o zaobilaženju proxyja odvojenih zarezima". ARC aplikacije upotrebljavat će samo HTTP proxy poslužitelj s najvišim prioritetom.

          Ako odaberete da će se upotrebljavati .pac proxy skripta, morate navesti URL skripte u pravilu "URL prema proxy .pac datoteci".

          Detaljne primjere možete pronaći ovdje:
          <ph name="PROXY_HELP_URL" />.

          Ako omogućite tu postavku, <ph name="PRODUCT_NAME" /> i ARC aplikacije zanemaruju sve opcije koje se odnose na proxy navedene u naredbenom retku.

          Ako se to pravilo ne postavi, korisnici će moći sami odabrati postavke proxyja.</translation>
<translation id="8858642179038618439">Nametni Siguran način rada na YouTubeu</translation>
<translation id="8860342862142842017">Onemogući provedbu Transparentnosti certifikata za popis hashiranja za subjectPublicKeyInfo</translation>
<translation id="8864975621965365890">Zaustavlja upit za odbijanje koji se pojavljuje kada web-lokaciju generira <ph name="PRODUCT_FRAME_NAME" />.</translation>
<translation id="8867464911288727016">Omogućuje integriranu uslugu Google Prevoditelj u proizvodu <ph name="PRODUCT_NAME" />.

      Ako omogućite tu postavku, <ph name="PRODUCT_NAME" /> korisniku nudi funkciju prijevoda prikazujući integriranu alatnu traku za prijevod (u odgovarajućoj situaciji) i opciju prevođenja na kontekstnom izborniku koji se aktivira desnim klikom.

      Ako onemogućite tu postavku, onemogućit će se sve ugrađene značajke prijevoda.

      Ako omogućite ili onemogućite tu postavku, korisnici je ne mogu mijenjati niti poništiti u proizvodu <ph name="PRODUCT_NAME" />.

      Ako ta postavka nije postavljena, korisnik može odlučiti hoće li upotrebljavati tu funkciju.</translation>
<translation id="8871974300055371298">Postavke sadržaja</translation>
<translation id="8876188741456358123">Nadjačava dvostruki način zadanog ispisa. Pravilo se zanemaruje ako način nije dostupan.</translation>
<translation id="8882006618241293596">Blokiraj dodatak <ph name="FLASH_PLUGIN_NAME" /> na ovim web-lokacijama</translation>
<translation id="8906768759089290519">Omogući način gosta</translation>
<translation id="8908294717014659003">Omogućuje vam da postavite hoće li web-lokacijama biti dopušten pristup medijskim uređajima za snimanje. Pristup medijskim uređajima za snimanje može biti dopušten prema zadanim postavkama ili se korisniku može postaviti pitanje svaki put kada web-lokacija želi pristupiti tim uređajima.

          Ako se to pravilo ne postavi, upotrijebit će se "PromptOnAccess" i korisnik će ga moći promijeniti.</translation>
<translation id="8909280293285028130">Određuje koliko vremena treba proteći bez aktivnosti korisnika da bi se zaslon zaključao tijekom napajanja izmjeničnom strujom.

          Kada je postavljeno na vrijednost veću od nule, ovo pravilo određuje koliko vremena treba proteći u neaktivnosti prije nego što <ph name="PRODUCT_OS_NAME" /> zaključa zaslon.

          Kada je ovo pravilo postavljeno na nulu, <ph name="PRODUCT_OS_NAME" /> ne zaključava zaslon tijekom neaktivnosti korisnika.

          Kada nije postavljeno, upotrebljava se zadano vrijeme.

          Preporučen je način za zaključavanje zaslona tijekom neaktivnosti omogućiti zaključavanje zaslona tijekom obustavljanja i postaviti <ph name="PRODUCT_OS_NAME" /> na obustavljanje nakon razdoblja neaktivnosti. Ovo bi se pravilo trebalo upotrebljavati samo kada bi do zaključavanja zaslona trebalo doći puno prije obustavljanja ili kada obustavljanje u razdoblju neaktivnosti uopće nije poželjno.

          Vrijednost pravila treba navesti u milisekundama. Vrijednosti su ograničene na vrijeme kraće od odgode neaktivnosti.</translation>
<translation id="891435090623616439">kodirano kao JSON niz, pojedinosti potražite na stranici <ph name="COMPLEX_POLICIES_URL" /></translation>
<translation id="8934944553121392674">Određuje koji su pisači iz pravila <ph name="DEVICE_PRINTERS_POLICY" /> dostupni korisnicima.

      Određuje koje se pravilo za pristup upotrebljava za skupnu konfiguraciju pisača. Ako se odabere <ph name="PRINTERS_ALLOW_ALL" />, prikazuju se svi pisači. Ako se odabere <ph name="PRINTERS_BLACKLIST" />, <ph name="DEVICE_PRINTERS_BLACKLIST" /> upotrebljava se za ograničenje pristupa navedenim pisačima. Ako se odabere <ph name="PRINTERS_WHITELIST" />, <ph name="DEVICE_PRINTERS_WHITELIST" /> određuje samo one pisače koji se mogu odabrati.

      Ako se to pravilo ne postavi, pretpostavlja se da vrijedi <ph name="PRINTERS_ALLOW_ALL" />.
      </translation>
<translation id="8938932171964587769">Obustavljeno u M69. Umjesto toga upotrebljavajte      OverrideSecurityRestrictionsOnInsecureOrigin.

      Pravilom se navodi popis polazišta (URLs) ili uzoraka naziva hosta (primjerice "*.example.com") na koje se neće primjenjivati sigurnosna ograničenja o nesigurnim polazištima.

      Namjera je omogućiti organizacijama da postave popis dopuštenih polazišta za stare aplikacije koje ne mogu upotrebljavati TLS ili da postave pripremni (engl. staging) poslužitelj za interni mrežni razvoj kako bi njihovi razvojni programeri mogli testirati značajke kojima su potrebni sigurni konteksti bez upotrebe TLS-a na pripremnom (engl. staging) poslužitelju. Tim će se pravilom također spriječiti da polazište bude označeno kao "Nesigurno" u višenamjenskom okviru.

      Postavljanje popisa URL-ova u ovim pravilima ima jednak učinak kao i postavljanje oznake naredbenog retka '--unsafely-treat-insecure-origin-as-secure' na popis jednakih URL-ova odijeljenih zarezom. Ako se to pravilo postavi, nadjačat će oznaku naredbenog retka.
      Ovo je pravilo obustavljeno u M69 u korist pravila
      OverrideSecurityRestrictionsOnInsecureOrigin. Ako su prisutna oba pravila, pravilo OverrideSecurityRestrictionsOnInsecureOrigin nadjačava ovo pravilo.

     Za više informacija o sigurnim kontekstima pogledajte
      https://www.w3.org/TR/secure-contexts/
      </translation>
<translation id="8942616385591203339">Ovo pravilo određuje može li se prilikom prve prijave korisniku prikazivati pristanak na sinkronizaciju. Treba ga postaviti na False ako pristanak na sinkronizaciju nikad nije potreban za korisnika.
      Ako se postavi na False, pristanak na sinkronizaciju neće se prikazivati.
      Ako se postavi na True ili se ne postavi, pristanak na sinkronizaciju može se prikazati.</translation>
<translation id="894510252300143386">Konfigurira postavke upravljanja proširenjima za <ph name="PRODUCT_NAME" />.

          To pravilo upravlja većim brojem postavki, uključujući postavke kojima upravljaju postojeća pravila koja se odnose na proširenja. To će pravilo nadjačati sva naslijeđena pravila ako su postavljena i ona.

          To pravila mapira ID proširenja ili URL za ažuriranje u svoju konfiguraciju. Uz ID proširenja konfiguracija će se primijeniti samo na navedeno proširenje. Zadana konfiguracija može se postaviti za posebni ID <ph name="DEFAULT_SCOPE" />, koji će se primjenjivati na sva proširenja za koja nije postavljena prilagođena konfiguracija u tom pravilu. Uz URL za ažuriranje konfiguracija će se primijeniti na sva proširenja s URL-om za ažuriranje navedenim u manifestu tog proširenja, kao što je opisano na <ph name="LINK_TO_EXTENSION_DOC1" />.

          Za instance Windowsa koje nisu pridružene domeni <ph name="MS_AD_NAME" /> prisilna instalacija ograničena je na aplikacije i proširenja koji su navedeni u Chrome web-trgovini.
          </translation>
<translation id="8947415621777543415">Prijava lokacije uređaja</translation>
<translation id="8951350807133946005">Postavi direktorij predmemorije na disku</translation>
<translation id="8952317565138994125">Onemogućuje sinkronizaciju podataka na usluzi <ph name="PRODUCT_NAME" /> putem usluga sinkronizacije hostiranih na Googleu i onemogućuje korisnicima da promjene tu postavku.

      Ako omogućite tu postavku, korisnici ne mogu promijeniti niti nadjačati tu postavku na usluzi <ph name="PRODUCT_NAME" />.

      Ako se to pravilo ne postavi, korisnik će moći odabrati hoće li upotrebljavati Google sinkronizaciju.

      Da biste potpuno onemogućili Google sinkronizaciju, preporučuje se da onemogućite uslugu Google sinkronizacije na konzoli Google Admina.

      To se pravilo ne bi trebalo omogućivati kada je pravilo <ph name="ROAMING_PROFILE_SUPPORT_ENABLED_POLICY_NAME" /> postavljeno na omogućeno jer ta značajka dijeli istu klijentsku funkciju. Sinkronizacija hostirana na Googleu u tom je slučaju potpuno onemogućena.</translation>
<translation id="8955719471735800169">Natrag na vrh</translation>
<translation id="8959992920425111821">Zadana konfiguracija</translation>
<translation id="8960850473856121830">Uzorci na tom popisu usporedit će se sa sigurnosnim izvorištem
      URL-a koji šalje zahtjev. Ako se pronađe podudaranje, pristup uređajima
      za snimanje zvuka dopuštat će se bez upita.

      NAPOMENA: do verzije 45 to je pravilo bilo podržano samo u načinu kioska.</translation>
<translation id="8970205333161758602">Zaustavljanje upita za odbijanje usluge <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="8976248126101463034">Dopusti autentifikaciju "gnubby" za hostove daljinskog pristupa</translation>
<translation id="8976531594979650914">Upotrijebi zadani pisač sustava kao zadani</translation>
<translation id="8992176907758534924">Ne dopuštaj web-lokacijama prikazivanje slika</translation>
<translation id="9013875414788074110">Tijekom prijave <ph name="PRODUCT_OS_NAME" /> može autentificirati korisnika putem poslužitelja (mrežno) ili upotrebom predmemorirane zaporke (izvanmrežno).

      Ako se to pravilo postavi na vrijednost -1, korisnik se može autentificirati izvanmrežno na neograničeno vrijeme. Ako se pravilo postavi na bilo koju drugu vrijednost, ona će određivati vrijeme od posljednje mrežne autentifikacije nakon kojeg se korisnik ponovo mora autentificirati putem mreže.

      Ako se to pravilo ne postavi, <ph name="PRODUCT_OS_NAME" /> upotrijebit će zadano vremensko ograničenje od 14 dana nakon kojeg korisnik mora ponovo upotrijebiti mrežnu autentifikaciju.

      To pravilo utječe samo na korisnike koji se autentificiraju pomoću SAML-a.

      Vrijednost pravila navodi se u sekundama.</translation>
<translation id="9035964157729712237">ID-jevi proširenja za izuzimanje s crne liste</translation>
<translation id="9038839118379817310">Omogući Wi-Fi</translation>
<translation id="9039822628127365650">Ako se postavi, to pravilo određuje vremensko razdoblje nakon kojeg se korisnik automatski odjavljuje, a sesija prekida. Korisnik može vidjeti preostalo vrijeme na tajmeru za odbrojavanje prikazanom na traci sustava.

      Ako se pravilo ne postavi, duljina sesije nije ograničena.

      Ako postavite to pravilo, korisnici ga neće moći promijeniti ni nadjačati.

      Vrijednost pravila treba se navesti u milisekundama. Vrijednosti su ograničene na raspon od 30 sekundi do 24 sata.</translation>
<translation id="9050853837490399534">Pravilo određuje treba li se uređaj ažurirati na međuverziju za brzi popravak.

      Ako se vrijednost pravila postavi na token koji mapira na međuverziju za brzi popravak, uređaj će se ažurirati na odgovarajuću međuverziju ako ažuriranje nije blokirano drugim pravilom.

      Ako se pravilo ne postavi ili njegova vrijednost ne mapira na međuverziju za brzi popravak, uređaj se neće ažurirati na međuverziju za brzi popravak. Ako je na uređaju već instalirana međuverzija za brzi popravak i pravilo više nije postavljeno ili njegova vrijednost više ne mapira na međuverziju za brzi popravak, uređaj će se ažurirati na regularnu međuverziju ako ažuriranje nije blokirano drugim pravilom.</translation>
<translation id="9054012305936267950">To pravilo upravlja ponašanjem prijave putem preglednika. Omogućuje vam da odredite može li se korisnik prijaviti u preglednik <ph name="PRODUCT_NAME" /> svojim računom i upotrebljavati usluge povezane s računom kao što je Chrome sinkronizacija.

      Ako se to pravilo postavi na "Onemogući prijavu putem preglednika", korisnik se ne može prijaviti u preglednik i upotrebljavati usluge računa. U tom se slučaju značajke na razini preglednika kao što je Chrome sinkronizacija ne mogu upotrebljavati i neće biti dostupne. Ako je korisnik bio prijavljen i pravilo se postavi na "Onemogućeno", korisnik će se odjaviti sljedeći put kad pokrene Chrome, no zadržat će se lokalni podaci profila kao što su oznake, zaporke itd. Korisnik će se i dalje moći prijaviti na Googleove web-usluge kao što je Gmail i moći će ih upotrebljavati.

      Ako se to pravilo postavi na "Omogući prijavu putem preglednika", korisnik se može prijaviti u preglednik i automatski se prijavljuje u preglednik kad se prijavi na Googleove web-usluge kao što je Gmail. Kad je korisnik prijavljen u pregledniku, to znači da preglednik sprema podatke o korisnikovom računu. No to ne znači da će Chrome sinkronizacija biti uključena prema zadanim postavkama; da bi upotrebljavao tu značajku, korisnik se mora uključiti zasebno. Ako se to pravilo omogući, korisnik neće moći isključiti postavku koja omogućuje prijavu u preglednik. Da biste kontrolirali dostupnost Chrome sinkronizacije, upotrijebite pravilo "SyncDisabled".

      Ako se pravilo postavi na "Nametni prijavu putem preglednika", korisniku se prikazuje dijaloški okvir za odabir računa i on mora odabrati račun i prijaviti se da bi upotrebljavao preglednik. Na taj se način za upravljane račune osigurava primjena i provedba pravila povezanih s računom. Prema zadanim postavkama time se uključuje Chrome sinkronizacija za račun, osim kad je sinkronizaciju onemogućio administrator domene ili kad je onemogućena putem pravila "SyncDisabled". Zadana vrijednost za BrowserGuestModeEnabled bit će postavljena na "netočno". Postojeći neprijavljeni profili zaključat će se i neće biti dostupni nakon što se to pravilo omogući. Više informacija potražite u članku centra za pomoć: https://support.google.com/chrome/a/answer/7572556. Ova opcija ne podržava Linux i, ako se koristi, vratit će se na "Omogući prijavu putem preglednika".

      Ako se to pravilo ne postavi, korisnik može odlučiti hoće li omogućiti opciju prijave putem preglednika i može je upotrebljavati kako želi.</translation>
<translation id="9072600218500597787">Konfigurira tražene nazive domena hosta koji će se nametnuti za hostove daljinskog pristupa i onemogućuje korisnicima da to promijene.

          Ako se ta postavka omogući, hostovi se mogu dijeliti samo putem računa registriranih na navedenom nazivu domene.

          Ako se ta postavka onemogući ili ne postavi, hostovi se mogu dijeliti putem bilo kojeg računa.

          Ta će postavka nadjačati pravilo RemoteAccessHostDomain ako je prisutno.

          Pogledajte i RemoteAccessHostClientDomainList.</translation>
<translation id="9077227880520270584">Odbrojavanje do automatske prijave na lokalni račun na uređaju</translation>
<translation id="9084985621503260744">Odredi utječe li aktivnost videozapisa na upravljanje napajanjem</translation>
<translation id="9088433379343318874">Omogući davatelja sadržaja nadziranog korisnika</translation>
<translation id="9088444059179765143">Konfiguriraj način automatskog otkrivanja vremenske zone</translation>
<translation id="9096086085182305205">Bijela lista poslužitelja za autentifikaciju</translation>
<translation id="9105265795073104888">Android aplikacijama dostupan je samo podskup opcija za konfiguraciju proxyja. Android aplikacije taj proxy mogu upotrebljavati dobrovoljno. Upotrebu proxyja ne možete im nametnuti.</translation>
<translation id="9106865192244721694">Dopusti WebUSB na ovim web-lokacijama</translation>
<translation id="9112727953998243860">Datoteka za konfiguraciju pisača tvrtke</translation>
<translation id="9112897538922695510">Omogućuje vam registriranje popisa rukovatelja protokola. To pravilo može biti samo preporučeno. Entitet |protocol| treba se postaviti u shemu kao "mailto", a entitet |url| treba se postaviti u uzorak URL-a aplikacije koja rukuje shemom. Uzorak može uključivati "%s" koji će se, ako postoji, zamijeniti rukovanim URL-om.

          Rukovatelji protokola koji su registrirani pravilom spojeni su s onima koje je registrirao korisnik i za upotrebu su dostupne obje vrste rukovatelja. Korisnik može nadjačati rukovatelje protokola instalirane pravilom tako što će instalirati novog zadanog rukovatelja, ali ne može ukloniti onoga koji je pravilom registriran.</translation>
<translation id="91196902572559194">To pravilo Google asistentu daje dopuštenje za osluškivanje izraza za glasovnu aktivaciju.

      Ako se pravilo omogući, Google asistent osluškivat će izraz za glasovnu aktivaciju.
      Ako se pravilo onemogući, Google asistent neće osluškivati izraz za glasovnu aktivaciju.
      Ako se pravilo ne postavi, korisnici mogu odlučiti hoće li dopustiti Google asistentu osluškivanje izraza za glasovnu aktivaciju.
      </translation>
<translation id="9123211093995421438">Određuje najmanji broj prijelaznih točaka za vraćanje sustava <ph name="PRODUCT_OS_NAME" /> koji se treba dopustiti počevši od stabilne verzije u bilo kojem trenutku.

      Zadana vrijednost za potrošače iznosi 0, a za uređaje prijavljene u organizacijama 4 (otprilike pola godine).

      Postavljanjem tog pravila sprječava se primjena zaštite od vraćanja sustava za najmanje onaj broj prijelaznih točaka koji je naveden.

      Postavljanje tog pravila ima trajni učinak: uređaj se MOŽDA neće moći vratiti na starije verzije, čak ni nakon što se vrijednost poništi i postavi na višu.

      Stvarne mogućnosti vraćanja sustava na starije verzije mogu ovisiti o modelu uređaja i zakrpama za kritične ranjivosti.</translation>
<translation id="9126014181388780690">"Dopusti Google asistentu pristup kontekstu zaslona"</translation>
<translation id="913195841488580904">Blokiranje pristupa popisu URL-ova</translation>
<translation id="9135033364005346124">Omogući <ph name="CLOUD_PRINT_NAME" /> proxy</translation>
<translation id="9136399279941091445">Razdoblja prekida rada kada se izdaju navedena pravila za uređaje</translation>
<translation id="9147029539363974059">Šalje zapisnike sustava poslužitelju za upravljanje da bi se administratorima
      omogućilo praćenje zapisnika sustava.

      Ako se pravilo postavi na "točno", zapisnici će se slati. Ako se postavi na
      "netočno" ili se ne postavi, zapisnici sustava neće se slati.</translation>
<translation id="9150416707757015439">Ovo je pravilo zastarjelo. Umjesto njega upotrijebite "IncognitoModeAvailability". Omogućuje anonimni način u proizvodu <ph name="PRODUCT_NAME" />. Ako je ova postavka omogućena ili nije konfigurirana, korisnici mogu otvarati web-stranice u anonimnom načinu. Ako je postavka onemogućena, korisnici ne mogu otvarati stranice u anonimnom načinu. Ako ovo pravilo nije postavljeno, to će biti omogućeno i korisnik će moći upotrebljavati anonimni način.</translation>
<translation id="915194831143859291">Ako se to pravilo postavi na "netočno" ili se ne konfigurira, <ph name="PRODUCT_OS_NAME" /> dopustit će korisniku isključivanje uređaja.
      Ako se pravilo postavi na "točno", <ph name="PRODUCT_OS_NAME" /> ponovo će pokrenuti uređaj kada ga korisnik isključi. <ph name="PRODUCT_OS_NAME" /> zamjenjuje sve gumbe za isključivanje na korisničkom sučelju gumbima za ponovno pokretanje. Ako korisnik isključi uređaj tipkom za uključivanje/isključivanje, uređaj se neće automatski ponovo pokrenuti, čak ni ako je to pravilo omogućeno.</translation>
<translation id="9152473318295429890">Omogući kontekstualne prijedloge povezanih web-stranica</translation>
<translation id="9153446010242995516">Vraća uređaj na ciljnu verziju i ostaje na njoj ako je verzija OS-a novija od ciljne. Pokušajte prenijeti konfiguraciju uređaja (uključujući mrežne vjerodajnice) ako je moguće, ali vraćanje izvršite uz potpuni powerwash čak i ako oporavak podataka nije moguć (zato što ciljna verzija ne podržava oporavak podataka ili zbog promjene koja nije kompatibilna sa starijim verzijama).
          Podržano u sustavu <ph name="PRODUCT_OS_NAME" /> verzije 75 i novijima. Za starije klijente ta vrijednost znači da vraćanje nije omogućeno.</translation>
<translation id="9158929520101169054">Omogući višestruku prijavu u pregledniku</translation>
<translation id="9159126470527871268">Obavještava korisnike da se <ph name="PRODUCT_NAME" /> mora ponovo pokrenuti ili se <ph name="PRODUCT_OS_NAME" /> mora ponovo pokrenuti radi primjene ažuriranja na čekanju.

      Ova postavka pravila omogućuje obavijesti koje informiraju korisnika o preporučenom ili obaveznom ponovnom pokretanju preglednika. Ako nije postavljeno, <ph name="PRODUCT_NAME" /> korisniku naznačuje potrebu za ponovnim pokretanjem putem sitnih promjena na izborniku dok <ph name="PRODUCT_OS_NAME" /> naznačuje isto putem obavijesti u traci sustava. Ako se postavi na "Preporučeno", korisniku će se prikazivati ponavljajuće upozorenje da je preporučeno ponovno pokretanje. Korisnik može odbaciti upozorenje i tako odgoditi ponovno pokretanje. Ako se postavi na "Obavezno", korisniku će se prikazati ponavljajuće upozorenje da će se preglednik prisilno ponovo pokrenuti nakon isteka naznačenog vremena u obavijesti. To razdoblje prema zadanim postavkama iznosi sedam dana za <ph name="PRODUCT_NAME" /> i četiri dana za <ph name="PRODUCT_OS_NAME" />, a može se konfigurirati putem postavke pravila <ph name="RELAUNCH_NOTIFICATION_PERIOD_POLICY_NAME" />.

      Korisnička će se sesija vratiti nakon ponovnog pokretanja.</translation>
<translation id="9165792353046089850">Omogućuje vam da odredite smiju li web-lokacije dobivati pristup povezanim USB uređajima. Pristup se može potpuno blokirati ili se može tražiti dopuštenje korisnika svaki put kad neka web-lokacija želi pristupiti povezanom USB uređaju.

          To se pravilo može nadjačati za određene uzorke URL-ova pomoću pravila "WebUsbAskForUrls" i "WebUsbBlockedForUrls".

          Ako se pravilo ne postavi, upotrebljavat će se vrijednost "3" i korisnik će to moći promijeniti.</translation>
<translation id="9167719789236691545">Onemogući Disk u aplikaciji Datoteke za <ph name="PRODUCT_OS_NAME" /></translation>
<translation id="9185107612228451403">Konfigurira pravila u vezi s proširenjima. Korisnik ne može instalirati proširenja s popisa nedopuštenih ako nisu navedena na popisu dopuštenih. <ph name="PRODUCT_NAME" /> možete i prisiliti da automatski instalira proširenja tako da ih navedete u pravilu <ph name="EXTENSION_INSTALL_FORCELIST_POLICY_NAME" />. Prisilno instalirana proširenja instaliraju se bez obzira na to jesu li navedena na popisu nedopuštenih.</translation>
<translation id="9187743794267626640">Onemogući priključivanje vanjske pohrane</translation>
<translation id="9197740283131855199">Postotak skaliranja odgode zatamnjivanja zaslona ako korisnik postane aktivan nakon zatamnjivanja</translation>
<translation id="9200828125069750521">Parametri za URL slike koji upotrebljava POST</translation>
<translation id="920209539000507585">Prisilno uključuje ili isključuje opciju "zaglavlja i podnožja" u dijaloškom okviru za ispis.

      Ako se pravilo ne postavi, korisnik može odlučiti hoće li ispisati zaglavlja i podnožja.

      Ako se pravilo postavi na False, opcija "Zaglavlja i podnožja" u dijaloškom okviru pregleda ispisa nije odabrana i korisnik to ne može promijeniti.

      Ako se pravilo postavi na True, opcija "Zaglavlja i podnožja" u dijaloškom okviru pregleda ispisa odabrana je i korisnik to ne može promijeniti.</translation>
<translation id="9217154963008402249">Učestalost mrežnih paketa za praćenje</translation>
<translation id="922540222991413931">Konfiguracija izvora instalacija proširenja, aplikacija i korisničkih skripti</translation>
<translation id="924557436754151212">Uvoz spremljenih zaporki iz zadanog preglednika pri prvom pokretanju</translation>
<translation id="926146562923985266">To pravilo određuje naredbu koja će se upotrebljavati za otvaranje URL-ova u pregledniku <ph name="PRODUCT_NAME" /> prilikom prelaska iz Internet Explorera.

      To pravilo nema utjecaja ako nije instaliran dodatak Podrška za stare preglednike za Internet Explorer.

      Ako se pravilo ne postavi, Internet Explorer automatski će otkrivati izvršni put preglednika <ph name="PRODUCT_NAME" /> kada se <ph name="PRODUCT_NAME" /> pokrene iz Internet Explorera.

      Ako se to pravilo postavi, ono će se upotrebljavati za pokretanje preglednika <ph name="PRODUCT_NAME" /> prilikom pokretanja preglednika <ph name="PRODUCT_NAME" /> iz Internet Explorera.

      To se pravilo može postaviti na put izvršne datoteke ili ${chrome} radi automatskog otkrivanja Chromeovog mjesta instalacije.</translation>
<translation id="930930237275114205">Postavi direktorij korisničkih podataka za pravilo <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="943865157632139008">Omogućuje vam da konfigurirate zadani HTML ispunjivač kada je instaliran <ph name="PRODUCT_FRAME_NAME" />.
      Zadana je postavka ta da se pregledniku hosta dopušta generiranje, ali to po izboru možete nadjačati i kao zadano postaviti da HTML stranice generira <ph name="PRODUCT_FRAME_NAME" />.</translation>
<translation id="944817693306670849">Postavi veličinu predmemorije diska</translation>
<translation id="966854160628341653">Kontrolira dopušta li sustav <ph name="PRODUCT_OS_NAME" /> izradu novih korisničkih računa. Ako se pravilo postavi na false, korisnici koji još nemaju račun neće se moći prijaviti.

      Ako se pravilo postavi na true ili se ne konfigurira, izrada novih korisničkih računa bit će dopuštena pod uvjetom da pravilo <ph name="DEVICE_USER_WHITELIST_POLICY_NAME" /> ne sprječava prijavu korisnika.</translation>
<translation id="981346395360763138">Onemogućene su Googleove usluge lokacije</translation>
<translation id="982497069985795632">Omogući provjeru pravopisa</translation>
<translation id="991560005425213776">Pošalji korisničko ime i naziv datoteke nativnim pisačima</translation>
</translationbundle>