<?xml version="1.0" ?>
<!DOCTYPE translationbundle>
<translationbundle lang="cs">
<translation id="101438888985615157">Otočit obrazovku o 180 stupňů</translation>
<translation id="1016912092715201525">Slouží ke konfiguraci kontroly výchozího prohlížeče v prohlížeči <ph name="PRODUCT_NAME" /> a brání uživatelům, aby tato nastavení změnili.

Pokud toto nastavení aktivujete, <ph name="PRODUCT_NAME" /> při spuštění vždy zkontroluje, zda je výchozím prohlížečem, a pokud to bude možné, automaticky se zaregistruje.

Pokud je toto nastavení deaktivováno, <ph name="PRODUCT_NAME" /> nebude kontrolovat, zda je výchozím prohlížečem, a deaktivuje uživatelské ovládací prvky pro zapnutí této kontroly.

Pokud toto nastavení není nakonfigurováno, může uživatel v prohlížeči <ph name="PRODUCT_NAME" /> určit, zda jej chce nastavit jako výchozí prohlížeč a zda se má zobrazit oznámení v případě, že jím není.

Poznámka pro administrátory systému <ph name="MS_WIN_NAME" />: Aktivace tohoto nastavení bude fungovat jen na počítačích se systémem Windows 7. V případě systému Windows 8 a pozdějších verzí systému Windows je potřeba implementovat soubor s přiřazením výchozích aplikací, v němž bude prohlížeče <ph name="PRODUCT_NAME" /> nastaven jako obslužný nástroj pro protokoly <ph name="HHTPS_PROTOCOL" /> a <ph name="HTTP_PROTOCOL" /> (a volitelně případně také pro protokol <ph name="FTP_PROTOCOL" /> a formáty souborů jako <ph name="HTML_EXTENSION" />, <ph name="HTM_EXTENSION" />, <ph name="PDF_EXTENSION" />, <ph name="SVG_EXTENSION" />, <ph name="WEBP_EXTENSION" /> apod.). Další informace najdete na stránce <ph name="SUPPORT_URL" />.</translation>
<translation id="1017967144265860778">Správa možností napájení na přihlašovací obrazovce</translation>
<translation id="1019101089073227242">Nastavit adresář uživatelských dat</translation>
<translation id="1022361784792428773">ID rozšíření, která by uživatelé neměli instalovat (* znamená, že se černá listina týká všech rozšíření)</translation>
<translation id="102492767056134033">Nastavuje výchozí stav softwarové klávesnice na přihlašovací obrazovce.</translation>
<translation id="1027000705181149370">Určuje, zda soubory cookie pro ověření vytvořené poskytovatelem identity SAML při přihlášení mají být přeneseny do profilu uživatele.

      Když je uživatel při přihlášení ověřen prostřednictvím poskytovatele identity SAML, soubory cookie vytvořené poskytovatelem identity se nejprve zapíšou do dočasného profilu. Tyto soubory cookie lze přenést do profilu uživatele k dalšímu použití stavu ověření.

      Pokud je tato zásada nastavena na hodnotu True, soubory cookie vytvořené poskytovatelem identity se do profilu uživatele přenesou pokaždé, když se uživatel při přihlášení ověří prostřednictvím poskytovatele identity SAML.

      Pokud je tato zásada nastavena na hodnotu False nebo nastavena není, soubory cookie vytvořené poskytovatelem identity se do profilu uživatele přenesou pouze při prvním přihlášení do zařízení.

      Tato zásada má vliv pouze na uživatele, jejichž doména odpovídá doméně, ve které je zařízení zaregistrováno. V případě ostatních uživatelů se soubory cookie vytvořené poskytovatelem identity do profilu uživatele přenesou pouze při prvním přihlášení do zařízení.</translation>
<translation id="1030120600562044329">Aktivuje anonymní odesílání údajů o využití a selháních prohlížeče <ph name="PRODUCT_NAME" /> do Googlu a znemožní uživatelům toto nastavení změnit.

      Pokud je toto nastavení zapnuté, anonymní údaje o využití a selhání se budou odesílat do Googlu.  Pokud je vypnuté, tyto informace se do Googlu odesílat nebudou.  V obou případech uživatelé nemohou toto nastavení změnit ani přepsat.
      Pokud tuto zásadu ponecháte nenastavenou, bude jako nastavení použita volba uživatele při instalaci nebo prvním spuštění.

      Tato zásada je k dispozici jen v instancích systému Windows, které jsou připojené k doméně <ph name="MS_AD_NAME" />, nebo v instancích systému Windows 10 Pro nebo Enterprise, které jsou zaregistrované ke správě zařízení.
      (Pokud používáte Chrome OS, přečtěte si informace o zásadě DeviceMetricsReportingEnabled.)</translation>
<translation id="1035385378988781231">Tato zásada určuje, zda funkce Sdílené síťové složky pro prohlížeč <ph name="PRODUCT_NAME" /> bude k ověření používat protokol NTLM.

      Když je tato zásada nastavena na hodnotu True, v případě potřeby se k ověření sdílených složek SMB bude používat protokol NTLM.
      Když je tato zásada nastavena na hodnotu False, ověření pomocí protokolu NTLM bude pro sdílené složky SMB zapnuto.

      Pokud tato zásada není nastavena, u uživatelů spravovaných organizací bude toto ověření vypnuto a u ostatních uživatelů bude zapnuto.</translation>
<translation id="1040446814317236570">Před odesláním skriptu PAC z adres se schématem https:// odstraňovat citlivá data</translation>
<translation id="1044878202534415707">Nahlášení statistik hardwaru, například využití CPU/RAM.

Pokud je tato zásada nastavena na hodnotu false, statistiky nebudou hlášeny.
Pokud je nastavena na hodnotu true nebo nastavena není, statistiky hlášeny budou.</translation>
<translation id="1046484220783400299">Na omezenou dobu povolit zastaralé funkce platformy Web Platform</translation>
<translation id="1047128214168693844">Nepovolovat sledování fyzické polohy žádným webovým stránkám</translation>
<translation id="1049138910114524876">Konfiguruje jazyk používaný povinně na přihlašovací obrazovce systému <ph name="PRODUCT_OS_NAME" />.

      Je-li nastavena tato zásada, přihlašovací obrazovka se vždy zobrazí v jazyce, který je určen první hodnotou této zásady (z důvodu kompatibility s budoucími verzemi je zásada definována jako seznam). Pokud tato zásada není nastavena nebo je nastavena na prázdný seznam, zobrazí se přihlašovací obrazovka v jazyce poslední uživatelské návštěvy. Pokud je tato zásada nastavena na hodnotu, která není platným jazykem, zobrazí se přihlašovací obrazovka v záložním jazyce (aktuálně americká angličtina).</translation>
<translation id="1062011392452772310">Povolit vzdálené ověření identity zařízení</translation>
<translation id="1062407476771304334">Nahradit</translation>
<translation id="1079801999187584280">Zakázat používání Nástrojů pro vývojáře</translation>
<translation id="1093082332347834239">Pokud je zapnuto toto nastavení, hostitel vzdálené pomoci bude spuštěn v procesu s oprávněními <ph name="UIACCESS_PERMISSION_NAME" />. Vzdálení uživatelé tak na počítači místního uživatele budou moci provádět interakci s okny, která vyžadují zvýšená oprávnění.

          Pokud je toto nastavení vypnuto nebo není nakonfigurováno, hostitel vzdálené pomoci poběží v kontextu uživatele a vzdálení uživatelé na počítači nebudou moci provádět interakci s okny, která vyžadují zvýšená oprávnění.</translation>
<translation id="1096105751829466145">Výchozí poskytovatel vyhledávání</translation>
<translation id="1099282607296956954">Aktivace izolace webů u všech webů</translation>
<translation id="1100570158310952027">
      Tato zásada určuje seznam zdrojů (adres URL) nebo vzorů názvů hostitelů (například „*.example.com“), na které se nebudou vztahovat bezpečnostní omezení nezabezpečených zdrojů.

      Cílem je umožnit organizacím nastavit seznam povolených zdrojů pro starší aplikace, do kterých nelze implementovat protokol TLS, nebo nastavit zkušební server pro vývoj interních webových stránek, aby vývojáři mohli testovat funkce, které vyžadují zabezpečené kontexty, aniž by na testovacím serveru museli implementovat protokol TLS. Tato zásada také zabrání označení zdroje jako nezabezpečeného v omniboxu.

      Nastavení seznamu adres URL v této zásadě má stejný dopad jako nastavení příznaku příkazového řádku --unsafely-treat-insecure-origin-as-secure na čárkami oddělený seznam stejných adres URL. Je-li nastavena tato zásada, bude jí příznak příkazového řádku přepsán.

      Pokud je nastavená zásada UnsafelyTreatInsecureOriginAsSecure, tato zásada ji přepíše.

      Další informace o bezpečných kontextech najdete na stránce https://www.w3.org/TR/secure-contexts/.
      </translation>
<translation id="1107764601871839136">Určuje dobu platnosti (v hodinách) mezipaměti objektů zásad skupiny. Namísto opětovného stahování objektů zásad skupiny při každém načítání zásad může systém použít objekty zásad skupiny z mezipaměti (pokud se jejich verze nezmění). Tato zásada určuje maximální dobu, po kterou je objekty zásad skupiny možné používat před opětovným stažením. Restartováním a odhlášením se mezipaměť vymaže.

      Pokud tato zásada není nastavená, objekty zásad skupiny je možné používat až 25 hodin.

      Pokud je tato zásada nastavená na hodnotu 0, je ukládání objektů zásad skupiny do mezipaměti vypnuté. Upozorňujeme, že to vede k vyššímu zatížení serveru, protože objekty zásad skupiny se při každém načítání zásad stahují znovu i v případě, že se nezměnily.</translation>
<translation id="1117535567637097036">Obslužné nástroje protokolů nastavené pomocí této zásady se nepoužívají při zpracovávání zpráv Intent systému Android.</translation>
<translation id="1118093128235245168">Povolit webům žádat uživatele o udělení přístupu k připojenému zařízení USB</translation>
<translation id="1128903365609589950">Slouží ke konfiguraci adresáře, který bude <ph name="PRODUCT_NAME" /> používat k ukládání souborů do mezipaměti na disku.

      Pokud tuto zásadu nastavíte, <ph name="PRODUCT_NAME" /> bude používat stanovený adresář bez ohledu na to, zda uživatel zadal příznak „--disk-cache-dir“. Abyste předešli ztrátě dat a jiným neočekávaným chybám, nenastavujte tuto zásadu na kořenový adresář svazku ani na adresář používaný k dalším účelům, protože obsah adresáře spravuje prohlížeč <ph name="PRODUCT_NAME" />.

      Seznam proměnných, které lze použít, naleznete na stránce https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Pokud tuto zásadu nenastavíte, bude použit výchozí adresář mezipaměti a uživatel jej bude moci přepsat pomocí příznaku příkazového řádku „--disk-cache-dir“.</translation>
<translation id="113521240853905588">Konfiguruje jazyky, které systém <ph name="PRODUCT_OS_NAME" /> může používat jako preferované.

      Pokud je tato zásada nastavena, může uživatel do seznamu preferovaných jazyků přidat jen jeden z jazyků uvedených v této zásadě. Jestliže tato zásada není nastavena nebo je nastavena na prázdný seznam, může uživatel jako preferované zadat libovolné jazyky. Pokud je tato zásada nastavena na seznam s neplatnými hodnotami, všechny neplatné hodnoty budou ignorovány. Pokud uživatel do seznamu preferovaných jazyků dříve přidal nějaké jazyky, které tato zásada nepovoluje, budou odstraněny. Pokud uživatel dříve nakonfiguroval, aby se systém <ph name="PRODUCT_OS_NAME" /> zobrazoval v jazyce, který tato zásada nepovoluje, přepne se zobrazovaný jazyk při příštím přihlášení uživatele na povolený jazyk uživatelského rozhraní. Jinak se systém <ph name="PRODUCT_OS_NAME" /> přepne na první platnou hodnotu zadanou v této zásadě, nebo na záložní národní prostředí (aktuálně en-US), pokud tato zásada obsahuje pouze neplatné hodnoty.</translation>
<translation id="1135264353752122851">Určuje, která rozvržení klávesnice jsou povolena pro uživatelské návštěvy systému <ph name="PRODUCT_OS_NAME" />.

      Pokud je tato zásada nastavená, může uživatel vybrat jen jednu z metod zadávání dat zadaných v této zásadě. Pokud tato zásada není nastavená nebo je nastavená na prázdný seznam, může uživatel vybrat všechny podporované metody zadávání. Pokud tato zásada nepovoluje aktuální metodu zadávání, bude přepnuta na rozložení hardwarové klávesnice (pokud je povoleno) nebo na první platnou položku v tomto seznamu. Všechny neplatné nebo nepodporované metody zadávání v tomto seznamu budou ignorovány.</translation>
<translation id="1138294736309071213">Tato zásada je aktivní pouze v režimu pro obchody.

      Určuje dobu nečinnosti před zobrazením spořiče obrazovky na přihlašovací obrazovce v režimu pro obchody.

      Hodnota zásady se určuje v milisekundách.</translation>
<translation id="1151353063931113432">Povolit obrázky na těchto stránkách</translation>
<translation id="1152117524387175066">Hlásí stav přepínače režimu pro vývojáře při spuštění zařízení.

      Pokud je tato zásada nastavena na hodnotu false, stav přepínače režimu pro vývojáře se hlásit nebude.</translation>
<translation id="1160479894929412407">Povolit protokol QUIC</translation>
<translation id="1160939557934457296">Zakázat pokračování ze stránky s upozorněním Bezpečného prohlížení</translation>
<translation id="1189817621108632689">Umožňuje nastavit seznam vzorů adres URL webových stránek, které nemají povoleno zobrazovat obrázky.

          Pokud tuto zásadu nenastavíte, použije se pro všechny webové stránky globální výchozí hodnota buď ze zásady DefaultImageSetting (pokud je nastavena), nebo z osobního nastavení uživatele.

          Dříve tato zásada byla omylem k dispozici na zařízeních Android, ale tato funkce v systému Android nikdy nebyla plně podporována.</translation>
<translation id="1198465924256827162">Frekvence odesílání informací o stavu zařízení (v milisekundách).

Není-li tato zásada nastavena, výchozí frekvence je 3 hodiny. Minimální povolená frekvence je 60 sekund.</translation>
<translation id="1204263402976895730">Povolené podnikové tiskárny</translation>
<translation id="1219695476179627719">Určuje, zda se má zařízení vrátit k verzi nastavené v zásadě <ph name="DEVICE_TARGET_VERSION_PREFIX_POLICY_NAME" />, pokud je v něm již spuštěna novější verze.

      Výchozí nastavení je RollbackDisabled.</translation>
<translation id="1221359380862872747">Načíst konkrétní adresy URL při přihlášení do ukázky</translation>
<translation id="1223789468190631420">Stav povolení Bezpečného prohlížení pro důvěryhodné zdroje</translation>
<translation id="122899932962115297">Seznam, který určuje, jaké metody rychlého odemknutí obrazovky uzamčení může uživatel nakonfigurovat a používat.

          Hodnotou je seznam řetězců. Platné jsou tyto hodnoty: „all“, „PIN“ a "FINGERPRINT". Když na seznam přidáte hodnotu „all“, uživatel bude moci použít všechny metody rychlého odemknutí, včetně těch, které budou implementovány v budoucnu. V opačném případě budou k dispozici pouze metody uvedené na seznamu.

          Příklad: Chcete-li povolit všechny metody rychlého odemknutí, použijte hodnotu [„all“]. Chcete-li povolit pouze odemknutí pomocí kódu PIN, použijte hodnotu [„PIN“]. Chcete-li povolit kód PIN a otisk prstu, použijte hodnotu ["PIN", "FINGERPRINT"]. Chcete-li všechny metody rychlého odemknutí zakázat, použijte hodnotu [].

          Ve výchozím nastavení nejsou pro spravovaná zařízení k dispozici žádné metody rychlého odemknutí.</translation>
<translation id="123081309365616809">Povoluje odesílání obsahu do zařízení</translation>
<translation id="1231349879329465225">Umožňuje aktivovat nebo deaktivovat Rychlé převádění.
      Toto nastavení platí pro všechny uživatele a všechna rozhraní v zařízení.
      Aby se Rychlé převádění použilo, musí být zapnuté toto nastavení i vlastnost ONC na úrovni sítě.
      Jakmile je Rychlé převádění nastaveno, zůstane aktivní, dokud nebude deaktivováno změnou této zásady.

      Pokud tato zásada není nastavená nebo je nastavená na hodnotu false, Rychlé převádění se nepoužívá.
      Pokud je nastavená na hodnotu true, Rychlé převádění se používá v případě, že ho bezdrátový přístupový bod podporuje.</translation>
<translation id="1243570869342663665">Ovládat filtrování obsahu pro dospělé pomocí funkce SafeSites.</translation>
<translation id="1257550411839719984">Nastavit výchozí adresář pro stahování</translation>
<translation id="1265053460044691532">Omezit dobu, po kterou se uživatel ověřený pomocí technologie SAML může přihlásit offline</translation>
<translation id="1291880496936992484">Upozornění: Po verzi 52 (přibližně v září 2016) bude šifrovací algoritmus RC4 z prohlížeče <ph name="PRODUCT_NAME" /> zcela odstraněn a tato zásada přestane fungovat.

      Pokud tato zásada není nastavena nebo je nastavena na hodnotu false, v protokolu TLS nebudou povoleny šifrovací sady RC4. Nastavením této zásady na hodnotu true je možné zajistit kompatibilitu se zastaralým serverem. Toto nastavení by však mělo být použito pouze jako dočasné nouzové opatření a server by měl být překonfigurován.</translation>
<translation id="1297182715641689552">Použít skript proxy serveru ve formátu PAC</translation>
<translation id="1304973015437969093">ID aplikací/rozšíření a adresy URL aktualizací, které se mají nainstalovat na pozadí</translation>
<translation id="1307415922184340052">S každou tiskovou úlohou do nativních tiskáren odesílat uživatelské jméno a název souboru. Ve výchozím nastavení se tyto údaje neodesílají.</translation>
<translation id="1307454923744766368">Vzory zdrojů nebo názvů hostitelů, na které se nemají vztahovat omezení ohledně nezabezpečených zdrojů.</translation>
<translation id="1313457536529613143">Určuje, o kolik procent bude prodloužena prodleva ztmavení obrazovky, když je v případě ztmavené obrazovky nebo záhy po vypnutí obrazovky zaznamenána aktivita uživatele.

Pokud je tato zásada nastavena, udává procento, o které bude prodloužena prodleva ztmavení obrazovky, když je v případě ztmavené obrazovky nebo záhy po vypnutí obrazovky zaznamenána aktivita uživatele. Při prodloužení prodlevy ztmavení budou prodlouženy i prodlevy vypnutí, uzamčení obrazovky a nečinnosti tak, aby mezi nimi a prodlevou ztmavení zůstala stejná doba.

Není-li tato zásada nastavena, bude použita výchozí hodnota prodloužení.

Hodnota prodloužení musí být 100 % nebo více.</translation>
<translation id="131353325527891113">Zobrazit uživatelská jména na přihlašovací obrazovce</translation>
<translation id="1327466551276625742">Povolit zobrazení výzvy ke konfiguraci sítě v režimu offline</translation>
<translation id="1330145147221172764">Povolit softwarovou klávesnici</translation>
<translation id="13356285923490863">Název zásady</translation>
<translation id="1352174694615491349">Tato zásada umožňuje slučování připojení HTTP/2 při použití certifikátů klienta. Aby připojení bylo možné sloučit, musí název hostitele potenciálního nového připojení i název hostitele existujícího připojení odpovídat alespoň jednomu ze vzorů zadaných v této zásadě. Tato zásada je seznam hostitelů ve formátu filtru URLBlacklist: „example.com“ odpovídá doméně „example.com“ a všem subdoménám (např. „sub.example.com“), „.example.net“ však odpovídá pouze doméně „example.net“.

      Slučování požadavků pro různé hostitele přes připojení, která používají certifikáty klientů, může vést k problémům se zabezpečením a ochranou soukromí, protože bude u všech požadavků použita ambientní autorita i v případě, že to uživatel výslovně nepovolil. Tato zásada je dočasná a v budoucím vydání bude odstraněna. Viz https://crbug.com/855690.

      Je-li tato zásada ponechána nenastavená, použije se výchozí chování, při němž slučování připojení HTTP/2, která používají certifikáty klienta, není povoleno.</translation>
<translation id="1353966721814789986">Stránky otevírané při spuštění</translation>
<translation id="1354424209129232709">Maximum:</translation>
<translation id="1359553908012294236">Pokud je tato zásada nastavena na hodnotu True nebo nastavena není, prohlížeč <ph name="PRODUCT_NAME" /> povolí přihlášení hosta. Přihlášení hosta v prohlížeči <ph name="PRODUCT_NAME" /> jsou profily, ve kterých jsou všechna okna v anonymním režimu.

Pokud je tato zásada nastavena na hodnotu False, <ph name="PRODUCT_NAME" /> vytváření profilů hosta nepovolí.</translation>
<translation id="1363275621236827384">Povolit dotazy na server Quirks pro hardwarové profily</translation>
<translation id="1384459581748403878">Reference: <ph name="REFERENCE_URL" /></translation>
<translation id="1387596372902085462">Zda důvěřovat starší infrastruktuře PKI od společnosti Symantec</translation>
<translation id="1393485621820363363">Povolené podnikové tiskárny pro zařízení</translation>
<translation id="1397855852561539316">URL výchozího vyhledávače pro návrhy</translation>
<translation id="1413936351612032792">Hlásit informace o využití Linuxových aplikací</translation>
<translation id="142346659686073702">Povolit cizím uživatelům používat Crostini</translation>
<translation id="1426410128494586442">Ano</translation>
<translation id="1427655258943162134">Adresa (nebo adresa URL) proxy serveru</translation>
<translation id="1431272318313028342">Aktivuje v prohlížeči <ph name="PRODUCT_NAME" /> funkci Bezpečné prohlížení a brání uživatelům ve změně tohoto nastavení.

      Pokud toto nastavení aktivujete, Bezpečné prohlížení bude vždy aktivní.

      Pokud toto nastavení deaktivujete, Bezpečné prohlížení nebude nikdy aktivní.

      Pokud toto nastavení aktivujete nebo deaktivujete, uživatelé nebudou moci v prohlížeči <ph name="PRODUCT_NAME" /> změnit ani přepsat nastavení Povolit ochranu proti phishingu a malwaru.

Pokud tuto zásadu ponecháte nenastavenou, bude tato možnost aktivovaná, ale uživatelé budou moci nastavení změnit.

      Další informace o Bezpečném prohlížení najdete na stránce https://developers.google.com/safe-browsing.

      Tato zásada je k dispozici jen v instancích systému Windows, které jsou připojené k doméně <ph name="MS_AD_NAME" />, nebo v instancích systému Windows 10 Pro nebo Enterprise, které jsou zaregistrované ke správě zařízení.</translation>
<translation id="1435659902881071157">Konfigurace sítě na úrovni zařízení</translation>
<translation id="1438739959477268107">Výchozí nastavení generování klíčů</translation>
<translation id="1454846751303307294">Umožňuje nastavit seznam vzorů adres URL stránek, kterým není povoleno spouštět JavaScript.

          Pokud zásadu nenastavíte, použije se pro všechny webové stránky globální výchozí hodnota buď ze zásady DefaultJavaScriptSetting (pokud je nastavena), nebo z osobního nastavení uživatele.</translation>
<translation id="1456822151187621582">Windows (klienti <ph name="PRODUCT_OS_NAME" />):</translation>
<translation id="1464848559468748897">Určuje chování uživatele v multiprofilové relaci v zařízeních se systémem <ph name="PRODUCT_OS_NAME" />.
      Pokud je tato zásada nastavena na hodnotu MultiProfileUserBehaviorUnrestricted, uživatel může být v multiprofilové relaci buď primárním, nebo sekundárním uživatelem.

      Pokud je tato zásada nastavena na hodnotu MultiProfileUserBehaviorMustBePrimary, uživatel může být v multiprofilové relaci pouze primárním uživatelem.

      Pokud je tato zásada nastavena na hodnotu MultiProfileUserBehaviorNotAllowed, uživatel nemůže být součástí multiprofilové návštěvy.

      Pokud tuto zásadu nastavíte, uživatelé ji nebudou moci změnit ani přepsat.

      Pokud dojde ke změně ve chvíli, kdy je uživatel přihlášen k multiprofilové relaci, bude nastavení zkontrolováno u všech uživatelů v dané relaci. Pokud některý uživatel již nebude mít právo návštěvy se účastnit, bude návštěvy ukončena.

      Pokud tato zásada není nastavena, bude pro uživatele spravované organizací použita výchozí hodnota „MultiProfileUserBehaviorMustBePrimary“ a pro uživatele, kteří nejsou spravováni, bude použita hodnota „MultiProfileUserBehaviorUnrestricted“.</translation>
<translation id="1465619815762735808">Spustit kliknutím</translation>
<translation id="1468307069016535757">Nastavuje výchozí stav funkce usnadnění přístupu pomocí režimu vysokého kontrastu na přihlašovací obrazovce.

Pokud je tato zásada nastavena na hodnotu true, bude při zobrazení obrazovky přihlášení režim vysokého kontrastu aktivní.

Pokud je nastavena na hodnotu false, bude při zobrazení přihlašovací obrazovky režim vysokého kontrastu deaktivován.

Pokud tuto zásadu nastavíte, uživatelé ji budou moci dočasně přepsat aktivací nebo deaktivací režimu vysokého kontrastu. Volba uživatele nicméně nebude trvalá a po opětovném zobrazení přihlašovací obrazovky nebo nečinnosti uživatele na přihlašovací obrazovce po dobu jedné minuty se obnoví původní nastavení.

Pokud tuto zásadu nenastavíte, bude při prvním zobrazení obrazovky přihlášení režim vysokého kontrastu deaktivován. Uživatelé budou moci režim vysokého kontrastu kdykoli aktivovat nebo deaktivovat a zvolený stav na přihlašovací obrazovce přetrvá i u jiných uživatelů.</translation>
<translation id="1468707346106619889">Pokud je tato zásada nastavena na hodnotu true, jednotná plocha je povolena a aktivována automaticky (výchozí nastavení), což umožňuje rozložení aplikací přes více obrazovek. Jednotnou plochu na jednotlivých displejích může uživatel vypnout zrušením zaškrtnutí v nastavení displeje.

Pokud je tato zásada nastavena na hodnotu false nebo ponechána bez nastavení, jednotná plocha bude zakázána. V takovém případě uživatel funkci nemůže zapnout.</translation>
<translation id="1474273443907024088">Zakázat optimalizaci TLS False Start</translation>
<translation id="1477934438414550161">TLS 1.2</translation>
<translation id="1484146587843605071">U hostitelů v tomto seznamu prohlížeč <ph name="PRODUCT_NAME" /> obejde všechny proxy servery. 

          Tato zásada bude použita pouze v případě, že jste v zásadě „Zvolit způsob konfigurace nastavení proxy serveru“ zvolili ruční nastavení.

          Pokud jste vybrali jiný režim nastavení zásad proxy serveru, tuto zásadu byste nastavovat neměli.

          Podrobnější příklady naleznete na následující stránce:
          <ph name="PROXY_HELP_URL" /></translation>
<translation id="1502843533062797703">Zapnout blokování vkládání softwaru třetích stran</translation>
<translation id="1504431521196476721">Vzdálené ověření identity</translation>
<translation id="1507957856411744193">Je-li tato zásada nastavena na hodnotu true, bude se <ph name="PRODUCT_NAME" /> připojovat k zařízením Cast na všech IP adresách, nikoliv pouze na soukromých adresách RFC1918/RFC4193.

          Je-li tato zásada nastavena na hodnotu false, bude se <ph name="PRODUCT_NAME" /> připojovat pouze k zařízením Cast na soukromých adresách RFC1918/RFC4193.

          Pokud tato zásada není nastavena, bude se <ph name="PRODUCT_NAME" /> připojovat pouze k zařízením Cast na soukromých adresách RFC1918/RFC4193 s výjimkou případů, kdy je aktivována funkce CastAllowAllIPs.

          Je-li zásada EnableMediaRouter nastavena na hodnotu false, hodnoty této zásady se nijak neprojeví.</translation>
<translation id="1509692106376861764">V prohlížečích <ph name="PRODUCT_NAME" /> verze 29 a novějších byla tato zásada zrušena.</translation>
<translation id="1514888685242892912">Povolit <ph name="PRODUCT_NAME" /></translation>
<translation id="1522425503138261032">Umožňuje webovým stránkám sledovat fyzickou polohu uživatele</translation>
<translation id="1523774894176285446">Alternativní prohlížeč, který se má spustit pro nakonfigurované weby.</translation>
<translation id="152657506688053119">Seznam alternativních adres URL výchozího poskytovatele vyhledávání</translation>
<translation id="1530812829012954197">Následující vzory adres URL vykreslit vždy v hostitelském prohlížeči</translation>
<translation id="1541170838458414064">Omezit velikost stránky tisku</translation>
<translation id="1553684822621013552">Je-li zásada nastavena na hodnotu true, rozšíření ARC bude uživateli povoleno (pokud bude v aktuální uživatelské relaci povolen režim dočasných profilů nebo vícenásobné přihlašování, rozšíření ARC dostupné nebude).

Pokud je toto nastavení zakázáno nebo není nakonfigurováno, firemní uživatelé rozšíření ARC nebudou moci používat.</translation>
<translation id="1559980755219453326">Tato zásada určuje, zda se mají hlásit informace o rozšířeních a pluginech.

      Pokud je tato zásada ponechána nenastavená nebo je nastavená na hodnotu True, údaje o rozšířeních a pluginech se shromažďují.
      Pokud je tato zásada nastavená na hodnotu False, údaje o rozšířeních a pluginech se neshromažďují.

      Tato zásada je účinná pouze v případě, že je zapnutá zásada <ph name="CHROME_REPORTING_EXTENSION_NAME" /> a počítač je zaregistrován pomocí zásady <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="1561424797596341174">Přepsání zásad pro ladicí sestavení hostitele vzdáleného přístupu</translation>
<translation id="1561967320164410511">U2F plus rozšíření pro individuální atestaci</translation>
<translation id="1574554504290354326">Podpora tohoto nastavení byla ukončena, použijte namísto něj zásadu SafeBrowsingExtendedReportingEnabled. Povolení nebo zakázání zásady SafeBrowsingExtendedReportingEnabled je ekvivalentní k nastavení zásady SafeBrowsingExtendedReportingOptInAllowed na hodnotu False.

      Pokud tuto zásadu nastavíte na hodnotu false, uživatelé nebudou moci zvolit, že se mají některé informace o systému a obsahu stránek odesílat na servery Google. Pokud je tato zásada nastavena na hodnotu true nebo není nakonfigurována, uživatelé budou moci odesílat část informací o systému a obsahu stránek do Bezpečného prohlížení a pomoci tak rozpoznávat nebezpečné aplikace a weby.

      Další informace o Bezpečném prohlížení najdete na stránce https://developers.google.com/safe-browsing.</translation>
<translation id="1583248206450240930">Ve výchozím nastavení používat plugin <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="1599424828227887013">Aktivovat izolaci webů u určených zdrojů na zařízeních Android</translation>
<translation id="1608755754295374538">Adresy URL, kterým bude udělen přístup pro záznam zvuku bez zobrazení výzvy</translation>
<translation id="1615221548356595305">Pro tyto hostitele povolit slučování připojení HTTP/2 i při použití certifikátů klienta</translation>
<translation id="1617235075406854669">Aktivovat smazání historie prohlížeče a stahování</translation>
<translation id="163200210584085447">Vzory v tomto seznamu budou porovnány s žádající adresou URL. Pokud bude nalezena shoda, bude na přihlašovacích stránkách SAML udělen přístup k zařízením pro záznam videa. Pokud shoda nalezena nebude, přístup bude automaticky odepřen. Vzory se zástupnými znaky nejsou povoleny.</translation>
<translation id="1634989431648355062">Povolit plugin <ph name="FLASH_PLUGIN_NAME" /> na těchto webech</translation>
<translation id="1655229863189977773">Nastavit velikost diskové mezipaměti v bajtech</translation>
<translation id="166427968280387991">Proxy server</translation>
<translation id="1668836044817793277">Udává, zda má mít automaticky spouštěná terminálová aplikace s nulovým zpožděním povoleno ovládat verzi systému <ph name="PRODUCT_OS_NAME" />.

      Tato zásada řídí, zda bude mít automaticky spouštěná terminálová aplikace s nulovým zpožděním povoleno ovládat verzi systému <ph name="PRODUCT_OS_NAME" /> tím, že ve svém manifestu deklaruje klíč required_platform_version, který se použije jako předpona cílové verze u automatických aktualizací.

      Je-li tato zásada nastavena na hodnotu true, hodnota klíče required_platform_version v manifestu automaticky spouštěné terminálové aplikace s nulovým zpožděním se použije jako předpona cílové verze automatických aktualizací.

      Pokud tato zásada není nakonfigurována nebo je nastavena na hodnotu false, klíč manifestu required_platform_version je ignorován a automatické aktualizace fungují běžným způsobem.

      Upozornění: Delegovat řízení verze systému <ph name="PRODUCT_OS_NAME" /> na terminálovou aplikaci se nedoporučuje, neboť to zařízení může zabránit v přijímání aktualizací softwaru a kritických oprav zabezpečení. Delegování řízení verze systému <ph name="PRODUCT_OS_NAME" /> by uživatele mohlo vystavit riziku.</translation>
<translation id="1675002386741412210">Podpora:</translation>
<translation id="1689963000958717134">Umožňuje přenést nastavení sítě, která se budou používat pro všechny uživatele zařízení se systémem <ph name="PRODUCT_OS_NAME" />. Konfigurace sítě je řetězec ve formátu JSON, který se řídí definicí formátu Open Network Configuration popsanou na stránce <ph name="ONC_SPEC_URL" />.</translation>
<translation id="1708496595873025510">Nastavit omezení pro načítání počáteční hodnoty variace</translation>
<translation id="1717817358640580294">Pokud tato zásada není nastavená a Chrome Cleanup nalezne nežádoucí software, může metadata o kontrole poskytnout Googlu v souladu s nastavením zásady SafeBrowsingExtendedReportingEnabled. Chrome Cleanup se poté uživatele zeptá, zda chce nežádoucí software odstranit. Uživatel může výsledky čištění sdílet s Googlem a pomoci tak se zjišťováním nežádoucího softwaru do budoucna. Výsledky obsahují metadata souborů, automaticky nainstalovaná rozšíření a klíče registru, jak je popsáno v dokumentu Informace o ochraně soukromí v prohlížeči Google Chrome.

      Pokud je tato zásada deaktivovaná a Chrome Cleanup nalezne nežádoucí software, metadata o kontrole do Googlu nenahlásí (bez ohledu na nastavení zásady SafeBrowsingExtendedReportingEnabled). Chrome Cleanup se uživatele zeptá, zda chce nežádoucí software odstranit.  Výsledky čištění nebudou nahlášeny Googlu a nebude je moci nahlásit ani uživatel.

      Pokud je tato zásada aktivovaná a Chrome Cleanup nalezne nežádoucí software, může metadata o kontrole nahlásit do Googlu v souladu s nastavením zásady SafeBrowsingExtendedReportingEnabled. Chrome Cleanup se uživatele zeptá, zda chce nežádoucí software odstranit.  Výsledky čištění budou nahlášeny Googlu a uživatel tomu nebude moci zabránit.

      Tato zásada je k dispozici jen v instancích systému Windows, které jsou připojené k doméně <ph name="MS_AD_NAME" />, nebo v instancích systému Windows 10 Pro nebo Enterprise, které jsou zaregistrované ke správě zařízení.</translation>
<translation id="172374442286684480">Umožnit nastavení místních dat všem webům</translation>
<translation id="1734716591049455502">Konfigurace možností vzdáleného přístupu</translation>
<translation id="1736269219679256369">Povolit pokračování ze stránky s upozorněním protokolu SSL</translation>
<translation id="1745780278307622857">Určuje, zda prohlížeč <ph name="PRODUCT_NAME" /> u souborů z důvěryhodných zdrojů může povolit stažení bez kontrol Bezpečného prohlížení.

      Když je tato zásada nastavená na hodnotu False, soubory stahované z důvěryhodných zdrojů se nebudou odesílat k analýze pomocí Bezpečného prohlížení.

      Když tato zásada není nastavená (nebo je nastavená na hodnotu True), stahované soubory se odesílají k analýze pomocí Bezpečného prohlížení i v případě, že pocházejí z důvěryhodného zdroje.

      Tato omezení se vztahují na stahování spuštěná z obsahu webových stránek i pomocí možnosti Uložit odkaz v kontextové nabídce. Tato omezení se nevztahují na uložení či stažení aktuálně zobrazené stránky ani na uložení do souboru PDF v možnostech tisku.

      Tato zásada je k dispozici jen v instancích systému Windows, které jsou připojené k doméně <ph name="MS_AD_NAME" />, nebo v instancích systému Windows 10 Pro nebo Enterprise, které jsou zaregistrované ke správě zařízení.</translation>
<translation id="1749815929501097806">Nastavuje smluvní podmínky, které musí uživatel přijmout před zahájením návštěvy prostřednictvím účtu v zařízení.

      Pokud je tato zásada nastavena, systém <ph name="PRODUCT_OS_NAME" /> stáhne při zahájení návštěvy prostřednictvím účtu v zařízení smluvní podmínky a zobrazí je uživateli. Uživatel bude moci pokračovat v relaci, pouze pokud tyto smluvní podmínky přijme.

      Není-li tato zásada nastavena, žádné smluvní podmínky se nezobrazí.

      Jako hodnotu této zásady zadejte adresu URL, ze které může systém <ph name="PRODUCT_OS_NAME" /> smluvní podmínky stáhnout. Smluvní podmínky musejí být uloženy ve formátu prostého textu s typem MIME „text/plain“. Nejsou povoleny žádné značky.</translation>
<translation id="1750315445671978749">Blokovat veškerá stahování</translation>
<translation id="1781356041596378058">Tato zásada také ovládá přístup k možnostem Pro vývojáře v systému Android. Pokud tuto zásadu nastavíte na hodnotu True, uživatelé nebudou mít přístup k sekci Pro vývojáře. Pokud tuto zásadu nastavíte na hodnotu False nebo ji nenastavíte, uživatelé budou moci možnosti Pro vývojáře otevřít tak, že v aplikaci Nastavení Android sedmkrát klepnou na číslo sestavení.</translation>
<translation id="1797233582739332495">Zobrazovat uživateli opakovaně výzvu s oznámením, že je vyžadován restart</translation>
<translation id="1798559516913615713">Doba platnosti mezipaměti GPO</translation>
<translation id="1803646570632580723">Seznam připnutých aplikací, které se zobrazují ve spouštěči</translation>
<translation id="1808715480127969042">Blokovat soubory cookie na těchto stránkách</translation>
<translation id="1810261428246410396">Povolit používání dynamického tetheringu</translation>
<translation id="1817685358399181673">Tato zásada určuje obrázek <ph name="PLUGIN_VM_NAME" /> pro uživatele. Zásada se nastavuje zadáním adresy URL, ze které zařízení obrázek může stáhnout, a hodnoty hash SHA-256 k ověření integrity staženého obsahu.

      Tuto zásadu je třeba zadat jako řetězec ve formátu JSON, který udává adresu URL a hodnotu hash.</translation>
<translation id="1827523283178827583">Použít pevně dané servery proxy</translation>
<translation id="1831495419375964631">Tato zásada je adresa URL souboru XML ve stejném formátu jako zásady <ph name="IEEM_SITELIST_POLICY" /> prohlížeče Internet Explorer. Pravidla ze souboru XML se načtou, aniž by se sdílela s prohlížečem Internet Explorer.

      Když je tato zásada ponechaná nenastavená nebo není nastavená na platnou adresu URL, prohlížeč <ph name="PRODUCT_NAME" /> ji jako zdroj pravidel pro přepínání prohlížečů nepoužívá.

      Když je tato zásada nastavená na platnou adresu URL, prohlížeč <ph name="PRODUCT_NAME" /> z ní stáhne seznam webů a použije pravidla, jako kdyby byla nakonfigurovaná pomocí zásady <ph name="SITELIST_POLICY_NAME" />.

      Další informace o zásadách <ph name="IEEM_SITELIST_POLICY" /> prohlížeče Internet Explorer: https://docs.microsoft.com/internet-explorer/ie11-deploy-guide/what-is-enterprise-mode</translation>
<translation id="1839060937202387559">Hlásí hardwarové statistiky a identifikátory pro úložná zařízení.

      Pokud je tato zásada nastavena na hodnotu false, statistiky nebudou hlášeny.
      Pokud je nastavena na hodnotu true nebo nastavena není, statistiky hlášeny budou.</translation>
<translation id="1843117931376765605">Obnovovací frekvence zásad pro uživatele</translation>
<translation id="1844620919405873871">Konfiguruje zásady související s rychlým odemknutím.</translation>
<translation id="1847960418907100918">Udává parametry, které se použijí při dynamickém vyhledávání pomocí metody POST. Sestává z párů název–hodnota oddělených čárkou. Pokud je hodnotou parametr šablony (např. {searchTerms} v příkladu výše), bude nahrazen skutečnými údaji vyhledávacích dotazů.

          Tato zásada je nepovinná. Pokud není nastavena, požadavek na dynamické vyhledávání bude odeslán pomocí metody GET.

          Tato zásada je respektována pouze v případě, že je aktivována zásada DefaultSearchProviderEnabled.</translation>
<translation id="1852294065645015766">Povolit automatické přehrávání médií</translation>
<translation id="1859859319036806634">Upozornění: Po verzi 52 (přibližně v září 2016) bude používání záložních nižších verzí TLS z prohlížeče <ph name="PRODUCT_NAME" /> odstraněno a tato zásada přestane fungovat.

      Pokud metoda handshake protokolu TLS selže, prohlížeč <ph name="PRODUCT_NAME" /> se pokusí o připojení znovu, ale jako dočasné řešení pro případ chyby serveru HTTPS použije nižší verzi protokolu TLS. Toto nastavení konfiguruje verzi, u které se tento záložní proces zastaví. Pokud server provede vyjednávání verze správně (tj. bez přerušení spojení), toto nastavení se nepoužije. Bez ohledu na toto nastavení musí výsledné připojení odpovídat také zásadě SSLVersionMin.

      Pokud tato zásada není nakonfigurována nebo je nastavena na hodnotu „tls1.2“, prohlížeč <ph name="PRODUCT_NAME" /> tento záložní postup neprovede. Tato zásada nedeaktivuje podporu starších verzí protokolu TLS, pouze určuje, zda se bude prohlížeč <ph name="PRODUCT_NAME" /> snažit řešit potíže s chybně fungujícími servery, které nedokážou správně vyjednávat verze.

      Pokud je třeba zajistit kompatibilitu s chybným serverem, lze nastavit hodnotu „tls1.1“. Jedná se však o nouzové řešení a server by měl být co nejrychleji opraven.</translation>
<translation id="1864269674877167562">Pokud tato zásada není nastavena nebo je nastavena na prázdný textový řetězec, <ph name="PRODUCT_OS_NAME" /> během procesu přihlášení nezobrazí možnost automatického doplňování.
      Pokud je tato zásada nastavena na textový řetězec, který představuje název domény, <ph name="PRODUCT_OS_NAME" /> během procesu přihlášení zobrazí možnost automatického doplňování a uživatel bude moci zadat pouze uživatelské jméno bez přípony s názvem domény. Příponu s názvem domény uživatel bude moci přepsat.</translation>
<translation id="1864382791685519617">Aktivuje v prohlížeči <ph name="PRODUCT_NAME" /> předvídání akcí sítě a brání uživatelům ve změně tohoto nastavení.

Tato zásada ovlivňuje předběžné načítání záznamů DNS, předběžná připojení TCP a SSL a předběžné vykreslování webových stránek.

Pokud tuto zásadu nastavíte, uživatelé ji v prohlížeči <ph name="PRODUCT_NAME" /> nebudou moci změnit ani přepsat.

Pokud tuto zásadu ponecháte nenastavenou, bude předvídání akcí sítě aktivováno, ale uživatelé nastavení budou moci změnit.</translation>
<translation id="1865417998205858223">Klíčová oprávnění</translation>
<translation id="186719019195685253">Akce, která bude provedena, pokud bude dosaženo limitu doby nečinnosti při provozu na síťové napájení</translation>
<translation id="187819629719252111">Umožňuje přistupovat k místním souborům v počítači tím, že aplikaci <ph name="PRODUCT_NAME" /> povolí, aby zobrazovala dialogová okna pro výběr souboru. 

      Pokud toto nastavení aktivujete, uživatelé budou moci otevírat dialogová okna pro výběr souboru obvyklým způsobem. 
      
      Pokud toto nastavení deaktivujete a uživatel provede akci, po které by se mu v obvyklém případě zobrazilo dialogové okno pro výběr souboru (například import záložek, nahrávání souborů, ukládání odkazů apod.), zobrazí se mu namísto tohoto dialogového okna zpráva a prohlížeč se zachová, jako kdyby uživatel v dialogovém okně pro výběr souboru kliknul na možnost Zrušit. 
      
      Pokud toto nastavení neupravíte, uživatelé budou moci otevírat dialogová okna pro výběr souboru obvyklým způsobem.</translation>
<translation id="1885782360784839335">Povolit zobrazování propagačního obsahu na celou kartu</translation>
<translation id="1888871729456797026">Token pro registraci zásad využití cloudu na počítači</translation>
<translation id="1897365952389968758">Povolit všem webům spouštět JavaScript</translation>
<translation id="1906888171268104594">Udává, zda se do Googlu hlásí metriky využití a diagnostická data včetně zpráv o selhání.

      Pokud je tato zásada nastavena na hodnotu true, bude systém <ph name="PRODUCT_OS_NAME" /> hlásit metriky využití a diagnostická data.

      Pokud je tato zásada nastavena na hodnotu false, bude hlášení metrik a diagnostických dat zakázáno.

      Pokud tato zásada není nakonfigurována, bude hlášení metrik a diagnostických dat na nespravovaných zařízeních zakázáno a na spravovaných zařízeních bude povoleno.</translation>
<translation id="1907431809333268751">Konfiguruje seznam podnikových přihlašovacích adres URL (pouze schémata HTTP a HTTPS). Na těchto adresách URL se bude pořizovat otisk hesla, který bude následně sloužit k detekci opětovného použití hesla.
      Aby prohlížeč <ph name="PRODUCT_NAME" /> mohl správně pořizovat otisky hesel, měly by přihlašovací stránky odpovídat pokynům na stránce https://www.chromium.org/developers/design-documents/create-amazing-password-forms.

      Pokud je toto nastavení zapnuté, bude služba pro ochranu hesel na těchto adresách URL pořizovat otisk hesla pro účely detekce jeho opětovného použití.
      Pokud je toto nastavení vypnuté nebo není zadané, bude služba pro ochranu hesel pořizovat otisk hesla pouze na adrese https://accounts.google.com.
      Tato zásada je k dispozici jen v instancích systému Windows, které jsou připojené k doméně <ph name="MS_AD_NAME" />, nebo v instancích systému Windows 10 Pro nebo Enterprise, které jsou zaregistrované ke správě zařízení.</translation>
<translation id="1920046221095339924">Povolit v zařízení spravovanou relaci</translation>
<translation id="1929709556673267855">Poskytuje konfigurace pro podnikové tiskárny svázané se zařízeními.

Tato zásada umožňuje poskytnout zařízením <ph name="PRODUCT_OS_NAME" /> konfigurace tiskáren. Má stejný formát jako slovník NativePrinters, ale obsahuje navíc povinné pole „id“ nebo „guid“ pro každou tiskárnu, která má být zařazena na seznam povolených nebo zakázaných.

Soubor nesmí být větší než 5 MB a musí být zakódován ve formátu JSON. Formát je stejný jako ve slovníku NativePrinters. Podle odhadů by se do souboru o velikosti 5 MB mělo vejít přibližně 21 000 tiskáren. Kryptografický hash se používá k ověření integrity staženého souboru.

Soubor se stáhne a uloží do mezipaměti. Při každé změně adresy URL nebo hodnoty hash se stáhne znovu.

Je-li tato zásada nastavena, stáhne <ph name="PRODUCT_OS_NAME" /> soubor s konfiguracemi tiskáren a zpřístupní tiskárny v souladu se zásadami <ph name="DEVICE_PRINTERS_ACCESS_MODE" />, <ph name="DEVICE_PRINTERS_WHITELIST" /> a <ph name="DEVICE_PRINTERS_BLACKLIST" />.

Tato zásada nemá vliv na to, zda uživatelé mohou konfigurovat tiskárny na jednotlivých zařízeních. Je zamýšlena jako doplněk ke konfiguraci tiskáren ze strany jednotlivých uživatelů.

Tato zásada doplňuje zásadu <ph name="BULK_PRINTERS_POLICY" />.

Pokud tato zásada není nastavena, nebude mít zařízení žádné tiskárny a ostatní zásady <ph name="DEVICE_PRINTERS_POLICY_PATTERN" /> budou ignorovány.
      </translation>
<translation id="193259052151668190">Seznam povolených odpojitelných zařízení USB</translation>
<translation id="1933378685401357864">Obrázek tapety</translation>
<translation id="1956493342242507974">Umožňuje konfigurovat na přihlašovací obrazovce systému <ph name="PRODUCT_OS_NAME" /> řízení spotřeby.

      Tato zásada umožňuje nakonfigurovat chování systému <ph name="PRODUCT_OS_NAME" /> v případech, kdy je zobrazena přihlašovací obrazovka a uživatel po určitou dobu neprovádí žádnou činnost. Tato zásada řídí několik nastavení. Jejich individuální sémantika a rozsahy hodnot se řídí odpovídajícími zásadami pro řízení spotřeby v rámci návštěvy. Oproti těmto zásadám platí u této zásady následující odlišnosti:
      * Akce, která bude provedena při nečinnosti nebo zavření krytu, nemůže být ukončení návštěvy.
      * Výchozí akce, která bude provedena při nečinnosti během provozu na síťové napájení, je vypnutí.

      Pokud některá možnost nebude nakonfigurována, použije se výchozí hodnota.

      Pokud tato zásada není nastavena, budou pro všechna nastavení použity výchozí hodnoty.</translation>
<translation id="1958138414749279167">Aktivuje v prohlížeči <ph name="PRODUCT_NAME" /> funkci Automatické vyplňování a umožňuje uživatelům automaticky ve webových formulářích vyplňovat adresní údaje s použitím dříve uložených dat.

      Pokud je toto nastavení vypnuto, automatické vyplňování nebude navrhovat ani vyplňovat adresní údaje a nebude ani ukládat další informace o adresách, které uživatel při prohlížení webu odešle.

      Pokud je toto nastavení zapnuto nebo nemá žádnou hodnotu, uživatel bude moci automatické vyplňování adres ovládat v uživatelském rozhraní.</translation>
<translation id="1960840544413786116">Udává, zda mají být povoleny certifikáty vydané místními kotvami vztahu důvěryhodnosti bez rozšíření subjectAlternativeName.</translation>
<translation id="1962273523772270623">Povolit shromažďování protokolů událostí WebRTC ze služeb Google</translation>
<translation id="1964634611280150550">Anonymní režim zakázán</translation>
<translation id="1964802606569741174">Tato zásada nemá vliv na aplikaci YouTube pro Android. Chcete-li na YouTube vynutit bezpečný režim, měli byste instalaci aplikace YouTube pro Android zakázat.</translation>
<translation id="1969212217917526199">Přepíše zásady u ladicích sestavení hostitele vzdáleného připojení.

Hodnota je analyzována jako slovník JSON s mapováním názvu zásady na hodnoty zásady.</translation>
<translation id="1969808853498848952">Vždy spustit pluginy, které vyžadují autorizaci (zastaralé)</translation>
<translation id="1988371335297483117">Datové části automatických aktualizací systému <ph name="PRODUCT_OS_NAME" /> lze namísto protokolu HTTPS stahovat prostřednictvím protokolu HTTP. To umožňuje transparentní ukládání souborů stahovaných pomocí protokolu HTTP do mezipaměti.

      Pokud tuto zásadu nastavíte na hodnotu true, systém <ph name="PRODUCT_OS_NAME" /> se bude pokoušet stahovat datové části automatických aktualizací prostřednictvím protokolu HTTP. Pokud tuto zásadu nastavíte na hodnotu false nebo ji nenastavíte, ke stahování datových částí automatických aktualizací se bude používat protokol HTTPS.</translation>
<translation id="199764499252435679">Povolit aktualizace komponent v prohlížeči <ph name="PRODUCT_NAME" /></translation>
<translation id="2006530844219044261">Správa možností napájení</translation>
<translation id="201557587962247231">Frekvence nahrávání hlášení o stavu zařízení</translation>
<translation id="2017301949684549118">Adresy URL webových aplikací, které mají být instalovány na pozadí.</translation>
<translation id="2018836497795982119">Určuje interval (v ms), ve kterém budou službě správy zařízení zasílány požadavky na informace o zásadách pro uživatele.

      Nastavení této zásady přepíše výchozí hodnotu 3 hodiny. Platné hodnoty pro tuto zásadu jsou v rozsahu od 1800000 (30 minut) do 86400000 (1 den). Místo hodnot mimo tento rozsah bude použita příslušná mezní hodnota. Pokud platforma podporuje oznámení o zásadách, bude interval aktualizací nastaven na 24 hodin, protože se očekává, že při změně zásad bude aktualizace vynucena automaticky prostřednictvím oznámení.

      Pokud tuto zásadu nenastavíte, použije <ph name="PRODUCT_NAME" /> výchozí hodnotu, což jsou 3 hodiny.

      Upozorňujeme, že pokud platforma podporuje oznámení o zásadách, budou všechna výchozí nastavení i hodnota této zásady ignorovány a interval aktualizací bude nastaven na 24 hodin. Očekává se totiž, že při změně zásad bude aktualizace vynucena automaticky prostřednictvím oznámení.</translation>
<translation id="2024476116966025075">Konfigurace povinného názvu domény pro klienty vzdáleného přístupu</translation>
<translation id="2030905906517501646">Klíčové slovo výchozího poskytovatele vyhledávání</translation>
<translation id="203096360153626918">Tato zásada nemá vliv na aplikace pro Android. Budou moci přejít do režimu celé obrazovky i v případě, že je tato zásada nastavena na hodnotu <ph name="FALSE" />.</translation>
<translation id="2043770014371753404">Zakázané podnikové tiskárny</translation>
<translation id="2057317273526988987">Povolit přístup k seznamu adres URL</translation>
<translation id="206623763829450685">Určuje, která schémata ověření v protokolu HTTP bude prohlížeč <ph name="PRODUCT_NAME" /> podporovat.

          Zadat můžete hodnoty „basic“, „digest“, „ntlm“ a „negotiate“. Chcete-li zadat více hodnot, oddělte je čárkami.

          Pokud tuto zásadu nenastavíte, budou se používat všechna čtyři schémata.</translation>
<translation id="2067011586099792101">Blokování přístupu k webům mimo obsahové balíčky</translation>
<translation id="2073552873076775140">Povolit přihlášení do prohlížeče <ph name="PRODUCT_NAME" /></translation>
<translation id="2077129598763517140">V případě dostupnosti použít hardwarovou akceleraci</translation>
<translation id="2077273864382355561">Prodleva vypnutí obrazovky při napájení z baterie</translation>
<translation id="2082205219176343977">Konfigurace minimální povolené verze Chromu v zařízení.</translation>
<translation id="209586405398070749">Stabilní verze</translation>
<translation id="2098658257603918882">Aktivovat odesílání dat o využití nebo selhání</translation>
<translation id="2104418465060359056">Hlášení informací o rozšířeních a pluginech</translation>
<translation id="2107601598727098402">
        Podpora této zásady je ve verzi M72 ukončena. Použijte namísto ní zásadu CloudManagementEnrollmentToken.
        </translation>
<translation id="2111016292707172233">Aktivuje dostupnost Vyhledání klepnutím v zobrazení obsahu prohlížeče <ph name="PRODUCT_NAME" />.

Pokud toto nastavení aktivujete, Vyhledání klepnutím bude pro uživatele dostupné (uživatel jej bude moci zapnout nebo vypnout).

Pokud toto nastavení deaktivujete, Vyhledání klepnutím bude zcela vypnuté.

Pokud zásadu nenastavíte, bude se považovat za aktivované (viz popis výše).</translation>
<translation id="2113068765175018713">Omezit provozní dobu zařízení automatickým restartováním</translation>
<translation id="2116790137063002724">Tato zásada určuje, zda se mají hlásit informace, pomocí kterých lze identifikovat uživatele, jako jsou například přihlašovací údaje operačního systému, přihlašovací údaje profilu <ph name="PRODUCT_NAME" />, název profilu <ph name="PRODUCT_NAME" />, cesta profilu <ph name="PRODUCT_NAME" /> a cesta ke spustitelnému souboru <ph name="PRODUCT_NAME" />.

      Když je tato zásada ponechána nenastavená nebo je nastavena na hodnotu True, informace, pomocí nichž lze identifikovat uživatele, se shromažďují.
      Když je tato zásada nastavena na hodnotu False, informace, pomocí nichž lze identifikovat uživatele, se neshromažďují.

      Tato zásada je účinná, když je zapnuto rozšíření <ph name="CHROME_REPORTING_EXTENSION_NAME" /> a počítač je zaregistrován pomocí tokenu <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="2127599828444728326">Povolit na těchto stránkách oznámení</translation>
<translation id="2131902621292742709">Prodleva snížení jasu obrazovky při napájení z baterie</translation>
<translation id="2132732175597591362">Určuje seznam povolených vzorů adres URL, na nichž bude vždy povoleno automatické přehrávání.

      Pokud je povoleno automatické přehrávání, mohou se videa v prohlížeči <ph name="PRODUCT_NAME" /> přehrávat automaticky (bez souhlasu uživatele), včetně zvuku.

      Vzor adres URL musí být naformátován podle pokynů na stránce https://www.chromium.org/administrators/url-blacklist-filter-format.

      Je-li zásada AutoplayAllowed nastavena na hodnotu True, nemá tato zásada žádný účinek.

      Je-li zásada AutoplayAllowed nastavena na hodnotu False, u všech vzorů adres URL nastavených v této zásadě bude přehrávání přesto povoleno.

      Pokud je prohlížeč <ph name="PRODUCT_NAME" /> spuštěn a tato zásada se změní, použije se nové nastavení pouze na nově otevřené karty. Některé karty proto mohou nadále vykazovat předchozí chování.</translation>
<translation id="2134437727173969994">Povolit uzamknutí obrazovky</translation>
<translation id="2137064848866899664">Pokud je tato zásada nastavena, každý displej se při prvním připojení po změně hodnoty zásady a při každém restartu otočí do požadované orientace. Uživatelé mohou otočení displeje po přihlášení na stránce nastavení změnit, ale při příštím restartu se jejich nastavení hodnotou zásady přepíše.

Tato zásada platí pro primární i pro všechny sekundární displeje.

Pokud tato zásada není nastavena, použije se výchozí hodnota 0 a uživatel ji bude moci změnit. V tomto případě se nastavení uživatele při restartu nepřepíše.</translation>
<translation id="214901426630414675">Omezit oboustranný režim tisku</translation>
<translation id="2149330464730004005">Povolit barevný tisk</translation>
<translation id="2156132677421487971">Konfiguruje zásady pro <ph name="PRODUCT_NAME" />, což je funkce, která uživatelům umožňuje odesílat obsah karet, webů nebo plochy z počítače na vzdálené obrazovky a do vzdálených zvukových systémů.</translation>
<translation id="2166472654199325139">Nefiltrovat weby s obsahem pouze pro dospělé</translation>
<translation id="2168397434410358693">Prodleva nečinnosti při napájení ze sítě</translation>
<translation id="2170233653554726857">Povolení optimalizace WPAD</translation>
<translation id="2176565653304920879">Když je tato zásada nastavena, automatické zjištění časového pásma bude v závislosti na hodnotě nastavení probíhat jedním z následujících způsobů:

      Je-li tato zásada nastavena na možnost TimezoneAutomaticDetectionUsersDecide, uživatelé budou moci automatické zjišťování časového pásma ovládat pomocí běžných ovládacích prvků na stránce chrome://settings.

      Je-li tato zásada nastavena na možnost TimezoneAutomaticDetectionDisabled, ovládací prvky automatického zjišťování časového pásma na stránce chrome://settings budou deaktivovány. Automatické zjišťování časového pásma bude vždy vypnuto.

      Je-li tato zásada nastavena na možnost TimezoneAutomaticDetectionIPOnly, ovládací prvky časových pásem na stránce chrome://settings budou deaktivovány. Automatické zjišťování časového pásma bude vždy zapnuto. Poloha se za účelem zjištění časového pásma bude určovat pouze podle IP adresy.

      Je-li tato zásada nastavena na možnost TimezoneAutomaticDetectionSendWiFiAccessPoints, ovládací prvky časových pásem na stránce chrome://settings budou deaktivovány. Automatické zjišťování časového pásma bude vždy zapnuto. Za účelem přesného určení časového pásma se vždy odešle seznam viditelných přístupových bodů Wi-Fi na server Geolocation API.

      Je-li tato zásada nastavena na možnost TimezoneAutomaticDetectionSendAllLocationInfo, ovládací prvky časových pásem na stránce chrome://settings budou deaktivovány. Automatické zjišťování časového pásma bude vždy zapnuto. Údaje o poloze (jako jsou přístupové body Wi-Fi, dostupné vysílače mobilní sítě a informace ze systému GPS) budou za účelem přesného určení časového pásma odeslány na server.

      Pokud tato zásada není nastavena, bude se chovat, jako by byla nastavena na možnost TimezoneAutomaticDetectionUsersDecide.

      Pokud je nastavena zásada SystemTimezone, má před touto zásadou přednost. V tomto případě je automatické zjišťování časového pásma zcela vypnuto.</translation>
<translation id="2178899310296064282">Vynutit na YouTube alespoň střední nastavení omezeného režimu</translation>
<translation id="2182291258410176649">O aktivaci zálohování a obnovení rozhoduje uživatel</translation>
<translation id="2183294522275408937">Toto nastavení udává, jak často bude na obrazovce uzamčení vyžadováno zadání hesla, aby bylo možné i nadále používat rychlé odemknutí. Při každém vstupu na obrazovku uzamčení se zkontroluje, jaká doba uplynula od posledního zadání hesla. Pokud uplynula delší doba než udává toto nastavení, funkce rychlého odemknutí nebude k dispozici. Pokud uživatel na obrazovce uzamčení zůstane a tato doba bude překročena, bude uživatel o heslo požádán, buď až zadá nesprávný kód, nebo až znovu přejde na obrazovku uzamčení (podle toho, co nastane dříve).

      Je-li toto nastavení nakonfigurováno, uživatelé, kteří používají rychlé odemknutí, budou muset na obrazovce uzamčení zadávat heslo podle tohoto nastavení.

      Pokud toto nastavení není nakonfigurováno, uživatelé, kteří používají rychlé odemknutí, budou na obrazovce uzamčení muset zadávat heslo každý den.</translation>
<translation id="2194470398825717446">Podpora této zásady byla ve verzi M61 ukončena. Použijte namísto ní zásadu EcryptfsMigrationStrategy.

Určuje, jak se má chovat zařízení dodané s šifrováním ecryptfs, které potřebuje přejít na šifrování ext4.

Pokud tuto zásadu nastavíte na hodnotu DisallowArc, budou aplikace pro Android u všech uživatelů zařízení zakázány (včetně uživatelů, kteří již šifrování ext4 mají) a žádným uživatelům nebude nabídnuta migrace ze šifrování ecryptfs na ext4.

Pokud tuto zásadu nastavíte na hodnotu AllowMigration, uživatelům s domovskými adresáři šifrovanými pomocí ecryptfs bude podle potřeby nabízena migrace adresářů na šifrování ext4 (momentálně ve chvíli, kdy v zařízení bude dostupný systém Android N).

Tato zásada se netýká terminálových aplikací – ty jsou migrovány automaticky. Pokud tato zásada nebude nastavena, bude se zařízení chovat, jako kdyby byla vybrána hodnota DisallowArc.</translation>
<translation id="2195032660890227692">Tato zásada byla ve verzi 68 prohlížeče <ph name="PRODUCT_NAME" /> odstraněna a nahrazena zásadou <ph name="ARC_BR_POLICY_NAME" />.</translation>
<translation id="2201555246697292490">Konfigurace seznamu povolených hostitelů zasílání nativních zpráv</translation>
<translation id="2204753382813641270">Řídit automatické skrývání poličky</translation>
<translation id="2208976000652006649">Parametry adresy URL vyhledávání používající metodu POST</translation>
<translation id="2214880135980649323">Když je tato zásada povolena, rozšíření nainstalovaná podnikovými zásadami mohou používat rozhraní Enterprise Hardware Platform API.
Pokud zásada povolena není nebo není nastavena, rozšíření uvedené rozhraní API používat nemohou.
Zásada platí také pro rozšíření komponent, jako je rozšíření Hangout Services.</translation>
<translation id="2223598546285729819">Výchozí nastavení oznámení</translation>
<translation id="2231817271680715693">Importování historie procházení z výchozího prohlížeče při prvním spuštění</translation>
<translation id="2236488539271255289">Nepovolovat nastavení místních dat žádným webům</translation>
<translation id="2240879329269430151">Umožňuje nastavit, zda mohou webové stránky zobrazovat vyskakovací okna. Zobrazování vyskakovacích oken lze buď povolit pro všechny weby, nebo je pro všechny weby zakázat.

          Není-li zásada nastavena, bude použita zásada BlockPopups a uživatelé ji budou moci změnit.</translation>
<translation id="2269319728625047531">Zapnout zobrazení souhlasu se synchronizací při přihlašování</translation>
<translation id="2274864612594831715">Tato zásada konfiguruje aktivaci virtuální klávesnice jako vstupního zařízení v systému Chrome OS. Tuto zásadu nemohou uživatelé přepsat.

          Pokud je zásada nastavena na hodnotu True, bude softwarová virtuální klávesnice vždy povolena.

      Pokud je nastavena na hodnotu False, bude softwarová virtuální klávesnice vždy zakázána.

      Pokud tuto zásadu nastavíte, uživatelé ji nebudou moci změnit ani přepsat. Uživatelé však nadále budou moci povolit a zakázat softwarovou klávesnici usnadnění, která má přednost před virtuální klávesnicí ovládanou touto zásadou. Ovládání softwarové klávesnice usnadnění naleznete pod zásadou |VirtualKeyboardEnabled|.

      Pokud tuto zásadu ponecháte nenastavenou, softwarová klávesnice bude ve výchozím nastavení zakázána, ale uživatelé ji budou moci kdykoli povolit. O zobrazování klávesnice může být rozhodováno rovněž na základě heuristických pravidel.</translation>
<translation id="228659285074633994">Určuje dobu bez zásahu uživatele, po které se při napájení zařízení ze sítě zobrazí okno s upozorněním.

          Pokud je zásada nastavena, určuje dobu nečinnosti uživatele, po jejímž uplynutí systém <ph name="PRODUCT_OS_NAME" /> zobrazí okno s upozorněním, že bude provedena akce z důvodu nečinnosti.

          Pokud zásada není nastavena, okno s upozorněním se nezobrazí.

          Hodnota zásady by měla být stanovena v milisekundách. Hodnoty musí být menší nebo stejné jako prodleva nečinnosti.</translation>
<translation id="2292084646366244343"><ph name="PRODUCT_NAME" /> může k opravení pravopisných chyb použít webovou službu společnosti Google. Je-li toto nastavení zapnuto, služba je používána neustále. Je-li nastavení vypnuto, služba není používána nikdy.

      Kontrolu pravopisu lze nicméně provést pomocí staženého slovníku. Tato zásada se vztahuje pouze na používání internetových služeb.

      Pokud toto nastavení není nakonfigurováno, uživatelé mohou zvolit, zda službu pro kontrolu pravopisu chtějí použít či nikoli.</translation>
<translation id="2294382669900758280">Přehrávání videí v aplikacích Android není bráno v potaz ani v případě, že je tato zásada nastavena na hodnotu <ph name="TRUE" />.</translation>
<translation id="2298647742290373702">Konfiguruje výchozí stránku Nová karta v prohlížeči <ph name="PRODUCT_NAME" />.</translation>
<translation id="2299220924812062390">Zadat seznam aktivovaných pluginů</translation>
<translation id="2303795211377219696">Povolit automatické vyplňování pro platební karty</translation>
<translation id="2309390639296060546">Výchozí nastavení geolokace</translation>
<translation id="2312134445771258233">Umožňuje konfigurovat stránky, které se načtou při spuštění.

      Pokud jste v části „Akce při spuštění“ nezvolili možnost „Otevřít seznam adres URL“, budou položky v seznamu „Adresy URL otevírané při spuštění“ ignorovány.</translation>
<translation id="2327252517317514801">Definování domén, kterým je povolen přístup ke službám G Suite</translation>
<translation id="237494535617297575">Umožňuje nastavit seznam vzorů adres URL webových stránek, které mají povoleno nastavovat upozornění.

          Pokud zásadu nenastavíte, použije se pro všechny webové stránky globální výchozí hodnota buď ze zásady DefaultNotificationsSetting (pokud je nastavena), nebo z osobního nastavení uživatele.</translation>
<translation id="2386362615870139244">Povolit uzamčení obrazovky při probuzení</translation>
<translation id="2411817661175306360">Ochrana hesla – upozornění je vypnuté</translation>
<translation id="2411919772666155530">Blokovat upozornění na těchto stránkách</translation>
<translation id="2418507228189425036">Deaktivuje ukládání historie procházení v prohlížeči <ph name="PRODUCT_NAME" /> a brání uživatelům, aby toto nastavení změnili.

Pokud je toto nastavení deaktivováno, historie procházení nebude ukládána. Toto nastavení také deaktivuje synchronizaci karet.

Pokud je toto nastavení deaktivováno nebo není nakonfigurováno, historie procházení bude ukládána.</translation>
<translation id="2426782419955104525">Aktivuje v prohlížeči <ph name="PRODUCT_NAME" /> funkci Dynamický režim a brání uživatelům ve změně tohoto nastavení.

Pokud toto nastavení aktivujete, bude Dynamický režim prohlížeče <ph name="PRODUCT_NAME" /> aktivní.

Pokud toto nastavení deaktivujete, bude Dynamický režim prohlížeče <ph name="PRODUCT_NAME" /> deaktivován.

Pokud tuto zásadu aktivujete nebo deaktivujete, uživatelé je nebudou moci změnit ani přepsat.

Pokud toto nastavení ponecháte nenastavené, uživatelé se budou moci rozhodnout, zda tuto funkci chtějí používat.

Z prohlížeče <ph name="PRODUCT_NAME" /> verze 29 a novějších verzí bylo toto nastavení odebráno.</translation>
<translation id="2433412232489478893">Tato zásada určuje, zda má uživatel v prohlížeči <ph name="PRODUCT_NAME" /> povolenou funkci sdílených síťových složek.

      Pokud tato zásada není nakonfigurována nebo je nastavena na hodnotu True, uživatelé sdílené síťové složky budou moci používat.

      Pokud je tato zásada nastavena na hodnotu False, uživatelé sdílené síťové složky nebudou moci používat.</translation>
<translation id="2438609638493026652">Umožňuje hlášení zásadních událostí během instalace aplikací pro Android do Googlu. Události se zaznamenávají pouze pro aplikace, jejichž instalace byla spuštěna prostřednictvím zásady.

      Pokud je tato zásada nastavena na hodnotu true, budou se události protokolovat.
      Pokud je tato zásada nastavena na hodnotu false nebo není nastavena, události se protokolovat nebudou.</translation>
<translation id="244317009688098048">Bude aktivována nouzová klávesová zkratka pro automatické přihlašování.

      Pokud tato zásada není nastavena nebo má hodnotu True a místní účet v zařízení je nakonfigurován na automatické přihlašování s nulovou prodlevou, systém <ph name="PRODUCT_OS_NAME" /> bude sledovat klávesovou zkratku Ctrl+Alt+S, pomocí které bude možné obejít automatické přihlášení a zobrazit přihlašovací obrazovku.

      Pokud má tato zásada hodnotu False, automatické přihlašování s nulovou prodlevou (je-li nastaveno) nelze obejít.</translation>
<translation id="2463365186486772703">Jazyk aplikace</translation>
<translation id="2466131534462628618">Ověření captive portálu ignoruje proxy server</translation>
<translation id="2482676533225429905">Zasílání nativních zpráv</translation>
<translation id="2483146640187052324">Předvídat síťové akce u všech síťových připojení</translation>
<translation id="2484208301968418871">Tato zásada ovládá použití filtru SafeSites pro adresy URL.
      Tento filtr pomocí rozhraní Google Safe Search API klasifikuje adresy URL, zda mají pornografický charakter.

      Když tato zásada není nakonfigurována nebo je nastavena na možnost „Nefiltrovat weby s obsahem pouze pro dospělé“, weby se nefiltrují.

      Když je tato zásada nastavená na možnost „Filtrovat weby nejvyšší úrovně s obsahem pouze pro dospělé“, weby klasifikované jako pornografické budou odfiltrovány.</translation>
<translation id="2486371469462493753">Deaktivuje vynucování požadavků zásad Certificate Transparency pro uvedené adresy URL.

      Tato zásada povolí použití certifikátů pro názvy hostitelů v uvedených adresách URL bez zveřejnění prostřednictvím Certificate Transparency. Bude tak možné používat certifikáty, které by jinak byly považovány za nedůvěryhodné, protože nebyly zveřejněny. Bude však obtížnější odhalit zneužití certifikátů těchto hostitelů.

      Vzor adres URL musí být naformátován podle pokynů na stránce https://www.chromium.org/administrators/url-blacklist-filter-format. Protože jsou však certifikáty pro určitý název hostitele platné bez ohledu na schéma, port nebo cestu, uvažuje se z adresy URL pouze část s názvem hostitele. V názvu hostitele nejsou podporovány zástupné znaky.

      Pokud tato zásada není nastavena, každý certifikát, u kterého je vyžadováno zveřejnění prostřednictvím Certificate Transparency, ale který není zveřejněn v souladu se zásadou Certificate Transparency, bude považován za nedůvěryhodný.</translation>
<translation id="2488010520405124654">Povolit zobrazení výzvy ke konfiguraci sítě v režimu offline.

      Pokud tato zásada není nastavena nebo je nastavena na hodnotu Pravda, v zařízení je nakonfigurován místní účet s automatickým přihlašováním bez prodlevy a zařízení není připojeno k internetu, zobrazí systém <ph name="PRODUCT_OS_NAME" /> výzvu ke konfiguraci sítě.

      Pokud je tato zásada nastavena na hodnotu Nepravda, namísto výzvy ke konfiguraci sítě se zobrazí chybová zpráva.</translation>
<translation id="2498238926436517902">Vždy poličku automaticky skrýt</translation>
<translation id="2514328368635166290">Určuje adresu URL ikony výchozího poskytovatele vyhledávání.

          Zásada je nepovinná. Pokud není nastavena, nezobrazí se žádná ikona poskytovatele vyhledávání.

          Zásada bude dodržována pouze v případě, že je aktivní zásada DefaultSearchProviderEnabled.</translation>
<translation id="2516600974234263142">Aktivuje tisk v prohlížeči <ph name="PRODUCT_NAME" /> a zabrání uživatelům toto nastavení změnit.

      Pokud je toto nastavení aktivní nebo není nakonfigurované, uživatelé mohou tisknout.

      Pokud je toto nastavení deaktivované, uživatelé nemohou tisknout z prohlížeče <ph name="PRODUCT_NAME" />. Tisk je deaktivován v nabídce Nástroje, rozšířeních, aplikacích JavaScript apod. I nadále lze tisknout pomocí pluginů, které při tisku prohlížeč <ph name="PRODUCT_NAME" /> obcházejí. Kontextová nabídka některých aplikací Flash například obsahuje možnost tisku, na kterou se tato zásada nevztahuje.</translation>
<translation id="2518231489509538392">Povolit přehrávání zvuku</translation>
<translation id="2521581787935130926">Zobrazovat na liště záložek zástupce aplikací</translation>
<translation id="2529659024053332711">Umožňuje nastavit možnosti spouštění.

          Pokud vyberete možnost Otevřít stránku Nová karta, otevře se při spuštění prohlížeče <ph name="PRODUCT_NAME" /> stránka Nová karta.

Pokud vyberete možnost Obnovit poslední relaci, otevřou se adresy URL, které byly otevřené při posledním ukončení prohlížeče <ph name="PRODUCT_NAME" />, a návštěvy prohlížeče se obnoví ve stavu, v jakém jste ji opustili.
          Výběrem této možnosti deaktivujete některá nastavení, která jsou závislá na relacích nebo provádějí akce při zavření prohlížeče (například smazání údajů o prohlížení při ukončení nebo omezení souborů cookie pouze na relaci).

          Pokud vyberete možnost Otevřít seznam adres, otevřou se při spuštění prohlížeče <ph name="PRODUCT_NAME" /> adresy uvedené v seznamu Adresy URL otevírané při spuštění.

Pokud toto nastavení aktivujete, uživatelé ho v prohlížeči <ph name="PRODUCT_NAME" /> nemohou změnit ani přepsat.

Pokud toto nastavení deaktivujete, je to stejné, jako kdybyste ho nenastavili. Uživatelé ho v prohlížeči <ph name="PRODUCT_NAME" /> budou moci změnit.

          Tato zásada je k dispozici jen v instancích systému Windows, které jsou připojené k doméně <ph name="MS_AD_NAME" />, nebo v instancích systému Windows 10 Pro nebo Enterprise, které jsou zaregistrované ke správě zařízení.</translation>
<translation id="2529880111512635313">Konfigurace seznamu aplikací a rozšíření, jejichž instalace je vynucena</translation>
<translation id="253135976343875019">Prodleva upozornění na nečinnost při napájení ze sítě</translation>
<translation id="2536525645274582300">O povolení služeb určování polohy Google rozhoduje uživatel</translation>
<translation id="254653220329944566">Aktivuje cloudové hlášení prohlížeče <ph name="PRODUCT_NAME" /></translation>
<translation id="2548572254685798999">Hlášení informací Bezpečného prohlížení</translation>
<translation id="2550593661567988768">Pouze jednostranný tisk</translation>
<translation id="2552966063069741410">Časové pásmo</translation>
<translation id="2562339630163277285">Určuje adresu URL vyhledávače, který bude použit k získání výsledků dynamického vyhledávání. Adresa URL by měla obsahovat řetězec <ph name="SEARCH_TERM_MARKER" />. Tento řetězec bude během dotazování nahrazen textem, který do daného okamžiku zadal uživatel.

          Tato zásada je volitelná. Pokud ji nenastavíte, výsledky dynamického vyhledávání se nebudou zobrazovat.

          Adresu URL Googlu pro výsledky dynamického vyhledávání lze zadat takto: <ph name="GOOGLE_INSTANT_SEARCH_URL" />.

          Tato zásada je respektována pouze v případě, že je aktivována zásada DefaultSearchProviderEnabled.</translation>
<translation id="2569647487017692047">Pokud je tato zásada nastavena na hodnotu False, systém <ph name="PRODUCT_OS_NAME" /> zakáže rozhraní Bluetooth a uživatel jej nebude moci povolit.

      Pokud je tato zásada nastavena na hodnotu True nebo je ponechána nenastavená, uživatel bude moci rozhraní Bluetooth povolit či zakázat dle svého uvážení.

      Pokud je tato zásada nastavena, uživatel ji nemůže změnit ani přepsat.

      Když Bluetooth povolujete, změny se projeví až poté, co se uživatel odhlásí a znovu přihlásí (když Bluetooth zakazujete, toto není potřeba).</translation>
<translation id="2571066091915960923">Aktivuje nebo deaktivuje datovou kompresi na proxy serveru a zabrání uživatelům toto nastavení změnit.

      Pokud tuto zásadu aktivujete nebo deaktivujete, uživatelé je nebudou moci změnit ani přepsat.

      Pokud zásadu nenastavíte, bude na uživatelích, aby zvolili, zda funkci datové komprese proxy serveru chtějí nebo nechtějí použít.</translation>
<translation id="2587719089023392205">Nastavit <ph name="PRODUCT_NAME" /> jako výchozí prohlížeč</translation>
<translation id="2592091433672667839">Doba nečinnosti před zobrazením spořiče obrazovky na přihlašovací obrazovce v režimu pro obchody</translation>
<translation id="2596260130957832043">Udává, zda je povolen protokol NTLMv2.

          Všechny verze serverů Samba a Windows z poslední doby protokol NTLMv2 podporují. Jeho zakázání snižuje bezpečnost ověřování a měli byste k němu přistupovat jen v případě, že potřebujete zajistit zpětnou kompatibilitu.

          Pokud tato zásada není nastavena, použije se výchozí nastavení true a protokol NTLMv2 bude povolen.</translation>
<translation id="2604182581880595781">Konfigurace zásad souvisejících se sdílenými síťovými složkami.</translation>
<translation id="2623014935069176671">Počkat na první aktivitu uživatele</translation>
<translation id="262740370354162807">Povolí odesílání dokumentů do služby <ph name="CLOUD_PRINT_NAME" /></translation>
<translation id="2627554163382448569">Poskytuje konfigurace pro podnikové tiskárny.
 
Tato zásada umožňuje poskytnout zařízením <ph name="PRODUCT_OS_NAME" /> konfigurace tiskáren. Má stejný formát jako slovník NativePrinters, ale obsahuje navíc povinné pole „id“ nebo „guid“ pro každou tiskárnu, která má být zařazena na seznam povolených nebo zakázaných.

Soubor nesmí být větší než 5 MB a musí být zakódován ve formátu JSON. Podle odhadů by se do souboru o velikosti 5 MB mělo vejít přibližně 21 000 tiskáren. Kryptografický hash se používá k ověření integrity staženého souboru.

Soubor se stáhne a uloží do mezipaměti. Při každé změně adresy URL nebo hodnoty hash se stáhne znovu.
 
Je-li tato zásada nastavena, stáhne <ph name="PRODUCT_OS_NAME" /> soubor s konfiguracemi tiskáren a zpřístupní tiskárny v souladu se zásadami <ph name="BULK_PRINTERS_ACCESS_MODE" />, <ph name="BULK_PRINTERS_WHITELIST" /> a <ph name="BULK_PRINTERS_BLACKLIST" />.
Pokud tuto zásadu nastavíte, uživatelé ji nebudou moci změnit ani přepsat.

Tato zásada nemá vliv na to, zda uživatelé mohou konfigurovat tiskárny na jednotlivých zařízeních. Je zamýšlena jako doplněk ke konfiguraci tiskáren ze strany jednotlivých uživatelů.
      </translation>
<translation id="2633084400146331575">Aktivovat hlasovou odezvu</translation>
<translation id="2646290749315461919">Umožňuje nastavit, zda mohou webové stránky sledovat fyzickou polohu uživatele. Sledování fyzické polohy uživatelů lze nakonfigurovat tak, že bude ve výchozím nastavení povoleno nebo zakázáno. Také lze nastavit, že se při každém pokusu webových stránek o sledování fyzické polohy uživateli zobrazí výzva.

         Není-li zásada nastavena, bude použita zásada AskGeolocation a uživatel ji bude moci změnit.</translation>
<translation id="2647069081229792812">Povolit nebo zakázat úpravy záložek</translation>
<translation id="2650049181907741121">Akce při zavření víka</translation>
<translation id="2655233147335439767">Určuje adresu URL vyhledávače, který bude použit při výchozím vyhledávání. Adresa URL by měla obsahovat řetězec <ph name="SEARCH_TERM_MARKER" />, který bude během dotazování nahrazen vyhledávacími dotazy uživatele.

          Adresu URL Googlu pro vyhledávání lze zadat takto: <ph name="GOOGLE_SEARCH_URL" />.

          Tato možnost bude respektována, pouze pokud je aktivována zásada DefaultSearchProviderEnabled, a v tomto případě musí být nastavena.</translation>
<translation id="2659019163577049044">Je-li toto nastavení aktivováno, uživatelé budou moci ve svých zařízeních nastavit synchronizaci zpráv SMS mezi telefonem a Chromebookem. Upozorňujeme, že pokud je tato zásada povolena, uživatelé se k této funkci musejí výslovně přihlásit dokončením procesu nastavení. Po dokončení nastavení budou moci uživatelé odesílat a přijímat zprávy SMS v Chromebooku.

      Je-li toto nastavení deaktivováno, uživatelé nebudou moci nastavit synchronizaci SMS.

      Pokud tato zásada není nastavena, ve výchozím nastavení je pro spravované uživatele zakázána a pro nespravované uživatele povolena.</translation>
<translation id="2660846099862559570">Nikdy nepoužívat proxy server</translation>
<translation id="2663739737868438950">
      Tato zásada platí pro přihlašovací obrazovku. Prostudujte si také zásadu <ph name="SITE_PER_PROCESS_POLICY_NAME" />, která platí pro uživatelskou relaci. Obě zásady doporučujeme nastavit na stejnou hodnotu. Pokud se hodnoty neshodují, může při zahajování uživatelské návštěvy dojít ke zpoždění způsobenému používáním hodnoty zadané v zásadě pro uživatele.
      Chcete-li využívat izolaci, ale omezit její dopad na uživatele, použijte zásadu IsolateOrigins se seznamem webů, které chcete izolovat. Toto nastavení SitePerProcess izoluje všechny weby.
      Pokud tuto zásadu povolíte, bude se každý web spouštět ve vlastním procesu.
      Pokud tuto zásadu zakážete, budou zakázány zásady IsolateOrigins a SitePerProcess. Zásadu SitePerProcess však uživatelé budou moci povolit ručně pomocí příznaků příkazového řádku.
      Pokud tuto zásadu nenakonfigurujete, uživatel toto nastavení bude moci změnit.
      </translation>
<translation id="2672012807430078509">Ovládací prvky, které povolují protokol NTLM jako ověřovací protokol pro připojená úložiště SMB</translation>
<translation id="267596348720209223">Určuje kódování znaků podporovaná poskytovatelem vyhledávání. Kódování jsou názvy stránek kódů, například UTF-8, GB2312 nebo ISO-8859-1. Budou vyzkoušena v uvedeném pořadí.

          Tato zásada je nepovinná. Pokud není nastavena, použije se výchozí kódování UTF-8.

          Zásada bude dodržována pouze v případě, že je aktivní zásada DefaultSearchProviderEnabled.</translation>
<translation id="268577405881275241">Aktivace funkce datové komprese proxy serveru</translation>
<translation id="2693108589792503178">Konfiguruje adresu URL pro změnu hesla.</translation>
<translation id="2731627323327011390">Zakázat aplikacím ARC používání certifikátů systému <ph name="PRODUCT_OS_NAME" /></translation>
<translation id="2742843273354638707">Skryje ze stránky Nová karta a ze spouštěče aplikací systému <ph name="PRODUCT_OS_NAME" /> aplikaci Internetový obchod Chrome a odkaz na zápatí.

Je-li zásada nastavena na hodnotu True, budou ikony skryty.

Pokud je zásada nastavena na hodnotu False nebo nastavena není, budou ikony viditelné.</translation>
<translation id="2744751866269053547">Registrace obslužných nástrojů protokolů</translation>
<translation id="2746016768603629042">Podpora této zásady bude ukončena, používejte prosím zásadu DefaultJavaScriptSetting.

      Pomocí této zásady lze v prohlížeči <ph name="PRODUCT_NAME" /> zakázat jazyk JavaScript.

      Pokud je toto nastavení deaktivováno, webové stránky nemohou spouštět kód JavaScript a uživatel nemůže toto nastavení změnit.

      Pokud je toto nastavení aktivováno nebo není nastaveno na konkrétní hodnotu, webové stránky mohou spouštět kód JavaScript, ale uživatel může toto nastavení změnit.</translation>
<translation id="2753637905605932878">Omezit rozsah místních portů UDP používaných rozhraním WebRTC</translation>
<translation id="2755385841634849932">Tato zásada ovládá dostupnost zálohování a obnovení Android.

      Když tato zásada není nakonfigurována nebo je nastavena na možnost <ph name="BR_DISABLED" />, je zálohování a obnovení systému Android deaktivováno a uživatel ho nemůže aktivovat.

      Když je tato zásada nastavena na možnost <ph name="BR_UNDER_USER_CONTROL" />, bude uživatel dotázán, zda chce zálohování a obnovení systému Android používat. Pokud uživatel zálohování a obnovení zapne, budou se data aplikací Android nahrávat na zálohovací servery Android a při opětovné instalaci se z nich obnoví.</translation>
<translation id="2757054304033424106">Typy rozšíření nebo aplikací, které mohou být nainstalovány</translation>
<translation id="2759224876420453487">Řízení chování uživatele v multiprofilové relaci</translation>
<translation id="2761483219396643566">Prodleva upozornění na nečinnost při napájení z baterie</translation>
<translation id="2762164719979766599">Určuje seznam místních účtů v zařízení, které se zobrazují na přihlašovací obrazovce.

      Každá položka v seznamu uvádí identifikátor, který se používá k internímu rozlišení různých místních účtů v zařízení.</translation>
<translation id="2769952903507981510">Konfigurovat povinný název domény pro hostitele vzdáleného přístupu</translation>
<translation id="2787173078141616821">Hlásit informace o stavu systému Android</translation>
<translation id="2799297758492717491">Povolit automatické přehrávání médií zahrnutých v seznamu vzorů povolených adres URL</translation>
<translation id="2801230735743888564">Povolit uživatelům hrát hru s dinosaurem, když je zařízení offline.

      Je-li tato zásada nastavena na hodnotu False, uživatelé nemohou hrát hru s dinosaurem, když je zařízení offline. Pokud je tato zásada nastavena na hodnotu True, uživatelé hru s dinosaurem hrát mohou. Pokud tato zásada není nastavena, v zaregistrovaném systému Chrome OS uživatelé hru s dinosaurem hrát nemohou, ale za všech jiných okolností ji hrát mohou.</translation>
<translation id="2802085784857530815">Umožňuje ovládat, zda mají uživatelé přístup k jiným než podnikovým tiskárnám.

      Pokud je tato zásada nastavena na hodnotu True nebo není nastavena, budou uživatelé moci přidat a nakonfigurovat své vlastní nativní tiskárny a tisknout na nich.

      Je-li tato zásada nastavena na hodnotu False, uživatelé nebudou moci přidat a nakonfigurovat své vlastní nativní tiskárny. Nebudou moci ani tisknout na dříve nakonfigurovaných nativních tiskárnách.
      </translation>
<translation id="2805707493867224476">Povolit všem webům zobrazovat vyskakovací okna</translation>
<translation id="2808013382476173118">Povolí použití synchronizačních serverů a serverů STUN, když se vzdálení klienti pokouší připojit k tomuto počítači.

          Pokud je toto nastavení aktivováno, mohou vzdálení klienti tento počítač objevit a připojit se k němu i v případě, že jsou odděleni bránou firewall.

          Pokud je toto nastavení deaktivováno a odchozí připojení UDP jsou filtrována bránou firewall, lze se k tomuto počítači připojit pouze z klientských počítačů v místní síti.

          Pokud tato zásada není nastavena, bude nastavení aktivováno.</translation>
<translation id="2813281962735757923">Tato zásada určuje časové rámce, v nichž zařízení se systémem <ph name="PRODUCT_OS_NAME" /> nemá povoleno automaticky kontrolovat dostupnost aktualizací.
      Když je tato zásada nastavená na neprázdný seznam časových intervalů:
      Zařízení během zadaných časových intervalů nebudou moci automaticky kontrolovat dostupnost aktualizací. Tato zásada vzhledem k možným bezpečnostním problémům nebude mít vliv na zařízení, která vyžadují vrácení na starší verzi nebo v nichž je nižší než minimální verze systému <ph name="PRODUCT_OS_NAME" />. Nebude také blokovat kontroly dostupnosti aktualizací, o které požádají uživatelé nebo administrátoři.
      Když tato zásada není nastavená nebo neobsahuje žádné časové intervaly:
      Tato zásada nebude blokovat automatické kontroly dostupnosti aktualizací, mohou je však blokovat jiné zásady. Tato funkce je aktivovaná jen na zařízeních Chrome, která jsou nakonfigurována jako automaticky spouštěné terminály. Ostatní zařízení touto zásadou omezena nebudou.</translation>
<translation id="2823870601012066791">Umístění v registru systému Windows pro klienty <ph name="PRODUCT_OS_NAME" />:</translation>
<translation id="2824715612115726353">Povolit anonymní režim</translation>
<translation id="2838830882081735096">Zakázat migraci dat a rozšíření ARC</translation>
<translation id="2839294585867804686">Nastavení sdílených síťových složek</translation>
<translation id="2840269525054388612">Určuje, které tiskárny uživatel může používat.

Tato zásada se použije, jen pokud je v zásadě <ph name="PRINTERS_WHITELIST" /> vybrána možnost <ph name="DEVICE_PRINTERS_ACCESS_MODE" />.

Je-li tato zásada použita, bude mít uživatel k dispozici pouze tiskárny, jejichž ID se shodují s hodnotami v této zásadě. ID musejí odpovídat polím „id“ a „guid“ v souboru, který je uveden v zásadě <ph name="DEVICE_PRINTERS_POLICY" />.
      </translation>
<translation id="285480231336205327">Aktivovat vysoce kontrastní režim</translation>
<translation id="2854919890879212089">Způsobí, že bude <ph name="PRODUCT_NAME" /> v Náhledu tisku jako výchozí výběr používat výchozí tiskárnu systému (namísto naposledy použité tiskárny).

      Pokud toto nastavení zakážete nebo nenastavíte žádnou hodnotu, bude Náhled tisku jako výchozí cíl používat naposledy použitou tiskárnu.

      Pokud aktivujete toto nastavení, bude Náhled tisku jako výchozí cíl používat výchozí tiskárnu systému.</translation>
<translation id="2856674246949497058">Pokud je verze operačního systému novější než cílová verze, vrátit se zpět k cílové verzi a zachovat ji. Během tohoto procesu spustit Powerwash.</translation>
<translation id="2872961005593481000">Vypnout</translation>
<translation id="2873651257716068683">Přepíše výchozí velikost stránky tisku. Pokud velikost stránky není k dispozici, zásada bude ignorována.</translation>
<translation id="2874209944580848064">Poznámka ohledně zařízení se systémem <ph name="PRODUCT_OS_NAME" />, která podporují aplikace pro Android:</translation>
<translation id="2877225735001246144">Deaktivovat vyhledání záznamů CNAME při vyjednávání ověření protokolu Kerberos</translation>
<translation id="2890645751406497668">Automaticky těmto webům udělit oprávnění připojit se k zařízením USB daného dodavatele s danými ID produktu.</translation>
<translation id="2892414556511568464">Omezí oboustranný režim tisku. Pokud zásada nebude nastavena nebo bude nastavena jako prázdná, bude to považováno za žádné omezení.</translation>
<translation id="2893546967669465276">Odesílat systémové protokoly na server správy</translation>
<translation id="2899002520262095963">Aplikace Android mohou používat konfigurace sítě a certifikáty CA nastavené pomocí této zásady, ale nemají přístup k některým možnostem konfigurace.</translation>
<translation id="290002216614278247">Umožňuje uzamknout relaci uživatele na základě času klienta nebo denní kvóty použití.

          Údaj |time_window_limit| udává denní časové okno, v němž by návštěvy uživatele měla být uzamknuta. Pro každý den v týdnu podporujeme jen jedno pravidlo, pole |entries| proto může obsahovat 0 až 7 prvků. |starts_at| a |ends_at| jsou začátek a konec časového okna. Když je hodnota |ends_at| menší než |starts_at|, znamená to, že časové okno |time_limit_window| končí následující den. |last_updated_millis| je časové razítko UTC poslední aktualizace tohoto záznamu. Odesílá se jako textový řetězec, protože do celočíselné hodnoty by se časové razítko nevešlo.

          Údaj |time_usage_limit| udává denní kvótu použití zařízení. Po jejím dosažení se návštěvy uživatele uzamkne. Je k dispozici vlastnost pro každý den v týdnu, která by měla být nastavena jen v případě, že pro daný den existuje aktivní kvóta. |usage_quota_mins| udává, jak dlouho je spravované zařízení během dne možné používat, a |reset_at| udává, kdy se kvóta použití obnoví. Výchozí hodnotou |reset_at| je půlnoc ({'hour': 0, 'minute': 0}). |last_updated_millis| je časové razítko UTC poslední aktualizace tohoto záznamu. Odesílá se jako textový řetězec, protože do celočíselné hodnoty by se časové razítko nevešlo.

          |overrides| umožňuje dočasně deaktivovat jedno nebo více předchozích pravidel.
          * Pokud není aktivní time_window_limit ani time_usage_limit, je možné zařízení zamknout pomocí hodnoty |LOCK|.
          * |LOCK| uživatelskou relaci dočasně uzamkne do začátku příštího období time_window_limit nebo time_usage_limit.
          * |UNLOCK| odemkne uživatelskou relaci uzamknutou pomocí údaje time_window_limit nebo time_usage_limit.
          |created_time_millis| je časové razítko UTC vytvoření přepisu. Odesílá se jako textový řetězec, protože do celočíselné hodnoty by se časové razítko nevešlo. Používá se ke zjištění, zda se tento přepis má nadále používat. Pokud aktuálně aktivní funkce časového omezení (limit doby používání nebo časové okno) začala platit po vytvoření přepisu, neměl by se přepis projevit. Přepis by se neměl použít ani v případě, že byl vytvořen před poslední změnou aktivních hodnot time_window_limit nebo time_usage_window.

          Přepisů lze odeslat několik. Použije se nejnovější platná položka.</translation>
<translation id="2905984450136807296">Doba platnosti mezipaměti ověřovacích údajů</translation>
<translation id="2906874737073861391">Seznam rozšíření AppPack</translation>
<translation id="2907992746861405243">Určuje, které tiskárny ze zásady <ph name="BULK_PRINTERS_POLICY" /> budou uživatelům dostupné.

      Stanovuje, která zásada přístupu se použije pro hromadnou konfiguraci tiskáren. Je-li vybrána možnost <ph name="PRINTERS_ALLOW_ALL" />, budou zobrazeny všechny tiskárny. Je-li vybrána možnost <ph name="PRINTERS_BLACKLIST" />, bude zakázán přístup k tiskárnám uvedeným v zásadě <ph name="BULK_PRINTERS_BLACKLIST" />. Je-li vybrána možnost <ph name="PRINTERS_WHITELIST" />, bude možné vybrat pouze tiskárny uvedené v zásadě <ph name="BULK_PRINTERS_WHITELIST" />.

      Pokud tato zásada není nastavena, předpokládá se použití možnosti <ph name="PRINTERS_ALLOW_ALL" />.
      </translation>
<translation id="2908277604670530363">Maximální počet současných připojení k proxy serveru</translation>
<translation id="2952347049958405264">Omezení:</translation>
<translation id="2956777931324644324">Podpora této zásady byla ve verzi 36 prohlížeče <ph name="PRODUCT_NAME" /> ukončena.

      Určuje, zda má být povoleno rozšíření certifikátů svázaných s doménami.

      Toto nastavení se používá k aktivaci rozšíření certifikátů TLS svázaných s doménami pro účely testování. Toto experimentální nastavení bude v budoucnu odebráno.</translation>
<translation id="2957506574938329824">Nedovolit žádnému webu požadovat přístup k zařízením Bluetooth pomocí rozhraní Web Bluetooth API</translation>
<translation id="2957513448235202597">Typ účtu pro ověření protokolu <ph name="HTTP_NEGOTIATE" /></translation>
<translation id="2959898425599642200">Pravidla vynechání proxy serveru</translation>
<translation id="2960128438010718932">Plán zavádění nové aktualizace po etapách</translation>
<translation id="2960691910306063964">Aktivovat nebo deaktivovat ověřování bez kódu PIN u hostitelů vzdáleného přístupu</translation>
<translation id="2976002782221275500">Udává dobu nečinnosti uživatele, po které bude při napájení z baterie snížen jas obrazovky.

          Pokud je tato zásada nastavena hodnotu větší než nula, jedná se o dobu, po kterou musí uživatel zůstat v nečinnosti, než systém <ph name="PRODUCT_OS_NAME" /> sníží jas obrazovku.

          Pokud je tato zásada nastavena na nulovou hodnotu, systém <ph name="PRODUCT_OS_NAME" /> jas obrazovky při nečinnosti uživatele nesníží.

          Není-li tato zásada nastavena, bude použita výchozí doba.

          Hodnotu zásady zadávejte v milisekundách. Maximální hodnota je stejná jako prodleva vypnutí obrazovky (pokud je nastavena) a prodleva režimu spánku.</translation>
<translation id="2987155890997901449">Povolit rozšíření ARC</translation>
<translation id="2987227569419001736">Ovládat používání rozhraní Web Bluetooth API</translation>
<translation id="3016255526521614822">Seznam povolených aplikací k přidávání poznámek na obrazovku uzamčení v systému <ph name="PRODUCT_OS_NAME" /></translation>
<translation id="3021562480854470924">Počet povolených milníků pro vrácení zpět (rollback)</translation>
<translation id="3023572080620427845">Adresa URL souboru XML, v němž jsou uvedeny adresy URL, které se mají načítat v alternativním prohlížeči.</translation>
<translation id="3030000825273123558">Povolit hlášení o metrikách</translation>
<translation id="3034580675120919256">Umožňuje nastavit, zda mohou webové stránky spouštět JavaScript. Spouštění JavaScriptu lze buď povolit pro všechny weby, nebo naopak pro všechny weby zakázat.

         Pokud zásadu nenastavíte, použije se zásada AllowJavaScript a uživatelé ji budou moci změnit.</translation>
<translation id="3038323923255997294">Po ukončení prohlížeče <ph name="PRODUCT_NAME" /> nechat aplikace na pozadí spuštěné</translation>
<translation id="3046192273793919231">Odesílat na server správy síťové pakety ke sledování stavu online</translation>
<translation id="3047732214002457234">Určuje, jak nástroj Chrome Cleanup hlásí data do Googlu</translation>
<translation id="304775240152542058">Tato zásada určuje parametry příkazového řádku, které se mají použít při spouštění alternativního prohlížeče.

      Když je tato zásada ponechána nenastavená, pomocí parametrů příkazového řádku se předává pouze adresa URL.

      Když je tato zásada nastavená na seznam řetězců, každý řetězec se do alternativního prohlížeče předá jako samostatný parametr příkazového řádku. V systému Windows jsou jednotlivé parametry odděleny mezerami. V systémech Mac OS X a Linux může parametr obsahovat mezery a přesto být považován za jeden parametr.

      Pokud prvek obsahuje hodnotu ${url}, nahradí se adresou URL stránky, která se má otevřít.

      Pokud žádný prvek hodnotu ${url} neobsahuje, přidá se adresa URL na konec příkazového řádku.

      Proměnné prostředí se nahradí hodnotami. V systému Windows se zástupný symbol %ABC% nahradí hodnotou proměnné prostředí ABC. V systémech Mac OS X a Linux, se zástupný symbol ${ABC} nahradí hodnotou proměnné prostředí ABC.</translation>
<translation id="3048744057455266684">Pokud je tato zásada nastavena a adresa URL pro vyhledávání navržená v omniboxu obsahuje tento parametr v řetězci dotazu nebo v identifikátoru fragmentu, jako návrh budou namísto samotné adresy URL zobrazeny vyhledávací dotazy a poskytovatel vyhledávání.

          Tato zásada je volitelná. Pokud není nastavena, nebudou prováděna žádná nahrazení vyhledávacích dotazů.

          Tato zásada je zohledňována pouze v případě, že je aktivována zásada DefaultSearchProviderEnabled.</translation>
<translation id="306887062252197004">Tato zásada povoluje uživatelům funkce WebDriver přepsat zásady, které by mohly narušovat operace této funkce.

V současné době tato zásada deaktivuje zásady SitePerProcess a IsolateOrigins.

Pokud je tato zásada povolena, funkce WebDriver bude moci přepsat nekompatibilní zásady.
Pokud je tato zásada zakázána nebo není nakonfigurována, funkce WebDriver nebude moci přepsat nekompatibilní zásady.</translation>
<translation id="3069958900488014740">Umožňuje vypnout v prohlížeči <ph name="PRODUCT_NAME" /> optimalizaci WPAD (Web Proxy Auto-Discovery).

      Je-li tato zásada nastavena na hodnotu false, je optimalizace WPAD zakázána, a <ph name="PRODUCT_NAME" /> proto bude na servery WPAD založené na DNS čekat déle. Pokud tato zásada není nastavena, je optimalizace WPAD povolena.

      Nezávisle na tom, zda je tato zásada nastavena nebo jak je nastavena, uživatelé nastavení optimalizace WPAD nemohou změnit.</translation>
<translation id="3072045631333522102">Spořič obrazovky, který bude použit na přihlašovací obrazovce v režimu pro obchody</translation>
<translation id="3072847235228302527">Nastavit smluvní podmínky pro účet v zařízení</translation>
<translation id="3077183141551274418">Povolí nebo zakáže životní cykly karet</translation>
<translation id="3086995894968271156">Nakonfigurujte přijímač Cast ve službě <ph name="PRODUCT_NAME" />.</translation>
<translation id="3088796212846734853">Umožňuje nastavit seznam vzorů adres URL webových stránek, které mají povoleno zobrazovat obrázky.

          Pokud tuto zásadu nenastavíte, použije se pro všechny webové stránky globální výchozí hodnota buď ze zásady DefaultImageSetting (pokud je nastavena), nebo z osobního nastavení uživatele.

          Dříve tato zásada byla omylem k dispozici na zařízeních Android, ale tato funkce v systému Android nikdy nebyla plně podporována.</translation>
<translation id="3096595567015595053">Seznam aktivovaných pluginů</translation>
<translation id="3101501961102569744">Zvolit způsob konfigurace nastavení proxy serveru</translation>
<translation id="3101709781009526431">Datum a čas</translation>
<translation id="3117676313396757089">Upozornění: Po verzi 57 (přibližně v březnu 2017) bude šifrovací algoritmus DHE z prohlížeče <ph name="PRODUCT_NAME" /> zcela odstraněn a tato zásada přestane fungovat.

      Pokud tato zásada není nastavena nebo je nastavena na hodnotu false, v protokolu TLS nebudou povoleny šifrovací sady DHE. Nastavením této zásady na hodnotu true je možné šifrovací sady DHE povolit a zajistit tak kompatibilitu se zastaralým serverem. Toto nastavení by však mělo být použito pouze jako dočasné nouzové opatření a server by měl být překonfigurován.

      Doporučujeme migrovat servery na šifrovací sady ECDHE. Pokud nejsou k dispozici, měla by být aktivována šifrovací sada s výměnou klíčů RSA.</translation>
<translation id="3117706142826400449">Pokud je tato zásada deaktivovaná, zakazuje nástroji Chrome Cleanup vyhledávat v systému nežádoucí software a čistit jej. Ruční spuštění nástroje Chrome Cleanup ze stránky chrome://settings/cleanup je zakázáno.

      Pokud je tato zásada aktivovaná nebo není nastavená, bude Chrome Cleanup v systému pravidelně vyhledávat nežádoucí software, a pokud nějaký najde, zeptá se uživatele, zda jej chce odstranit. Ruční spuštění nástroje Chrome Cleanup ze stránky chrome://settings je povoleno.

      Tato zásada je k dispozici jen v instancích systému Windows, které jsou připojené k doméně <ph name="MS_AD_NAME" />, nebo v instancích systému Windows 10 Pro nebo Enterprise, které jsou zaregistrované ke správě zařízení.</translation>
<translation id="3165808775394012744">Tyto zásady zde jsou zahrnuty, aby je bylo možné snadno odstranit.</translation>
<translation id="316778957754360075">V prohlížečích <ph name="PRODUCT_NAME" /> verze 29 a novějších bylo toto nastavení zrušeno. Doporučený způsob, jak nastavit sbírky rozšíření nebo aplikací hostovaných organizací, je zahrnout web hostující balíčky CRX do seznamu ExtensionInstallSources a na webovou stránku umístit přímé odkazy pro stažení balíčků. Spouštěč pro danou webovou stránku lze vytvořit pomocí zásady ExtensionInstallForcelist.</translation>
<translation id="3171369832001535378">Šablona názvu hostitelské sítě zařízení</translation>
<translation id="3185009703220253572">od verze <ph name="SINCE_VERSION" /></translation>
<translation id="3187220842205194486">Aplikace Android k podnikovým klíčům nemají přístup. Tato zásada na ně nemá vliv.</translation>
<translation id="3201273385265130876">Umožňuje zadat proxy server, který bude prohlížeč <ph name="PRODUCT_NAME" /> používat, a brání uživatelům ve změně nastavení proxy serveru.

          Pokud zvolíte, že proxy server nikdy používat nechcete a chcete se vždy připojovat přímo, všechny další možnosti budou ignorovány. 

          Pokud zvolíte, že chcete použít systémové nastavení proxy serveru, všechny další možnosti budou ignorovány.

          Pokud zvolíte, že chcete nastavení proxy serveru zjistit automaticky, všechny další možnosti budou ignorovány.

          Pokud zvolíte režim proxy s pevně daným serverem, můžete v zásadách „Adresa (nebo adresa URL) proxy serveru“ a „Seznam pravidel vynechání proxy serveru oddělených čárkami“ zadat další možnosti. Aplikacím ARC je k dispozici pouze proxy server HTTP s nejvyšší prioritou.

          Pokud zvolíte, že chcete používat skript .pac proxy serveru, musíte v zásadě Adresa URL souboru PAC proxy serveru zadat adresu URL skriptu.

          Podrobné příklady naleznete na následující stránce:
          <ph name="PROXY_HELP_URL" />.

          Pokud aktivujete toto nastavení, prohlížeč <ph name="PRODUCT_NAME" /> a aplikace ARC budou ignorovat veškeré možnosti související s proxy serverem zadané na příkazovém řádku.

          Pokud tato zásada nebude nastavena, uživatelé budou moci nastavení proxy serveru zvolit sami.</translation>
<translation id="3205825995289802549">Při prvním spuštění maximalizovat první okno prohlížeče</translation>
<translation id="3211426942294667684">Nastavení přihlášení do prohlížeče</translation>
<translation id="3214164532079860003">Je-li tato zásada aktivovaná, vynucuje import domovské stránky z aktuálního výchozího prohlížeče.

     Je-li deaktivovaná, k importu domovské stránky nedojde.

     Není-li nastavena, může se uživatelům zobrazit výzva, zda chtějí domovskou stránku importovat, nebo může import probíhat automaticky.</translation>
<translation id="3219421230122020860">Anonymní režim dostupný</translation>
<translation id="3220624000494482595">Je-li terminálová aplikace aplikace Android, nebude mít nad verzí systému <ph name="PRODUCT_OS_NAME" /> kontrolu ani v případě, že je tato zásada nastavena na hodnotu <ph name="TRUE" />.</translation>
<translation id="3236046242843493070">Vzory adres URL, ze kterých je možné instalovat rozšíření, aplikace a uživatelské skripty</translation>
<translation id="3240609035816615922">Zásada přístupu ke konfiguraci tiskáren.</translation>
<translation id="3243309373265599239">Udává dobu nečinnosti uživatele, po které bude při napájení ze sítě snížen jas obrazovky.

          Pokud je tato zásada nastavena hodnotu větší než nula, jedná se o dobu, po kterou musí uživatel zůstat v nečinnosti, než systém <ph name="PRODUCT_OS_NAME" /> sníží jas obrazovku.

          Pokud je tato zásada nastavena na nulovou hodnotu, systém <ph name="PRODUCT_OS_NAME" /> jas obrazovky při nečinnosti uživatele nesníží.

          Není-li tato zásada nastavena, bude použita výchozí doba.

          Hodnotu zásady zadávejte v milisekundách. Maximální hodnota je stejná jako prodleva vypnutí obrazovky (pokud je nastavena) a prodleva režimu spánku.</translation>
<translation id="3251500716404598358">Konfiguruje zásady přepínání mezi prohlížeči.

      Nakonfigurované weby se automaticky otevřou v jiném prohlížeči než <ph name="PRODUCT_NAME" />.</translation>
<translation id="3264793472749429012">Kódování výchozího poskytovatele vyhledávání</translation>
<translation id="3273221114520206906">Výchozí nastavení JavaScriptu</translation>
<translation id="3284094172359247914">Ovládat používání rozhraní WebUSB API</translation>
<translation id="3288595667065905535">Kanál verzí</translation>
<translation id="3292147213643666827">Umožňuje prohlížeči <ph name="PRODUCT_NAME" /> fungovat jako proxy server mezi službou <ph name="CLOUD_PRINT_NAME" /> a staršími tiskárnami připojenými k počítači.

      Pokud je toto nastavení aktivované nebo není nakonfigurované, mohou uživatelé proxy server pro tisk z cloudu aktivovat ověřením pomocí účtu Google.

      Pokud je toto nastavení deaktivováno, uživatelé proxy server nebudou moci aktivovat a počítač nebude moci sdílet připojené tiskárny se službou <ph name="CLOUD_PRINT_NAME" />.</translation>
<translation id="3307746730474515290">Určuje, jaké typy aplikací nebo rozšíření lze instalovat, a omezuje přístup k běhovému prostředí.

          Toto nastavení uvádí seznam povolených rozšíření nebo aplikací, které lze nainstalovat do prohlížeče <ph name="PRODUCT_NAME" />, a hostitelů, se kterými mohou komunikovat. Hodnota představuje seznam řetězců. Musí se jednat o řetězce z následujícího výčtu: extension, theme, user_script, hosted_app, legacy_packaged_app, platform_app. Další informace o těchto typech naleznete v dokumentaci k rozšířením prohlížeče <ph name="PRODUCT_NAME" />.

          Tato zásada se vztahuje i na rozšíření a aplikace, jejichž instalace je vynucena prostřednictvím zásady ExtensionInstallForcelist.

          Pokud je toto nastavení nakonfigurováno, typy rozšíření a aplikací, které nejsou na seznamu uvedeny, nebudou nainstalovány.

          Pokud je toto nastavení ponecháno nenakonfigurované, žádná omezení týkající se přijatelných typů rozšíření a aplikací vynucována nebudou.</translation>
<translation id="3322771899429619102">Umožňuje nastavit seznam vzorů adres URL webových stránek, které mají povoleno generovat klíče. Vzory adres URL uvedené v zásadě KeygenBlockedForUrls tyto výjimky přepíšou.

Pokud tuto zásadu nenastavíte, použije se pro všechny webové stránky globální výchozí hodnota buď ze zásady DefaultKeygenSetting (pokud je nastavena), nebo z osobního nastavení uživatele.</translation>
<translation id="332771718998993005">Určuje název uváděný jako cíl služby <ph name="PRODUCT_NAME" />.

          Je-li tato zásada nastavena na neprázdný řetězec, bude jako název cíle služby <ph name="PRODUCT_NAME" /> použit příslušný řetězec. V opačném případě bude jako název cíle použit název zařízení. Pokud tato zásada není nastavena, bude jako název cíle použit název zařízení a vlastník zařízení (nebo uživatel z domény, která zařízení spravuje) jej bude moci změnit. Název smí mít maximálně 24 znaků.</translation>
<translation id="3335468714959531450">Umožňuje nastavit seznam vzorů adres URL webových stránek, které mohou nastavovat soubory cookie.

          Pokud tuto zásadu nenastavíte, použije se pro všechny webové stránky globální výchozí hodnota buď ze zásady DefaultCookiesSetting (pokud je nastavena), nebo z osobního nastavení uživatele.

          Podívejte se také na zásady CookiesBlockedForUrls a CookiesSessionOnlyForUrls. Vzory adres URL v těchto třech zásadách navzájem nesmějí být v konfliktu – není dáno, která zásada má přednost.</translation>
<translation id="3373364525435227558">Nastavuje jedno nebo více doporučených národních prostředí pro spravovanou relaci, což uživatelům usnadňuje výběr některého z nich.

Před zahájením spravované návštěvy může uživatel zvolit národní prostředí a rozložení klávesnice. Ve výchozím nastavení jsou všechna národní prostředí podporovaná systémem <ph name="PRODUCT_OS_NAME" /> uvedena v abecedním pořadí. Pomocí této zásady můžete přesunout sadu doporučených národních prostředí na začátek seznamu.

Pokud tuto zásadu ponecháte nenastavenou, bude předvybráno aktuální národní prostředí uživatelského rozhraní.

Pokud je tato zásada nastavena, budou doporučená národní prostředí přesunuta na začátek seznamu a vizuálně odlišena od ostatních. Doporučená národní prostředí budou uvedena v pořadí, ve kterém jsou uvedena v nastavení zásady. První doporučené národní prostředí bude předvybráno.

Pokud nastavíte více než jedno doporučené národní prostředí, předpokládá se, že si z nich uživatel bude chtít vybrat. Při zahájení spravované návštěvy bude uživateli výrazným způsobem nabídnuta možnost výběru. Jinak se předpokládá, že většina uživatelů bude chtít použít předvybrané národní prostředí. V takovém případě bude uživateli při zahájení spravované návštěvy výběr národního prostředí a rozložení nabídnut méně výrazným způsobem.

Pokud je tato zásada nastavena a je aktivováno automatické přihlašování (viz zásady |DeviceLocalAccountAutoLoginId| a |DeviceLocalAccountAutoLoginDelay|), automaticky zahájená spravovaná návštěvy použije první doporučené národní prostředí a nejoblíbenější rozložení klávesnice, které mu odpovídá.

Jako předvybrané rozložení klávesnice se vždy použije nejoblíbenější rozložení odpovídajících předvybranému národnímu prostředí.

Tuto zásadu lze nastavit pouze jako doporučenou. Zásada slouží k přesunutí několika doporučených národních prostředí na začátek seznamu. Uživatelé však pro svou relaci mohou vždy zvolit kterékoliv z národních prostředí, která systém <ph name="PRODUCT_OS_NAME" /> podporuje.
      </translation>
<translation id="3381968327636295719">Používat ve výchozím nastavení hostitelský prohlížeč</translation>
<translation id="3388153794103186066">Umožňuje nastavit seznam adres URL určujících, kterým webům bude automaticky uděleno oprávnění k přístupu k zařízení USB od určitého dodavatele s určitými ID produktu. Aby zásada byla platná, musí každá položka v seznamu obsahovat jak zařízení, tak adresy URL. Každá položka zařízení může obsahovat pole ID dodavatele a ID produktu. Chybějící ID je považováno za zástupný znak. ID produktu však nesmí být zadáno bez ID dodavatele, jinak zásada nebude platná.

        Model oprávnění USB k udělení přístupu k zařízení USB žádajícímu webu používá adresu URL žádajícího webu („žádající adresa URL“) a adresu URL webu v rámci nejvyšší úrovně („adresa URL hlavního rámce“). Pokud je žádající web načten v prvku iframe, může se žádající adresa URL od adresy URL hlavního rámce lišit. Pole „urls“ proto může obsahovat až dva řetězce URL oddělené čárkou, které určují žádající adresu URL a adresu URL hlavního rámce. Pokud je zadána jen jedna adresa URL, bude přístup k příslušným zařízením USB udělen, když adresa URL žádajícího webu odpovídá této adrese URL, bez ohledu na stav vložení. Adresy URL v poli „urls“ musejí být platné, jinak tato zásada bude ignorována.

        Pokud tuto zásadu nenastavíte, použije se pro všechny webové stránky globální výchozí hodnota buď ze zásady DefaultWebUsbGuardSetting (pokud je nastavena), nebo z osobního nastavení uživatele.

        Vzory adres URL v této zásadě by neměly být v konfliktu se vzory nakonfigurovanými prostřednictvím zásady WebUsbBlockedForUrls. V případě konfliktu bude mít tato zásada před zásadami WebUsbBlockedForUrls a WebUsbAskForUrls přednost.</translation>
<translation id="3414260318408232239">Pokud tato zásada není nakonfigurovaná, používá <ph name="PRODUCT_NAME" /> výchozí minimální verzi, což je TLS 1.0.

      Jinak lze zásadu nastavit na jednu z těchto hodnot: tls1, tls1.1 nebo tls1.2. Je-li nastavena, nebude <ph name="PRODUCT_NAME" /> používat verze protokolů SSL a TLS nižší, než je uvedená verze. Nerozpoznané hodnoty budou ignorovány.</translation>
<translation id="3417418267404583991">Pokud je tato zásada nastavena na hodnotu True nebo není nastavena, povolí systém <ph name="PRODUCT_OS_NAME" /> přihlášení hosta. Přihlášení hosta jsou anonymní uživatelské návštěvy a nevyžadují heslo.

      Je-li tato zásada nastavena na hodnotu False, systém <ph name="PRODUCT_OS_NAME" /> spuštění relací hosta nepovolí.</translation>
<translation id="3418871497193485241">Vynutí minimální nastavení omezeného režimu na YouTube a znemožní uživatelům vybrat méně omezený režim.

      Je-li tato zásada nastavena na hodnotu Přísný, bude na YouTube vždy aktivní přísný omezený režim.

      Je-li tato zásada nastavena na hodnotu Střední, uživatel na YouTube bude moci vybrat pouze střední nebo přísný omezený režim, ale nebude moci omezený režim deaktivovat.

      Pokud je tato zásada nastavena na hodnotu Vypnuto nebo není nastavena žádná hodnota, prohlížeč <ph name="PRODUCT_NAME" /> na YouTube omezený režim vynucovat nebude. Omezený režim však může být vynucován externími zásadami, například zásadami služby YouTube.</translation>
<translation id="3428247105888806363">Aktivovat předvídání akcí sítě</translation>
<translation id="3437924696598384725">Povolit uživateli spravovat připojení VPN</translation>
<translation id="3449886121729668969">Konfiguruje nastavení proxy serveru pro prohlížeč <ph name="PRODUCT_NAME" />. Tato nastavení proxy serveru budou k dispozici i aplikacím ARC.

      Tato zásada zatím není připravena k použití. Nepoužívejte ji prosím.</translation>
<translation id="3459509316159669723">Tisk</translation>
<translation id="3460784402832014830">Určuje adresu URL, kterou výchozí vyhledávač použije na stránce nové karty.

          Tato zásada je nepovinná. Pokud ji nenastavíte, žádná stránka nové karty se nezobrazí.

          Tato zásada je respektována pouze v případě, že je aktivována zásada DefaultSearchProviderEnabled.</translation>
<translation id="3461279434465463233">Hlásit stav napájení</translation>
<translation id="346731943813722404">Určuje, zda mají prodlevy systému správy napájení a limit délky relací začít běžet až poté, co je v relaci zaznamenána první aktivita uživatele.

          Pokud je tato zásada nastavena na hodnotu True, prodlevy systému správy napájení a limit délky návštěvy začnou běžet až poté, co je v relaci zaznamenána první aktivita uživatele.

          Pokud je tato zásada nastavena na hodnotu False nebo je ponechána nenastavená, prodlevy správy obsahu a limit délky návštěvy začnou běžet ihned po zahájení návštěvy.</translation>
<translation id="3478024346823118645">Při odhlášení smazat uživatelská data</translation>
<translation id="348495353354674884">Aktivovat virtuální klávesnici</translation>
<translation id="3487623755010328395">
        Pokud je tato zásada nastavena, pokusí se <ph name="PRODUCT_NAME" /> zaregistrovat a použít pro všechny profily přidružené zásady použití cloudu.

        Hodnotou této zásady je registrační token, který lze získat v administrátorské konzoli Google.</translation>
<translation id="3496296378755072552">Správce hesel</translation>
<translation id="3500732098526756068">Umožňuje ovládat spouštění upozornění ohledně ochrany hesla. Upozornění ohledně ochrany hesla se uživatelům zobrazí, pokud své chráněné heslo použijí na potenciálně podezřelých webech.

      Pomocí zásad PasswordProtectionLoginURLs a PasswordProtectionChangePasswordURL můžete nakonfigurovat, která hesla mají být chráněna.

      Pokud tuto zásadu nastavíte na hodnotu PasswordProtectionWarningOff, upozornění ohledně ochrany hesla se zobrazovat nebude.
      Pokud tuto zásadu nastavíte na hodnotu PasswordProtectionWarningOnPasswordReuse, zobrazí se upozornění ohledně ochrany hesla, když uživatel použije chráněné heslo na webu, který není uveden na seznamu povolených.
      Pokud tuto zásadu nastavíte na hodnotu PasswordProtectionWarningOnPhishingReuse, zobrazí se upozornění ohledně ochrany hesla, když uživatel použije chráněné heslo na phishingovém webu.
      Pokud tuto zásadu ponecháte nenastavenou, bude služba pro ochranu hesel chránit pouze hesla Google, ale uživatel toto nastavení bude moci změnit.</translation>
<translation id="3502555714327823858">Povolit všechny oboustranné režimy</translation>
<translation id="350443680860256679">Konfigurace ARC</translation>
<translation id="3504791027627803580">Udává adresu URL vyhledávače, který se používá pro vyhledávání na základě obrázků. Požadavky na vyhledávání budou odesílány pomocí metody GET. Pokud je nastavena zásada DefaultSearchProviderImageURLPostParams, požadavky na vyhledávání na základě obrázků budou namísto toho využívat metodu POST.

          Tato zásada je nepovinná. Pokud není nastavena, nebude použito žádné vyhledávání podle obrázku.

          Tato zásada je respektována pouze v případě, že je aktivována zásada DefaultSearchProviderEnabled.</translation>
<translation id="350797926066071931">Aktivovat Překladač</translation>
<translation id="3512226956150568738">Pokud model zařízení klienta podporoval ARC již předtím, než kvůli spuštění ARC bylo potřeba migrovat na ext4, a zásada ArcEnabled je nastavena na hodnotu true, bude se tato možnost chovat jako AskUser (hodnota 3). Ve všech ostatních případech (model zařízení dříve ARC nepodporoval nebo je zásada ArcEnabled nastavena na hodnotu false) se tato možnost bude chovat jako DisallowArc (hodnota 0).</translation>
<translation id="3524204464536655762">Nedovolit žádnému webu požadovat přístup k zařízením USB pomocí rozhraní WebUSB API</translation>
<translation id="3526752951628474302">Pouze černobílý tisk</translation>
<translation id="3528000905991875314">Aktivovat alternativní chybové stránky</translation>
<translation id="3545457887306538845">Umožňuje ovládat, kde je možné používat Nástroje pro vývojáře.

      Pokud je tato zásada nastavena na možnost DeveloperToolsDisallowedForForceInstalledExtensions (výchozí hodnota 0), je přístup k Nástrojům pro vývojáře a konzoli JavaScriptu obecně povolen, ale není povolen v kontextu rozšíření nainstalovaných pomocí podnikových zásad.
      Je-li tato zásada nastavena na možnost DeveloperToolsAllowed (hodnota 1), je možné Nástroje pro vývojáře a konzoli JavaScriptu otevřít a používat ve všech kontextech, včetně rozšíření nainstalovaných pomocí podnikových zásad.
      Je-li tato zásada nastavena na možnost DeveloperToolsDisallowed (hodnota 2), Nástroje pro vývojáře nelze otevřít a nelze prozkoumávat prvky na webech. Deaktivovány budou také veškeré klávesové zkratky a položky klasických či kontextových nabídek, pomocí kterých lze nástroje pro vývojáře nebo konzoli JavaScriptu otevřít.</translation>
<translation id="3547954654003013442">Nastavení proxy serveru</translation>
<translation id="355118380775352753">Weby, které se mají otevírat v alternativním prohlížeči</translation>
<translation id="3577251398714997599">Nastavení reklam pro weby s rušivými reklamami</translation>
<translation id="3591527072193107424">Aktivovat funkci Podpora starších prohlížečů.</translation>
<translation id="3591584750136265240">Konfigurace chování přihlašovacího ověření</translation>
<translation id="3624171042292187668">
      Chcete-li využívat izolaci, ale omezit její dopad na uživatele, použijte zásadu IsolateOrigins se seznamem webů, které chcete izolovat. Toto nastavení (SitePerProcess) izoluje všechny weby.
      Pokud tuto zásadu povolíte, bude se každý web spouštět ve vlastním procesu.
      Pokud tuto zásadu zakážete, budou zakázány zásady IsolateOrigins a SitePerProcess. Zásadu SitePerProcess však uživatelé budou moci povolit ručně pomocí příznaků příkazového řádku.
      Pokud tuto zásadu nenakonfigurujete, uživatel toto nastavení bude moci změnit.
      V systému <ph name="PRODUCT_OS_NAME" /> je doporučeno nastavit na stejnou hodnotu také zásadu zařízení <ph name="DEVICE_LOGIN_SCREEN_SITE_PER_PROCESS_POLICY_NAME" />. Pokud se hodnoty neshodují, může při zahajování uživatelské návštěvy dojít ke zpoždění způsobenému používáním hodnoty zadané v zásadě pro uživatele.

      POZNÁMKA: Tato zásada nefunguje na zařízeních Android. K aktivaci zásady SitePerProcess na zařízeních Android použijte zásadu SitePerProcessAndroid.
      </translation>
<translation id="3627678165642179114">Povolit nebo zakázat webovou službu kontroly pravopisu</translation>
<translation id="3628480121685794414">Povolit jednostranný tisk</translation>
<translation id="3646859102161347133">Nastavení typu lupy</translation>
<translation id="3653237928288822292">Ikona výchozího poskytovatele vyhledávání</translation>
<translation id="3660510274595679517">
        Pokud je tato zásada nastavená na hodnotu True, je registrace do cloudové správy povinná a v případě selhání blokuje proces spuštění Chromu.

        Pokud je tato zásada ponechána nenastavená nebo je nastavená na hodnotu False, je registrace do cloudové správy volitelná a v případě selhání neblokuje proces spuštění Chromu.

        Tato zásada se používá k registraci cloudových zásad pro počítač. V systému Windows ji lze nastavit pomocí registru nebo objektů zásad skupiny, na počítačích Mac pomocí souboru plist a v Linuxu pomocí souboru JSON se zásadami.</translation>
<translation id="3660562134618097814">Přenos souborů cookie od poskytovatele identity SAML při přihlášení</translation>
<translation id="3702647575225525306"><ph name="POLICY_NAME" /> (Podpora pole s jedním řádkem byla ukončena. Začněte používat níže uvedené textové pole s více řádky.)</translation>
<translation id="3709266154059827597">Konfigurace seznamu zakázaných položek instalace rozšíření</translation>
<translation id="3711895659073496551">Pozastavit</translation>
<translation id="3715569262675717862">Ověřování založené na certifikátech klientů</translation>
<translation id="3736879847913515635">Povolit přidání osoby ve správci uživatelů</translation>
<translation id="3738723882663496016">Tato zásada určuje licenční klíč pluginu <ph name="PLUGIN_VM_NAME" /> pro toto zařízení.</translation>
<translation id="3748900290998155147">Určuje, zda je povoleno blokování přechodu do režimu spánku. O blokování přechodu do režimu spánku mohou žádat aplikace ARC a rozšíření prostřednictvím rozhraní API pro řízení spotřeby.

          Pokud tato zásada není nastavena na hodnotu true nebo je ponechána nenastavená, blokování přechodu do režimu spánku budou při řízení spotřeby dodržována.

          Pokud je tato zásada nastavena na hodnotu false, žádosti o blokování přechodu do režimu spánku budou ignorovány.</translation>
<translation id="3750220015372671395">Blokovat generování klíčů na těchto stránkách</translation>
<translation id="3756011779061588474">Blokovat režim pro vývojáře</translation>
<translation id="3758089716224084329">Umožňuje zadat proxy server, který bude prohlížeč <ph name="PRODUCT_NAME" /> používat, a brání uživatelům ve změně nastavení proxy serveru.

      Pokud zvolíte, že proxy server nikdy používat nechcete a chcete se vždy připojovat přímo, všechny další možnosti budou ignorovány.

      Pokud zvolíte, že chcete nastavení proxy serveru zjistit automaticky, všechny další možnosti budou ignorovány.

      Podrobné příklady naleznete na následující stránce:
      <ph name="PROXY_HELP_URL" />.

      Pokud aktivujete toto nastavení, prohlížeč <ph name="PRODUCT_NAME" /> a aplikace ARC budou ignorovat veškeré možnosti související s proxy serverem zadané na příkazovém řádku.

      Pokud tyto zásady ponecháte nenastavené, uživatelé budou moci zvolit vlastní nastavení proxy serveru.</translation>
<translation id="3758249152301468420">Deaktivovat nástroje pro vývojáře</translation>
<translation id="3764248359515129699">Deaktivuje vynucování požadavků Certificate Transparency pro seznam starších certifikačních autorit.

      Tato zásada umožňuje deaktivovat požadavky Certificate Transparency na zveřejnění pro řetězce certifikátů, které obsahují certifikáty s některou ze zadaných hodnot hash údaje subjectPublicKeyInfo. Pro podnikové hostitelské servery je pak možné používat certifikáty, které by jinak byly považovány za nedůvěryhodné, protože nebyly zveřejněny.

      Aby při nastavení této zásady bylo vynucování požadavků Certificate Transparency deaktivováno, musí hodnota hash odpovídat údaji subjectPublicKeyInfo v certifikátu CA, který je považován za starší certifikační autoritu (CA). Starší CA je CA, které ve výchozím natavení veřejně důvěřují některé operační systémy podporované prohlížečem <ph name="PRODUCT_NAME" />, ale kterou nepovažuje za důvěrnou Android Open Source Project nebo systém <ph name="PRODUCT_OS_NAME" />.

      Hodnotu hash subjectPublicKeyInfo tvoří název hashovacího algoritmu následovaný znakem „/“ a kódováním Base64 hodnoty hash získané použitím daného hashovacího algoritmu na údaj subjectPublicKeyInfo certifikátu v kódování DER. Toto kódování Base64 má stejný formát jako otisk SPKI definovaný v oddílu 2.4 specifikace RFC 7469. Neznámé hashovací algoritmy jsou ignorovány. V současné době je podporován pouze hashovací algoritmus sha256.

      Pokud tato zásada není nastavena, každý certifikát, u kterého je vyžadováno zveřejnění prostřednictvím Certificate Transparency, ale který není zveřejněn v souladu se zásadou Certificate Transparency, bude považován za nedůvěryhodný.</translation>
<translation id="3765260570442823273">Doba zobrazení zprávy s upozorněním na odhlášení z důvodu nečinnosti</translation>
<translation id="377044054160169374">Vynucování zásahů proti obtěžujícímu chování</translation>
<translation id="3780152581321609624">Zahrnout do hlavního názvu služby protokolu Kerberos nestandardní port</translation>
<translation id="3780319008680229708">Je-li tato zásada nastavena na hodnotu true, bude ikona Cast na liště nebo v rozbalovací nabídce vždy zobrazena a uživatelé ji nebudou moci odebrat.

          Pokud je tato zásada nastavena na hodnotu false nebo není nastavena, uživatelé ikonu budou moci připnout nebo odebrat pomocí kontextové nabídky.

          Pokud je zásada EnableMediaRouter nastavena na hodnotu false, hodnota této zásady se nijak neprojeví a ikona se na liště zobrazovat nebude.</translation>
<translation id="3788662722837364290">Nastavení řízení spotřeby při neaktivitě uživatele</translation>
<translation id="3790085888761753785">Pokud je toto nastavení zapnuto, uživatelé se ke svému účtu budou moci přihlásit pomocí funkce Smart Lock. Toto nastavení je mírnější než obvyklé chování funkce Smart Lock, které uživatelům povoluje pouze odemknout obrazovku.

      Je-li toto nastavení vypnuto, uživatelé přihlášení pomocí funkce Smart Lock nebudou moci používat.

      Pokud tato zásada není nastavena, pro uživatele spravované organizací bude nastavení zakázáno a pro ostatní uživatele povoleno.</translation>
<translation id="379602782757302612">Umožňuje zadat, která rozšíření uživatelé NEMOHOU instalovat. Již nainstalovaná rozšíření uvedená na seznamu zakázaných budou deaktivována. Když bude takto deaktivované rozšíření ze seznamu odstraněno, automaticky se znovu aktivuje.

          Hodnota * v seznamu zakázaných znamená, že jsou zakázána všechna rozšíření, která nejsou uvedena na seznamu povolených.

          Pokud tato zásada není nastavena, může uživatel v prohlížeči <ph name="PRODUCT_NAME" /> nainstalovat libovolné rozšíření.</translation>
<translation id="3800626789999016379">Slouží ke konfiguraci adresáře, do kterého bude prohlížeč <ph name="PRODUCT_NAME" /> stahovat soubory.

      Pokud tuto zásadu nastavíte, použije <ph name="PRODUCT_NAME" /> zadaný adresář i v případě, že uživatel zadal jiný adresář nebo zvolil, že chce pokaždé zobrazit výzvu k zadání umístění stahovaného souboru.

      Seznam proměnných, které můžete použít, naleznete na stránce https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Pokud tato zásada není nastavena, bude se používat výchozí adresář pro stažené soubory a uživatel jej bude moci změnit.</translation>
<translation id="3805659594028420438">Povolit rozšíření certifikátů TLS vázaných na doménu (zastaralé)</translation>
<translation id="3808945828600697669">Určit seznam deaktivovaných pluginů</translation>
<translation id="3811562426301733860">Povolit reklamy na všech webech</translation>
<translation id="3816312845600780067">Aktivovat nouzovou klávesovou zkratku pro automatické přihlášení</translation>
<translation id="3820526221169548563">Povolí funkci usnadnění přístupu pomocí softwarové klávesnice. 

          Pokud je tato zásada nastavena na hodnotu true, bude softwarová klávesnice vždy povolena.

          Pokud je tato zásada nastavena na hodnotu false, bude softwarová klávesnice vždy zakázána.

          Pokud tuto zásadu nastavíte, uživatelé ji nebudou moci změnit ani přepsat. 

          Pokud ji ponecháte nenastavenou, softwarová klávesnice bude ve výchozím nastavení zakázána, ale uživatelé ji budou moci kdykoli povolit.</translation>
<translation id="382476126209906314">Konfigurovat předponu TalkGadget pro hostitele vzdáleného přístupu</translation>
<translation id="3831376478177535007">Když je toto nastavení aktivováno, povoluje <ph name="PRODUCT_NAME" /> důvěřovat certifikátům vydaným pomocí operací starší infrastruktury PKI společnosti Symantec (pokud je jinak možné je úspěšně ověřit a propojit s uznávaným certifikátem CA).

      Upozorňujeme, že tato zásada závisí na tom, zda operační systém stále uznává certifikáty ze starší infrastruktury společnosti Symantec. Jestliže při aktualizaci operačního systému dojde ke změně zpracování takových certifikátů operačním systémem, tato zásada již nebude fungovat. Tato zásada je určena jako dočasné řešení, které má podnikům poskytnout více času k přechodu ze starších certifikátů Symantec na jiné. Kolem 1. ledna 2019 bude odstraněna.

      Pokud tato zásada není nastavena nebo je nastavena na hodnotu false, bude se <ph name="PRODUCT_NAME" /> řídit veřejně publikovaným harmonogramem ukončení podpory.

      Další informace o tomto ukončení podpory najdete na stránce https://g.co/chrome/symantecpkicerts.</translation>
<translation id="383466854578875212">Umožňuje určit, na které hostitele zasílání nativních zpráv se nebude vztahovat seznam zakázaných hostitelů.

          Hodnota * v seznamu zakázaných znamená, že jsou všichni hostitelé zasílání nativních zpráv zakázáni a že budou načteni pouze hostitelé uvedení na seznamu povolených hostitelů.

          Ve výchozím nastavení jsou povoleni všichni hostitelé zasílání nativních zpráv. Pokud však byly všichni hostitelé zasílání nativních zpráv pomocí zásady přidáni na seznam zakázaných, je možné tuto zásadu pomocí seznamu povolených hostitelů přepsat.</translation>
<translation id="384743459174066962">Umožňuje nastavit seznam vzorů adres URL stránek, které nemají povoleno otevírat vyskakovací okna.

           Pokud zásadu nenastavíte, použije se pro všechny webové stránky globální výchozí hodnota buď ze zásady DefaultPopupsSetting (pokud je nastavena), nebo z osobního nastavení uživatele.</translation>
<translation id="3851039766298741586">Hlášení informací o aktivní relaci veřejného terminálu, jako je ID a verze aplikace.

      Je-li tato zásada nastavena na hodnotu False, informace o relaci veřejného terminálu se hlásit nebudou. Pokud je nastavena na hodnotu True nebo nastavena není, informace o relaci veřejného terminálu se hlásit budou.</translation>
<translation id="3858658082795336534">Výchozí režim oboustranného tisku</translation>
<translation id="3859780406608282662">Přidá parametr k načítání počátečních hodnot variant v systému <ph name="PRODUCT_OS_NAME" />.

      Pokud je tato zásada nastavena, přidá se k adrese URL, která slouží k načítání počáteční hodnoty variant, parametr s názvem „restrict“. Hodnota parametru bude odpovídat hodnotě určené touto zásadou.

      Pokud tato zásada není nastavena, zůstane adresa URL počáteční hodnoty variant nezměněna.</translation>
<translation id="3863409707075047163">Minimální aktivovaná verze protokolu SSL</translation>
<translation id="3864020628639910082">Určuje adresu URL vyhledávače, který bude použit k získání návrhů pro vyhledávání. Adresa URL by měla obsahovat řetězec <ph name="SEARCH_TERM_MARKER" />. Tento řetězec bude během dotazování nahrazen textem, který do daného okamžiku zadal uživatel.

          Tato zásada je volitelná. Pokud není nastavena, nebude použita žádná adresa URL pro návrhy.

          Adresu URL Googlu pro návrhy lze zadat takto: <ph name="GOOGLE_SUGGEST_SEARCH_URL" />.

          Tato zásada je respektována pouze v případě, že je aktivována zásada DefaultSearchProviderEnabled.</translation>
<translation id="3864129983143201415">Nakonfigurovat povolené jazyky v uživatelské relaci</translation>
<translation id="3866249974567520381">Popis</translation>
<translation id="3868347814555911633">Tato zásada je aktivní pouze v režimu pro obchody.

      Seznam rozšíření, která se automaticky nainstalují pro uživatele ukázky v zařízeních v režimu pro obchody. Tato rozšíření se uloží v zařízení a po instalaci mohou být nainstalována v režimu offline.

      Každý záznam v seznamu obsahuje adresář, který musí zahrnovat ID rozšíření v poli „extension-id“ a jeho webovou adresu pro aktualizace v poli „update-url“.</translation>
<translation id="3874773863217952418">Aktivovat funkci Vyhledání klepnutím</translation>
<translation id="3877517141460819966">Režim integrovaného dvoufaktorového ověření</translation>
<translation id="3879208481373875102">Konfigurace seznamu webových aplikací s vynucenou instalací</translation>
<translation id="388237772682176890">Ve verzi M53 byla podpora této zásady ukončena a ve verzi M54 byla tato zásada zcela odstraněna, protože byla odstraněna podpora protokolu SPDY/3.1.

      Zakáže v prohlížeči <ph name="PRODUCT_NAME" /> použití protokolu SPDY.

      Pokud je tato zásada aktivní, nebude protokol SPDY v prohlížeči <ph name="PRODUCT_NAME" /> k dispozici.

      Pokud tuto zásadu deaktivujete, povolíte tím využívání protokolu SPDY.

      Pokud tuto zásadu ponecháte nenastavenou, bude protokol SPDY k dispozici.</translation>
<translation id="3890999316834333174">Zásady související s rychlým odemknutím</translation>
<translation id="3891357445869647828">Povolit JavaScript</translation>
<translation id="3895557476567727016">Konfiguruje výchozí adresář, do kterého bude <ph name="PRODUCT_NAME" /> stahovat soubory.

      Pokud tuto zásadu nastavíte, změní výchozí adresář, do kterého bude <ph name="PRODUCT_NAME" /> stahovat soubory. Tato zásada není závazná. Uživatel adresář bude moci změnit.

      Pokud tuto zásadu nenastavíte, bude <ph name="PRODUCT_NAME" /> používat svůj obvyklý výchozí adresář (specifický pro platformu).

      Seznam proměnných, které můžete použít, naleznete na stránce https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.</translation>
<translation id="3904459740090265495">Tato zásada ovládá chování prohlížeče při přihlašování. Umožňuje zadat, zda se uživatel do prohlížeče <ph name="PRODUCT_NAME" /> může přihlásit pomocí svého účtu a používat služby související s účtem, jako je například synchronizace Chromu.

      Pokud je tato zásada nastavena na hodnotu Zakázat přihlášení do prohlížeče, uživatel se přihlásit do prohlížeče a používat služby založené na účtu nemůže. V tomto případě funkce na úrovni prohlížeče, jako je synchronizace Chromu, nelze používat a nebudou k dispozici. Pokud byl uživatel přihlášen a zásada je nastavena na hodnotu Zakázáno, bude při příštím spuštění Chromu odhlášen, ale data v jeho místním profilu, jako jsou záložky, hesla apod., zůstanou zachována. Uživatel se i nadále bude moci přihlásit do webových služeb Google, jako je Gmail, a používat je.

      Pokud je tato zásada nastavena na hodnotu Povolit přihlášení do prohlížeče, uživatel má povoleno přihlásit se do prohlížeče, a když se přihlásí do webových služeb Google, jako je Gmail, bude do prohlížeče přihlášen automaticky. Přihlášení do prohlížeče znamená, že prohlížeč bude uchovávat informace o účtu uživatele. Neznamená to však, že bude ve výchozím nastavení zapnuta synchronizace Chromu. K použití této funkce se uživatel musí přihlásit samostatně. Aktivací této zásady uživateli znemožníte vypnout nastavení, které povoluje přihlášení do prohlížeče. Chcete-li nastavit dostupnost synchronizace Chromu, použijte zásadu SyncDisabled.

      Pokud je tato zásada nastavena na hodnotu Vynutit přihlášení do prohlížeče, zobrazí se uživateli dialogové okno k výběru účtu, v němž před použitím prohlížeče musí vybrat účet a přihlásit se k němu. Zajistí se tím, aby u spravovaných účtů byly použity a vynuceny zásady přidružené k účtu. Ve výchozím nastavení tato možnost pro účet zapne synchronizaci Chromu. Výjimkou jsou případy, kdy synchronizace byla zakázána administrátorem nebo prostřednictvím zásady SyncDisabled. Výchozí hodnota zásady BrowserGuestModeEnabled bude nastavena na hodnotu false. 
Existující nepřihlášené profily po zapnutí této zásady budou uzamčeny a přestanou být přístupné. Další informace najdete v tomto článku v centru nápovědy: https://support.google.com/chrome/a/answer/7572556.

      Pokud tato zásada není nastavena, může se uživatel podle svého uvážení rozhodnout, zda chce možnost přihlášení do prohlížeče zapnout a používat.</translation>
<translation id="3911737181201537215">Na protokolování prováděné systémem Android tato zásada nemá vliv.</translation>
<translation id="391531815696899618">Pokud má hodnotu True, deaktivuje synchronizaci aplikace Soubory systému <ph name="PRODUCT_OS_NAME" /> s Diskem Google. Na Disk Google se v tomto případě nebudou nahrávat žádná data.

          Pokud má tato zásada hodnotu False nebo není nastavena, uživatelé budou moci přenášet soubory na Disk Google.</translation>
<translation id="3915395663995367577">Adresa URL souboru PAC proxy serveru</translation>
<translation id="3925377537407648234">Nastavit rozlišení a měřítko obrazovky</translation>
<translation id="3939893074578116847">Odesílá na server správy síťové pakety ke sledování stavu online, což serveru umožňuje zjistit, zda zařízení není offline.

      Je-li tato zásada nastavena na hodnotu True, budou se odesílat sledovací síťové pakety (tzv. <ph name="HEARTBEATS_TERM" />).
      Pokud je nastavena na hodnotu False nebo není nastavena, pakety se odesílat nebudou.</translation>
<translation id="3950239119790560549">Časová omezení aktualizací</translation>
<translation id="3956686688560604829">Použít zásadu SiteList prohlížeče Internet Explorer pro podporu starších prohlížečů.</translation>
<translation id="3958586912393694012">Povolit používání funkce Smart Lock</translation>
<translation id="3963602271515417124">Pokud je tato zásada nastavena na hodnotu true, bude pro zařízení povolena vzdálená atestace a bude automaticky vygenerován certifikát, který se nahraje na server správy zařízení.

          Pokud je tato zásada nastavena na hodnotu false nebo není nakonfigurována, nebude vygenerován žádný certifikát a volání rozhraní API enterprise.platformKeys se nezdaří.</translation>
<translation id="3965339130942650562">Časový limit před odhlášením nečinného uživatele</translation>
<translation id="3973371701361892765">Nikdy poličku automaticky neskrývat</translation>
<translation id="3984028218719007910">Určuje, zda systém <ph name="PRODUCT_OS_NAME" /> po odhlášení zachová místní data účtu. Pokud je tato zásada nastavena na hodnotu True, nebude systém <ph name="PRODUCT_OS_NAME" /> uchovávat žádné účty trvale a všechna data návštěvy uživatele budou po odhlášení smazána. Pokud je tato zásada nastavena na hodnotu False, nebo není nastavena, může zařízení uchovat (šifrovaná) místní uživatelská data.</translation>
<translation id="398475542699441679">Tato zásada ovládá zapnutí funkce Podpora starších prohlížečů.

      Když je tato zásada ponechána nenastavená nebo je nastavená na hodnotu false, Chrome se zadané adresy URL nebude pokoušet otevírat v alternativním prohlížeči.

      Když je tato zásada nastavená na hodnotu true, Chrome se některé adresy URL bude pokoušet otevřít v alternativním prohlížeči (jako je Internet Explorer). Tato funkce se konfiguruje pomocí zásad ve skupině <ph name="LEGACY_BROWSER_SUPPORT_POLICY_GROUP" />.

      Tato funkce nahrazuje rozšíření <ph name="LEGACY_BROWSER_SUPPORT_EXTENSION_NAME" />. Konfigurace se z rozšíření přenese do této funkce. Místo rozšíření důrazně doporučujeme používat zásady Chromu. Zajistíte tím lepší kompatibilitu do budoucnosti.</translation>
<translation id="3997519162482760140">Adresy URL, kterým bude na přihlašovacích stránkách SAML udělen přístup k zařízením pro záznam videa</translation>
<translation id="4001275826058808087">Administrátoři IT spravující podniková zařízení mohou pomocí tohoto příznaku uživatelům povolit nebo zakázat uplatnění zvláštních nabídek při registraci systému Chrome OS.

      Pokud je tato zásada nastavena na hodnotu true nebo ponechána bez nastavení, uživatelé budou moci při registraci systému Chrome OS uplatňovat zvláštní nabídky.

      Pokud je tato zásada nastavena na hodnotu false, uživatelé zvláštní nabídky nebudou moci uplatnit.</translation>
<translation id="4008507541867797979">Pokud je tato zásada nastavena na hodnotu true nebo není nakonfigurována, bude <ph name="PRODUCT_OS_NAME" /> na přihlašovací obrazovce ukazovat existující uživatele a umožní vybrat si z nich.

      Pokud je tato zásada nastavena na hodnotu false, <ph name="PRODUCT_OS_NAME" /> na přihlašovací obrazovce existující uživatele zobrazovat nebude. Jestliže není nakonfigurována spravovaná návštěvy, zobrazí se běžná přihlašovací obrazovka (vyzývající k zadání e‑mailu a hesla nebo telefonu uživatele) nebo vsunutá obrazovka SAML (pokud je zapnuta pomocí zásady <ph name="LOGIN_AUTHENTICATION_BEHAVIOR_POLICY_NAME" />). Když je nakonfigurována spravovaná návštěvy, budou se zobrazovat jen účty spravované návštěvy a bude si z nich možné vybrat.

      Upozorňujeme, že tato zásada nemá vliv na to, zda zařízení uchovává nebo zahazuje data místního uživatele.</translation>
<translation id="4010738624545340900">Povolit zobrazování dialogových oken pro výběr souboru</translation>
<translation id="4012737788880122133">Pokud je tato zásada nastavena na hodnotu True, budou zakázány automatické aktualizace.

      Pokud tato zásada není nastavena nebo je nastavena na hodnotu False, zařízení se systémem <ph name="PRODUCT_OS_NAME" /> automaticky kontrolují aktualizace.

      Upozornění: Doporučuje se ponechat automatické aktualizace zapnuté, aby uživatelé mohli dostávat aktualizace softwaru a kritické opravy zabezpečení. Vypnutí automatických aktualizací by uživatele mohlo vystavit riziku.</translation>
<translation id="4020682745012723568">Aplikace Android k souborům cookie převedeným do profilu uživatele nemají přístup.</translation>
<translation id="402759845255257575">Nepovolovat spouštění JavaScriptu žádnému webu</translation>
<translation id="4027608872760987929">Aktivovat výchozího poskytovatele vyhledávání</translation>
<translation id="4039085364173654945">Kontroluje, zda je na stránce u obsahu třetích stran povoleno vyskakování dialogového okna HTTP Basic Auth.

          Tato možnost je obvykle vypnuta jako ochrana proti phishingu. Pokud zásada není nastavena, je tato možnost vypnuta a u obsahu třetích stran nebude povoleno vyskakování dialogového okna HTTP Basic Auth.</translation>
<translation id="4056910949759281379">Deaktivovat protokol SPDY</translation>
<translation id="4059515172917655545">Tato zásada ovládá dostupnost služeb určování polohy Google.

      Když tato zásada není nakonfigurována nebo je nastavena na hodnotu <ph name="GLS_DISABLED" />, jsou služby určování polohy Google deaktivovány a uživatel je nemůže zapnout.

      Když je tato zásada nastavena na hodnotu <ph name="GLS_UNDER_USER_CONTROL" />, bude uživatel dotázán, zda se služby určování služeb Google mají používat. Aplikace pro Android tak pomocí těchto služeb budou moci zjistit polohu zařízení a také bude možné odesílat do Googlu anonymní údaje o poloze.

      Upozorňujeme, že když je zásada <ph name="DEFAULT_GEOLOCATION_SETTING_POLICY_NAME" /> nastavena na hodnotu <ph name="BLOCK_GEOLOCATION_SETTING" />, jsou služby určování polohy Google vždy zakázány a tato zásada je ignorována.</translation>
<translation id="408029843066770167">Povolit dotazy na časovou službu Google</translation>
<translation id="408076456549153854">Povolit přihlášení do prohlížeče</translation>
<translation id="4088589230932595924">Anonymní režim je povinný.</translation>
<translation id="4088983553732356374">Umožňuje určit, zda mohou webové stránky nastavovat místní data. Nastavení místních dat lze buď povolit pro všechny weby, nebo je pro všechny weby zakázat.

Pokud je tato zásada nastavena na možnost Uchovat soubory cookie po dobu trvání návštěvy, po ukončení návštěvy budou soubory cookie vymazány. Pokud je prohlížeč <ph name="PRODUCT_NAME" /> spuštěn na pozadí, návštěvy se po zavření okna nemusí ukončit. Další informace o konfiguraci tohoto chování naleznete v podrobnostech o zásadě BackgroundModeEnabled.

Není-li zásada nastavena, bude použita zásada AllowCookies a uživatelé ji budou moci změnit.</translation>
<translation id="4103289232974211388">Po potvrzení uživatele přesměrovat na poskytovatele identity SAML</translation>
<translation id="410478022164847452">Udává dobu nečinnosti uživatele, po které bude při napájení ze sítě provedena úsporná akce.

          Pokud je tato zásada nastavena, jedná se o dobu, po kterou musí uživatel zůstat v nečinnosti, než systém <ph name="PRODUCT_OS_NAME" /> provede úspornou akci. Tuto akci lze nakonfigurovat samostatně.

          Není-li tato zásada nastavena, bude použita výchozí doba.

          Hodnota zásady se zadává v milisekundách.</translation>
<translation id="4105989332710272578">Deaktivovat vynucování zásad Certificate Transparency pro seznam adres URL</translation>
<translation id="4121350739760194865">Zabraňuje zobrazování propagace aplikací na stránce Nová karta</translation>
<translation id="412697421478384751">Povolit uživatelům nastavovat slabé kódy PIN pro odemknutí obrazovky</translation>
<translation id="4138655880188755661">Časový limit</translation>
<translation id="4150201353443180367">Displej</translation>
<translation id="4157003184375321727">Hlásit verzi operačního systému a firmwaru</translation>
<translation id="4157594634940419685">Povolit přístup k nativním tiskárnám CUPS</translation>
<translation id="4183229833636799228">Výchozí nastavení pluginu <ph name="FLASH_PLUGIN_NAME" /></translation>
<translation id="4192388905594723944">Adresa URL k potvrzení ověřovacího tokenu klienta vzdáleného připojení</translation>
<translation id="4203389617541558220">Omezuje dobu, po kterou může být zařízení spuštěno, naplánováním automatických restartů.

Pokud je tato zásada nastavena, udává dobu, po kterou je zařízení spuštěno a po jejímž uplynutí dojde k automatickému restartu. 
Pokud tato zásada není nastavena, doba, po kterou může být zařízení spuštěno, není omezena.

Pokud tuto zásadu nastavíte, uživatelé ji nebudou moci změnit ani přepsat.

Automatický restart bude naplánován na zvolený čas, ale pokud bude uživatel zařízení používat, bude automatický restart možné odložit až o 24 hodin.

Poznámka: V současnosti jsou automatické restarty povoleny pouze v době, kdy je zobrazena přihlašovací obrazovka nebo kdy je spuštěna návštěvy terminálové aplikace. V budoucnu se tyto podmínky změní a tato zásada bude platit vždy, nehledě na to, zda je spuštěna návštěvy libovolného typu.

Hodnotu zásady je třeba zadat v sekundách. Hodnota musí být minimálně 3600 (jedna hodina).</translation>
<translation id="4203879074082863035">Uživatelům se zobrazují pouze tiskárny uvedené v seznamu povolených</translation>
<translation id="420512303455129789">Slovník, který mapuje adresy URL na logický příznak, který určuje, zda je přístup k hostitelskému serveru povolen (true) nebo blokován (false).

Tato zásada je určena k internímu použití prohlížečem <ph name="PRODUCT_NAME" />.</translation>
<translation id="4224610387358583899">Prodlevy uzamčení obrazovky</translation>
<translation id="423797045246308574">Umožňuje nastavit seznam vzorů adres URL webových stránek, které nemají povoleno generovat klíče. Pokud je uveden vzor adres URL v zásadě KeygenAllowedForUrls, tato zásada tyto výjimky přepíše.

Pokud tuto zásadu nenastavíte, použije se pro všechny webové stránky globální výchozí hodnota buď ze zásady DefaultKeygenSetting (pokud je nastavena), nebo z osobního nastavení uživatele.</translation>
<translation id="4239720644496144453">Pro aplikace Android se mezipaměť nepoužívá. Pokud několik uživatelů nainstaluje stejnou aplikaci Android, stáhne se aplikace pro každého uživatele znovu.</translation>
<translation id="4243336580717651045">Zapne v prohlížeči <ph name="PRODUCT_NAME" /> shromažďování anonymizovaných dat přidružených k adresám URL a znemožní uživatelům toto nastavení změnit.

      Při shromažďování anonymizovaných dat přidružených k adresám URL se adresy URL navštívených stránek odesílají do Googlu kvůli usnadnění vyhledávání a prohlížení.

      Pokud zapnete tuto zásadu, shromažďování anonymizovaných dat přidružených k adresám URL bude vždy aktivní.

      Pokud tuto zásadu vypnete, shromažďování anonymizovaných dat nebude nikdy aktivní.

      Pokud tuto zásadu ponecháte nenastavenou, bude shromažďování anonymizovaných dat zapnuto, ale uživatel to bude moci změnit.</translation>
<translation id="4250680216510889253">Ne</translation>
<translation id="4261820385751181068">Jazyk přihlašovací obrazovky zařízení</translation>
<translation id="427220754384423013">Určuje, které tiskárny uživatel může používat.

Tato zásada se použije, jen pokud je v zásadě <ph name="PRINTERS_WHITELIST" /> vybrána možnost <ph name="BULK_PRINTERS_ACCESS_MODE" />.

Je-li tato zásada použita, bude mít uživatel k dispozici pouze tiskárny, jejichž ID se shodují s hodnotami v této zásadě. ID musejí odpovídat polím „id“ a „guid“ v souboru, který je uveden v zásadě <ph name="BULK_PRINTERS_POLICY" />.
      </translation>
<translation id="427632463972968153">Udává parametry, které se použijí při vyhledávání podle obrázku pomocí metody POST. Sestává z párů název–hodnota oddělených čárkou. Pokud je hodnotou parametr šablony (např. {imageThumbnail} v příkladu výše), bude nahrazen skutečnými údaji vyhledávacích dotazů.

          Tato zásada je nepovinná. Pokud není nastavena, požadavek na vyhledávání podle obrázku bude odeslán pomocí metody GET.

          Tato zásada je respektována pouze v případě, že je aktivována zásada DefaultSearchProviderEnabled.</translation>
<translation id="4285674129118156176">Povolit cizím uživatelům používat ARC</translation>
<translation id="4298509794364745131">Určuje seznam aplikací, které lze povolit jako aplikace k přidávání poznámek na obrazovku uzamčení v systému <ph name="PRODUCT_OS_NAME" />.

      Je-li na obrazovce uzamčení povolena preferovaná aplikace k přidávání poznámek, obrazovka uzamčení bude obsahovat prvek uživatelského rozhraní ke spuštění preferované aplikace.
      Když bude aplikace spuštěna, bude moci v horní části obrazovky uzamčení vytvořit okno aplikace a vkládat na ni datové položky (poznámky). Aplikace bude moci vytvořené poznámky importovat do primární návštěvy uživatele, bude-li návštěvy odemčená. V současné době jsou na obrazovce uzamčení podporovány pouze aplikace k přidávání poznámek pro Chrome.

      Bude-li tato zásada aktivována, uživatel bude moci aplikaci na obrazovce uzamčení aktivovat jen v případě, že mezi hodnotami zásady bude uvedeno ID rozšíření aplikace.
      To znamená, že pokud tuto zásadu nastavíte jako prázdný seznam, přidávání poznámek na obrazovku uzamčení bude zcela zakázáno.
      Upozorňujeme, že zásada obsahující ID aplikace nutně neznamená, že uživatel bude moci určitou aplikaci povolit jako aplikaci k přidávání poznámek na obrazovku uzamčení. Například v Chromu verze 61 jsou dostupné aplikace navíc omezeny ze strany platformy.

      Pokud zásada nebude nastavena, nebudou na základě zásady uplatňována žádná omezení ohledně sady aplikací, které uživatel může na obrazovce uzamčení povolit.</translation>
<translation id="4309640770189628899">Zda jsou v protokolu TLS povoleny šifrovací sady DHE</translation>
<translation id="4322842393287974810">Povolit automaticky spouštěné terminálové aplikaci s nulovým zpožděním ovládat verzi systému <ph name="PRODUCT_OS_NAME" /></translation>
<translation id="4325690621216251241">Přidat na hlavní panel systému tlačítko pro odhlášení</translation>
<translation id="4332177773549877617">Protokolovat události při instalaci aplikací pro Android</translation>
<translation id="4346674324214534449">Umožňuje nastavit, zda mají být blokovány reklamy na webech s rušivými reklamami.

      Je-li tato zásada nastavena na hodnotu 2, budou reklamy na webech s rušivými reklamami blokovány.
      Toto chování se však neprojeví v případě, že je zásada SafeBrowsingEnabled nastavena na hodnotu False.
      Je-li tato zásada nastavena na hodnotu 1, reklamy na webech s rušivými reklamami blokovány nebudou.
      Pokud tato zásada není nastavena, použije se hodnota 2.</translation>
<translation id="4347908978527632940">Pokud je tato zásada nastavena na hodnotu true a jedná se o dozorovaného uživatele, ostatní aplikace pro Android mohou prostřednictvím poskytovatele obsahu zjišťovat, jaká omezení přístupu k webu se na uživatele vztahují.

          Pokud je nastavena na hodnotu false nebo nastavena není, poskytovatel obsahu nevrátí žádné informace.</translation>
<translation id="435461861920493948">Obsahuje seznam vzorů, které určují viditelnost účtů v prohlížeči <ph name="PRODUCT_NAME" />.

      Každý účet Google v zařízení bude porovnán se vzory uloženými v této zásadě s cílem určit jeho viditelnost v prohlížeči <ph name="PRODUCT_NAME" />. Pokud účet odpovídá některému vzoru v seznamu, bude viditelný. Jinak bude skryt.

      Zástupný znak „*“ odpovídá prázdnému řetězci nebo několika libovolným znakům. Únikový znak je „\“. Chcete-li tedy zadat skutečné znaky „*“ nebo „\“, vložte před ně znak „\“.

      Pokud tato zásada nebude nastavena, budou v prohlížeči <ph name="PRODUCT_NAME" /> viditelné všechny účty Google v zařízení.</translation>
<translation id="436581050240847513">Odesílat informace o síťových rozhraních zařízení</translation>
<translation id="4372704773119750918">Nepovolí podnikovým uživatelům být součástí multiprofilu (primárního či sekundárního)</translation>
<translation id="4377599627073874279">Povolit všem webům zobrazování všech obrázků</translation>
<translation id="437791893267799639">Zásada nenastavena, zakázat migraci dat a rozšíření ARC</translation>
<translation id="4389091865841123886">Konfiguruje vzdálené ověření identity pomocí mechanismu TPM.</translation>
<translation id="4408428864159735559">Seznam předem nakonfigurovaných sdílených síťových úložišť.</translation>
<translation id="4410236409016356088">Zapnout omezení rychlosti připojení</translation>
<translation id="441217499641439905">Zakázat v aplikaci Soubory v systému <ph name="PRODUCT_OS_NAME" /> přístup k Disku Google přes mobilní připojení</translation>
<translation id="4418726081189202489">Pokud tuto zásadu nastavíte na hodnotu False, přestane <ph name="PRODUCT_NAME" /> odesílat příležitostné dotazy na server Google k získání přesného časového razítka. Pokud tato zásada bude nastavena na hodnotu True nebo nebude nastavena, budou tyto dotazy povoleny.</translation>
<translation id="4423597592074154136">Zadat nastavení proxy serveru ručně</translation>
<translation id="4429220551923452215">Povolí nebo zakáže zástupce aplikací na liště záložek.

      Pokud tato zásada není nastavena, uživatel si v kontextové nabídce záložek může vybrat, zda zástupce aplikací chce zobrazit, či nikoliv.

      Pokud je tato zásada nakonfigurována, uživatel ji nemůže změnit a zástupce aplikací je buď zobrazen vždy, nebo není zobrazen nikdy.</translation>
<translation id="4432762137771104529">Zapnout rozšířené hlášení Bezpečnému prohlížení</translation>
<translation id="443454694385851356">Starší (není bezpečné)</translation>
<translation id="443665821428652897">Po vypnutí prohlížeče vymazat data webů (zastaralé)</translation>
<translation id="4439132805807595336">Povolit tomuto zařízení spouštět PluginVm.

      Pokud je tato zásada nastavená na hodnotu false nebo je ponechaná nenastavená, <ph name="PLUGIN_VM_NAME" /> pro zařízení není povolen. Pokud je nastavená na hodnotu true, je <ph name="PLUGIN_VM_NAME" /> pro uživatele povolen (pokud jej povolují i jiná nastavení). Aby <ph name="PLUGIN_VM_NAME" /> bylo možné spustit, zásada <ph name="PLUGIN_VM_ALLOWED_POLICY_NAME" /> musí být true a musí být nastavená zásady <ph name="PLUGIN_VM_LICENSE_KEY_POLICY_NAME" /> a <ph name="PLUGIN_VM_IMAGE_POLICY_NAME" />.</translation>
<translation id="4439336120285389675">Určuje seznam zastaralých funkcí webové platformy, které budou znovu aktivovány.

Tato zásada umožňuje administrátorům na omezenou dobu znovu aktivovat zastaralé funkce webové platformy. Funkce jsou označeny pomocí značky řetězce. Funkce odpovídající značkám uvedeným v seznamu, který určuje tato zásada, budou znovu aktivovány .

Pokud je tato zásada ponechána nenastavená nebo je seznam prázdný či neodpovídá některé z podporovaných značek řetězců, zůstanou všechny funkce zastaralé webové platformy zakázány.

Samotná zásada je na výše uvedených platformách podporována. Funkce, které zásada podporuje, však mohou být k dispozici na méně platformách. Některé zastaralé funkce platformy Web Platform nelze znovu povolit. Po různě dlouhou omezenou dobu lze povolit pouze ty, které jsou výslovně uvedeny níže. Obecný formát řetězcové značky je [NázevZastaraléFunkce]_EffectiveUntil[RRRRMMDD]. Důvody změny funkcí platformy Web Platform a informace naleznete zde: https://bit.ly/blinkintents.
      </translation>
<translation id="4442582539341804154">Aktivovat zámek, pokud jsou zařízení nečinná nebo pozastavená</translation>
<translation id="4449545651113180484">Otočit obrazovku ve směru hodinových ručiček o 270 stupňů</translation>
<translation id="4454820008017317557">Zobrazit ikonu lišty prohlížeče <ph name="PRODUCT_NAME" /></translation>
<translation id="4467952432486360968">Blokovat soubory cookie třetích stran</translation>
<translation id="4474167089968829729">Povolit ukládání hesel do správce hesel</translation>
<translation id="4476769083125004742">Je-li tato zásada nastavena na možnost <ph name="BLOCK_GEOLOCATION_SETTING" />, aplikace Android nemají přístup k informacím o poloze. Pokud tuto zásadu nastavíte na jinou hodnotu nebo ji ponecháte nenastavenou a aplikace Android bude chtít získat přístup k informacím o poloze, zobrazí se uživateli žádost o schválení.</translation>
<translation id="4480694116501920047">Vynutit Bezpečné vyhledávání</translation>
<translation id="4482640907922304445">Zobrazí na liště aplikace <ph name="PRODUCT_NAME" /> tlačítko Domovská stránka.

      Pokud toto nastavení aktivujete, tlačítko Domovská stránka se bude vždy zobrazovat.

      Pokud toto nastavení deaktivujete, tlačítko Domovská stránka se nikdy nezobrazí

      Pokud toto nastavení aktivujete nebo deaktivujete, uživatelé je v aplikace <ph name="PRODUCT_NAME" /> nebudou moci změnit ani přepsat.

      Pokud zásadu nenastavíte, umožníte uživatelům zvolit, zda se tlačítko Domovská stránka zobrazí.</translation>
<translation id="4483649828988077221">Zakázat automatické aktualizace</translation>
<translation id="4485425108474077672">Konfigurace adresy URL stránky Nová karta</translation>
<translation id="4492287494009043413">Zakázat pořizování snímků obrazovky</translation>
<translation id="449423975179525290">Konfiguruje zásady související s pluginem <ph name="PLUGIN_VM_NAME" />.</translation>
<translation id="450537894712826981">Slouží ke konfiguraci velikosti mezipaměti, kterou bude <ph name="PRODUCT_NAME" /> používat k ukládání mediálních souborů do mezipaměti na disku.

      Pokud tuto zásadu nastavíte, <ph name="PRODUCT_NAME" /> bude používat stanovenou velikost mezipaměti bez ohledu na to, zda uživatel zadal příznak „--media-cache-size“. Hodnota stanovená touto zásadou neurčuje pevný limit, jedná se spíše o návrh pro systém ukládání do mezipaměti. Hodnoty menší než několik megabajtů jsou příliš malé a budou zaokrouhleny nahoru na rozumné minimum.

      Pokud pro tuto zásadu nastavíte hodnotu 0, bude použita výchozí velikost mezipaměti, ale uživatel ji nebude moci změnit.

      Pokud tuto zásadu nenastavíte, bude použita výchozí velikost a uživatel ji bude moci přepsat pomocí příznaku  „--media-cache-size“.</translation>
<translation id="4508686775017063528">Pokud je tato zásada nastavena na hodnotu True nebo není nastavena, služba <ph name="PRODUCT_NAME" /> bude aktivována a uživatelé ji budou moci spustit pomocí nabídky aplikace, kontextových nabídek stránky, ovládacích prvků médií na webových stránkách s podporou technologie Cast a ikony Cast na panelu nástrojů (bude-li zobrazena).

          Je-li tato zásada nastavena na hodnotu False, služba <ph name="PRODUCT_NAME" /> bude deaktivována.</translation>
<translation id="4515404363392014383">Zapnout Bezpečné prohlížení pro důvěryhodné zdroje</translation>
<translation id="4518251772179446575">Dotázat se vždy, když se webové stránky snaží sledovat fyzickou polohu uživatele</translation>
<translation id="4519046672992331730">Aktivuje v adresním řádku prohlížeče <ph name="PRODUCT_NAME" /> funkci návrhů pro vyhledávání a brání uživatelům, aby toto nastavení změnili.

      Pokud toto nastavení aktivujete, budou se zobrazovat návrhy pro vyhledávání.

      Pokud toto nastavení deaktivujete, návrhy pro vyhledávání se nikdy nezobrazí.

      Pokud toto nastavení aktivujete nebo deaktivujete, uživatelé je v prohlížeči <ph name="PRODUCT_NAME" /> nebudou moci změnit ani přepsat.

      Pokud zásadu nenastavíte, bude tato funkce zapnuta a uživatelé budou moci nastavení změnit.</translation>
<translation id="4531706050939927436">Instalaci aplikací Android lze vynutit z administrátorské konzole pomocí Google Play. Tato zásada se na ně nevztahuje.</translation>
<translation id="4534500438517478692">Název omezení Android:</translation>
<translation id="4541530620466526913">Místní účty v zařízení</translation>
<translation id="4544079461524242527">Konfiguruje nastavení správy rozšíření prohlížeče <ph name="PRODUCT_NAME" />.

          Tato zásada řídí několik nastavení, včetně těch, která jsou nakonfigurována existujícími zásadami pro rozšíření. Pokud je tato zásada nastavena, přepíše všechny starší nastavené zásady.

          Tato zásada mapuje konfiguraci na ID rozšíření nebo adresu URL. Pokud je definováno ID rozšíření, bude konfigurace použita pouze na konkrétní rozšíření. Pro zvláštní ID <ph name="DEFAULT_SCOPE" /> lze nastavit výchozí konfiguraci. Tato konfigurace bude použita na všechna rozšíření, která v této zásadě nemají nastavenou vlastní konfiguraci. Pokud je definována adresa URL pro aktualizaci, bude konfigurace použita na všechna rozšíření, která mají v manifestu uvedenou přesně tuto adresu URL pro aktualizaci (viz <ph name="LINK_TO_EXTENSION_DOC1" />).

          Úplný popis možných nastavení a struktury této zásady najdete na stránce https://www.chromium.org/administrators/policy-list-3/extension-settings-full.
          </translation>
<translation id="4554651132977135445">Režim zpracování zásad pro uživatele (loopback)</translation>
<translation id="4554841826517980623">Tato zásada určuje, zda smí funkce sdílení síťových položek prohlížeče <ph name="PRODUCT_NAME" /> rozpoznávat sdílení v síti pomocí protokolu <ph name="NETBIOS_PROTOCOL" />.
      Je-li tato zásada nastavena na hodnotu true, při rozpoznávání sdílení v síti bude používán protokol <ph name="NETBIOS_PROTOCOL" />.
      Je-li tato zásada nastavena na hodnotu false, při rozpoznávání sdílení nebude protokol <ph name="NETBIOS_PROTOCOL" /> používán.
      Pokud tato zásada není nastavena, ve výchozím nastavení je pro spravované uživatele zakázána a pro nespravované uživatele povolena.</translation>
<translation id="4555850956567117258">Aktivuje vzdálené ověření identity uživatele</translation>
<translation id="4557134566541205630">Výchozí adresa URL stránky nové karty poskytovatele vyhledávání</translation>
<translation id="4567137030726189378">Povolit použití Nástrojů pro vývojáře</translation>
<translation id="4600786265870346112">Aktivovat velký kurzor</translation>
<translation id="4604931264910482931">Konfigurace seznamu zakázaných položek zasílání nativních zpráv</translation>
<translation id="4613508646038788144">Je-li tato zásada nastavena na hodnotu false, bude software třetích stran moci vkládat spustitelný kód do procesů prohlížeče Chrome. Pokud tato zásada není nastavena nebo je nastavena na hodnotu true, bude mít software třetích stran vkládání spustitelného kódu do procesů prohlížeče Chrome zakázáno.</translation>
<translation id="4617338332148204752">Přeskočení kontroly metaznaček ve službě <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="4625915093043961294">Konfigurovat seznam povolených pro instalaci rozšíření</translation>
<translation id="4632343302005518762">Umožnit pluginu <ph name="PRODUCT_FRAME_NAME" /> zpracovávat uvedené typy obsahu</translation>
<translation id="4632566332417930481">Umožňuje zakázat používání Nástrojů pro vývojáře v rozšířeních nainstalovaných pomocí podnikových zásad, ale povolit jejich používání v jiných kontextech</translation>
<translation id="4633786464238689684">Změní výchozí chování horní řady kláves tak, aby tyto klávesy fungovaly jako funkční.

          Pokud je tato zásada nastavena na hodnotu true, klávesy v horní řadě budou ve výchozím nastavení fungovat jako funkční klávesy. Aby tyto klávesy fungovaly jako mediální, je potřeba současně stisknout vyhledávací tlačítko.

          Pokud je tato zásada nastavena na hodnotu false nebo je ponechána nenastavená, klávesnice bude ve výchozím nastavení odesílat příkazy mediálních kláves a při podržení vyhledávacího tlačítka příkazy funkčních kláves.</translation>
<translation id="4639407427807680016">Názvy hostitelů zasílání nativních zpráv, kterým chcete udělit výjimku ze seznamu zakázaných položek.</translation>
<translation id="4650759511838826572">Deaktivovat schémata protokolu adresy URL</translation>
<translation id="465099050592230505">Adresa URL podnikového úložiště aplikací (podpora ukončena)</translation>
<translation id="4665897631924472251">Nastavení správy rozšíření</translation>
<translation id="4668325077104657568">Výchozí nastavení obrázků</translation>
<translation id="4670865688564083639">Minimum:</translation>
<translation id="4671708336564240458">Umožňuje nastavit, zda mají mít weby s obtěžujícím chováním zakázáno otevírat nová okna a karty.

      Je-li tato zásada nastavena na hodnotu True, nebudou weby s obtěžujícím chováním moci otevírat nová okna ani karty.
      Toto chování se však neprojeví v případě, že je zásada SafeBrowsingEnabled nastavena na hodnotu False.
      Je-li tato zásada nastavena na hodnotu False, weby s obtěžujícím chováním budou mít otevírání nových oken a karet povoleno.
      Pokud tato zásada není nastavena, použije se hodnota True.</translation>
<translation id="467236746355332046">Podporované funkce:</translation>
<translation id="4674167212832291997">Umožňuje personalizovat seznam vzorů adres URL, které by měl vždy vykreslit plugin <ph name="PRODUCT_FRAME_NAME" />.

          Pokud tato zásada není nastavena, použije se pro všechny weby výchozí modul vykreslení určený zásadou ChromeFrameRendererSettings.

          Ukázkové vzory naleznete na stránce https://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="467449052039111439">Otevřít seznam adres URL</translation>
<translation id="4674871290487541952">V kontrolách integrity při aktualizacích a instalacích rozšíření povolit nezabezpečené algoritmy</translation>
<translation id="4680936297850947973">Podpora této zásady byla od verze M68 ukončena. Použijte namísto ní zásadu DefaultPopupsSetting.

      Úplné vysvětlení najdete na stránce https://www.chromestatus.com/features/5675755719622656.
      Je-li tato zásada aktivována, budou weby moci zároveň provádět navigaci a otevírat nová okna/karty.
      Pokud je tato zásada zakázána nebo není nastavena, budou mít weby současné provádění navigace a otevírání nových oken/karet zakázáno.</translation>
<translation id="4680961954980851756">Aktivovat Automatické vyplňování</translation>
<translation id="4703402283970867140">Povolit chytrému modelu ztmavování prodloužit dobu do ztmavení obrazovky</translation>
<translation id="4722122254122249791">Aktivace izolace webů u určených zdrojů</translation>
<translation id="4722399051042571387">Pokud je tato zásada nastavena na hodnotu false, uživatelé nebudou moci nastavit PIN, který je slabý a lze jej snadno uhodnout.

          Příklady slabých kódů PIN: PIN tvořený pouze jednou opakující se číslicí (1111), PIN se vzestupnou nebo sestupnou řadou číslic (1234 nebo 4321), často používané kódy PIN.

          Pokud uživatelé zadají slabý kód PIN, ve výchozím nastavení se jim zobrazí upozornění (nikoli chyba).</translation>
<translation id="4723829699367336876">Povolení přechodu přes bránu firewall z klienta vzdáleného připojení</translation>
<translation id="4725528134735324213">Povolit službu Android Backup Service</translation>
<translation id="4725801978265372736">Vyžadovat shodu jména místního uživatele a vlastníka hostitele vzdáleného přístupu</translation>
<translation id="4733471537137819387">Zásady související s integrovaným ověřením pomocí protokolu HTTP</translation>
<translation id="4744190513568488164">Servery, na které může <ph name="PRODUCT_NAME" /> delegovat ověření.

Chcete-li zadat několik názvů serverů, oddělte je čárkami. Zástupné znaky (*) jsou povoleny.

Pokud zásadu nenastavíte, <ph name="PRODUCT_NAME" /> nebude delegovat přihlašovací údaje uživatelů ani v případě, že server bude zjištěn jako intranet.</translation>
<translation id="4752880493649142945">Klientský certifikát pro připojení k RemoteAccessHostTokenValidationUrl</translation>
<translation id="4757671984625088193">Pokud je tato zásada nastavená na hodnotu true nebo není nastavená, bude prohlížeč <ph name="PRODUCT_NAME" /> navrhovat stránky související s aktuální stránkou.
      Tyto návrhy se načítají vzdáleně ze serverů Google.

      Pokud je tato zásada nastavená na hodnotu false, návrhy se načítat ani zobrazovat nebudou.</translation>
<translation id="4788252609789586009">Aktivuje v prohlížeči <ph name="PRODUCT_NAME" /> funkci Automatické vyplňování a umožňuje uživatelům automaticky ve webových formulářích vyplňovat informace o platebních kartách pomocí dříve uložených údajů.

      Pokud je toto nastavení vypnuto, nebude automatické vyplňování navrhovat ani vyplňovat informace o platebních kartách a nebude ani ukládat další informace o platebních kartách, které uživatel při prohlížení webu odešle.

      Pokud je toto nastavení zapnuto nebo nemá žádnou hodnotu, uživatel bude moci automatické vyplňování pro platební karty ovládat v uživatelském rozhraní.</translation>
<translation id="4791031774429044540">Aktivuje funkci usnadnění přístupu pomocí velkého kurzoru.

Pokud je tato zásada nastavena na hodnotu true, velký kurzor bude vždy aktivní.

Pokud je tato zásada nastavena na hodnotu false, velký kurzor bude vždy deaktivován.

Pokud tuto zásadu nastavíte, uživatelé ji nebudou moci změnit ani přepsat.

Pokud ji ponecháte nenastavenou, velký kurzor bude ve výchozím nastavení deaktivován, ale uživatelé jej budou moci kdykoli aktivovat.</translation>
<translation id="4802905909524200151">Konfigurace chování aktualizace firmwaru <ph name="TPM_FIRMWARE_UPDATE_TPM" /></translation>
<translation id="4807950475297505572">Bude odstraněno tolik uživatelů, od jejichž posledního použití uplynula nejdelší doba, kolik bude potřeba k uvolnění dostatečného množství místa.</translation>
<translation id="4815725774537609998">Podpora této zásady byla ukončena, použijte místo ní zásadu ProxyMode.

          Umožňuje zadat proxy server, který bude prohlížeč <ph name="PRODUCT_NAME" /> používat, a brání uživatelům ve změně nastavení proxy serveru.

          Pokud zvolíte, že proxy server nikdy používat nechcete a chcete se vždy připojovat přímo, všechny další možnosti budou ignorovány. 

          Pokud zvolíte, že chcete použít systémové nastavení proxy serveru nebo jej zjistit automaticky, všechny další možnosti budou ignorovány.

          Pokud zvolíte ruční nastavení proxy serveru, můžete v zásadách „Adresa (nebo adresa URL) proxy serveru“, „Adresa URL souboru PAC proxy serveru“ a „Seznam pravidel vynechání proxy serveru oddělených čárkami“ zadat další možnosti. Aplikacím ARC je k dispozici pouze proxy server HTTP s nejvyšší prioritou.

          Podrobné příklady naleznete na následující stránce:
          <ph name="PROXY_HELP_URL" />.

          Pokud aktivujete toto nastavení, prohlížeč <ph name="PRODUCT_NAME" /> bude ignorovat veškeré možnosti související s proxy serverem zadané na příkazovém řádku.

          Pokud tato zásada nebude nastavena, uživatelé budou moci nastavení proxy serveru zvolit sami.</translation>
<translation id="4816674326202173458">Povolit firemnímu uživateli být primárním i sekundárním uživatelem (výchozí chování pro nespravované uživatele)</translation>
<translation id="4826326557828204741">Akce, která bude provedena, pokud bude dosaženo limitu doby nečinnosti při provozu na baterii</translation>
<translation id="4834526953114077364">Bude odstraněno tolik uživatelů, od jejichž posledního použití uplynula nejdelší doba, kolik bude potřeba k uvolnění dostatečného množství volného místa. Odstraněni budou pouze uživatelé, kteří se během posledních 3 měsíců nepřihlásili.</translation>
<translation id="4858735034935305895">Povolení režimu celé obrazovky</translation>
<translation id="4861767323695239729">Nakonfigurovat metody zadávání povolené v uživatelské relaci</translation>
<translation id="487460824085252184">Migrovat automaticky, nežádat uživatele o souhlas.</translation>
<translation id="4874982543810021567">Blokovat rozhraní WebUSB na těchto webech</translation>
<translation id="4876805738539874299">Maximální povolená verze SSL</translation>
<translation id="4897928009230106190">Udává parametry, které se použijí při vyhledávání s našeptávačem pomocí metody POST. Sestává z párů název–hodnota oddělených čárkou. Pokud je hodnotou parametr šablony (např. {searchTerms} v příkladu výše), bude nahrazen skutečnými údaji vyhledávacích dotazů.
          Tato zásada je nepovinná. Pokud není nastavena, požadavek na vyhledávání s našeptávačem bude odeslán pomocí metody GET.

          Tato zásada je respektována pouze v případě, že je aktivována zásada DefaultSearchProviderEnabled.</translation>
<translation id="489803897780524242">Parametr nastavující nahrazení vyhledávacích dotazů pro výchozího poskytovatele vyhledávání</translation>
<translation id="4899708173828500852">Aktivovat Bezpečné prohlížení</translation>
<translation id="4899802251198446659">Umožňuje určit, zda se v prohlížeči <ph name="PRODUCT_NAME" /> mohou videa automaticky (bez souhlasu uživatele) přehrávat se zvukovým obsahem.

      Je-li tato zásada nastavena na hodnotu True, může <ph name="PRODUCT_NAME" /> automaticky přehrávat média.
      Je-li tato zásada nastavena na hodnotu False, <ph name="PRODUCT_NAME" /> média automaticky přehrávat nemůže. Toto nastavení lze pro konkrétní vzory adres URL přepsat pomocí zásady AutoplayWhitelist.
      Ve výchozím nastavení <ph name="PRODUCT_NAME" /> média automaticky přehrávat nemůže. Toto nastavení lze pro konkrétní vzory adres URL přepsat pomocí zásady AutoplayWhitelist.

      Pokud je prohlížeč <ph name="PRODUCT_NAME" /> spuštěn a tato zásada se změní, použije se nové nastavení pouze na nově otevřené karty. Některé karty proto mohou nadále vykazovat předchozí chování.
      </translation>
<translation id="4906194810004762807">Obnovovací frekvence zásad pro zařízení</translation>
<translation id="4917385247580444890">Silný</translation>
<translation id="4923806312383904642">Povolit funkci WebDriver přepsat nekompatibilní zásady</translation>
<translation id="494613465159630803">Přijímač Cast</translation>
<translation id="4962262530309732070">Pokud je tato zásada nastavena na hodnotu true nebo nastavena není, bude <ph name="PRODUCT_NAME" /> povolovat přidávání osob ze správce uživatelů.

      Pokud je tato zásada nastavena na hodnotu false, <ph name="PRODUCT_NAME" /> vytváření nových profilů ze správce uživatelů povolovat nebude.</translation>
<translation id="4970855112942626932">Zakázat přihlášení do prohlížeče</translation>
<translation id="4978405676361550165">Pokud je nastavena zásada OffHours, jsou v zadaných časových intervalech ignorovány určené zásady zařízení (použije se jejich výchozí nastavení). Na začátku a konci každého intervalu zadaného v zásadě OffHours prohlížeč Chrome znovu použije zásady zařízení. Pokud se na konci intervalu OffHours zásady zařízení změní, bude o tom uživatel informován a bude se muset odhlásit (například pokud je přihlášen pomocí účtu, který již není povolen).</translation>
<translation id="4980635395568992380">Typ údajů:</translation>
<translation id="4983201894483989687">Povolit spouštění zastaralých pluginů</translation>
<translation id="4988291787868618635">Akce prováděná po určité době nečinnosti</translation>
<translation id="4995548127349206948">Povolení nebo zakázání ověření NTLMv2.</translation>
<translation id="5047604665028708335">Povolit přístup k webům mimo obsahové balíčky</translation>
<translation id="5052081091120171147">Je-li tato zásada aktivovaná, vynucuje import historie procházení z aktuálního výchozího prohlížeče. Aktivace této zásady má také vliv na dialogové okno importu
     
      Je-li deaktivovaná, k importu historie procházení nedojde. Pokud není nakonfigurovaná, bude použito výchozí chování

      Není-li nastavena, může se uživatelům zobrazit výzva, zda chtějí historii importovat, nebo může import probíhat automaticky.</translation>
<translation id="5056708224511062314">Deaktivace lupy</translation>
<translation id="5058573563327660283">Vybrat strategii pro uvolnění místa na disku při automatickém čištění (zastaralé)</translation>
<translation id="5067143124345820993">Seznam povolených uživatelů k přihlášení</translation>
<translation id="5068140065960598044">Cloudové zásady prohlížeče <ph name="PRODUCT_NAME" /> přepisují zásady pro počítač.</translation>
<translation id="5076274878326940940">Umožňuje použití výchozího poskytovatele vyhledávání.

          Pokud toto nastavení aktivujete, po zadání textu (jiného než adresa URL) do omniboxu proběhne výchozí vyhledávání.

          Konkrétního výchozího poskytovatele vyhledávání můžete určit nastavením zbylých zásad výchozího vyhledávání. Pokud je nenastavíte, výchozího poskytovatele si bude moci zvolit uživatel.

          Pokud toto nastavení deaktivujete, po zadání textu do omniboxu (jiného než adresa URL) žádné vyhledávání neproběhne.

          Pokud toto nastavení aktivujete nebo deaktivujete, uživatelé ho v prohlížeči <ph name="PRODUCT_NAME" /> nebudou moci změnit ani přepsat.

Pokud tuto zásadu nenastavíte, bude aktivován výchozí poskytovatel vyhledávání a seznam poskytovatelů vyhledávání bude moci nastavit uživatel.

          Tato zásada je k dispozici jen v instancích systému Windows, které jsou připojené k doméně <ph name="MS_AD_NAME" />, nebo v instancích systému Windows 10 Pro nebo Enterprise, které jsou zaregistrované ke správě zařízení.</translation>
<translation id="5085647276663819155">Deaktivovat náhled tisku</translation>
<translation id="5090209345759901501">Rozšířit nastavení obsahu Flash na veškerý obsah</translation>
<translation id="5093540029655764852">Určuje, jak často (ve dnech) klient mění heslo účtu počítače. Heslo generuje klient náhodně a uživatel jej nemůže zobrazit.

      Hesla počítačů by se stejně jako hesla uživatelů měla pravidelně měnit. Zakázání této zásady nebo její nastavení na velký počet dní může mít negativní dopad na bezpečnost, protože potenciální útočníci budou mít více času zjistit heslo počítače a použít jej.

      Pokud tato zásada není nastavena, mění se heslo účtu počítače každých 30 dní.

      Pokud je tato zásada nastavena na hodnotu 0, je změna hesla počítače zakázána.

      Jestliže byl klient delší dobu offline, mohou být hesla starší než zadaný počet dní.</translation>
<translation id="5105313908130842249">Prodleva uzamčení obrazovky při napájení z baterie</translation>
<translation id="5108031557082757679">Zakázané podnikové tiskárny pro zařízení</translation>
<translation id="5113732180192599620">Tato zásada určuje seznam webů, které nikdy nezpůsobí přepnutí prohlížeče.

      Položky lze do tohoto seznamu přidat také pomocí zásad <ph name="USE_IE_SITELIST_POLICY_NAME" /> a <ph name="EXTERNAL_SITELIST_URL_POLICY_NAME" />.

      Pokud tato zásada není nastavená, nepřidají se do seznamu žádné weby.

      Pokud je tato zásada nastavená, každá položka se považuje za pravidlo, podobně jako v případě zásady <ph name="URL_LIST_POLICY_NAME" />. Logika je však opačná: při shodě s pravidlem se alternativní prohlížeč neotevře.

      Na rozdíl od zásady <ph name="URL_LIST_POLICY_NAME" /> fungují pravidla oběma směry, tj. když je přítomen a zapnut doplněk prohlížeče Internet Explorer, tato zásada také určuje, zda má <ph name="IE_PRODUCT_NAME" /> tyto adresy URL otevírat v prohlížeči <ph name="PRODUCT_NAME" />.</translation>
<translation id="5130288486815037971">Zda jsou v protokolu TLS povoleny šifrovací sady RC4</translation>
<translation id="5141670636904227950">Nastavení výchozího typu lupy, který je aktivován na přihlašovací obrazovce</translation>
<translation id="5142301680741828703">Následující vzory adres URL vykreslovat vždy v pluginu <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="5148753489738115745">Umožňuje nastavit dodatečné parametry, které plugin <ph name="PRODUCT_FRAME_NAME" /> při spouštění aplikace <ph name="PRODUCT_NAME" /> použije.

          Když tato zásada není nastavena, bude použit výchozí příkazový řádek.</translation>
<translation id="5159469559091666409">Udává, jak často se odesílají sledovací síťové pakety (v milisekundách).

      Je-li tato zásada ponechána nenastavená, použije se výchozí interval tři minuty. Minimální interval je 30 sekund a maximální 24 hodin – hodnoty mimo tento rozsah budou přizpůsobeny příslušné hranici.</translation>
<translation id="5163002264923337812">Aktivovat staré webové přihlašování</translation>
<translation id="5182055907976889880">Konfigurace Disku Google v systému <ph name="PRODUCT_OS_NAME" /></translation>
<translation id="5183383917553127163">Umožňuje určit rozšíření, kterých se netýká seznam zakázaných rozšíření.

          Pokud je na seznamu zakázaných rozšíření uvedena hodnota *, znamená to, že jsou na ní všechna rozšíření a uživatelé mohou instalovat pouze rozšíření uvedená v seznamu povolených rozšíření.

          Ve výchozím nastavení jsou všechna rozšíření na seznamu povolených. Pokud však byla všechna rozšíření pomocí zásady umístěna na seznam zakázaných rozšíření, lze tuto zásadu pomocí seznamu povolených přepsat.</translation>
<translation id="519247340330463721">Konfiguruje zásady týkající se Bezpečného prohlížení.</translation>
<translation id="5192837635164433517">Umožňuje využívat alternativní chybové stránky předdefinované v aplikaci <ph name="PRODUCT_NAME" /> (např. stránka nenalezena) a brání uživatelům, aby toto nastavení změnili.

      Pokud toto nastavení aktivujete, budou používány alternativní chybové stránky.

      Pokud toto nastavení deaktivujete, alternativní chybové stránky používány nebudou.

      Pokud toto nastavení aktivujete nebo deaktivujete, uživatelé je v aplikaci <ph name="PRODUCT_NAME" /> nebudou moci změnit ani přepsat.

      Pokud zásadu nenastavíte, aktivuje se toto nastavení a uživatelé je budou moci měnit.</translation>
<translation id="5196805177499964601">Zablokuje režim pro vývojáře.

      Pokud je tato zásada nastavena na hodnotu true, systém <ph name="PRODUCT_OS_NAME" /> zabrání spuštění zařízení v režimu pro vývojáře. Po zapnutí přepínače pro vývojáře se systém odmítne spustit a zobrazí se obrazovka s chybou.

      Pokud tato zásada není nastavena nebo je nastavena na hodnotu false, režim pro vývojáře bude v zařízení nadále k dispozici.</translation>
<translation id="520403427390290017">Funkce životních cyklů karet umožňuje znovu získat kapacitu procesoru a případně také paměť obsazenou spuštěnými kartami, které již dlouhou dobu nebyly použity. Takovým kartám se nejdříve omezí prostředky, poté se zmrazí a nakonec se zahodí.

      Je-li tato zásada nastavena na hodnotu false, jsou životní cykly karet zakázány a všechny karty budou běžně ponechány spuštěné.

      Pokud je tato zásada nastavena na hodnotu true nebo není zadána, je funkce životního cyklu karet povolena.</translation>
<translation id="5207823059027350538">Konfiguruje výchozí adresu URL stránky Nová karta v prohlížeči a znemožňuje uživatelům změnit ji.

          Stránka Nová karta je stránka, která se otevírá při otevření nové karty (včetně karty otevřené v novém okně).

          Tato zásada nerozhoduje o tom, které stránky se mají otevřít při spuštění. To určují zásady <ph name="RESTORE_ON_STARTUP_POLICY_NAME" />. Tato zásada však má vliv na domovskou a počáteční stránku (pokud jsou nastaveny tak, aby otevíraly stránku Nová karta).

          Pokud tato zásada není nastavená nebo je ponechaná prázdná, použije se výchozí stránka Nová karta.

          Tato zásada je k dispozici jen v instancích systému Windows, které jsou připojené k doméně <ph name="MS_AD_NAME" />, nebo v instancích systému Windows 10 Pro nebo Enterprise, které jsou zaregistrované ke správě zařízení.</translation>
<translation id="5208240613060747912">Umožňuje nastavit seznam vzorů adres URL webových stránek, které nemají povoleno zobrazovat oznámení.

         Pokud zásadu nenastavíte, použije se pro všechny webové stránky globální výchozí hodnota buď ze zásady DefaultNotificationsSetting (pokud je nastavena), nebo z osobního nastavení uživatele.</translation>
<translation id="5213038356678567351">Weby, které by nikdy neměly spustit přepnutí prohlížeče.</translation>
<translation id="5219844027738217407">U aplikací Android má tato zásada vliv pouze na mikrofon. Když je tato zásada nastavena na hodnotu True, je mikrofon pro všechny aplikace Android bez výjimky ztlumen.</translation>
<translation id="5228316810085661003">Prodleva automatického přihlášení místního účtu na zařízení.

      Jestliže není nastavena zásada |DeviceLocalAccountAutoLoginId| nemá tato zásada žádný účinek. Jinak:

      Pokud je tato zásada nastavena, určuje dobu bez aktivity uživatele, po které dojde k automatickému přihlášení k účtu v zařízení uvedenému v zásadě |DeviceLocalAccountAutoLoginId|.

      Pokud tato zásada není nastavená, použije se časová prodleva 0 milisekund.

      Tato zásada se zadává v milisekundách.</translation>
<translation id="523505283826916779">Nastavení usnadnění přístupu</translation>
<translation id="5247006254130721952">Blokovat nebezpečná stahování</translation>
<translation id="5248863213023520115">Nastavuje typy šifrování, které jsou povoleny při žádání o lístky Kerberos ze serveru <ph name="MS_AD_NAME" />.

      Je-li tato zásada nastavena na hodnotu Vše, jsou povoleny typy šifrování AES aes256-cts-hmac-sha1-96 a aes128-cts-hmac-sha1-96 i typ šifrování RC4 rc4-hmac. Pokud server podporuje oba typy šifrování, použijete se přednostně šifrování AES. Upozorňujeme, že šifrování RC4 není bezpečné. Je-li to možné, měl by být server překonfigurován tak, aby podporoval šifrování AES.

      Pokud je tato zásada nastavena na hodnotu Silné nebo je ponechána nenastavená, jsou povoleny pouze typy šifrování AES.

      Je-li tato zásada nastavena na hodnotu Starší, je povolen pouze typ šifrování RC4. Tato možnost není bezpečná a měla by se používat pouze za velmi specifických okolností.

      Viz také https://wiki.samba.org/index.php/Samba_4.6_Features_added/changed#Kerberos_client_encryption_types.</translation>
<translation id="5255162913209987122">Doporučuje se</translation>
<translation id="527237119693897329">Umožňuje zadat, kteří hostitelé zasílání nativních zpráv se nemají načítat.

          Hodnota * v seznamu zakázaných hostitelů znamená, že jsou zakázáni všichni hostitelé zasílání nativních zpráv, kteří nejsou uvedeni na seznamu povolených.

          Pokud je tato zásada ponechána nenastavená, <ph name="PRODUCT_NAME" /> bude načítat všechny nainstalované hostitele zasílání nativních zpráv.</translation>
<translation id="5272684451155669299">Pokud má hodnotu true, uživatel může pomocí hardwaru, který je součástí zařízení Chrome, vzdáleně potvrdit svou identitu certifikační autoritě (CA) pro zajištění soukromí prostřednictvím rozhraní <ph name="ENTERPRISE_PLATFORM_KEYS_API" /> pomocí funkce <ph name="CHALLENGE_USER_KEY_FUNCTION" />.

          Pokud má tato zásada hodnotu false nebo není nastavena, volání rozhraní API se nezdaří a bude vrácen kód chyby.</translation>
<translation id="5277806246014825877">Umožnit tomuto uživateli spouštět Crostini.

      Pokud je tato zásada nastavena na hodnotu false, uživatel Crostini spustit nemůže.
      Pokud je nastavena na hodnotu true nebo je ponechána nenastavená, je program Crostini pro uživatele povolen (pokud jej povolují i jiná nastavení).
      Aby bylo povoleno spouštět Crostini, musejí být všechny tři zásady, VirtualMachinesAllowed, CrostiniAllowed a DeviceUnaffiliatedCrostiniAllowed pro Crostini nastaveny na hodnotu true.
      ;Pokud se tato zásada změní na hodnotu false, bude platit pro spouštění nových kontejnerů Crostini, ale již spuštěné kontejnery nebudou ukončeny.</translation>
<translation id="5283457834853986457">Deaktivovat nástroj pro vyhledávání pluginů (podpora ukončena)</translation>
<translation id="5288772341821359899">Je-li nastavena tato zásada, je rozsah portů UDP používaný rozhraním WebRTC omezen na zadaný interval portů (včetně mezních hodnot).

      Pokud tato zásada není nastavena nebo je nastavena na prázdný řetězec nebo neplatný rozsah portů, má rozhraní WebRTC povoleno používat libovolný dostupný místní port UDP.</translation>
<translation id="5290940294294002042">Určete seznam pluginů, které uživatel může povolit nebo zakázat</translation>
<translation id="5304269353650269372">Určuje dobu bez zásahu uživatele, po které se při napájení zařízení z baterie zobrazí okno s upozorněním.

          Pokud je tato zásada nastavena, určuje dobu nečinnosti uživatele, po jejímž uplynutí systém <ph name="PRODUCT_OS_NAME" /> zobrazí okno s upozorněním, že bude provedena akce z důvodu nečinnosti.
         
          Pokud zásada není nastavena, okno s upozorněním se nezobrazí.

          Hodnota zásady by měla být stanovena v milisekundách. Hodnoty musí být menší nebo stejné jako prodleva nečinnosti.</translation>
<translation id="5307432759655324440">Dostupnost anonymního režimu</translation>
<translation id="5318185076587284965">Povolit použití předávacích serverů hostitelem vzdáleného přístupu</translation>
<translation id="5323128137188992869">Umožňuje odesílání obsahu do zařízení pomocí služby <ph name="PRODUCT_NAME" />.

          Je-li tato zásada nastavena na hodnotu False, uživatelé do svého zařízení nebudou moci odesílat obsah. Je-li tato zásada nastavena na hodnotu True, uživatelé obsah odesílat mohou. Pokud tato zásada není nastavena, uživatelé nemohou odesílat obsah do zaregistrovaných zařízení se systémem Chrome OS, ale do nezaregistrovaných zařízení jej odesílat mohou.</translation>
<translation id="5329007337159326804">Upozornění: Přibližně od verze 75 (červenec 2019) bude z prohlížeče <ph name="PRODUCT_NAME" /> zcela odebrána zásada maximální verze TLS.

      Pokud nebude nakonfigurována tato zásada, bude <ph name="PRODUCT_NAME" /> používat výchozí maximální verzi.

      Zásadu lze nastavit na následující hodnoty: tls1.2 nebo tls1.3. Když je nastavena, <ph name="PRODUCT_NAME" /> nebude používat verze protokolu SSL/TLS vyšší než je zadaná verze. Nerozpoznané hodnoty budou ignorovány.</translation>
<translation id="5330684698007383292">Umožnit pluginu <ph name="PRODUCT_FRAME_NAME" /> zpracovávat následující typy obsahu</translation>
<translation id="5365476955714838841">Parametry příkazového řádku pro alternativní prohlížeč.</translation>
<translation id="5365946944967967336">Zobrazit na liště tlačítko Domů</translation>
<translation id="5366745336748853475">Umožňuje zadat seznam vzorů adres URL webů, pro které se na přihlašovací obrazovce v rámci procesu SAML automaticky vybere certifikát klienta, pokud o něj daný web požádá. Tuto zásadu lze využít například k nakonfigurování certifikátu pro celé zařízení, který bude předkládán poskytovateli identity SAML.

      Hodnota musí být pole slovníků JSON převedených na řetězce. Každý slovník musí mít tvar { "pattern": "$URL_PATTERN", "filter" : $FILTER }, kde $URL_PATTERN je vzor nastavení obsahu. $FILTER omezuje klientské certifikáty, ze kterých bude prohlížeč automaticky vybírat. Nezávisle na filtru budou vybrány pouze certifikáty, které odpovídají žádosti serveru o certifikát. Pokud má $FILTER tvar { "ISSUER": { "CN": "$ISSUER_CN" } }, budou navíc vybrány pouze ty klientské certifikáty, které byly vydány certifikátem s běžným názvem $ISSUER_CN. Pokud je $FILTER prázdný slovník, není výběr klientských certifikátů dále nijak omezen.
      Je-li tato zásada ponechána nenastavená, nebude se automatický výběr provádět pro žádný web.</translation>
<translation id="5366977351895725771">Pokud tuto zásadu nastavíte na hodnotu false, vytváření a přihlašování dozorovaných uživatelů bude zakázáno. Všichni existující dozorovaní uživatelé budou stále k dispozici.

          Pokud tuto zásahu nenakonfigurujete nebo ji nastavíte na hodnotu true, tento uživatel bude moci vytvářet a spravovat dozorovaného uživatele.</translation>
<translation id="5369937289900051171">Pouze barevný tisk</translation>
<translation id="5370279767682621504">Povolit podporu protokolu HTTP/0.9 na jiných než výchozích portech</translation>
<translation id="5378985487213287085">Umožňuje nastavit, zda mohou webové stránky zobrazovat oznámení na ploše. Zobrazování oznámení na ploše lze nakonfigurovat tak, že bude ve výchozím nastavení povoleno nebo zakázáno. Také lze nastavit, že se při každém pokusu webových stránek o zobrazení oznámení na ploše zobrazí uživateli výzva.

          Pokud tuto zásadu nenastavíte, použije se zásada AskNotifications a uživatelé ji budou moci změnit.</translation>
<translation id="538108065117008131">Umožňuje pluginu <ph name="PRODUCT_FRAME_NAME" /> zpracovávat následující typy obsahu.</translation>
<translation id="5391388690191341203">Místní účet na zařízení pro automatické přihlášení</translation>
<translation id="5392172595902933844">Informace o stavu systému Android se odesílají zpět na server.

      Je-li tato zásada nastavena na hodnotu False nebo nenastavena, nebudou hlášeny žádné informace o stavu.
      Pokud je nastavena na hodnotu True, informace budou hlášeny.

      Tato zásada se používá pouze v případě, že jsou povoleny aplikace pro Android.</translation>
<translation id="5395271912574071439">Povolí blokování uživatelského rozhraní hostitelů vzdáleného přístupu během připojení.
          Je-li nastavení povoleno, jsou fyzická vstupní a výstupní zařízení hostitele během probíhajícího vzdáleného připojení deaktivována.

          Pokud je nastavení zakázáno nebo není nastaveno, mohou místní nebo vzdálení uživatelé během sdílení provádět interakci s hostitelem.</translation>
<translation id="5396049152026347991">Povolit uživateli spravovat připojení VPN.

      Pokud je tato zásada nastavena na hodnotu false, jsou deaktivovány veškeré prvky uživatelského rozhraní prohlížeče <ph name="PRODUCT_NAME" />, pomocí nichž by uživatel mohl připojení VPN odpojit nebo upravit.

      Pokud tato zásada není nastavena nebo je nastavena na hodnotu true, mohou se uživatelé připojení VPN odpojit nebo upravit jako obvykle.

      Pokud je připojení VPN vytvořeno pomocí aplikace VPN, uživatelské rozhraní v této aplikaci touto zásadou není dotčeno. Uživatel by tedy připojení VPN mohl upravit pomocí této aplikace.

      Tato zásada je určena k použití společně s funkcí Trvalá síť VPN, pomocí níž administrátor při spuštění může aktivovat připojení VPN.</translation>
<translation id="5405289061476885481">Konfiguruje, která rozložení klávesnic jsou povolena na přihlašovací obrazovce systému <ph name="PRODUCT_OS_NAME" />.

      Je-li tato zásada nastavena na seznam metod zadávání, budou na přihlašovací obrazovce k dispozici příslušné metody zadávání. První metoda zadávání bude předvybrána. Když je na přihlašovací obrazovce zakliknut profil konkrétního uživatele, bude kromě metod zadávání definovaných touto zásadou k dispozici také metoda zadávání, kterou uživatel naposledy použil. Pokud tato zásada není nastavena, metody zadávání na přihlašovací obrazovce budou vycházet z jazyka, ve kterém se zobrazuje přihlašovací obrazovka. Hodnoty, které nejsou platnými identifikátory metod zadávání budou ignorovány.</translation>
<translation id="5422643441807528365">Licenční klíč pluginu <ph name="PLUGIN_VM_NAME" /></translation>
<translation id="5423001109873148185">Je-li tato zásada aktivovaná, vynucuje import vyhledávačů z aktuálního výchozího prohlížeče. Aktivace této zásady má také vliv na dialogové okno importu.
     
     Je-li deaktivovaná, k importu výchozího vyhledávače nedojde.

     Není-li nastavena, může se uživatelům zobrazit výzva, zda chtějí vyhledávač importovat, nebo může import probíhat automaticky.</translation>
<translation id="5423197884968724595">Název omezení Android WebView:</translation>
<translation id="5424147596523390018">Povolit všechny barevné režimy</translation>
<translation id="5442026853063570579">Tato zásada také ovládá přístup k možnostem Pro vývojáře v systému Android. Pokud tuto zásadu nastavíte na možnost DeveloperToolsDisallowed (hodnota 2), uživatelé k možnostem Pro vývojáře nebudou mít přístup. Pokud tuto zásadu nastavíte na jinou hodnotu nebo ji nenastavíte, uživatelé budou moci možnosti Pro vývojáře otevřít tak, že v aplikaci Nastavení Android sedmkrát klepnou na číslo sestavení.</translation>
<translation id="5447306928176905178">Povolit hlášení informací o paměti (velikost haldy JavaScriptu) stránce (podpora byla ukončena)</translation>
<translation id="5457065417344056871">Povolit v prohlížeči režim hosta</translation>
<translation id="5457924070961220141">Umožňuje nakonfigurovat výchozí modul vykreslování obsahu HTML, pokud je nainstalován plugin <ph name="PRODUCT_FRAME_NAME" />.
          Pokud není tato zásada nastavena, vykresluje obsah ve výchozím nastavení hostitelský prohlížeč, toto nastavení však můžete přepsat a namísto toho vykreslovat stránky HTML pomocí pluginu <ph name="PRODUCT_FRAME_NAME" />.</translation>
<translation id="5464816904705580310">Konfigurace nastavení pro spravované uživatele</translation>
<translation id="546726650689747237">Prodleva snížení jasu obrazovky při napájení ze sítě</translation>
<translation id="5469143988693423708">Uživatel může spouštět Crostini</translation>
<translation id="5469825884154817306">Blokovat obrázky na těchto stránkách</translation>
<translation id="5472668698895343595">Tato zásada určuje seznam webů, které se mají otevřít v alternativním prohlížeči.

      Položky lze do tohoto seznamu přidat také pomocí zásad <ph name="USE_IE_SITELIST_POLICY_NAME" /> a <ph name="EXTERNAL_SITELIST_URL_POLICY_NAME" />.

      Pokud tato zásada není nastavená, nepřidají se do seznamu žádné weby.

      Pokud je tato zásada nastavená, každá položka se považuje za pravidlo k otevření něčeho v alternativním prohlížeči. <ph name="PRODUCT_NAME" /> na základě těchto pravidel rozhoduje, zda se má adresa URL otevřít v alternativním prohlížeči.

      Pokud je přítomen a aktivován doplněk prohlížeče Internet Explorer a adresa URL neodpovídá žádnému pravidlu, přepne prohlížeč Internet Explorer zpět na <ph name="PRODUCT_NAME" />.

      Pokud si pravidla vzájemně odporují, použije <ph name="PRODUCT_NAME" /> to nejkonkrétnější z nich.</translation>
<translation id="5475361623548884387">Povolit tisk</translation>
<translation id="547601067149622666">Nepovolovat reklamy na webech s rušivými reklamami</translation>
<translation id="5499375345075963939">Tato zásada je aktivní pouze v režimu pro obchody.

      Je-li hodnota zásady nastavena a nerovná se 0, aktuálně přihlášený uživatel ukázky bude automaticky odhlášen po uplynutí zadané délky nečinnosti.

      Hodnota zásady musí být zadána v milisekundách.</translation>
<translation id="5511702823008968136">Aktivovat panel záložek</translation>
<translation id="5512418063782665071">Adresa URL domovské stránky</translation>
<translation id="551639594034811656">Tato zásada určuje seznam procentuálních podílů zařízení se systémem <ph name="PRODUCT_OS_NAME" /> v organizační jednotce, která se aktualizují každý den ode dne prvního objevení aktualizace. Čas objevení je pozdější než čas publikování aktualizace, protože zařízení může dostupnost aktualizací zkontrolovat až nějakou dobu po publikování aktualizace.

Každý pár (den, procento) udává, jaké procento všech zařízení musí být aktualizováno do daného počtu dní od prvního objevení aktualizace. Páry [(4, 40), (10, 70), (15, 100)] například znamenají, že 40 % zařízení má být aktualizováno do 4 dnů po objevení aktualizace, 70 % má být aktualizováno do 10 dnů atd.

Pokud je v této zásadě definovaná nějaká hodnota, budou aktualizace ignorovat zásadu <ph name="DEVICE_UPDATE_SCATTER_FACTOR_POLICY_NAME" /> a budou se namísto ní řídit touto zásadou.

Je-li seznam prázdný, aktualizace se nebudou zavádět na etapy, ale podle jiných zásad zařízení.

Tato zásada se nevztahuje na přepínání mezi kanály.</translation>
<translation id="5526701598901867718">Všechny (není bezpečné)</translation>
<translation id="5529037166721644841">Určuje interval (v ms), ve kterém budou službě správy zařízení zasílány požadavky na informace o zásadách pro zařízení.

      Nastavení této zásady přepíše výchozí hodnotu 3 hodiny. Platné hodnoty pro tuto zásadu jsou v rozsahu od 1800000 (30 minut) do 86400000 (1 den). Místo hodnot mimo tento rozsah bude použita příslušná mezní hodnota.

      Pokud tato zásada nebude nastavena, použije systém <ph name="PRODUCT_OS_NAME" /> výchozí hodnotu, což jsou 3 hodiny.

      Upozorňujeme, že pokud platforma podporuje oznámení o zásadách, budou všechna výchozí nastavení i hodnota této zásady ignorovány a interval aktualizací bude nastaven na 24 hodin. Očekává se totiž, že při změně zásad bude aktualizace vynucena automaticky prostřednictvím oznámení.</translation>
<translation id="5530347722229944744">Blokovat potenciálně nebezpečná stahování</translation>
<translation id="5535973522252703021">Seznam povolených serverů pro delegování ověření protokolu Kerberos</translation>
<translation id="555077880566103058">Povolit všem webům automatické spouštění pluginu <ph name="FLASH_PLUGIN_NAME" /></translation>
<translation id="5559079916187891399">Tato zásada nemá vliv na aplikace Android.</translation>
<translation id="5560039246134246593">Přidá parametr k načítání počáteční hodnoty variace v prohlížeči <ph name="PRODUCT_NAME" />.

      Je-li zásada stanovena, bude k adrese URL přidán parametr dotazu s názvem „omezit“, který se použije k načtení počáteční hodnoty variace. Hodnota parametru bude představovat hodnotu stanovenou v této zásadě.

     Pokud zásada stanovena není, adresa URL počáteční hodnoty variace se nezmění.</translation>
<translation id="5561811616825571914">Automatický výběr certifikátů klienta pro uvedené weby na přihlašovací obrazovce</translation>
<translation id="556941986578702361">Řídí automatické skrývání poličky systému <ph name="PRODUCT_OS_NAME" />.

Pokud je tato zásada nastavena na hodnotu AlwaysAutoHideShelf, polička se vždy automaticky skryje.

Pokud je tato zásada nastavena na hodnotu NeverAutoHideShelf, polička se nikdy automaticky skrývat nebude.

Pokud nastavíte tuto zásadu, uživatelé ji nebudou moci změnit ani přepsat.

Pokud tuto zásadu ponecháte nenastavenou, uživatelé budou moci nastavit automatické skrývání poličky sami.</translation>
<translation id="557360560705413259">Když je toto nastavení zapnuto, u certifikátů bez rozšíření subjectAlternativeName posoudí prohlížeč <ph name="PRODUCT_NAME" /> shodu s názvem hostitele podle údaje commonName serverového certifikátu. Podmínkou je, že certifikát musí být úspěšně ověřen a jeho řetěz důvěryhodnosti musí vést k místně nainstalovaným certifikátům CA.

      Zapnutí této možnost se nedoporučuje, protože může umožnit obejití rozšíření nameConstraints, jež omezuje názvy hostitelů, pro které může být certifikát autorizován.

      Pokud tato zásada není nastavena nebo je nastavena na hodnotu false, certifikáty serverů bez rozšíření subjectAlternativeName, které obsahují buď název DNS nebo IP adresu, nebudou považovány za důvěryhodné.</translation>
<translation id="5581292529942108810">Konfiguruje zásady související s rozšířením Chrome Reporting.

      Tato zásada platí, pouze pokud je povoleno rozšíření <ph name="CHROME_REPORTING_EXTENSION_NAME" /> a počítač je zaregistrován pomocí tokenu <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="5584132346604748282">Ovládání služeb určování polohy Google systému Android</translation>
<translation id="5586942249556966598">Nedělat nic</translation>
<translation id="5592242031005200087">
      Pokud tuto zásadu povolíte, bude se každý z uvedených zdrojů v seznamu odděleném čárkami spouštět ve vlastním procesu. Budou izolovány i zdroje uvedené v subdoménách – např. pokud zadáte web https://example.com/, bude izolována také subdoména https://foo.example.com/, která je jeho součástí.
      Pokud tuto zásadu zakážete, nebude se provádět žádná explicitní izolace webů a zkušební verze zásad IsolateOriginsAndroid a SitePerProcessAndroid budou zakázány. Zásadu IsolateOrigins však uživatelé budou moci povolit ručně pomocí příznaku příkazového řádku.
      Pokud tuto zásadu nenakonfigurujete, uživatel toto nastavení bude moci změnit.

      POZNÁMKA: Na zařízeních Android je izolace webů experimentální. Podpora se postupně bude zlepšovat, ale v současné době tato funkce může způsobovat problémy s výkonem.

      POZNÁMKA: Tato zásada se vztahuje pouze na Chrome pro Android na zařízeních s více než 1 GB paměti RAM. Na jiných platformách než Android použijte zásadu IsolateOrigins.
      </translation>
<translation id="5630352020869108293">Obnovit poslední relaci</translation>
<translation id="5645779841392247734">Povolit soubory cookie na těchto stránkách</translation>
<translation id="5689430183304951538">Výchozí velikost stránky tisku</translation>
<translation id="5693469654327063861">Povolit migraci dat</translation>
<translation id="5694594914843889579">Když je tato zásada nastavena na hodnotu True, externí úložiště nebude k dispozici v prohlížeči souborů.

      Tato zásada má vliv na všechny typy úložných médií. Jedná se například o jednotky USB flash, externí pevné disky, paměťové karty SD a další paměťové karty, optická úložiště apod. Na interní úložiště tato zásada vliv nemá. Soubory ve složce Stažené zůstanou přístupné. Tato zásada nemá vliv ani na Disk Google.

      Pokud je toto nastavení deaktivováno nebo není nakonfigurováno, mohou uživatelé v zařízení používat všechny podporované typy externích úložišť.</translation>
<translation id="5697306356229823047">Hlásit uživatele zařízení</translation>
<translation id="5699487516670033016">Určuje dobu platnosti (v hodinách) mezipaměti ověřovacích údajů. Mezipaměť se používá k urychlení přihlašování. Obsahuje obecná data (název pracovní skupiny apod.) o přidružených sférách, tj. sféry, kterým sféra počítače důvěřuje. Do mezipaměti se neukládají žádné údaje specifické pro uživatele ani žádné údaje týkající se sfér, které nejsou přidruženy. Při restartu zařízení se mezipaměť vymaže.

      Pokud zásada není nastavená, ověřovací údaje uložené v mezipaměti se mohou používat opakovaně po dobu až 73 hodin.

      Pokud je zásada nastavená na hodnotu 0, je ukládání ověřovacích údajů do mezipaměti vypnuté. Může to výrazně zpomalit přihlašování přidružených uživatelů, protože údaje specifické pro sféru je potřeba načíst při každém přihlášení.

      Údaje sféry se ukládají do mezipaměti i u dočasných uživatelů. Pokud je třeba předejít sledování sféry dočasných uživatelů, je mezipaměť nutné vypnout.</translation>
<translation id="570062449808736508">Když je tato zásada nastavena na neprázdný řetězec, služba WebView bude načítat omezení adres URL od poskytovatele obsahu pod zadaným názvem autority.</translation>
<translation id="5701714006401683963">Pokud je tato zásada nastavena na hodnotu false, spravovaná návštěvy hosta se bude chovat podle dokumentace na stránce https://support.google.com/chrome/a/answer/3017014 (jako standardní veřejná návštěvy).

      Pokud je tato zásada nastavena na hodnotu true nebo není nastavena, bude se spravovaná návštěvy hosta chovat jako spravovaná návštěvy, což znamená, že se na ni nebudou vztahovat některá omezení, která se vztahují na běžné veřejné návštěvy.

      Pokud je tato zásada nastavena, uživatel ji nemůže změnit ani přepsat.</translation>
<translation id="572155275267014074">Nastavení zařízení Android</translation>
<translation id="5722934961007828462">Pokud je toto nastavení aktivní, prohlížeč <ph name="PRODUCT_NAME" /> vždy provede kontrolu odvolání u certifikátů serveru, které budou úspěšně ověřeny a podepsány místně nainstalovanými certifikáty CA.

Pokud se prohlížeči <ph name="PRODUCT_NAME" /> údaje o stavu odvolání získat nepodaří, příslušné certifikáty budou považovány za odvolané (selhání).

Pokud tato zásada není nastavena nebo je nastavena na hodnotu false, prohlížeč <ph name="PRODUCT_NAME" /> použije existující online nastavení kontroly odvolání.</translation>
<translation id="5728154254076636808">Povoluje vytvoření cestovních kopií dat profilu <ph name="PRODUCT_NAME" /></translation>
<translation id="5732972008943405952">Importovat při prvním spuštění údaje automatického vyplňování formulářů z výchozího prohlížeče</translation>
<translation id="5765780083710877561">Popis:</translation>
<translation id="5770738360657678870">Verze pro vývojáře (mohou být nestabilní)</translation>
<translation id="5774856474228476867">Adresa URL vyhledávání výchozího poskytovatele vyhledávání</translation>
<translation id="5776485039795852974">Dotázat se vždy, když se webové stránky snaží zobrazit oznámení na ploše</translation>
<translation id="5781412041848781654">Určuje knihovnu GSSAPI, která bude použita pro ověření v protokolu HTTP. Nastavit lze buď pouze název knihovny, nebo celou cestu.

          Pokud nezadáte žádné nastavení, použije prohlížeč <ph name="PRODUCT_NAME" /> výchozí název knihovny.</translation>
<translation id="5781806558783210276">Udává dobu nečinnosti uživatele, po které bude při napájení z baterie provedena úsporná akce.

          Pokud je tato zásada nastavena, jedná se o dobu, po kterou musí uživatel zůstat v nečinnosti, než systém <ph name="PRODUCT_OS_NAME" /> provede úspornou akci. Tuto akci lze nakonfigurovat samostatně.

          Není-li tato zásada nastavena, bude použita výchozí doba.

          Hodnotu zásady zadávejte v milisekundách.</translation>
<translation id="5783009211970309878">Tisknout záhlaví a zápatí</translation>
<translation id="5809728392451418079">Nastavit viditelný název pro místní účty v zařízení</translation>
<translation id="5814301096961727113">Nastavení výchozího stavu hlasové odezvy na přihlašovací obrazovce</translation>
<translation id="5815129011704381141">Automaticky restartovat po aktualizaci</translation>
<translation id="5815353477778354428">Slouží ke konfiguraci adresáře, do kterého bude <ph name="PRODUCT_FRAME_NAME" /> ukládat uživatelská data.

      Pokud tuto zásadu nastavíte, bude <ph name="PRODUCT_FRAME_NAME" /> používat zadaný adresář.

      Seznam proměnných, které můžete použít, naleznete na stránce https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

          Pokud tuto zásadu ponecháte nenastavenou, použije se výchozí adresář.</translation>
<translation id="5826047473100157858">Určuje, zda uživatel může v aplikaci <ph name="PRODUCT_NAME" /> otevřít stránky v anonymním režimu. 

     Je-li zvolena možnost Povoleno, stránky lze otevřít v anonymním režimu.

     Je-li zvolena možnost Zakázáno, stránky nelze otevřít v anonymním režimu. 

     Je-li zvolena možnost Povinné, stránky lze otevřít POUZE v anonymním režimu.</translation>
<translation id="582857022372205358">Povolit oboustranný tisk s vazbou krátkého okraje</translation>
<translation id="583091600226586337">
      Pokud je tato zásada povolena, bude uživatel před stažením každého souboru dotázán, kam jej chce uložit.
      Je-li tato zásada zakázána, bude se stahování souborů spouštět ihned a uživatel nebude tázán, kam chce soubor uložit.
      Pokud tato zásada není nakonfigurována, uživatel může toto nastavení změnit.
      </translation>
<translation id="5832274826894536455">Zásady, jejichž podpora byla ukončena</translation>
<translation id="5835124959204887277">Určuje adresy URL a domény, pro které se při žádosti o atestační certifikáty z bezpečnostních klíčů nezobrazí žádná výzva. Kromě toho se bezpečnostnímu klíči odešle signál, že je možné použít individuální atestaci. Bez tohoto nastavení se uživatelům v Chromu verze 65 nebo vyšší při žádosti webů o atestaci bezpečnostních klíčů zobrazí výzva.

      Adresy URL (jako je https://example.com/nejaka/cesta) se budou porovnávat pouze jako U2F appID. Domény (například example.com) se porovnávají pouze jako ID přijímající strany webauthn. K pokrytí rozhraní API U2F i webauthn pro konkrétní web je proto potřeba uvést jak adresu URL appID, tak doménu.</translation>
<translation id="5836064773277134605">Omezí rozsah portů UDP používaný hostitelem vzdáleného přístupu.</translation>
<translation id="5861856285460256766">Konfigurace rodičovského přístupového kódu</translation>
<translation id="5862253018042179045">Nastavuje výchozí stav funkce usnadnění přístupu pomocí hlasové odezvy na přihlašovací obrazovce.

Pokud je zásada nastavena na hodnotu true, bude při zobrazení obrazovky přihlášení hlasová odezva aktivní.

Pokud je zásada nastavena na hodnotu false, bude při zobrazení přihlašovací obrazovky hlasová odezva deaktivována.

Pokud tuto zásadu nastavíte, uživatelé ji budou moci dočasně přepsat aktivací nebo deaktivací hlasové odezvy. Volba uživatele nicméně nebude trvalá a po opětovném zobrazení přihlašovací obrazovky nebo nečinnosti uživatele na přihlašovací obrazovce po dobu jedné minuty se obnoví původní nastavení.

Pokud tuto zásadu nenastavíte, bude při prvním zobrazení přihlašovací obrazovky hlasová odezva deaktivována. Uživatelé budou moci hlasovou odezvu kdykoli aktivovat nebo deaktivovat a zvolený stav na přihlašovací obrazovce přetrvá i u jiných uživatelů.</translation>
<translation id="5868414965372171132">Konfigurace sítě na úrovni uživatele</translation>
<translation id="5879014913445067283">Ovládání rozpoznávání sdílení síťových položek prostřednictvím rozhraní <ph name="NETBIOS_NAME" /></translation>
<translation id="5883015257301027298">Výchozí nastavení souborů cookie</translation>
<translation id="5887414688706570295">Slouží ke konfiguraci předpony TalkGadget, kterou budou používat hostitelé vzdáleného přístupu, a brání uživatelům, aby ji změnili.

          Je-li tato předpona zadána, je přidána před základní název TalkGadget, čímž vznikne celý název domény TalkGadget. Základní název domény TalkGadget je „.talkgadget.google.com“.

          Je-li toto nastavení zapnuto, budou hostitelé při přihlašování k doméně TalkGadget používat vlastní název domény namísto výchozího názvu.

          Je-li toto nastavení vypnuto nebo není-li nastaveno, pro všechny hostitele bude používán výchozí název domény TalkGadget (chromoting-host.talkgadget.google.com).

          Nastavení této zásady nemá žádný vliv na klienty se vzdáleným přístupem, kteří se k doméně TalkGadget budou přihlašovat vždy pomocí adresy chromoting-client.talkgadget.google.com.</translation>
<translation id="5893553533827140852">Pokud je toto nastavení povoleno, žádosti gnubby o ověření budou zprostředkovány přes připojení ke vzdálenému hostiteli.

          Pokud je toto nastavení zakázáno nebo není nakonfigurováno, žádosti gnubby o ověření nebudou zprostředkovány.</translation>
<translation id="5898486742390981550">Když je přihlášeno několik uživatelů, může aplikace Android používat pouze primární uživatel.</translation>
<translation id="5900196529149231477">
      Tato zásada platí pro přihlašovací obrazovku. Prostudujte si také zásadu <ph name="ISOLATE_ORIGINS_POLICY_NAME" />, která platí pro uživatelskou relaci. Obě zásady doporučujeme nastavit na stejnou hodnotu. Pokud se hodnoty neshodují, může při zahajování uživatelské návštěvy dojít ke zpoždění způsobenému používáním hodnoty zadané v zásadě pro uživatele.
      Pokud tuto zásadu povolíte, každý z uvedených zdrojů v seznamu odděleném čárkami se spustí ve vlastním procesu. Budou izolovány i zdroje uvedené v subdoménách – např. pokud zadáte web https://example.com/, bude izolována také subdoména https://foo.example.com/, která je jeho součástí.
      Pokud je tato zásada zakázána, zásady IsolateOrigins a SitePerProcess budou zakázány. Zásadu IsolateOrigins však uživatelé budou moci povolit ručně pomocí příznaků příkazového řádku.
      Pokud tuto zásadu ponecháte nenakonfigurovanou, použije se pro přihlašovací obrazovku výchozí nastavení platformy týkající se izolace webů.
      </translation>
<translation id="5901427587865226597">Pouze oboustranný tisk</translation>
<translation id="5906199912611534122">Umožňuje aktivovat nebo deaktivovat omezení rychlosti sítě.
      Toto nastavení platí pro všechny uživatele a všechna rozhraní v zařízení. Jakmile je omezení nastaveno,
      zůstane aktivní, dokud nebude deaktivováno změnou této zásady.

      Je-li tato zásada nastavena na hodnotu False, omezení je vypnuto.
      Je-li nastavena na hodnotu True, bude systém omezen tak, aby bylo dosaženo zadaných rychlostí nahrávání a stahování (v kilobitech za sekundu).</translation>
<translation id="5921713479449475707">Povolení stahování automatických aktualizací prostřednictvím protokolu HTTP</translation>
<translation id="5921888683953999946">Nastavuje výchozí stav funkce usnadnění přístupu pomocí velkého kurzoru na přihlašovací obrazovce.

Pokud je tato zásada nastavena na hodnotu true, bude při zobrazení přihlašovací obrazovky velký kurzor aktivní.

Pokud je zásada nastavena na hodnotu false, bude při zobrazení přihlašovací obrazovky velký kurzor deaktivován.

Pokud tuto zásadu nastavíte, uživatelé ji budou moci dočasně přepsat aktivací nebo deaktivací velkého kurzoru. Volba uživatele nicméně nebude trvalá a po opětovném zobrazení přihlašovací obrazovky nebo nečinnosti uživatele na přihlašovací obrazovce po dobu jedné minuty se obnoví původní nastavení.

Pokud tuto zásadu nenastavíte, bude při prvním zobrazení přihlašovací obrazovky velký kurzor deaktivován. Uživatelé budou moci velký kurzor kdykoli aktivovat nebo deaktivovat a zvolený stav na přihlašovací obrazovce přetrvá i u jiných uživatelů.</translation>
<translation id="5929855945144989709">Povolit zařízením spouštět v systému Chrome OS virtuální počítače</translation>
<translation id="5932767795525445337">Tuto zásadu lze využít také k připnutí aplikací pro Android.</translation>
<translation id="5936622343001856595">Vynutí, aby se při použití Vyhledávání Google vždy aktivovalo Bezpečné vyhledávání, a zabrání uživatelům toto nastavení změnit.

      Pokud toto nastavení aktivujete, bude Bezpečné vyhledávání při použití Vyhledávání Google vždy aktivní.

      Pokud toto nastavení deaktivujete nebo nenastavíte žádnou hodnotu, Bezpečné vyhledávání nebude při použití Vyhledávání Google vynuceno.</translation>
<translation id="5946082169633555022">Verze beta</translation>
<translation id="5950205771952201658">Vzhledem k tomu, že online kontroly zamítnutých certifikátů nepřinášejí žádné efektivní bezpečnostní výhody a také snadno selhávají, jsou v prohlížeči <ph name="PRODUCT_NAME" /> verze 19 a vyšší ve výchozím nastavení deaktivovány. Nastavíte-li tuto zásadu na hodnotu True, obnoví se předchozí chování a budou prováděny online kontroly OCSP/CRL.

Pokud tato zásada není nastavena nebo je nastavena na hodnotu False, <ph name="PRODUCT_NAME" /> nebude u verzí <ph name="PRODUCT_NAME" /> 19 a novějších provádět online kontroly zamítnutých certifikátů.</translation>
<translation id="5966615072639944554">Rozšíření, která mohou používat rozhraní API vzdáleného ověření identity</translation>
<translation id="5983708779415553259">Výchozí chování pro stránky, které nejsou součástí žádného obsahového balíčku</translation>
<translation id="5997543603646547632">Ve výchozím nastavení použít 24hodinový formát</translation>
<translation id="5997846976342452720">Určuje, zda má být deaktivován nástroj pro vyhledávání pluginů (podpora ukončena)</translation>
<translation id="6017568866726630990">Zobrazí místo náhledu tisku systémové dialogové okno tisku.

      Pokud je toto nastavení aktivované, prohlížeč <ph name="PRODUCT_NAME" /> zobrazí při požadavku uživatele na tisk stránky systémové dialogové okno tisku (namísto integrovaného náhledu tisku).

      Pokud tato zásada není nastavena nebo je nastavena na hodnotu false, příkaz tisku zobrazí obrazovku s náhledem tisku.</translation>
<translation id="6022948604095165524">Akce při spuštění</translation>
<translation id="6023030044732320798">Určuje sadu zásad, které budou předány běhovému prostředí ARC. Hodnota musí být platný objekt JSON.

      Pomocí této zásady lze nakonfigurovat, které aplikace Android budou v zařízení automaticky nainstalovány:

      {
        "type": "object",
        "properties": {
          "applications": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "packageName": {
                  "description": "Identifikátor aplikace Android, například „com.google.android.gm“ pro Gmail.",
                  "type": "string"
                },
                "installType": {
                  "description": "Udává typ instalace aplikace. OPTIONAL: Aplikace není nainstalována automaticky, ale uživatel ji může nainstalovat. Toto je výchozí nastavení, pokud tato zásada není zadána. PRELOAD: Aplikace je automaticky nainstalována, ale uživatel ji může odinstalovat. FORCE_INSTALLED: Aplikace je automaticky nainstalována a uživatel ji nemůže odinstalovat. BLOCKED: Aplikace je blokována a nelze ji nainstalovat. Pokud byla na základě předchozí zásady nainstalována, odinstaluje se.",
                  "type": "string",
                  "enum": [
                    "OPTIONAL",
                    "PRELOAD",
                    "FORCE_INSTALLED",
                    "BLOCKED"
                  ]
                },
                "defaultPermissionPolicy": {
                  "description": "Zásada k udělování žádostí o oprávnění aplikacím. PERMISSION_POLICY_UNSPECIFIED: Zásada není zadána. Pokud pro oprávnění není zadána žádná zásada na žádné úrovni, použije se ve výchozím nastavení chování PROMPT. PROMPT: Vyzvat uživatele k udělení oprávnění. GRANT: Automaticky oprávnění udělit. DENY: Automaticky oprávnění zamítnout.",
                  "type": "string",
                  "enum": [
                    "PERMISSION_POLICY_UNSPECIFIED",
                    "PROMPT",
                    "GRANT",
                    "DENY"
                  ]
                },
                "managedConfiguration": {
                  "description": "Konfigurační objekt JSON specifický pro aplikaci tvořený sadou párů klíč–hodnota, například "managedConfiguration": { "key1": value1, "key2": value2 }. Klíče jsou definovány v manifestu aplikace.",
                  "type": "object"
                }
              }
            }
          }
        }
      }

      Chcete-li aplikace připnout ke spouštěči, vyhledejte zásadu PinnedLauncherApps.</translation>
<translation id="602728333950205286">Adresa URL dynamického vyhledávání výchozího poskytovatele vyhledávání</translation>
<translation id="603410445099326293">Parametry pro adresu URL návrhu, která používá metodu POST</translation>
<translation id="6036523166753287175">Povolení přechodu přes bránu firewall z hostitele vzdáleného připojení</translation>
<translation id="6070667616071269965">Rozložení klávesnice na přihlašovací obrazovce zařízení</translation>
<translation id="6074963268421707432">Nepovolovat žádnému webu zobrazovat oznámení na ploše</translation>
<translation id="6074964551275531965">Nastavit dobu pro oznámení o aktualizacích</translation>
<translation id="6076099373507468537">Definuje seznam zařízení USB, která lze odpojit od ovladače jádra a použít přímo ve webové aplikaci prostřednictvím rozhraní chrome.usb API. Hodnotami jsou páry identifikátorů (dodavatel a produkt), které určují konkrétní hardwarové zařízení.

      Pokud tato zásada není nastavena, seznam odpojitelných zařízení USB je prázdný.</translation>
<translation id="6083631234867522991">Windows (klienti Windows):</translation>
<translation id="6091233616732024397">Vynutit, aby se uživatelé kvůli používání prohlížeče museli přihlásit</translation>
<translation id="6093156968240188330">Při relacích vzdálené pomoci vzdáleným uživatelům povolit interakci s okny, která vyžadují zvýšená oprávnění</translation>
<translation id="6095999036251797924">Udává dobu bez interakce uživatele, po jejímž uplynutí se při napájení ze sítě nebo z baterie uzamkne obrazovka.

          Pokud je tato doba nastavena na hodnotu vyšší než nula, udává, jak dlouho musí být uživatel neaktivní, než systém <ph name="PRODUCT_OS_NAME" /> uzamkne obrazovku.

          Pokud je tato doba nastavena na nulu, systém <ph name="PRODUCT_OS_NAME" /> obrazovku při neaktivitě uživatele nezamkne.

          Pokud doba není nastavena, použije se výchozí doba.

          Doporučený způsob uzamknutí obrazovky při nečinnosti je povolit uzamčení obrazovky při pozastavení a zapnout pozastavení systému <ph name="PRODUCT_OS_NAME" /> po uplynutí časové prodlevy nečinnosti. Tuto zásadu použijte, pouze pokud chcete obrazovku uzamknout podstatně dříve, než má dojít k pozastavení, nebo pokud pozastavení při nečinnosti vůbec nechcete používat.

          Hodnota této zásady se zadává v milisekundách. Pokud zadáte hodnotu vyšší než je prodleva při nečinnosti, použije se hodnota prodlevy při nečinnosti.</translation>
<translation id="6097601282776163274">Zapnout shromažďování anonymizovaných dat přidružených k adresám URL</translation>
<translation id="6099853574908182288">Výchozí barevný režim tisku</translation>
<translation id="6111936128861357925">Povolit hru s dinosaurem</translation>
<translation id="6114416803310251055">zastaralé</translation>
<translation id="6133088669883929098">Povolit všem webům generovat klíče</translation>
<translation id="6145799962557135888">Umožňuje nastavit seznam vzorů adres URL stránek, kterým je povoleno spouštět JavaScript.

          Pokud zásadu nenastavíte, použije se pro všechny webové stránky globální výchozí hodnota buď ze zásady DefaultJavaScriptSetting (pokud je nastavena), nebo z osobního nastavení uživatele.</translation>
<translation id="614662973812186053">Tato zásada ovládá také shromažďování údajů o využití a diagnostických údajů systému Android.</translation>
<translation id="6153048425064249648">Tato zásada ovládá cloudové hlášení prohlížeče <ph name="PRODUCT_NAME" />, které nahrává informace o provozu prohlížeče do administrátorské konzole Google.

      Když je tato zásada ponechána nenastavená nebo je nastavená na hodnotu False, neshromažďují ani nenahrávají se žádná data.
      Když je tato zásada nastavená na hodnotu True, data se shromažďují a nahrávají do administrátorské konzole Google.
      Nahrávaná data můžete ovládat pomocí zásad ve skupině Rozšíření Chrome Reporting.

      Tato zásada je účinná jen v případě, že je zařízení zaregistrováno pomocí zásady <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.

      Tato zásada vynutí instalaci rozšíření <ph name="CHROME_REPORTING_EXTENSION_NAME" /> k hlášení a přepíše případné zásady, které se ho týkají.</translation>
<translation id="6155247658847899816">Když je tato zásada nastavená, jsou rozlišení a měřítko každé obrazovky nastaveny na zadané hodnoty. Nastavení externích obrazovek platí pro všechny připojené externí obrazovky.

      Hodnoty „external_width“ a „external_height“ je třeba zadat v pixelech. Hodnoty „external_scale_percentage“ a „internal_scale_percentage“ je třeba zadat v procentech.

      Pokud je parametr „external_use_native“ nastavený na hodnotu true, bude zásada ignorovat hodnoty „external_height“ a „external_width“ a nastaví rozlišení externích obrazovek na jejich nativní rozlišení.

      Pokud je parametr „external_use_native“ nastavený na hodnotu false nebo není nastavený a není nastavená jedna z hodnot „external_height“ a „external_width“, zásada na nastavení externích obrazovek nemá vliv. Pokud některá obrazovka zadané rozlišení nebo měřítko nepodporuje, zásada se na ni nepoužije.

      Pokud je příznak „recommended“ nastavený na hodnotu true, uživatelé mohou po přihlášení změnit rozlišení a měřítko libovolné obrazovky pomocí stránky nastavení. Při příštím restartu však budou jejich nastavení přepsána hodnotami ze zásady.
      Pokud je příznak „recommended“ nastavený na hodnotu false nebo není nastavený, uživatelé nemohou nastavení obrazovky změnit.</translation>
<translation id="6155936611791017817">Nastavení výchozího stavu velkého kurzoru na přihlašovací obrazovce</translation>
<translation id="6157537876488211233">Seznam pravidel vynechání proxy serveru oddělených čárkami</translation>
<translation id="6158324314836466367">Název podnikového úložiště aplikací (podpora ukončena)</translation>
<translation id="6181608880636987460">Umožňuje nastavit seznam vzorů adres URL webů, které nemají povoleno spouštět plugin <ph name="FLASH_PLUGIN_NAME" />.

          Pokud tuto zásadu nenastavíte, použije se pro všechny weby globální výchozí hodnota buď ze zásady DefaultPluginsSetting (pokud je nastavena), nebo z osobní konfigurace uživatele.</translation>
<translation id="6190022522129724693">Výchozí nastavení vyskakovacích oken</translation>
<translation id="6190367314942602985">Hlásit identifikační údaje uživatelů</translation>
<translation id="6197453924249895891">Uděluje rozšířením přístup k podnikovým klíčům.

K podnikovému použití jsou určeny ty klíče, které jsou vygenerovány pomocí rozhraní chrome.platformKeys API ve spravovaném účtu. Klíče importované nebo vygenerované jiným způsobem k podnikovému použití určeny nejsou.

Přístup ke klíčům určeným k podnikovému použití je řízen pouze touto zásadou. Uživatel rozšířením přístup k podnikovým klíčům udělit ani odebrat nemůže.

Rozšíření nemůže klíč určený k podnikovému použití ve výchozím nastavení používat. Tento stav je ekvivalentní k nastavení zásady allowCorporateKeyUsage pro dané rozšíření na hodnotu false.

Klíč platformy určený k podnikovému použití může rozšíření k podepisování libovolných dat používat pouze v případě, že je zásada allowCorporateKeyUsage nastavena na hodnotu true. Toto oprávnění byste měli udělit, pouze pokud rozšíření důvěřujete, že dokáže přístup ke klíči zabezpečit před útočníky.</translation>
<translation id="6208896993204286313">Hlásit informace o zásadách prohlížeče <ph name="PRODUCT_NAME" /></translation>
<translation id="6210259502936598222">Hlásit informace o operačním systému a verzi prohlížeče <ph name="PRODUCT_NAME" /></translation>
<translation id="6211428344788340116">Hlásí časy aktivity zařízení.

      Pokud tato zásada není nastavena nebo je nastavena na hodnotu True, budou registrovaná zařízení pravidelně hlásit časová období, kdy uživatel zařízení aktivně používá. Pokud je nastavena na hodnotu False, informace o časech aktivity zařízení se zaznamenávat ani hlásit nebudou.</translation>
<translation id="6212868225782276239">Zobrazují se všechny tiskárny s výjimkou tiskáren v seznamu zakázaných.</translation>
<translation id="6219965209794245435">Je-li tato zásada aktivovaná, vynucuje importování dat automatického vyplňování formulářů z předchozího výchozího prohlížeče. Aktivace této zásady má také vliv na dialogové okno importu.

Je-li zásada deaktivovaná, k importu dat automatického vyplňování formulářů nedojde.

Není-li zásada nastavena, může se uživatelům zobrazit výzva, zda chtějí data importovat, nebo může import probíhat automaticky.</translation>
<translation id="6224304369267200483">Adresy URL/domény s automatickým povolením k přímé atestaci bezpečnostních klíčů</translation>
<translation id="6233173491898450179">Nastavit adresář pro stahování</translation>
<translation id="6244210204546589761">Adresy URL otevírané při spuštění</translation>
<translation id="6258193603492867656">Určuje, zda by měl vygenerovaný hlavní název služby (SPN) protokolu Kerberos obsahovat nestandardní port. 
   
            Pokud toto nastavení aktivujete a bude zadán nestandardní port (tedy jiný port než 80 nebo 443), bude zahrnut do vygenerovaného hlavního názvu služby (SPN) protokolu Kerberos.
            
            Pokud toto nastavení deaktivujete nebo nenastavíte, vygenerovaný hlavní název služby (SPN) protokolu Kerberos port v žádném případě obsahovat nebude.</translation>
<translation id="6261643884958898336">Hlásit informace o počítači</translation>
<translation id="6281043242780654992">Konfiguruje zásady pro zasílání nativních zpráv. Hostitelé zasílání nativních zpráv uvedení na seznamu zakázaných nebudou povoleni (pokud nebudou uvedeni na seznamu povolených hostitelů).</translation>
<translation id="6282799760374509080">Povolit nebo zakázat záznam zvuku</translation>
<translation id="6284362063448764300">TLS 1.1</translation>
<translation id="6310223829319187614">Aktivovat automatické doplňování názvu domény při přihlášení uživatele</translation>
<translation id="6315673513957120120">Pokud uživatel přejde na web, který obsahuje chyby protokolu SSL, Chrome zobrazí stránku s upozorněním. Když je tato zásada nastavena na hodnotu True, mohou uživatelé stránky s upozorněním přeskočit a pokračovat. Platí to také ve výchozím nastavení.
Nastavením této zásady na hodnotu False přeskočení stránky s upozorněním zakážete.</translation>
<translation id="6352543686437322588">Místní účet na zařízení pro automatické přihlášení po prodlevě.

      Pokud je nastavena tato zásada, po uplynutí určité doby na přihlašovací obrazovce bez interakce uživatele se automaticky přihlásí zadaná návštěvy. Místní účet na zařízení již musí být nakonfigurován (viz |DeviceLocalAccounts|).

      Pokud tato zásada není nastavena, automatické přihlášení neproběhne.</translation>
<translation id="6353901068939575220">Udává parametry, které budou použity při vyhledávání adresy URL pomocí metody POST. Sestává z párů název–hodnota oddělených čárkou. Pokud je hodnotou parametr šablony (např. {searchTerms} v příkladu výše), bude nahrazen skutečnými údaji vyhledávacích dotazů.

          Tato zásada je nepovinná. Pokud není nastavena, požadavek na vyhledávání bude odeslán pomocí metody GET.

          Tato zásada je respektována pouze v případě, že je aktivována zásada DefaultSearchProviderEnabled.</translation>
<translation id="6367755442345892511">Zda má být kanál verzí nastavitelný uživatelem</translation>
<translation id="6368011194414932347">Konfigurace adresy URL domovské stránky</translation>
<translation id="6368403635025849609">Povolit JavaScript na těchto stránkách</translation>
<translation id="6376659517206731212">Může být povinné</translation>
<translation id="6377355597423503887">Podpora této zásady byla ukončena, použijte místo ní zásadu BrowserSignin.

Umožňuje uživateli přihlásit se do prohlížeče <ph name="PRODUCT_NAME" />.

Nastavením této zásady můžete nakonfigurovat, zda má uživatel povoleno přihlásit se do prohlížeče <ph name="PRODUCT_NAME" />. Pokud tuto zásadu nastavíte na hodnotu False, aplikace a rozšíření používající rozhraní API chrome.identity nebudou fungovat. Doporučujeme proto namísto toho použít zásadu SyncDisabled.</translation>
<translation id="6378076389057087301">Určuje, zda aktivita zvukových zařízení ovlivňuje správu napájení</translation>
<translation id="637934607141010488">Hlásit seznam uživatelů zařízení, kteří se nedávno přihlásili.

      Pokud je tato zásada nastavena na hodnotu false, informace o uživatelích odesílány nebudou.</translation>
<translation id="6394350458541421998">U systémů <ph name="PRODUCT_OS_NAME" /> verze 29 a novějších byla tato zásada zrušena. Použijte prosím namísto toho zásadu PresentationScreenDimDelayScale.</translation>
<translation id="6401669939808766804">Odhlášení uživatele</translation>
<translation id="6406448383934634215">Pokud je jako akce při spuštění zaškrtnuto políčko „Otevřít seznam adres URL“, tato zásada umožňuje zvolit seznam adres URL, které budou otevřeny. Pokud tato zásada není nastavená, po spuštění se neotevře žádná adresa URL.

          Tato zásada funguje pouze v případě, že je zásada RestoreOnStartup nastavená na hodnotu RestoreOnStartupIsURLs.

          Tato zásada je k dispozici jen v instancích systému Windows, které jsou připojené k doméně <ph name="MS_AD_NAME" />, nebo v instancích systému Windows 10 Pro nebo Enterprise, které jsou zaregistrované ke správě zařízení.</translation>
<translation id="6426205278746959912">U aplikací Android nelze používání proxy serveru vynutit. Aplikacím Android je poskytnuta část nastavení proxy serveru a mohou se rozhodnout, zda tato nastavení budou respektovat.

          Pokud zvolíte, že se proxy server nemá používat, budou aplikace Android informovány, že není nakonfigurován žádný proxy server.

          Pokud zvolíte, že se mají používat systémová nastavení proxy serveru nebo pevně daný proxy server, obdrží aplikace Android adresu a port proxy serveru HTTP. 

          Pokud zvolíte, že se má proxy server zjistit automaticky, obdrží aplikace Android adresu URL skriptu http://wpad/wpad.dat. Žádná jiná část protokolu automatické detekce serveru proxy se nepoužije.

          Pokud zvolíte, že chcete používat skript .pac proxy serveru, obdrží aplikace Android adresu URL skriptu.</translation>
<translation id="6430366557948788869">Rozšíření Chrome Reporting</translation>
<translation id="6440051664870270040">Povolit webům zároveň provádět navigaci a otevírat vyskakovací okna</translation>
<translation id="6447948611083700881">Zálohování a obnovení zakázáno</translation>
<translation id="645425387487868471">Aktivovat vynucené přihlášení do prohlížeče <ph name="PRODUCT_NAME" /></translation>
<translation id="6464074037294098618">Povolit automatické vyplňování pro adresy</translation>
<translation id="6473623140202114570">Konfiguruje seznam domén, na kterých Bezpečné prohlížení nebude zobrazovat upozornění.</translation>
<translation id="6488627892044759800">Nakonfiguruje v prohlížeči <ph name="PRODUCT_NAME" /> typ výchozí domovské stránky a zabrání uživatelům ve změně tohoto nastavení. Domovská stránka může být nastavená buď na konkrétní adresu URL, nebo na stránku Nová karta.

          Pokud toto nastavení aktivujete, jako domovská stránka se vždy použije stránka Nová karta a adresa URL domovské stránky bude ignorována.

          Pokud toto nastavení deaktivujete, stránka Nová karta se jako domovská stránka uživatele použije pouze v případě, že bude adresa URL domovské stránky nastavená na „chrome://newtab“.

          Pokud toto nastavení aktivujete nebo deaktivujete, uživatelé typ domovské stránky v prohlížeči <ph name="PRODUCT_NAME" /> nebudou moci změnit.

Pokud tato zásada nebude nastavená, uživatel bude moci sám zvolit, zda se jako domovská stránka použije stránka Nová karta.

          Tato zásada je k dispozici jen v instancích systému Windows, které jsou připojené k doméně <ph name="MS_AD_NAME" />, nebo v instancích systému Windows 10 Pro nebo Enterprise, které jsou zaregistrované ke správě zařízení.</translation>
<translation id="6491139795995924304">Povolit na zařízení Bluetooth</translation>
<translation id="6495328383950074966">Konfiguruje seznam domén, kterým bude Bezpečné prohlížení důvěřovat: 
      Adresy URL v těchto doménách nebude Bezpečné prohlížení kontrolovat na výskyt nebezpečných zdrojů (např. phishing, malware nebo nežádoucí software).
      Služba Bezpečného prohlížení pro ochranu před staženými soubory nebude kontrolovat stahované soubory hostované v těchto doménách.
      Služba Bezpečného prohlížení pro ochranu hesel na stránkách, jejichž adresy URL odpovídají těmto doménám, nebude kontrolovat opětovné použití hesel.

      Pokud je toto nastavení zapnuté, bude Bezpečné prohlížení těmto doménám důvěřovat.
      Pokud je toto nastavení vypnuté nebo není nastavené, bude se pro všechny zdroje používat výchozí ochrana Bezpečného prohlížení.
      Tato zásada je k dispozici jen v instancích systému Windows, které jsou připojené k doméně <ph name="MS_AD_NAME" />, nebo v instancích systému Windows 10 Pro nebo Enterprise, které jsou zaregistrované ke správě zařízení.</translation>
<translation id="6515357889978918016">Obrázek <ph name="PLUGIN_VM_NAME" /></translation>
<translation id="6520802717075138474">Importování vyhledávačů z výchozího prohlížeče při prvním spuštění</translation>
<translation id="6525955212636890608">Pokud zapnete toto nastavení, na webech, pro které byl v nastavení povolen obsah Flash (buď uživatelem nebo podnikovými zásadami), se bude spouštět veškerý obsah Flash, včetně obsahu z jiných zdrojů a malého obsahu.

      Výběr webů, které mohou spouštět Flash, lze nastavit pomocí zásad DefaultPluginsSetting, PluginsAllowedForUrls a PluginsBlockedForUrls.

      Pokud je toto nastavení zakázáno nebo není nastaveno, obsah Flash z jiných zdrojů a malý obsah může být blokován.</translation>
<translation id="6532769014584932288">Povolit blokování přechodu do režimu spánku</translation>
<translation id="653608967792832033">Udává dobu nečinnosti uživatele, po které bude obrazovka při napájení z baterie uzamčena.

          Pokud je tato zásada nastavena na hodnotu větší než nula, jedná se o dobu, po kterou musí uživatel zůstat v nečinnosti, než systém <ph name="PRODUCT_OS_NAME" /> uzamkne obrazovku.

          Pokud je tato zásada nastavena na nulovou hodnotu, systém <ph name="PRODUCT_OS_NAME" /> obrazovku při nečinnosti uživatele neuzamkne.

          Není-li tato zásada nastavena, bude použita výchozí doba.

          Doporučený způsob zamykání obrazovky při nečinnosti je povolit uzamčení obrazovky v režimu spánku a nastavit časovou prodlevu pro přechod systému <ph name="PRODUCT_OS_NAME" /> do režimu spánku. Tuto zásadu doporučujeme použít pouze v případě, že chcete obrazovku zamknout o mnoho dříve, než nastane přechod do režimu spánku, nebo pokud nechcete režim spánku využívat vůbec.

          Hodnotu zásady zadávejte v milisekundách. Maximální hodnota je nižší než prodleva režimu spánku.</translation>
<translation id="6536600139108165863">Automaticky restartovat po vypnutí zařízení</translation>
<translation id="6539246272469751178">Na aplikace Android tato zásada nemá vliv. Aplikace Android používají pro stažené soubory vždy výchozí adresář a k souborům, které systém <ph name="PRODUCT_OS_NAME" /> stáhl do jiného než výchozího adresáře, nemají přístup.</translation>
<translation id="654303922206238013">Strategie migrace pro šifrování ecryptfs</translation>
<translation id="6544897973797372144">Pokud je tato zásada nastavena na hodnotu True a zásada ChromeOsReleaseChannel není určena, uživatelé smějí v zařízení změnit kanál verzí. Pokud je tato zásada nastavena hodnotu False, zařízení je uzamčeno v kanálu, ve kterém bylo naposledy nastaveno.

      Kanál vybraný uživatelem bude přepsán zásadou ChromeOsReleaseChannel, avšak je-li kanál zásady stabilnější než kanál nainstalovaný v zařízení, změní se kanál až ve chvíli, kdy bude pro stabilnější kanál k dispozici vyšší verze než pro kanál nainstalovaný k zařízení.</translation>
<translation id="6553143066970470539">Procento jasu obrazovky</translation>
<translation id="6559057113164934677">Nedovolit žádnému webu používat kameru a mikrofon</translation>
<translation id="6561396069801924653">Zobrazit možnosti usnadnění přístupu v nabídce panelu systému</translation>
<translation id="6563458316362153786">Aktivovat rychlé převádění 802.11r</translation>
<translation id="6565312346072273043">Nastavuje výchozí stav funkce usnadnění přístupu pomocí softwarové klávesnice na přihlašovací obrazovce.

          Pokud je tato zásada nastavena na hodnotu true, bude při zobrazení přihlašovací obrazovky softwarová klávesnice aktivní.

          Pokud je zásada nastavena na hodnotu false, bude při zobrazení přihlašovací obrazovky softwarová klávesnice deaktivována.

          Pokud tuto zásadu nastavíte, uživatelé ji budou moci dočasně přepsat aktivací nebo deaktivací softwarové klávesnice. Volba uživatele nicméně nebude trvalá a po opětovném zobrazení přihlašovací obrazovky nebo nečinnosti uživatele na přihlašovací obrazovce po dobu jedné minuty se obnoví původní nastavení.

          Pokud tuto zásadu nenastavíte, bude při prvním zobrazení přihlašovací obrazovky softwarová klávesnice deaktivována. Uživatelé budou moci softwarovou klávesnici kdykoli aktivovat nebo deaktivovat a zvolený stav na přihlašovací obrazovce přetrvá i u jiných uživatelů.</translation>
<translation id="6573305661369899995">Nastavit externí zdroj omezení adres URL</translation>
<translation id="6598235178374410284">Obrázek avatara uživatele</translation>
<translation id="6603004149426829878">Při určování časového pásma na server vždy odesílat všechny dostupné signály týkající se polohy</translation>
<translation id="6628120204569232711">Hlásit stav úložiště</translation>
<translation id="6628646143828354685">Umožňuje nastavit, zda weby mají povoleno získat přístup k blízkým zařízením Bluetooth. Přístup lze zcela zablokovat nebo je možné uživatele požádat pokaždé, když web chce získat přístup k blízkým zařízením Bluetooth.

          Pokud je tato zásada ponechána nenastavená, použije se hodnota „3“ a uživatel ji bude moci změnit.</translation>
<translation id="663685822663765995">Omezit barevný režim tisku</translation>
<translation id="6641981670621198190">Deaktivovat podporu rozhraní API pro 3D grafiku</translation>
<translation id="6647965994887675196">Pokud tuto zásadu nastavíte na hodnotu true, lze vytvářet a používat dozorovaného uživatele.

          Pokud tuto zásadu nenakonfigurujete nebo ji nastavíte na hodnotu false, bude vytváření a přihlašování dozorovaných uživatelů zakázáno. Všichni existující dozorovaní uživatelé budou skryti.

          POZNÁMKA: Výchozí chování pro zákaznická a podniková zařízení se liší. V zákaznických zařízeních budou dozorovaní uživatelé ve výchozím nastavení aktivní, zatímco v podnikových zařízeních nikoli.</translation>
<translation id="6649397154027560979">Podpora této zásady byla ukončena, použijte prosím namísto ní seznam URLBlacklist.

Deaktivuje uvedená schémata protokolů v prohlížeči <ph name="PRODUCT_NAME" />.
Adresy URL, které používají schémata uvedená v tomto seznamu, se nebudou načítat a nebude na ně možné přejít.

Pokud bude tato zásada ponechána nenastavená nebo bude seznam prázdný, bude v prohlížeči <ph name="PRODUCT_NAME" /> možné používat všechna schémata.</translation>
<translation id="6652197835259177259">Nastavení místně spravovaných uživatelů</translation>
<translation id="6658245400435704251">Určí počet sekund, o který může zařízení náhodně zdržet stahování aktualizace od doby, kdy byla poprvé zveřejněna na serveru. Zařízení může čekat určitý čas a pokusit se o určitý počet kontrol aktualizací. Zpoždění je však v každém případě omezeno neměnným maximálním časovým limitem tak, aby zařízení nečekalo na stažení aktualizace donekonečna.</translation>
<translation id="6665670272107384733">Nastavit, jak často musí uživatel zadat heslo, pokud chce používat rychlé odemknutí</translation>
<translation id="6681229465468164801">Umožňuje nastavit seznam vzorů adres URL webů, které uživatele nesmějí žádat o přístup k zařízení USB.

          Pokud tuto zásadu nenastavíte, použije se pro všechny webové stránky globální výchozí hodnota buď ze zásady DefaultWebUsbGuardSetting (pokud je nastavena), nebo z osobního nastavení uživatele.

          Vzory adres URL v této zásadě by neměly být v konfliktu se vzory nakonfigurovanými pomocí zásady WebUsbAskForUrls. Není jasně dáno, která z těchto dvou zásad má přednost, pokud adresa URL odpovídá oběma.</translation>
<translation id="6689792153960219308">Nahlásit stav hardwaru</translation>
<translation id="6698632841807204978">Povolit monochromatický tisk</translation>
<translation id="6699880231565102694">Povolit dvoufázové ověření pro hostitele vzdáleného přístupu</translation>
<translation id="6731757988219967594">Filtrovat weby nejvyšší úrovně (ale nikoliv vložené prvky iframe) s obsahem pouze pro dospělé</translation>
<translation id="6734521799274931721">Ovládá dostupnost sdílených síťových složek pro Chrome OS</translation>
<translation id="6735701345096330595">Vynutit povolení jazyků kontroly pravopisu</translation>
<translation id="673699536430961464">Toto nastavení uživatelům umožňuje přepínat mezi účty Google v obsahové oblasti okna prohlížeče po přihlášení k zařízení <ph name="PRODUCT_OS_NAME" />.

      Je-li tato zásada nastavena na hodnotu false, přihlášení k jinému učtu z obsahové oblasti neanonymního okna prohlížeče nebude povoleno.

      Pokud tato zásada není nastavena nebo je nastavena na hodnotu true, použije se výchozí chování: přihlášení k jinému účtu z obsahové oblasti prohlížeče bude povoleno s výjimkou dětských účtů, u nichž bude v obsahové oblasti neanonymních oken blokováno.

      Pokud nechcete povolovat přihlášení k jinému účtu pomocí anonymního režimu, zvažte zablokování tohoto režimu pomocí zásady IncognitoModeAvailability.

      Upozorňujeme, že uživatelé budou moci získat přístup ke službám Google v neověřeném stavu tím, že zablokují soubory cookie.</translation>
<translation id="6738326937072482736">Konfiguruje dostupnost a chování funkce aktualizace firmwaru <ph name="TPM_FIRMWARE_UPDATE_TPM" />.

Jednotlivá nastavení lze zadat ve vlastnostech objektu JSON:

<ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_POWERWASH" />: Pokud je nastavena na hodnotu <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_POWERWASH_TRUE" />, uživatelé budou moci spustit proces Powerwash a nainstalovat aktualizaci firmwaru <ph name="TPM_FIRMWARE_UPDATE_TPM" />.

<ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_PRESERVE_DEVICE_STATE" />: Pokud je nastavena na hodnotu <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_PRESERVE_DEVICE_STATE_TRUE" />, uživatelé budou moci spustit proces aktualizace firmwaru <ph name="TPM_FIRMWARE_UPDATE_TPM" />, při kterém zůstane zachován stav celého zařízení (včetně registrace do podnikové sítě), ale budou ztracena data uživatele. Tento aktualizovaný postup je k dispozici od verze 68.

Pokud tato zásada není nastavena, funkce aktualizace firmwaru <ph name="TPM_FIRMWARE_UPDATE_TPM" /> nebude k dispozici.</translation>
<translation id="6757438632136860443">Umožňuje nastavit seznam vzorů adres URL webů, které mají povoleno spouštět plugin <ph name="FLASH_PLUGIN_NAME" />.

          Pokud tuto zásadu nenastavíte, použije se pro všechny weby globální výchozí hodnota buď ze zásady DefaultPluginsSetting (pokud je nastavena), nebo z osobní konfigurace uživatele.</translation>
<translation id="6762235610019366960">Umožňuje ovládat prezentaci propagačního nebo vzdělávacího obsahu na celou kartu v prohlížeči <ph name="PRODUCT_NAME" />.

      Pokud tato zásada není nakonfigurována nebo je povolena (nastavena na hodnotu true), může <ph name="PRODUCT_NAME" /> uživatelům ukazovat obsah na celou kartu s informacemi o službách.

      Pokud je tato zásada zakázána (nastavena na hodnotu false), <ph name="PRODUCT_NAME" /> uživatelům obsah na celou kartu s informacemi o službách zobrazovat nebude.

      Toto nastavení ovládá prezentaci uvítacích stránek, které uživatelům pomáhají přihlásit se do prohlížeče <ph name="PRODUCT_NAME" />, zvolit jej jako výchozí prohlížeč nebo je jinak informují o funkcích služeb.</translation>
<translation id="6766216162565713893">Povolit webům žádat uživatele o udělení přístupu k blízkému zařízení Bluetooth</translation>
<translation id="6770454900105963262">Nahlásit aktivní návštěvy veřejného terminálu</translation>
<translation id="6786747875388722282">Rozšíření</translation>
<translation id="6786967369487349613">Nastavit adresář cestovního profilu</translation>
<translation id="6810445994095397827">Blokovat JavaScript na těchto stránkách</translation>
<translation id="681446116407619279">Podporovaná schémata ověření</translation>
<translation id="6816212867679667972">Určuje název hostitele používaný pro zařízení v požadavcích DHCP.

      Je-li tato zásada nastavena na neprázdný řetězec, použije se daný řetězec pro zařízení jako název hostitele v požadavku DHCP.

      Řetězec může obsahovat proměnné ${ASSET_ID}, ${SERIAL_NUM}, ${MAC_ADDR} a ${MACHINE_NAME}, které se v zařízení nahradí hodnotami, čímž vznikne název hostitele. Po nahrazení by měl vzniknout platný název hostitele (odpovídající sekci 3.1 specifikace RFC 1035).

      Pokud tato zásada není nastavena nebo název hostitele po nahrazení nebude platný, v požadavku DHCP žádný název hostitele nastaven nebude. </translation>
<translation id="6835883744948188639">Zobrazovat uživateli opakovaně výzvu s oznámením, že je doporučen restart</translation>
<translation id="6837480141980366278">Určuje, zda se v prohlížeči <ph name="PRODUCT_NAME" /> používá integrovaný klient DNS.

Pokud je tato zásada nastavená na hodnotu true, použije se integrovaný klient DNS (pokud je k dispozici).

      Pokud je tato zásada nastavená na hodnotu false, integrovaný klient DNS se nikdy nepoužije.

      Pokud tato zásada není nastavená, integrovaný klient DNS bude v systémech MacOS, Android (když není zapnutá funkce Soukromé DNS ani VPN) a ChromeOS ve výchozím nastavení zapnutý a uživatelé jeho používání budou moci změnit úpravou příznaku chrome://flags nebo zadáním příznaku příkazového řádku.</translation>
<translation id="6838056959556423778">Přepíše v prohlížeči <ph name="PRODUCT_NAME" /> pravidla výběru výchozí tiskárny.

      Tato zásada určuje pravidla pro výběr výchozí tiskárny v prohlížeči <ph name="PRODUCT_NAME" />, který se provede při prvním použití funkce tisku v profilu.

      Je-li tato zásada nastavena, <ph name="PRODUCT_NAME" /> se pokusí najít tiskárnu, která odpovídá všem zadaným atributům, a vybrat ji jako výchozí. Bude vybrána první tiskárna, která tuto zásadu splňuje. Pokud zásadě odpovídá více tiskáren, může být v závislosti na tom, v jakém pořadí jsou tiskárny objeveny, vybrána kterákoliv z nich.

      Pokud tato zásada není nastavena nebo do vypršení časového limitu odpovídající tiskárna není nalezena, vybere se integrovaná virtuální tiskárna na vytváření souborů PDF. Pokud tiskárna na vytváření souborů PDF není k dispozici, nebude vybrána žádná tiskárna.

      Hodnota se analyzuje jako objekt JSON odpovídající následujícímu schématu:
      {
        "type": "object",
        "properties": {
          "kind": {
            "description": "Informace o tom, zda má být vyhledávání odpovídající tiskárny omezeno na konkrétní množinu tiskáren.",
            "type": "string"
            "enum": [ "local", "cloud" ]
          },
          "idPattern": {
            "description": "Regulární výraz, kterému musí odpovídat ID tiskárny.",
            "type": "string"
          },
          "namePattern": {
            "description": "Regulární výraz, kterému musí odpovídat zobrazovaný název tiskárny.",
            "type": "string"
          }
        }
      }

      Tiskárny připojené ke službě <ph name="CLOUD_PRINT_NAME" /> jsou považovány za cloudové („<ph name="PRINTER_TYPE_CLOUD" />“), ostatní jsou klasifikovány jako místní („<ph name="PRINTER_TYPE_LOCAL" />“).
      Vynechání pole znamená, že v něm budou vyhovovat všechny hodnoty. Pokud například nezadáte způsob připojení, při náhledu tisku se spustí vyhledávání všech typů tiskáren: místních i cloudových.
      Regulární výrazy musejí odpovídat syntaxi objektů RegExp jazyka JavaScript a při vyhledávání shod se rozlišují velká a malá písmena.</translation>
<translation id="6843296367238757293">Podpora této zásady byla ukončena. Doporučujeme nepoužívat ji. Další informace najdete na stránce https://support.google.com/chrome/a/answer/7643500</translation>
<translation id="684856667300805181">Tato zásada byla ve verzi 68 prohlížeče <ph name="PRODUCT_NAME" /> odstraněna a nahrazena zásadou <ph name="ARC_GLS_POLICY_NAME" />.</translation>
<translation id="6856743875250214792">Tato zásada je zastaralá a ve verzi M66 byla odstraněna, protože byla používána pouze k internímu testování a představovala bezpečnostní ohrožení.

      Udává příznaky, které mají být na prohlížeč <ph name="PRODUCT_NAME" /> použity při spuštění (použijí se pouze na přihlašovací obrazovce). Příznaky nastavené prostřednictvím této zásady nezasahují do uživatelských relací.</translation>
<translation id="685769593149966548">Vynutit přísný omezený režim pro YouTube</translation>
<translation id="6857824281777105940">Tato zásada určuje, zda se mají hlásit informace Bezpečného prohlížení, včetně počtu upozornění Bezpečného prohlížení a počtu prokliků upozornění Bezpečného prohlížení.

Pokud tato zásada není nastavena nebo je nastavena na hodnotu True, informace Bezpečného prohlížení se shromažďují.
Pokud je tato zásada nastavena na hodnotu False, informace Bezpečného prohlížení se neshromažďují.

Tato zásada platí, pouze pokud je povoleno rozšíření <ph name="CHROME_REPORTING_EXTENSION_NAME" /> a počítač je zaregistrován pomocí tokenu <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="686079137349561371">Microsoft Windows 7 nebo novější</translation>
<translation id="687046793986382807">V prohlížečích <ph name="PRODUCT_NAME" /> verze 35 a novějších byla tato zásada zrušena.

      Informace o paměti jsou stránce hlášeny bez ohledu na nastavení této možnosti. Velikosti jsou však hlášeny jen po určitých přírůstcích a frekvence aktualizací je z bezpečnostních důvodů omezena. Chcete-li získat přesná data v reálném čase, použijte prosím nástroje, jako je Telemetry.</translation>
<translation id="6894178810167845842">Adresa URL stránky Nová karta</translation>
<translation id="6899705656741990703">Zjistit nastavení proxy serveru automaticky</translation>
<translation id="6903814433019432303">Tato zásada je aktivní pouze v režimu pro obchody.

      Určuje soubor adres URL, které se načtou po zahájení ukázkové návštěvy. Tato zásada přepíše ostatní mechanismy pro nastavení úvodní adresy URL a může být tedy uplatněna pouze u návštěvy, která není přiřazena konkrétnímu uživateli.</translation>
<translation id="6908640907898649429">Slouží ke konfiguraci výchozího poskytovatele vyhledávání. Můžete uživatelům zvolit výchozího poskytovatele vyhledávání nebo výchozí vyhledávání deaktivovat.</translation>
<translation id="6913068954484253496">Povolit prohlížeči <ph name="PRODUCT_NAME" /> připojovat se k zařízením Cast na všech IP adresách.</translation>
<translation id="6915442654606973733">Aktivuje funkci usnadnění přístupu pomocí hlasové odezvy.

Pokud je tato zásada nastavena na hodnotu true, bude hlasová odezva vždy aktivní.

Pokud je tato zásada nastavena na hodnotu false, bude hlasová odezva vždy deaktivována.
Pokud tuto zásadu nastavíte, uživatelé ji nebudou moci změnit ani přepsat.

Pokud ji ponecháte nenastavenou, bude hlasová odezva ve výchozím nastavení deaktivována, ale uživatelé ji budou moci kdykoli aktivovat.</translation>
<translation id="6916507170737609563">
      Chcete-li využívat izolaci, ale omezit její dopad na uživatele, použijte zásadu IsolateOriginsAndroid se seznamem webů, které chcete izolovat. Toto nastavení SitePerProcessAndroid izoluje všechny weby.
      Pokud tuto zásadu povolíte, bude se každý web spouštět ve vlastním procesu.
      Pokud tuto zásadu zakážete, nebude se provádět žádná explicitní izolace webů a zkušební verze zásad IsolateOriginsAndroid a SitePerProcessAndroid budou zakázány. Uživatelé však zásadu SitePerProcess budou moci aktivovat ručně.
      Pokud tuto zásadu nenakonfigurujete, uživatel toto nastavení bude moci změnit.

      POZNÁMKA: Na zařízeních Android je izolace webů experimentální. Podpora se postupně bude zlepšovat, ale v současné době tato funkce může způsobovat problémy s výkonem.

      POZNÁMKA: Tato zásada se vztahuje pouze na Chrome pro Android na zařízeních s více než 1 GB paměti RAM. Na jiných platformách než Android použijte zásadu SitePerProcess.
      </translation>
<translation id="6922884955650325312">Blokovat plugin <ph name="FLASH_PLUGIN_NAME" /></translation>
<translation id="6923366716660828830">Určuje název výchozího poskytovatele vyhledávání. Je-li toto pole ponecháno prázdné, bude použit název hostitele určený adresou URL vyhledávání.

          Tato zásada bude dodržována pouze v případě, že je aktivována zásada DefaultSearchProviderEnabled.</translation>
<translation id="6926703471186170050">Povolit oboustranný tisk s vazbou dlouhého okraje</translation>
<translation id="6931242315485576290">Deaktivovat synchronizaci dat se servery Google</translation>
<translation id="6936894225179401731">Určuje maximální počet souběžných připojení k proxy serveru.

      Některé servery proxy nedokážou zpracovat vysoký počet souběžných připojení na jednoho klienta, což lze vyřešit nastavením této zásady na nižší hodnotu. 

      Hodnota této zásady by měla být nižší než 100 a vyšší než 6. Výchozí hodnota je 32.

      Některé webové aplikace jsou známy tím, že v důsledku zablokovaných požadavků GET využívají mnoho připojení. Snížení hodnoty na méně než 32 může při otevření většího množství takových webových aplikací vést k zablokování síťových funkcí prohlížeče. Chcete-li hodnotu snížit pod výchozí hodnotu, činíte tak na vlastní riziko.

     Není-li zásada nastavena, bude použita výchozí hodnota, což je 32.</translation>
<translation id="6943577887654905793">Název nastavení v systémech Mac/Linux:</translation>
<translation id="6944167205014013774">Informace o využití Linuxových aplikací se odesílají na server.

Je-li tato zásada nastavena na hodnotu False nebo nenastavena, nebudou hlášeny žádné informace o využití. Pokud je nastavena na hodnotu True, informace budou hlášeny.

Tato zásada se používá pouze v případě, že jsou povoleny aplikace pro Linux.</translation>
<translation id="69525503251220566">Parametr poskytující funkci vyhledávání podle obrázku pro výchozího poskytovatele vyhledávání</translation>
<translation id="6956272732789158625">Nepovolit žádnému webu generovat klíče</translation>
<translation id="6965859329738616662">Udává, zda chytrý model ztmavování může prodloužit dobu do ztmavení obrazovky.

      Když se má obrazovka ztmavit, chytrý model ztmavování posoudí, zda by se ztmavení obrazovky nemělo odložit. Pokud chytrý model ztmavování ztmavení obrazovky odloží, prodlouží se tím doba do ztmavení obrazovky. Prodlevy vypnutí obrazovky, uzamčení obrazovky a nečinnosti se v tomto případě upraví tak, aby mezi nimi a prodlevou ztmavení zůstala původně nakonfigurovaná doba.
      Pokud je tato zásada nastavená na hodnotu True nebo není nastavená, bude chytrý model ztmavování zapnut a bude mít povoleno prodloužit dobu do ztmavení obrazovky. Pokud je tato zásada nastavená na hodnotu False, chytrý model ztmavování na ztmavení obrazovky nebude mít vliv.</translation>
<translation id="6994082778848658360">Udává, jak lze integrovaný bezpečnostní hardwarový prvek používat k dvoufaktorovému ověření, pokud je s touto funkcí kompatibilní. Ke zjištění fyzické přítomnosti uživatele se používá vypínač počítače.

      Pokud je vybrána možnost Deaktivováno, druhý faktor není k dispozici.

      Pokud je vybrána možnost U2F, bude se integrovaný druhý faktor chovat podle specifikace FIDO U2F.

      Pokud je vybrána možnost U2F_EXTENDED, bude integrovaný druhý faktor poskytovat funkce U2F plus rozšíření pro individuální atestaci.</translation>
<translation id="6997592395211691850">Určuje, zda jsou online kontroly OCSP/CRL vyžadovány pro místní kotvy důvěryhodnosti.</translation>
<translation id="7003334574344702284">Je-li tato zásada aktivovaná, vynucuje import uložených hesel z předchozího výchozího prohlížeče. Aktivace této zásady má také vliv na dialogové okno importu.

     Je-li deaktivovaná, k importu hesel nedojde. 

      Není-li nastavena, může se uživatelům zobrazit výzva, zda chtějí hesla importovat, nebo může import probíhat automaticky.</translation>
<translation id="7003746348783715221">Nastavení prohlížeče <ph name="PRODUCT_NAME" /></translation>
<translation id="7006788746334555276">Nastavení obsahu</translation>
<translation id="7007671350884342624">Slouží ke konfiguraci adresáře, do kterého bude <ph name="PRODUCT_NAME" /> ukládat uživatelská data.

      Pokud tuto zásadu nastavíte, <ph name="PRODUCT_NAME" /> bude používat stanovený adresář bez ohledu na to, zda uživatel zadal příznak „--user-data-dir“. Abyste předešli ztrátě dat a jiným neočekávaným chybám, nenastavujte tuto zásadu na kořenový adresář svazku ani na adresář používaný k dalším účelům, protože obsah adresáře spravuje prohlížeč <ph name="PRODUCT_NAME" />.

      Seznam proměnných, které lze použít, naleznete na stránce https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Pokud tuto zásadu nenastavíte, použije se výchozí cesta profilu a uživatelé ji budou moci přepsat pomocí příznaku příkazového řádku „--user-data-dir“.</translation>
<translation id="7027785306666625591">Konfiguruje správu napájení v systému <ph name="PRODUCT_OS_NAME" />.

      Tato zásada umožňuje konfigurovat chování systému <ph name="PRODUCT_OS_NAME" /> po určité době nečinnosti uživatele.</translation>
<translation id="7040229947030068419">Ukázková hodnota:</translation>
<translation id="7044883996351280650">Ovládání služby zálohování a obnovení systému Android</translation>
<translation id="7049373494483449255">Aktivuje v aplikaci <ph name="PRODUCT_NAME" /> odesílání dokumentů k tisku do služby <ph name="CLOUD_PRINT_NAME" />. POZNÁMKA: Zásada ovlivní pouze podporu služby <ph name="CLOUD_PRINT_NAME" /> v aplikaci <ph name="PRODUCT_NAME" />. Nezabraňuje uživatelům v odesílání tiskových úloh na webových stránkách.

      Pokud je toto nastavení aktivováno nebo není nakonfigurováno, uživatelé mohou ve službě <ph name="CLOUD_PRINT_NAME" /> tisknout z dialogového okna tisku v aplikaci <ph name="PRODUCT_NAME" />.

      Pokud je nastavení deaktivováno, uživatelé nemohou ve službě <ph name="CLOUD_PRINT_NAME" /> z dialogového okna tisku v aplikaci <ph name="PRODUCT_NAME" /> tisknout</translation>
<translation id="7053678646221257043">Je-li tato zásada aktivovaná, vynucuje import záložek z aktuálního výchozího prohlížeče. Aktivace této zásady má také vliv na dialogové okno importu.

      Je-li deaktivovaná, nebudou importovány žádné záložky.

      Není-li nastavena, může se uživatelům zobrazit výzva, zda chtějí záložky importovat, nebo může import probíhat automaticky.</translation>
<translation id="7063895219334505671">Povolit na těchto stránkách vyskakovací okna</translation>
<translation id="706568410943497889">
      Je-li zásada nastavena na hodnotu true, má <ph name="PRODUCT_NAME" /> povoleno shromažďovat protokoly událostí WebRTC ze služeb Google (např. Google Meet) a nahrávat je do Googlu.

      Je-li zásada nastavena na hodnotu false nebo je ponechána nenastavená, prohlížeč <ph name="PRODUCT_NAME" /> takové protokoly shromažďovat ani nahrávat nesmí.

      Tyto protokoly obsahují diagnostické údaje, které jsou užitečné při odstraňování problémů s audio nebo videohovory v Chromu, jako je čas a velikost odeslaných a přijatých paketů RTP, zpětná vazba ohledně zahlcení sítě a metadata ohledně času a kvality snímků zvuku a videa. Protokoly neobsahují zvukový ani obrazový obsah z hovoru.

      Toto shromažďování dat Chromem mohou spustit pouze webové služby Googlu, například Google Hangouts nebo Google Meet.

      Kvůli snazšímu ladění může Google tyto protokoly prostřednictvím ID návštěvy přidružit k jiným protokolům shromažďovaným samotnou službou Google.
      </translation>
<translation id="706669471845501145">Povolit webovým stránkám zobrazovat oznámení na ploše</translation>
<translation id="7072208053150563108">Frekvence změny hesla počítače</translation>
<translation id="7079519252486108041">Blokovat vyskakovací okna na těchto webech</translation>
<translation id="7085803328069945025">Umožňuje nastavit seznam vzorů adres URL webů, které uživatele mohou žádat o přístup k zařízení USB.

          Pokud tuto zásadu nenastavíte, použije se pro všechny webové stránky globální výchozí hodnota buď ze zásady DefaultWebUsbGuardSetting (pokud je nastavena), nebo z osobního nastavení uživatele.

          Vzory adres URL v této zásadě by neměly být v konfliktu se vzory nakonfigurovanými prostřednictvím zásady WebUsbBlockedForUrls. Není jasně dáno, která z těchto dvou zásad má přednost, pokud adresa URL odpovídá oběma.</translation>
<translation id="7106631983877564505">Aktivovat zámek, pokud jsou zařízení se systémem <ph name="PRODUCT_OS_NAME" /> nečinná nebo pozastavená.

      Pokud toto nastavení aktivujete, uživatelům se po probuzení zařízení z režimu spánku bude zobrazovat výzva k odemknutí zadáním hesla.

      Pokud toto nastavení deaktivujete, výzva k odemknutí zadáním hesla se uživatelům po probuzení zařízení z režimu spánku zobrazovat nebude.

      Pokud toto nastavení aktivujete nebo deaktivujete, uživatelé je nebudou moci změnit ani přepsat.

      Pokud tuto zásadu ponecháte nenastavenou, uživatel bude moci zvolit, zda výzvu k odemknutí zařízení zadáním hesla chce zobrazovat, či nikoliv.</translation>
<translation id="7115494316187648452">Určuje, zda je proces <ph name="PRODUCT_NAME" /> spuštěn při přihlášení do operačního systému a zda pokračuje v běhu i po uzavření posledního okna prohlížeče (což umožňuje, aby zůstaly aktivní aplikace na pozadí i aktuální návštěvy prohlížení včetně všech souborů cookie). Proces na pozadí zobrazuje ikonu na hlavním panelu systému, kde jej lze kdykoli zavřít.

Pokud je tato zásada nastavena na hodnotu true, režim na pozadí je aktivován a uživatel jej nemůže ovládat v nastaveních prohlížeče.

Pokud je tato zásada nastavena na hodnotu false, režim na pozadí je deaktivován a uživatel jej nemůže ovládat v nastaveních prohlížeče.

Pokud je tato zásada ponechána nenastavená, režim na pozadí je ve výchozím nastavení deaktivován, ale uživatel jej může ovládat v nastaveních prohlížeče.</translation>
<translation id="7123266440503901785">Prohlížeč <ph name="PRODUCT_NAME" /> zajišťuje bezpečnou aktualizaci a instalaci rozšíření. Obsah některých rozšíření hostovaných mimo Internetový obchod Chrome však může být chráněn jen nedostatečně bezpečnými podepisovacími nebo hašovacími algoritmy, jako je například SHA1. Pokud je tato zásada vypnutá, Chrome nové instalace a aktualizace takových rozšíření nebude povolovat (dokud vývojáři do rozšíření neimplementují bezpečnější algoritmy). Pokud je tato zásada zapnutá, instalace a aktualizace takových rozšíření jsou povoleny.

          Pokud tato zásada není nastavená, prohlížeč se chová, jako kdyby byla zapnutá.
          Od verze <ph name="PRODUCT_NAME" /> 75 se jako výchozí bude používat chování odpovídající vypnuté zásadě.

          Od verze <ph name="PRODUCT_NAME" /> 77 tato zásada bude ignorována a prohlížeč se bude chovat, jako kdyby byla vypnutá.</translation>
<translation id="7126716959063786004">Umožnit ukončování procesů ve Správci úloh</translation>
<translation id="7127892035367404455">Vrátit se k cílové verzi</translation>
<translation id="7128918109610518786">Seznam identifikátorů aplikací, které se v <ph name="PRODUCT_OS_NAME" /> zobrazují jako připnuté na liště spouštěče.

      Když je zásada nakonfigurována, jsou tyto aplikace pevně dány a uživatel je nemůže změnit.

      Pokud zásada nastavena není, uživatel seznam aplikací ve spouštěči změnit může.</translation>
<translation id="7132877481099023201">Adresy URL, kterým bude udělen přístup pro záznam videa bez zobrazení výzvy</translation>
<translation id="7138678301420049075">Ostatní</translation>
<translation id="7158064522994309072">Tato zásada určuje, který příkaz se má použít k otevření adres URl v alternativním prohlížeči.

      Když tato zásada není nastavená, použije se výchozí nastavení platformy: v systému Windows se spustí Internet Explorer, v systému Mac OS X se spustí Safari a v Linuxu se spuštění alternativního prohlížeče nezdaří.

      Když je tato zásada nastavená na jednu z hodnot ${ie}, ${firefox}, ${safari} nebo ${opera}, spustí se příslušný prohlížeč (pokud je nainstalován). Možnost ${ie} je k dispozici pouze v systému Windows a možnost ${safari} je k dispozici pouze v systémech Windows a Mac OS X.

      Když je tato zásada nastavená na cestu souboru, použije se příslušný spustitelný soubor.</translation>
<translation id="7167436895080860385">Umožnit uživatelům zobrazit hesla ve Správci hesel (podpora ukončena)</translation>
<translation id="7173856672248996428">Dočasný profil</translation>
<translation id="717630378807352957">Povolit všechny tiskárny z konfiguračního souboru.</translation>
<translation id="7176721759719212761">Určuje, zda je povoleno blokování přechodu obrazovky do režimu spánku. O blokování přechodu obrazovky do režimu spánku mohou žádat aplikace ARC a rozšíření prostřednictvím rozhraní API pro řízení spotřeby.

          Pokud je tato zásada nastavená na hodnotu true nebo není nastavená a zásada AllowWakeLocks není nastavená na hodnotu false, bude blokování přechodu obrazovky do režimu spánku při řízení spotřeby dodržováno.

          Pokud je tato zásada nastavená na hodnotu false, budou žádosti o blokování přechodu obrazovky do režimu spánku změněny na žádosti o blokování přechodu systému do režimu spánku.</translation>
<translation id="7185078796915954712">TLS 1.3</translation>
<translation id="718956142899066210">Typy připojení, pro které jsou povoleny aktualizace</translation>
<translation id="7194407337890404814">Název výchozího poskytovatele vyhledávání</translation>
<translation id="7202925763179776247">Povolit omezení stahování</translation>
<translation id="7207095846245296855">Vynutit Bezpečné vyhledávání Google</translation>
<translation id="7216442368414164495">Umožnit uživatelům přihlášení k rozšířeným přehledům Bezpečného prohlížení</translation>
<translation id="7221822638060296742">Umožňuje nastavit, zda mohou weby automaticky spouštět plugin <ph name="FLASH_PLUGIN_NAME" />. Automatické spouštění pluginu <ph name="FLASH_PLUGIN_NAME" /> lze buď pro všechny weby povolit, nebo naopak zakázat.

          Plugin <ph name="FLASH_PLUGIN_NAME" /> lze spustit pomocí funkce přehrání kliknutím. Uživatel však jeho spuštění musí aktivovat kliknutím na zástupný symbol.

          Automatické přehrávání je povoleno pouze u domén, které jsou výslovně uvedeny v zásadě <ph name="PLUGINS_ALLOWED_FOR_URLS_POLICY_NAME" />. Chcete-li automatické přehrávání povolit pro všechny weby, přidejte do tohoto seznamu položky http://* a https://*.

          Pokud je tato zásada ponechána nenastavená, uživatel toto nastavení bude moci ručně změnit.</translation>
<translation id="7229876938563670511">Nakonfiguruje v prohlížeči <ph name="PRODUCT_NAME" /> adresu URL výchozí domovské stránky a zabrání uživatelům, aby toto nastavení změnili.

          Domovská stránka je stránka, která se otevírá tlačítkem Domovská stránka. Stránky, které se otevírají po spuštění, jsou určeny zásadami RestoreOnStartup.

          Typ domovské stránky může být nastaven na adresu URL, kterou zde zadáte, nebo na stránku Nová karta. Pokud zvolíte stránku Nová karta, tato zásada se nebude uplatňovat.

          Pokud toto nastavení aktivujete, uživatelé v prohlížeči <ph name="PRODUCT_NAME" /> nebudou moci změnit adresu URL domovské stránky. Jako domovskou stránku však stále budou moci nastavit stránku Nová karta.

          Pokud tuto zásadu nenastavíte a není nastavená ani zásada HomepageIsNewTabPage, uživatelé si budou moci zvolit vlastní domovskou stránku.

          Tato zásada je k dispozici jen v instancích systému Windows, které jsou připojené k doméně <ph name="MS_AD_NAME" />, nebo v instancích systému Windows 10 Pro nebo Enterprise, které jsou zaregistrované ke správě zařízení.</translation>
<translation id="7229975860249300121">Obsahuje regulární výraz určující účty Google, které lze v prohlížeči <ph name="PRODUCT_NAME" /> nastavit jako primární (tj. jako účet, který se vybere během procesu přihlášení k synchronizaci).

      Pokud se uživatel pokusí nastavit v prohlížeči primární účet s uživatelským jménem, které se neshoduje s tímto vzorem, zobrazí se odpovídající chybová zpráva.

      Pokud tato zásada není nastavena nebo je prázdná, může uživatel v prohlížeči <ph name="PRODUCT_NAME" /> jako primární nastavit libovolný účet Google.</translation>
<translation id="723103540848640830">Určit minimální délku kódu PIN pro odemknutí obrazovky</translation>
<translation id="7232816984286843471">Je-li tato zásada nastavena na hodnotu false, cizí uživatelé nebudou moci používat Crostini.

      Pokud tato zásada není nastavena nebo je nastavena na hodnotu true, mohou Crostini používat všichni uživatelé (jestliže to povolují i jiná nastavení).
      Aby bylo povoleno spouštět Crostini, musejí být všechny tři zásady, VirtualMachinesAllowed, CrostiniAllowed a DeviceUnaffiliatedCrostiniAllowed pro Crostini nastaveny na hodnotu true.
      Pokud se tato zásada změní na hodnotu false, bude platit pro spouštění nových kontejnerů Crostini, ale již spuštěné kontejnery nebudou ukončeny.</translation>
<translation id="7234280155140786597">Názvy zakázaných hostitelů zasílání nativních zpráv (nebo * pro vše)</translation>
<translation id="7236775576470542603">Nastavuje výchozí typ lupy, který je aktivován na přihlašovací obrazovce.

Pokud je tato zásada nastavena, ovládá typ lupy, který je aktivní, když je zobrazena přihlašovací obrazovka. Nastavíte-li zásadu na hodnotu Žádné, lupa se deaktivuje. 

Pokud tuto zásadu nastavíte, uživatelé ji budou moci dočasně přepsat aktivací nebo deaktivací lupy. Volba uživatele nicméně nebude trvalá a po opětovném zobrazení přihlašovací obrazovky nebo nečinnosti uživatele na přihlašovací obrazovce po dobu jedné minuty se obnoví původní nastavení.

Pokud tuto zásadu nenastavíte, bude při prvním zobrazení přihlašovací obrazovky lupa deaktivována. Uživatelé budou moci lupu kdykoli aktivovat nebo deaktivovat a zvolený stav na přihlašovací obrazovce přetrvá i u jiných uživatelů.</translation>
<translation id="7249828445670652637">Povolit aplikacím ARC používání certifikátů CA systému <ph name="PRODUCT_OS_NAME" /></translation>
<translation id="7258823566580374486">Povolit blokování uživatelského rozhraní hostitelů vzdáleného přístupu</translation>
<translation id="7260277299188117560">Automatické aktualizace pomocí sítě p2p aktivovány</translation>
<translation id="7261252191178797385">Obrázek tapety zařízení</translation>
<translation id="7264704483008663819">Podpora této zásady byla ve verzi M68 ukončena. Použijte namísto ní zásadu DeveloperToolsAvailability.

      Deaktivuje nástroje pro vývojáře a konzoli JavaScriptu.

      Pokud toto nastavení aktivujete, nebude možné používat Nástroje pro vývojáře ani kontrolovat prvky webových stránek. Deaktivovány budou také veškeré klávesové zkratky a položky klasických či kontextových nabídek, pomocí kterých lze nástroje pro vývojáře nebo konzoli JavaScriptu otevřít.

      Pokud tuto možnost deaktivujete nebo ponecháte nenastavenou, uživatelé Nástroje pro vývojáře a konzoli JavaScriptu budou moci používat.

      Pokud je nastavena zásada DeveloperToolsAvailability, je hodnota zásady DeveloperToolsDisabled ignorována.</translation>
<translation id="7266471712301230894">Tato zásada byla z prohlížeče <ph name="PRODUCT_NAME" /> verze 64 odstraněna.

      Automatické vyhledávání a instalace chybějících pluginů již nejsou podporovány.</translation>
<translation id="7267809745244694722">Mediální klávesy ve výchozím nastavení slouží jako funkční klávesy</translation>
<translation id="7271085005502526897">Importování domovské stránky z výchozího prohlížeče při prvním spuštění</translation>
<translation id="7273823081800296768">Pokud je toto nastavení aktivní nebo není nakonfigurováno, uživatelé mohou zapnout párování klientů a hostitelů při připojování. Pak nebude nutné zadávat pokaždé kód PIN.

          Pokud je toto nastavení deaktivováno, tato funkce nebude dostupná.</translation>
<translation id="7275334191706090484">Spravované záložky</translation>
<translation id="7295019613773647480">Aktivovat dozorovaného uživatele</translation>
<translation id="7301543427086558500">Určuje seznam alternativních adres URL, ze kterých lze získat vyhledávací dotazy pro vyhledávač. Tyto adresy URL by měly obsahovat řetězec <ph name="SEARCH_TERM_MARKER" />, podle kterého budou vyhledávací dotazy rozpoznány.

          Tato zásada není povinná. Pokud není nastavena, nebudou vyhledávací dotazy získávány z alternativních adres URL.

          Tato zásada platí pouze v případě, že je aktivována zásada DefaultSearchProviderEnabled.</translation>
<translation id="7302043767260300182">Prodleva uzamčení obrazovky při napájení ze sítě</translation>
<translation id="7311458740754205918">Pokud je tato zásada nastavena na hodnotu True nebo je ponechána nenastavená, na stránce Nová karta se mohou zobrazovat návrhy obsahu na základě historie procházení, zájmů nebo polohy uživatele.

      Pokud je tato zásada nastavena na hodnotu False, automaticky generované návrhy obsahu se na stránce Nová karta nezobrazují.</translation>
<translation id="7313793931637495417">Tato zásada určuje, zda budou hlášeny informace o verzi, jako je verze, platforma a architektura operačního systému, verze prohlížeče <ph name="PRODUCT_NAME" /> a kanál prohlížeče <ph name="PRODUCT_NAME" />.

Pokud tato zásada není nastavena nebo je nastavena na hodnotu True, informace o verzi se shromažďují.
Pokud je tato zásada nastavena na hodnotu False, informace o verzi se neshromažďují.

Tato zásada platí, pouze pokud je povoleno rozšíření <ph name="CHROME_REPORTING_EXTENSION_NAME" /> a počítač je zaregistrován pomocí tokenu <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="7323896582714668701">Dodatečné parametry příkazového řádku pro <ph name="PRODUCT_NAME" /></translation>
<translation id="7326394567531622570">Podobné jako možnost Wipe (hodnota 2), ale pokusí se zachovat přihlašovací tokeny, aby se uživatel nemusel znovu přihlašovat.</translation>
<translation id="7329842439428490522">Udává dobu nečinnosti uživatele, po které bude obrazovka při napájení z baterie vypnuta.

           Pokud je tato zásada nastavena hodnotu větší než nula, jedná se o dobu, po kterou musí uživatel zůstat v nečinnosti, než systém <ph name="PRODUCT_OS_NAME" /> obrazovku vypne.

           Pokud je tato zásada nastavena na nulovou hodnotu, systém <ph name="PRODUCT_OS_NAME" /> obrazovku při nečinnosti uživatele nevypne.

           Není-li tato zásada nastavena, bude použita výchozí doba.

           Hodnotu zásady zadávejte v milisekundách. Maximální hodnota je stejná jako prodleva režimu spánku.</translation>
<translation id="7329968046053403405">Udává typ účtů poskytovaných ověřovací aplikací Android, která podporuje ověření protokolu <ph name="HTTP_NEGOTIATE" /> (např. ověření protokolem Kerberos). Tyto informace by měl poskytnout dodavatel ověřovací aplikace. Další podrobnosti naleznete na adrese https://goo.gl/hajyfN.

Pokud nezadáte žádné nastavení, ověření protokolu <ph name="HTTP_NEGOTIATE" /> v systému Android bude zakázáno.</translation>
<translation id="7331962793961469250">Je-li nastavena možnost True, na stránce Nová karta se nezobrazí propagace aplikací z Internetového obchodu Chrome.

      Je-li nastavena možnost False, nebo není-li možnost nastavena, propagace aplikací z Internetového obchodu Chrome se na stránce Nová karta zobrazí</translation>
<translation id="7332963785317884918">Tato zásada se již nepoužívá. Systém <ph name="PRODUCT_OS_NAME" /> vždy použije strategii vyčištění RemoveLRU.

      Ovládá chování při automatickém čištění zařízení se systémem <ph name="PRODUCT_OS_NAME" />. Automatické čištění se spustí, když množství volného místa na disku dosáhne kritické hranice a je třeba získat více místa.

      Je-li tato zásada nastavena na hodnotu RemoveLRU, budou při automatickém čištění odstraňováni uživatelé, kteří se nejdelší dobu nepřihlásili, dokud nevznikne dostatek volného místa.

      Je-li tato zásada nastavena na hodnotu RemoveLRUIfDormant, budou při automatickém čištění odstraňováni uživatelé, kteří se nejdelší dobu nepřihlásili, dokud nevznikne dostatek volného místa. Uživatelé, kteří se přihlásili během posledních 3 měsíců, však odstraněni nebudou.

      Pokud tato zásada nastavena není, bude při automatickém čištění použita výchozí integrovaná strategie. Aktuálně je to strategie RemoveLRUIfDormant.</translation>
<translation id="7336878834592315572">Uchovat soubory cookie po dobu trvání návštěvy</translation>
<translation id="7337967786223261174">Konfiguruje seznam tiskáren.

Tato zásada administrátorům umožňuje poskytnout uživatelům konfigurace tiskáren.

Hodnoty <ph name="PRINTER_DISPLAY_NAME" /> a <ph name="PRINTER_DESCRIPTION" /> jsou volně upravitelné textové řetězce, pomocí kterých lze usnadnit výběr tiskárny. Hodnoty <ph name="PRINTER_MANUFACTURER" /> a <ph name="PRINTER_MODEL" /> koncovým uživatelům umožní snáze tiskárnu rozpoznat. Představují výrobce a model tiskárny. Hodnotou <ph name="PRINTER_URI" /> by měla být adresa přístupná z klientského počítače, včetně údajů <ph name="URI_SCHEME" />, <ph name="URI_PORT" /> a <ph name="URI_QUEUE" />. Hodnota <ph name="PRINTER_UUID" /> je volitelná. Pokud je zadána, slouží k odebrání duplicitních tiskáren <ph name="ZEROCONF_DISCOVERY" />.

Hodnota <ph name="PRINTER_EFFECTIVE_MODEL" /> musí odpovídat jednomu z řetězců, které představují tiskárny podporované systémem <ph name="PRODUCT_NAME" />. Řetězec se použije k identifikaci a instalaci vhodného souboru PPD pro tiskárnu. Další informace naleznete na stránce https://support.google.com/chrome?p=noncloudprint.

Nastavení tiskárny se dokončí při jejím prvním použití. Soubory PPD se stáhnou až při použití tiskárny. Často používané soubory PPD budou následně uloženy do mezipaměti.

Tato zásada nemá vliv na to, zda uživatelé mohou konfigurovat tiskárny na jednotlivých zařízeních. Je zamýšlena jako doplněk ke konfiguraci tiskáren ze strany jednotlivých uživatelů.

U zařízení spravovaných pomocí služby Active Directory tato zásada podporuje rozšíření <ph name="MACHINE_NAME_VARIABLE" /> na název počítače ve službě Active Directory nebo jeho podřetězec. V případě názvu počítače <ph name="MACHINE_NAME_EXAMPLE" /> by byl řetězec <ph name="MACHINE_NAME_VARIABLE_EXAMPLE" /> nahrazen čtyřmi znaky po šesté pozici, tj. <ph name="MACHINE_NAME_PART_EXAMPLE" />. Pozice se počítají od nuly.
Podpora proměnné <ph name="MACHINE_NAME_VARIABLE_LOWERCASE" />(malá písmena) je ve verzi M71 ukončena ve verzi M72 bude odstraněna.
      </translation>
<translation id="7340034977315324840">Hlásit časy aktivity zařízení</translation>
<translation id="7343497214039883642">Konfigurační soubor podnikových tiskáren pro zařízení</translation>
<translation id="7349338075015720646">Určuje seznam webových stránek, které se instalují na pozadí bez zásahu uživatele a které uživatel nemůže odinstalovat ani deaktivovat.

      Každá položka v seznamu zásady je objekt se dvěma členy: „url“ a „launch_container“. „url“ má být adresa URL webové aplikace k instalaci a „launch_container“ má být buď „window“ (okno) nebo „tab“ (karta), aby bylo zadáno, jak bude webová aplikace po nainstalování otevřena. Pokud člen „launch_container“ vynecháte, aplikace se spustí v okně, jestliže Chrome vyhodnotí, že se jedná o progresivní webovou aplikaci, a v ostatních případech se spustí na kartě.</translation>
<translation id="735902178936442460">Tato zásada určuje, zda se mají hlásit informace umožňující identifikaci počítačů, jako jsou název počítače a síťové adresy.

Pokud tato zásada není nastavena nebo je nastavena na hodnotu True, informace umožňující identifikaci počítačů se shromažďují.
Pokud je tato zásada nastavena na hodnotu False, informace umožňující identifikaci počítačů se neshromažďují.

Tato zásada platí, pouze pokud je povoleno rozšíření <ph name="CHROME_REPORTING_EXTENSION_NAME" /> a počítač je zaregistrován pomocí tokenu <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="7367028210010532881">Když uživatel přejde na web, který je označen jako potenciálně škodlivý, zobrazí služba Bezpečné prohlížení stránku s upozorněním. Aktivace tohoto nastavení zabrání uživatelům pokračovat ze stránky s upozorněním na škodlivý web.

      Pokud je toto nastavení deaktivováno nebo není nakonfigurováno, uživatelé mohou po zobrazení upozornění pokračovat na nahlášený web.

      Další informace o Bezpečném prohlížení najdete na stránce https://developers.google.com/safe-browsing.</translation>
<translation id="737655323154569539">Pokud zásada nebude nastavena nebo bude nastavena jako prázdná, bude to považováno za žádné omezení.</translation>
<translation id="7417972229667085380">Procento prodloužení prodlevy režimu nečinnosti v režimu prezentace (podpora ukončena)</translation>
<translation id="7421483919690710988">Nastavit velikost diskové mezipaměti médií v bajtech</translation>
<translation id="7424751532654212117">Seznam výjimek ze seznamu deaktivovaných pluginů</translation>
<translation id="7426112309807051726">Určuje, zda má být zakázána optimalizace <ph name="TLS_FALSE_START" />. Z historických důvodů se tato zásada nazývá DisableSSLRecordSplitting.

Pokud tato zásada není nastavena nebo je nastavena na hodnotu False, optimalizace <ph name="TLS_FALSE_START" /> bude aktivována. Je-li nastavena na hodnotu True, optimalizace <ph name="TLS_FALSE_START" /> bude zakázána.</translation>
<translation id="7433714841194914373">Aktivovat Dynamický režim</translation>
<translation id="7443061725198440541">Pokud tato zásada není nastavena nebo je povolena, má uživatel dovoleno používat kontrolu pravopisu.

      Je-li tato zásada zakázána, uživatel kontrolu pravopisu používat nemůže. Pokud je tato zásada zakázána, bude také ignorována zásada SpellcheckLanguage.
      </translation>
<translation id="7443616896860707393">Požadavky typu cross-origin standardu HTTP Basic Auth</translation>
<translation id="7458437477941640506">Pokud je verze operačního systému novější než cílová verze, nevracet se k cílové verzi. Jsou zakázány i aktualizace.</translation>
<translation id="7464991223784276288">Omezit soubory cookie z odpovídajících adres URL na aktuální relaci</translation>
<translation id="7469554574977894907">Aktivovat návrhy pro vyhledávání</translation>
<translation id="7474249562477552702">Udává, zda jsou povoleny certifikáty podepsané algoritmem SHA-1 vydané místními kotvami důvěryhodnosti</translation>
<translation id="7485481791539008776">Pravidla výběru výchozí tiskárny</translation>
<translation id="749556411189861380">Hlásí verzi operačního systému a firmwaru v registrovaných zařízeních.

      Pokud tato zásada není nastavena nebo je nastavena na hodnotu True, budou registrovaná zařízení pravidelně hlásit verzi operačního systému a firmwaru. Pokud je nastavena na hodnotu False, informace o verzi se hlásit nebudou.</translation>
<translation id="7498946151094347510">Určuje, které tiskárny uživatel nesmí používat.

Tato zásada se použije, jen pokud je v zásadě <ph name="PRINTERS_BLACKLIST" /> vybrána možnost <ph name="DEVICE_PRINTERS_ACCESS_MODE" />.

Je-li tato zásada použita, bude mít uživatel k dispozici všechny tiskárny kromě těch, jejichž ID jsou v ní uvedena. ID musejí odpovídat polím „id“ a „guid“ v souboru, který je uveden v zásadě <ph name="DEVICE_PRINTERS_POLICY" />.
      </translation>
<translation id="7511361072385293666">Pokud je tato zásada nastavena na hodnotu true nebo nebo nastavena není, je v prohlížeči <ph name="PRODUCT_NAME" /> povoleno použití protokolu QUIC.
Pokud je tato zásada nastavena na hodnotu false, použití protokolu QUIC je zakázáno.</translation>
<translation id="7517845714620372896">Určuje procentuální jas obrazovky.
          Když je tato zásada nastavená, je počáteční jas obrazovky upraven na její hodnotu, ale uživatel jej později může změnit. Funkce automatického jasu jsou vypnuty.
          Když tato zásada není nastavená, uživatelské ovládací prvky obrazovky a funkce automatického jasu nejsou dotčeny.
          Hodnoty zásady by měly být zadány v procentech v rozsahu 0–100.</translation>
<translation id="7519251620064708155">Povolit generování klíčů na těchto webech</translation>
<translation id="7529100000224450960">Umožňuje nastavit seznam vzorů adres URL stránek, které mají povoleno otevírat vyskakovací okna.

          Pokud zásadu nenastavíte, použije se pro všechny webové stránky globální výchozí hodnota buď ze zásady DefaultPopupsSetting (pokud je nastavena), nebo z osobního nastavení uživatele.</translation>
<translation id="7529144158022474049">Faktor zpoždění automatické aktualizace</translation>
<translation id="7534199150025803530">Tato zásada nemá vliv na aplikaci Disk Google pro Android. Chcete-li zabránit používání Disku Google přes mobilní datové připojení, měli byste instalaci aplikace Disk Google pro Android zakázat.</translation>
<translation id="7547549430720182663">Sloučit</translation>
<translation id="7553535237300701827">Když je tato zásada nastavena, přihlašovací ověření bude v závislosti na hodnotě nastavení probíhat jedním z následujících způsobů:

      V případě nastavení na možnost GAIA proběhne přihlášení běžným ověřovacím procesem GAIA.

      V případě nastavení na možnost SAML_INTERSTITIAL se při přihlášení zobrazí vsunutá obrazovka, na které uživatel bude moci zvolit, zda chce pokračovat v ověření prostřednictvím poskytovatele identity SAML domény, do které je zařízení zaregistrováno, nebo se vrátit k běžnému procesu přihlášení GAIA.</translation>
<translation id="755951849901630953">Pokud tato zásada není nastavena nebo je nastavena na hodnotu True, povoluje aktualizace všech komponent v prohlížeči <ph name="PRODUCT_NAME" />.

      Pokud je nastavena na hodnotu False, jsou aktualizace komponent zakázány. Na některé komponenty se však tato zásada nevztahuje – nebudou zakázány aktualizace komponent, které neobsahují spustitelný kód, nemění významně chování prohlížeče nebo jsou nezbytně nutné k zajištění bezpečnosti.
      Mezi takové komponenty patří například seznamy zneplatněných certifikátů a údaje Bezpečného prohlížení.
      Další informace o Bezpečném prohlížení najdete na stránce https://developers.google.com/safe-browsing.</translation>
<translation id="7566878661979235378">Typ ověření při přihlášení pomocí technologie SAML</translation>
<translation id="757395965347379751">Když je toto nastavení aktivováno, povoluje <ph name="PRODUCT_NAME" /> certifikáty podepsané algoritmem SHA-1, pokud je možné je úspěšně ověřit a propojit s místně nainstalovanými certifikáty CA.

      Upozorňujeme, že tato zásada závisí na tom, zda podpisy SHA-1 povoluje ověřovací mechanismus operačních systému. Pokud při aktualizaci operačního systému dojde ke změně zpracování certifikátů SHA-1, tato zásada již nemusí fungovat. Tato zásada je určena jako dočasné řešení, které podnikům poskytne více času k přechodu na jiné podpisy než SHA-1. Tato zásada bude odstraněna kolem 1. ledna 2019.

      Pokud tato zásada není nastavena nebo je nastavena na hodnotu False, bude se <ph name="PRODUCT_NAME" /> řídit veřejně publikovaným harmonogramem ukončení podpory algoritmu SHA-1.</translation>
<translation id="7593523670408385997">Slouží ke konfiguraci velikosti mezipaměti, kterou bude aplikace <ph name="PRODUCT_NAME" /> používat k ukládání souborů do mezipaměti na disku.

      Pokud tuto zásadu nastavíte, <ph name="PRODUCT_NAME" /> bude používat stanovenou velikost mezipaměti bez ohledu na to, zda uživatel zadal příznak „--disk-cache-size“. Hodnota stanovená touto zásadou neurčuje pevný limit, jedná se spíše o návrh pro systém ukládání do mezipaměti. Hodnoty menší než několik megabajtů jsou příliš malé a budou zaokrouhleny nahoru na rozumné minimum.

      Pokud pro tuto zásadu nastavíte hodnotu 0, bude použita výchozí velikost mezipaměti, ale uživatel ji nebude moci změnit.

      Pokud tuto zásadu nenastavíte, bude použita výchozí velikost a uživatel ji bude moci přepsat pomocí příznaku  „--disk-cache-size“.</translation>
<translation id="759957074386651883">Nastavení Bezpečného prohlížení</translation>
<translation id="7604169113182304895">Aplikace Android se mohou samy rozhodnout, zda se tímto seznamem budou řídit. Nelze to u nich vynutit.</translation>
<translation id="7612157962821894603">Celosystémové příznaky, které se použití při spuštění prohlížeče <ph name="PRODUCT_NAME" /></translation>
<translation id="7614663184588396421">Seznam deaktivovaných schémat protokolu</translation>
<translation id="7617319494457709698">Tato zásada udává, která rozšíření mohou ke vzdálenému ověření používat funkci <ph name="CHALLENGE_USER_KEY_FUNCTION" /> rozhraní <ph name="ENTERPRISE_PLATFORM_KEYS_API" />. Aby rozšíření toto rozhraní API mohla používat, musí být přidána do tohoto seznamu.

          Pokud rozšíření v seznamu není nebo seznam není nastaven, volání tohoto rozhraní API se nezdaří a bude vrácen kód chyby.</translation>
<translation id="7618907117929117943">Vraťte se a zůstaňte u cílové verze, pokud je verze operačního systému novější než cílová a je možné přenést konfiguraci na úrovni zařízení (včetně přihlašovacích údajů k síti), případně po vrácení přeskočte počáteční nastavení. Pokud to není možné, vrácení zpět neprovádějte nebo zrušte (protože cílová verze nepodporuje obnovení dat nebo protože se jedná o změnu, která není zpětně kompatibilní).
          Podporováno u systému <ph name="PRODUCT_OS_NAME" /> verze 70 a vyšší. U starších klientů tato hodnota znamená, že vrácení zpět je zakázáno.</translation>
<translation id="7620869951155758729">Tato zásada určuje konfiguraci, která se použije k vygenerování a ověření rodičovského přístupového kódu.

      Ke generování přístupového kódu se vždy používá konfigurace |current_config|. K jeho ověření by se měla použít jen v případě, že jej nelze ověřit pomocí konfigurace |future_config|.
      |future_config| je primární konfigurace používaná k ověření přístupového kódu.
      Konfigurace |old_configs| by se k ověření přístupového kódu měly používat jen v případě, že jej nelze ověřit pomocí konfigurace |future_config| ani |current_config|.

      Předpokládaným způsobem použití této zásady je postupné střídání konfigurací přístupových kódů. Nová konfigurace se vždy vloží do |future_config| a stávající hodnota se současně přesune do |current_config|. Předchozí hodnoty |current_config| se přesunou do |old_configs| a po dokončení cyklu střídání se odstraní.

      Tato zásada se týká pouze podřízeného uživatele.
      Když je tato zásada nastavená, lze na zařízení dítěte ověřit rodičovský přístupový kód.
      Když tato zásada není nastavená, rodičovský přístupový kód na zařízení dítěte nelze ověřit.</translation>
<translation id="7625444193696794922">Určuje, jaký kanál verzí by měl být v zařízení nastaven a uzamčen.</translation>
<translation id="7632724434767231364">Název knihovny GSSAPI</translation>
<translation id="7635471475589566552">Slouží ke konfiguraci jazyka aplikace <ph name="PRODUCT_NAME" /> a brání uživatelům, aby nastavený jazyk změnili. 

      Pokud toto nastavení aktivujete, bude aplikace <ph name="PRODUCT_NAME" /> používat zvolený jazyk. Není-li nakonfigurovaný jazyk podporován, použije se místo něho nastavení „en-US“. 

      Pokud je toto nastavení deaktivováno nebo není nakonfigurováno, použije aplikace <ph name="PRODUCT_NAME" /> buď preferovaný jazyk nastavený uživatelem (je-li nakonfigurován), jazyk systému, nebo základní nastavení „en-US“.</translation>
<translation id="7641363659597330616">Určuje, jaký typ stahování bude prohlížeč <ph name="PRODUCT_NAME" /> zcela blokovat, aniž by uživatelům umožnil bezpečnostní rozhodnutí přepsat.

Pokud nastavíte tuto zásadu, bude prohlížeč <ph name="PRODUCT_NAME" /> určitým typům stahování bránit a nenechá uživatele bezpečnostní upozornění obejít.

Když je vybrána možnost Blokovat nebezpečná stahování, jsou povolena všechna stahování s výjimkou těch, u nichž se zobrazují upozornění Bezpečného prohlížení.

Když je vybrána možnost Blokovat potenciálně nebezpečná stahování, jsou povolena všechna stahování s výjimkou těch, u nichž se zobrazují upozornění Bezpečného prohlížení o potenciálně nebezpečném stahování.

Když je vybrána možnost Blokovat veškerá stahování, jsou blokována veškerá stahování.

Když tato zásada není nastavena (nebo je vybrána možnost Bez zvláštních omezení), použijí se na stahování běžná bezpečnostní omezení založená na výsledcích analýzy Bezpečného prohlížení.

Tato omezení se vztahují na stahování spuštěná z obsahu webových stránek i pomocí možnosti Uložit odkaz v kontextové nabídce. Tato omezení se nevztahují na uložení či stažení aktuálně zobrazené stránky ani na uložení do souboru PDF v možnostech tisku.

Další informace o Bezpečném prohlížení najdete na stránce https://developers.google.com/safe-browsing.</translation>
<translation id="7643883929273267746">Omezit účty, které jsou v prohlížeči <ph name="PRODUCT_NAME" /> viditelné</translation>
<translation id="7651739109954974365">Určuje, zda bude v zařízení povolen datový roaming. Pokud je tato zásada nastavena na hodnotu True, je datový roaming povolen. Pokud tato zásada není nastavena nebo je nastavena na hodnotu False, datový roaming nebude k dispozici.</translation>
<translation id="7673194325208122247">Doba (v milisekundách)</translation>
<translation id="7676708657861783864">Soubory cookie nastavené stránkami, které odpovídají těmto vzorům adres URL, budou omezeny na aktuální relaci, což znamená, že při ukončení prohlížeče budou vymazány.

          Pro adresy URL nezahrnuté ve zde zadaných vzorcích nebo pro všechny adresy URl, pokud tato zásada není nastavena, se použije globální výchozí hodnota buď ze zásady DefaultCookiesSetting (pokud je nastavena), nebo z osobní konfigurace uživatele.

          Pokud je prohlížeč <ph name="PRODUCT_NAME" /> spuštěn na pozadí, návštěvy se po zavření posledního okna prohlížeče nemusí ukončit. Namísto toho zůstane aktivní až do ukončení prohlížeče. Další informace o konfiguraci tohoto chování najdete v podrobnostech o zásadě BackgroundModeEnabled.

          Podívejte se také na zásady CookiesBlockedForUrls a CookiesBlockedForUrls. Vzory adres URL v těchto třech zásadách navzájem nesmějí být v konfliktu – není dáno, která zásada má přednost.

          Pokud je zásada RestoreOnStartup nastavena na obnovení adres URL z předcházejících relací, nebude tato zásada dodržována a soubory cookie se pro tyto webové stránky budou ukládat natrvalo.</translation>
<translation id="7683777542468165012">Dynamická aktualizace zásad</translation>
<translation id="7694807474048279351">Naplánuje automatický restart po použití aktualizace systému <ph name="PRODUCT_OS_NAME" />.

Pokud je tato zásada nastavena na hodnotu true, bude v případě, že je použita aktualizace <ph name="PRODUCT_OS_NAME" /> a k dokončení procesu je potřeba restart, naplánován automatický restart. Restart bude naplánován na zvolený čas, ale pokud bude uživatel zařízení používat, bude možné automatický restart odložit až o 24 hodin.

Pokud je tato zásada nastavena na hodnotu false, nebude po použití aktualizace <ph name="PRODUCT_OS_NAME" /> naplánován žádný automatický restart. Proces aktualizace bude dokončen, až uživatel příště restartuje zařízení.

Pokud tuto zásadu nastavíte, uživatelé ji nebudou moci změnit ani přepsat.

Poznámka: V současnosti jsou automatické restarty povoleny pouze tehdy, když je zobrazena přihlašovací obrazovka nebo když je spuštěna návštěvy terminálové aplikace. V budoucnu se tyto podmínky změní a tato zásada bude platit vždy, nehledě na to, zda je spuštěna návštěvy libovolného typu.</translation>
<translation id="7701341006446125684">Nastavit velikost mezipaměti aplikací a rozšíření (v bajtech)</translation>
<translation id="7709537117200051035">Slovník, který mapuje názvy hostitelských serverů na logický příznak, který určuje, zda je přístup k hostitelskému serveru povolen (true) nebo blokován (false).

Tato zásada je určena k internímu použití prohlížečem <ph name="PRODUCT_NAME" />.</translation>
<translation id="7712109699186360774">Dotázat se vždy, když se web snaží získat přístup ke kameře nebo mikrofonu</translation>
<translation id="7713608076604149344">Omezení stahování</translation>
<translation id="7715711044277116530">Procento prodloužení prodlevy ztmavení obrazovky v režimu prezentace</translation>
<translation id="7717938661004793600">Konfiguruje funkce usnadnění přístupu v systému <ph name="PRODUCT_OS_NAME" />.</translation>
<translation id="7724994675283793633">Tato zásada povolí protokol HTTP/0.9 na portech jiných než 80 pro HTTP a 443 pro HTTPS.

      Tato zásada je ve výchozím nastavení vypnuta. Pokud ji zapnete, vystavíte tím uživatele bezpečnostnímu riziku popsanému na stránce https://crbug.com/600352.

      Účelem této zásady je poskytnout organizacím čas k migraci existujících serverů na jiný protokol než HTTP/0.9 a v budoucnu bude odstraněna.

      Pokud tato zásada není nastavena, protokol HTTP/0.9 bude na jiných než výchozích portech zakázán.</translation>
<translation id="7747447585227954402">Povolit zařízení používat v systému <ph name="PRODUCT_OS_NAME" /> plugin <ph name="PLUGIN_VM_NAME" /></translation>
<translation id="7749402620209366169">Namísto kódu PIN zadaného uživatelem aktivuje dvoufázové ověření hostitelů vzdáleného přístupu.

          Je-li toto nastavení zapnuto, uživatelé musejí při přihlašování k hostitelskému serveru zadat platný kód dvoufázového ověření.

          Je-li toto nastavení vypnuto nebo není-li nastaveno, dvoufázové ověření nebude aktivováno a namísto něj bude použita výchozí možnost, což je uživatelem zadaný kód PIN.</translation>
<translation id="7750991880413385988">Otevřít stránku Nová karta</translation>
<translation id="7754704193130578113">Před stažením se vždy zeptat na místo uložení každého souboru</translation>
<translation id="7761446981238915769">Konfigurace seznamu nainstalovaných aplikací na přihlašovací obrazovce</translation>
<translation id="7763479091692861127"> Typy připojení, které lze používat pro aktualizaci operačního systému. Aktualizace operačního systému může vzhledem k objemu dat velmi zatěžovat připojení a může mít za následek dodatečné poplatky. Z tohoto důvodu jsou ve výchozím nastavení zakázány pro typy připojení, které jsou považovány za nákladné, což je v současnosti mimo jiné připojení WiMax, Bluetooth nebo mobilní připojení.
      Podporované identifikátory typu připojení jsou „ethernet“, „wifi“, „wimax“, „bluetooth“ a „cellular“.</translation>
<translation id="7763614521440615342">Zobrazovat na stránce Nová karta návrhy obsahu</translation>
<translation id="7765879851993224640">Povolit přihlášení pomocí funkce Smart Lock.</translation>
<translation id="7774768074957326919">Použít systémová nastavení proxy serveru</translation>
<translation id="7775831859772431793">Zde můžete zadat adresu URL proxy serveru.

          Tato zásada bude použita pouze v případě, že jste v zásadě „Zvolit způsob konfigurace nastavení proxy serveru“ zvolili ruční nastavení.

          Pokud jste vybrali jiný režim nastavení zásad proxy serveru, tuto zásadu byste nastavovat neměli.

          Další možnosti a podrobné příklady naleznete na následující stránce:
          <ph name="PROXY_HELP_URL" /></translation>
<translation id="7781069478569868053">Stránka Nová karta</translation>
<translation id="7788511847830146438">Podle profilu</translation>
<translation id="780603170519840350">Deaktivuje vynucování požadavků Certificate Transparency pro seznam hodnot hash údaje subjectPublicKeyInfo.

      Tato zásada umožňuje deaktivovat požadavky Certificate Transparency na zveřejnění pro řetězce certifikátů, které obsahují certifikáty s některou ze zadaných hodnot hash údaje subjectPublicKeyInfo. Pro podnikové hostitelské servery je pak možné používat certifikáty, které by jinak byly považovány za nedůvěryhodné, protože nebyly zveřejněny.

      Aby při nastavení této zásady bylo vynucování požadavků Certificate Transparency deaktivováno, musí být splněna jedna z těchto podmínek:
      1. Hodnota hash odpovídá údaji subjectPublicKeyInfo certifikátu serveru.
      2. Hodnota hash odpovídá údaji subjectPublicKeyInfo, který se vyskytuje v certifikátu CA v řetězci certifikátů, příslušný certifikát CA je omezen prostřednictvím rozšíření nameConstraints standardu X.509v3, v poli permittedSubtrees je přítomno alespoň jedno omezení nameConstraints directoryName a tento údaj directoryName obsahuje atribut organizationName.
      3. Hodnota hash odpovídá údaji subjectPublicKeyInfo, který se vyskytuje v certifikátu CA v řetězci certifikátů, příslušný certifikát CA má v poli Subject alespoň jeden atribut organizationName a certifikát serveru obsahuje stejný počet atributů organizationName, které jsou ve stejném pořadí a mají bajtově identické hodnoty.

      Hodnotu hash subjectPublicKeyInfo tvoří název hashovacího algoritmu následovaný znakem „/“ a kódováním Base64 hodnoty hash získané použitím daného hashovacího algoritmu na údaj subjectPublicKeyInfo certifikátu v kódování DER. Toto kódování Base64 má stejný formát jako otisk SPKI definovaný v oddílu 2.4 specifikace RFC 7469. Neznámé hashovací algoritmy jsou ignorovány. V současné době je podporován pouze hashovací algoritmus sha256.

      Pokud tato zásada není nastavena, každý certifikát, u kterého je vyžadováno zveřejnění prostřednictvím Certificate Transparency, ale který není zveřejněn v souladu se zásadou Certificate Transparency, bude považován za nedůvěryhodný.</translation>
<translation id="7818131573217430250">Nastavení výchozího stavu režimu vysokého kontrastu na přihlašovací obrazovce</translation>
<translation id="7822837118545582721">Pokud je tato zásada nastavena na hodnotu True, uživatelé do externích úložných zařízení nemohou nic zapisovat. 
      Pokud je tato zásada nastavena na hodnotu False nebo není nakonfigurována, uživatelé mohou vytvářet a upravovat soubory na externích úložných zařízeních, která fyzicky umožňují zápis.

      Zásada ExternalStorageDisabled má před touto zásadou přednost. Pokud je zásada ExternalStorageDisabled nastavena na hodnotu True, veškerý přístup k externím úložištím je zakázán a tato zásada je tedy ignorována.

      Dynamické obnovování této zásady je podporováno od verze M56.</translation>
<translation id="7831595031698917016">Udává maximální prodlevu (v ms) mezi přijetím zneplatnění zásady a načtením nové zásady ze služeb správy zařízení.

      Nastavením této zásady bude přepsána výchozí hodnota 5000 ms. Platné hodnoty pro tuto zásadu se pohybují v rozsahu od 1000 (1 s) do 300 000 (5 minut). Všechny hodnoty mimo tento rozsah budou sníženy (nebo zvýšeny) tak, aby spadaly do daného rozsahu.

      Pokud tato zásada nebude nastavena, prohlížeč <ph name="PRODUCT_NAME" /> použije výchozí hodnotu 5000 ms.</translation>
<translation id="7841880500990419427">Nejnižší verze zálohy TLS</translation>
<translation id="7842869978353666042">Konfigurace možností Disku Google</translation>
<translation id="787125417158068494">Pokud je tato zásada nastavena na hodnotu SyncDisabled nebo není nakonfigurována, certifikáty systému <ph name="PRODUCT_OS_NAME" /> nejsou k dispozici aplikacím ARC.

      Pokud je nastavena na hodnotu CopyCaCerts, všechny certifikáty CA nainstalované prostřednictvím ONC s atributem <ph name="WEB_TRUSTED_BIT" /> jsou k dispozici aplikacím ARC.</translation>
<translation id="7882585827992171421">Tato zásada je aktivní pouze v režimu pro obchody.

      Určuje ID rozšíření, které se použije jako spořič obrazovky na přihlašovací obrazovce. Rozšíření musí být součásti balíčku AppPack, který je pro tuto doménu nakonfigurován v rámci zásady DeviceAppPack.</translation>
<translation id="7882857838942884046">Deaktivace služby Google Sync způsobí, že zálohování a obnovení systému Android nebude fungovat správně.</translation>
<translation id="7882890448959833986">Potlačit upozornění ohledně nepodporovaného operačního systému</translation>
<translation id="7902255855035461275">Vzory v tomto seznamu budou porovnány s žádající adresou URL. Pokud bude nalezena shoda, přístup k zařízením pro záznam videa bude udělen bez zobrazení výzvy.

      POZNÁMKA: Až do verze 45 byla tato zásada podporována pouze v režimu veřejného terminálu.</translation>
<translation id="7912255076272890813">Konfigurovat povolené typy aplikací nebo rozšíření</translation>
<translation id="7915236031252389808">Zde můžete zadat adresu URL souboru PAC proxy serveru.

          Tato zásada bude použita pouze v případě, že jste v části „Zvolte způsob konfigurace nastavení proxy serveru“ zvolili ruční nastavení proxy serveru.

          Pokud jste vybrali jiný režim nastavení zásad proxy serveru, tuto zásadu byste nastavovat neměli.

          Podrobné příklady naleznete na následující adrese:
          <ph name="PROXY_HELP_URL" />.</translation>
<translation id="793134539373873765">Určuje, zda má být pro datové části aktualizací operačního systému použita síť p2p. Pokud zásadu nastavíte na hodnotu True, zařízení budou sdílet pokus o využití datových částí aktualizace v síti LAN, což může vést ke snížení zahlcení a míry využití připojení k internetu. Pokud datová část aktualizace není v síti LAN k dispozici, zařízení přepne zpět na stahování ze serveru aktualizace. Pokud tuto zásadu nenakonfigurujete nebo ji nastavíte na hodnotu False, síť p2p nebude použita.</translation>
<translation id="7933141401888114454">Povolit vytváření dozorovaných uživatelů</translation>
<translation id="793473937901685727">Nastavení dostupnosti certifikátů pro aplikace ARC</translation>
<translation id="7937766917976512374">Povolit nebo zakázat záznam videa</translation>
<translation id="7941975817681987555">Nepředvídat síťové akce u žádných síťových připojení</translation>
<translation id="7952002811557367112">Tato zásada uživateli zabraňuje v načítání webových stránek ze zakázaných adres URL. Seznam zakázaných položek obsahuje vzory adres URL. Ty určují, které adresy URL budou zakázány.

      Vzor adres URL musí být naformátován podle pokynů na stránce https://www.chromium.org/administrators/url-blacklist-filter-format.

      Výjimky lze zadat v zásadě pro povolené adresy URL. Počet záznamů v těchto zásadách je omezen na 1000. Všechny další záznamy budou ignorovány.

      Blokování interních adres URL s předponou „chrome://*“ nedoporučujeme, protože může vést k neočekávaným chybám.

      Tato zásada nezabraňuje dynamické aktualizaci stránky prostřednictvím JavaScriptu. Jestliže například zablokujete stránku example.com/abc, uživatelům by se mohlo podařit navštívit stránku example.com a kliknutím na odkaz navštívit stránku example.com/abc (pokud se stránka neobnoví).

      Pokud tato zásada není nastavená, nebude v prohlížeči zakázána žádná adresa URL.</translation>
<translation id="7953256619080733119">Hostitelské servery ručních výjimek spravovaného uživatele</translation>
<translation id="7961779417826583251">Deaktivovat vynucování zásad Certificate Transparency pro seznam starších certifikačních autorit</translation>
<translation id="7974114691960514888">Tato zásada již není podporována.
          Povolí použití synchronizačních serverů a serverů STUN při připojování ke vzdálenému klientu.

          Pokud je toto nastavení zapnuto, může tento počítač objevit vzdálené hostitelské počítače a připojit se k nim i v případě, že jsou odděleny bránou firewall.

          Pokud je toto nastavení vypnuto a odchozí připojení UDP jsou filtrována bránou firewall, může se tento počítač připojit pouze k hostitelským počítačům v místní síti.</translation>
<translation id="7976157349247117979">Název cíle <ph name="PRODUCT_NAME" /></translation>
<translation id="7980227303582973781">Bez zvláštních omezení</translation>
<translation id="7985242821674907985"><ph name="PRODUCT_NAME" /></translation>
<translation id="7992136759457836904">Umožňuje určit, zda má být v systému Chrome OS povoleno spouštění virtuálních počítačů.

      Pokud je tato zásada nastavena na hodnotu True, spouštění virtuálních počítačů je na zařízení povoleno.
      Pokud je tato zásada nastavena na hodnotu False, spouštění virtuálních počítačů na zařízení povoleno není.
      Aby bylo povoleno spouštět Crostini, musejí být všechny tři zásady, VirtualMachinesAllowed, CrostiniAllowed a DeviceUnaffiliatedCrostiniAllowed pro Crostini nastaveny na hodnotu true.
      Při změně na hodnotu False se pro spouštění nových virtuálních počítačů použije nové nastavení, ale již spuštěné virtuální počítače nebudou ukončeny.
      Pokud na spravovaném zařízení není nastavena tato zásada, je v něm spouštění virtuálních počítačů zakázáno.
      Na zařízeních, která nejsou spravována, je spouštění virtuálních počítačů povoleno.</translation>
<translation id="8001701200415781021">Omezení, které účty Google je v prohlížeči <ph name="PRODUCT_NAME" /> povoleno nastavit jako primární</translation>
<translation id="8009554972280451023">Pokud zapnete toto nastavení, budou nastavení uložená v profilech <ph name="PRODUCT_NAME" /> (např. záložky, data automatického vyplňování nebo hesla) zapsána také do souboru uloženého ve složce cestovního uživatelského profilu nebo v umístění, které administrátor definuje prostřednictvím zásady <ph name="ROAMING_PROFILE_LOCATION_POLICY_NAME" />. Aktivací této zásady deaktivujete cloudovou synchronizaci.

      Pokud je tato zásada vypnutá nebo není nastavená, budou se používat pouze běžné místní profily.

      Zásada <ph name="SYNC_DISABLED_POLICY_NAME" /> zakáže veškerou synchronizaci dat a tím zásadu <ph name="ROAMING_PROFILE_SUPPORT_ENABLED_POLICY_NAME" /> přepíše.</translation>
<translation id="802147957407376460">Otočit obrazovku o 0 stupňů</translation>
<translation id="8033913082323846868">Podpora této zásada byla ve verzi M70 ukončena. Použijte namísto ní zásady AutofillAddressEnabled a AutofillCreditCardEnabled.

      Aktivuje v aplikaci <ph name="PRODUCT_NAME" /> funkci Automatické vyplňování a umožní uživatelům automaticky vyplňovat pole webových formulářů pomocí dříve uložených informací (například adres nebo čísel platebních karet).

      Pokud toto nastavení deaktivujete, uživatelé nebudou mít k funkci Automatické vyplňování přístup.

      Pokud toto nastavení aktivujete nebo nenastavíte žádnou hodnotu, zůstane funkce Automatické vyplňování pod kontrolou uživatelů. Budou moci nakonfigurovat profily této funkce a podle vlastního uvážení ji zapínat nebo vypínat.</translation>
<translation id="8044493735196713914">Hlásit režim spuštění zařízení</translation>
<translation id="8050080920415773384">Nativní tisk</translation>
<translation id="8053580360728293758">Přepíše výchozí barevný režim tisku. Pokud režim není k dispozici, zásada bude ignorována.</translation>
<translation id="8059164285174960932">Adresa URL, u které by klienti vzdáleného připojení měli obdržet ověřovací token</translation>
<translation id="8078366200175825572">Umožňuje nastavit seznam vzorů adres URL webových stránek, které nemají povoleno nastavovat soubory cookie.

          Pokud tuto zásadu nenastavíte, použije se pro všechny webové stránky globální výchozí hodnota buď ze zásady DefaultCookiesSetting (pokud je nastavena), nebo z osobního nastavení uživatele.

          Podívejte se také na zásady CookiesAllowedForUrls a CookiesSessionOnlyForUrls. Vzory adres URL v těchto třech zásadách navzájem nesmějí být v konfliktu – není dáno, která zásada má přednost.</translation>
<translation id="8099880303030573137">Prodleva nečinnosti při napájení z baterie</translation>
<translation id="8102913158860568230">Výchozí nastavení mediálního přenosu</translation>
<translation id="8104186956182795918">Umožňuje nastavit, zda mají weby povoleno zobrazovat obrázky. Zobrazování obrázků je možné všem webům buď povolit, nebo zakázat.

          Je-li tato zásada ponechána nenastavená, použije se hodnota AllowImages a uživatel ji bude moci změnit.

          Dříve tato zásada byla omylem k dispozici na zařízeních Android, ale tato funkce v systému Android nikdy nebyla plně podporována.</translation>
<translation id="8104962233214241919">Automatický výběr certifikátů klienta u těchto webů</translation>
<translation id="8112122435099806139">Udává formát hodin, který se použije pro zařízení.

      Tato zásada konfiguruje formát hodin, který se použije na přihlašovací obrazovce a ve výchozím nastavení uživatelských relací. Uživatelé mohou ve svých účtech formát hodin přepsat.

      Pokud zásadu nastavíte na hodnotu True, zařízení použije 24hodinový formát hodin. Pokud zásadu nastavíte na hodnotu False, zařízení použije 12hodinový formát hodin.
      Pokud zásadu nenastavíte, zařízení ve výchozím nastavení použije 24hodinový formát hodin.</translation>
<translation id="8114382167597081590">Nevynucovat na YouTube omezený režim</translation>
<translation id="8118665053362250806">Nastaví velikost mezipaměti médií na disku</translation>
<translation id="8124468781472887384">Zásady přístupu ke konfiguraci tiskáren pro zařízení.</translation>
<translation id="8135937294926049787">Udává dobu nečinnosti uživatele, po které bude obrazovka při napájení ze sítě vypnuta.

           Pokud je tato zásada nastavena hodnotu větší než nula, jedná se o dobu, po kterou musí uživatel zůstat v nečinnosti, než systém <ph name="PRODUCT_OS_NAME" /> obrazovku vypne.

           Pokud je tato zásada nastavena na nulovou hodnotu, systém <ph name="PRODUCT_OS_NAME" /> obrazovku při nečinnosti uživatele nevypne.

           Není-li tato zásada nastavena, bude použita výchozí doba.

           Hodnotu zásady zadávejte v milisekundách. Maximální hodnota je stejná jako prodleva režimu spánku.</translation>
<translation id="8138009212169037227">Tato zásada určuje, zda se mají hlásit údaje o zásadách a doba načtení zásad.

      Když je tato zásada ponechána nenastavená nebo je nastavena na hodnotu True, údaje o zásadách a čas načtení zásady se shromažďují.
      Když je tato zásada nastavena na hodnotu False, údaje o zásadách a čas načtení zásad se neshromažďují.

      Tato zásada se projeví, pouze pokud je povoleno rozšíření <ph name="CHROME_REPORTING_EXTENSION_NAME" /> a počítač je zaregistrován pomocí tokenu <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="8140204717286305802">Odesílá seznam síťových rozhraní s informacemi o typu a hardwarových adresách na server.

      Pokud je tato zásada nastavena na hodnotu false, seznam rozhraní odesílán nebude.</translation>
<translation id="8141795997560411818">Tato zásada uživateli nezabrání v používání aplikace Disk Google pro Android. Chcete-li přístupu k Disku Google zabránit, měli byste také zakázat instalaci aplikace Disk Google pro Android.</translation>
<translation id="8142894094385450823">Nastavit doporučená národní prostředí pro spravovanou relaci</translation>
<translation id="8146727383888924340">Povolit uživatelům uplatnit při registraci systému Chrome OS nabídky</translation>
<translation id="8148785525797916822">Potlačí upozornění, které se zobrazuje, když je prohlížeč <ph name="PRODUCT_NAME" /> spuštěn na počítači nebo v operačním systému, který již není podporován.</translation>
<translation id="8148901634826284024">Aktivuje funkci usnadnění přístupu pomocí vysokého kontrastu.

Pokud je tato zásada nastavena na hodnotu true, režim vysokého kontrastu bude vždy aktivní.

Pokud je tato zásada nastavena na hodnotu false, režim vysokého kontrastu bude vždy deaktivován.

Pokud tuto zásadu nastavíte, uživatelé ji nebudou moci změnit ani přepsat.

Pokud ji ponecháte nenastavenou, režim vysokého kontrastu bude ve výchozím nastavení deaktivován, ale uživatelé jej budou moci kdykoli aktivovat.</translation>
<translation id="815061180603915310">Je-li tato zásada aktivována, vynucuje přepnutí profilu do dočasného režimu. Pokud je nastavena jako zásada operačního systému (např. GPO ve Windows), bude platit pro všechny profily v systému. Je-li nastavena jako cloudová zásada, bude platit pouze pro profil přihlášený pomocí spravovaného účtu.

      V tomto režimu zůstávají data profilu na disku jen po dobu trvání návštěvy uživatele. Funkce jako historie prohlížeče, rozšíření a jejich data, data webů (např. soubory cookie) ani webové databáze po zavření prohlížeče nebudou uchovány. To však uživatelům nezabraňuje v ručním stahování dat na disk ani v ukládání či tisku stránek.

      Pokud uživatel povolil synchronizaci, všechna tato data budou uchována v synchronizovaném profilu, stejně jako v případě běžných profilů. K dispozici je i anonymní režim (pokud není výslovně zakázán pomocí zásady).

      Je-li tato zásada deaktivována nebo ponechána nenastavená, budou se používat běžné profily.</translation>
<translation id="8158758865057576716">Povoluje vytvoření cestovních kopií dat profilu <ph name="PRODUCT_NAME" />.</translation>
<translation id="817455428376641507">Povoluje přístup k adresám URL uvedeným v seznamu, které tedy představují výjimky ze seznamu zakázaných adres URL.

      Formát položek v tomto seznamu naleznete v popisu zásady pro vytvoření seznamu zakázaných adres URL.

      Pomocí této zásady můžete určit výjimky ze seznamu zakázaných adres. Příklad: Přidáním pravidla „*“ na seznam zakázaných zablokujete všechny požadavky. Pomocí této zásady poté můžete povolit přístup omezenému seznamu adres URL. Můžete definovat výjimky v podobě schémat, subdomén, portů nebo konkrétních cest.

      Zda je adresa URL blokována nebo povolena, určuje vždy nejkonkrétnější filtr, přičemž seznam povolených má přednost před seznamem zakázaných adres.

      Počet záznamů v této zásadě je omezen na 1000. Všechny další záznamy budou ignorovány.

      Není-li zásada nastavena, nebudou ze zásady URLBlacklist učiněny žádné výjimky.</translation>
<translation id="8176035528522326671">Povolit firemnímu uživateli být pouze primárním uživatelem s více profily (výchozí chování pro uživatele spravované firmou)</translation>
<translation id="8214600119442850823">Konfiguruje správce hesel.</translation>
<translation id="8244525275280476362">Maximální zpoždění načítání po zneplatnění zásady</translation>
<translation id="8256688113167012935">Řídí, jaký název účtu systém <ph name="PRODUCT_OS_NAME" /> zobrazí na přihlašovací obrazovce pro odpovídající místní účet v zařízení.

      Pokud je tato zásada nastavena, přihlašovací obrazovka použije zadaný řetězec u obrázku, který slouží pro výběr přihlašovacích údajů odpovídajícího místního účtu v zařízení.

      Pokud tuto zásadu ponecháte nenastavenou, systém <ph name="PRODUCT_OS_NAME" /> použije jako viditelný název na přihlašovací obrazovce ID e-mailového účtu spojeného s místním účtem v zařízení.

      U běžných uživatelských účtů je tato zásada ignorována.</translation>
<translation id="8259375588339409826">Prohlížeče Chromium a Google Chrome podporují stejné zásady. Upozorňujeme, že tento dokument může obsahovat nevydané zásady (tj. jejich údaj „Podpora“ může odkazovat na dosud nevydanou verzi prohlížeče <ph name="PRODUCT_NAME" />). Takové zásady mohou být bez předchozího oznámení změněny nebo odstraněny a nevztahují se na ně žádné záruky, tedy ani záruky ohledně zabezpečení a ochrany soukromí.

Zásady jsou určeny pouze ke konfiguraci interních instancí prohlížeče <ph name="PRODUCT_NAME" /> ve vaší organizaci. Použití zásad mimo organizaci (např. ve veřejně distribuovaném programu) je považováno za malware a pravděpodobně za něj bude společností Google a dodavateli antivirového softwaru označeno.

Nastavení není potřeba konfigurovat ručně. Na adrese <ph name="POLICY_TEMPLATE_DOWNLOAD_URL" /> jsou k dispozici ke stažení snadno použitelné šablony pro Windows, Mac a Linux.

Doporučený způsob nastavení zásad ve Windows je prostřednictvím objektu zásad skupiny (GPO). V instancích Windows připojených k doméně <ph name="MS_AD_NAME" /> je však stále podporována i správa zásad prostřednictvím registru.</translation>
<translation id="8264653492961233132">Určuje seznam aplikací a rozšíření, které se instalují na pozadí bez zásahu uživatele a které uživatel nemůže odinstalovat ani deaktivovat. Všechna oprávnění požadovaná aplikacemi nebo rozšířeními jsou udělována implicitně bez zásahu uživatele, a to včetně všech dodatečných oprávnění požadovaných budoucími verzemi aplikace nebo rozšíření. Kromě toho jsou udělována také oprávnění k používání těchto rozhraní API pro rozšíření: enterprise.deviceAttributes a enterprise.platformKeys. (Tato rozhraní API jsou k dispozici pouze u aplikací/rozšíření, jejichž instalace je vynucena.)

Tato zásada má přednost před potenciálně konfliktní zásadou <ph name="EXTENSION_INSTALL_BLACKLIST_POLICY_NAME" />. Bude-li aplikace nebo rozšíření, které bylo dříve vynuceně nainstalováno, z tohoto seznamu odebráno, <ph name="PRODUCT_NAME" /> je automaticky odinstaluje.

U instancí systému Windows, které nejsou propojeny s doménou <ph name="MS_AD_NAME" />, je vynucená instalace omezena pouze na aplikace a rozšíření z Internetového obchodu Chrome.

Zdrojový kód libovolného rozšíření mohou uživatelé pomocí Nástrojů pro vývojáře upravit (což může způsobit, že rozšíření nebude fungovat). Pokud je to problém, nastavte zásadu <ph name="DEVELOPER_TOOLS_POLICY_NAME" />.

Každá položka v seznamu zásady představuje řetězec, který obsahuje ID rozšíření a volitelně také adresu URL pro aktualizaci oddělené středníkem (<ph name="SEMICOLON" />). ID rozšíření je řetězec s 32 písmeny a naleznete jej například zde: <ph name="CHROME_EXTENSIONS_LINK" /> (v režimu pro vývojáře). Pokud je zadána adresa URL pro aktualizaci, měla by odkazovat na dokument XML manifestu aktualizace (viz <ph name="LINK_TO_EXTENSION_DOC1" />). Ve výchozím nastavení se použije adresa URL pro aktualizaci Internetového obchodu Chrome (v současné době https://clients2.google.com/service/update2/crx). Adresa URL pro aktualizaci nastavená v této zásadě slouží pouze k počáteční instalaci. Další aktualizace rozšíření budou používat adresu URL pro aktualizaci uvedenou v manifestu rozšíření. Upozorňujeme, že až do verze 67 prohlížeče <ph name="PRODUCT_NAME" /> bylo explicitní zadání adresy URL pro aktualizaci povinné.

Například <ph name="EXTENSION_POLICY_EXAMPLE" /> nainstaluje aplikaci <ph name="EXTENSION_POLICY_EXAMPLE_EXTENSION_NAME" /> ze standardní adresy URL pro aktualizaci z Internetového obchodu Chrome. Další informace o hostování rozšíření viz <ph name="LINK_TO_EXTENSION_DOC2" />.

Je-li tato zásada ponechána nenastavená, žádné aplikace ani rozšíření se automaticky neinstalují a uživatel v prohlížeči <ph name="PRODUCT_NAME" /> může kteroukoliv aplikaci nebo rozšíření odinstalovat.

Tato zásada se nevztahuje na anonymní režim.</translation>
<translation id="8274603902181597201">Vymazat domovský adresář ecryptfs uživatele a začít s novým zašifrovaným domovským adresářem ext4.</translation>
<translation id="8285435910062771358">Aktivace lupy pro celou obrazovku</translation>
<translation id="8288199156259560552">Zapnout službu určování polohy Google systému Android</translation>
<translation id="8292322992383748446">Hlásí hardwarové statistiky pro komponenty systému na čipu.

      Pokud je tato zásada nastavena na hodnotu false, statistiky nebudou hlášeny.
      Pokud je nastavena na hodnotu true nebo nastavena není, statistiky hlášeny budou.</translation>
<translation id="8294750666104911727">Stránky s vlastností X-UA-Compatible nastavenou na hodnotu chrome=1 budou v běžném provozu vykresleny ve službě <ph name="PRODUCT_FRAME_NAME" /> bez ohledu na zásadu ChromeFrameRendererSettings.

         Pokud toto nastavení aktivujete, na stránkách nebudou hledány metaznačky.

          Pokud toto nastavení deaktivujete, na stránkách budou hledány metaznačky.

          Pokud zásada nebude nastavena, na stránkách budou hledány metaznačky.</translation>
<translation id="8300455783946254851">Pokud je nastavena na hodnotu True, zakáže synchronizaci Disku Google v aplikaci Soubory v systému <ph name="PRODUCT_OS_NAME" /> při použití mobilního připojení. Data se na Disk Google synchronizují pouze při připojení přes Wi-Fi nebo Ethernet.

Pokud tato zásada není nastavena nebo je nastavena na hodnotu False, uživatelé budou moci přenášet soubory na Disk Google prostřednictvím mobilních připojení.</translation>
<translation id="8300992833374611099">Určit, kde je možné používat Nástroje pro vývojáře</translation>
<translation id="8312129124898414409">Umožňuje nastavit, zda weby mohou generovat klíče. Generování klíčů je možné všem webům buď povolit, nebo zakázat.

Pokud tuto zásadu nenastavíte, použije se zásada BlockKeygen a uživatel ji bude moci změnit.</translation>
<translation id="8329984337216493753">Tato zásada je aktivní pouze v režimu pro obchody.

      Pokud je určena zásada DeviceIdleLogoutTimeout, určuje tato zásada, jak dlouho před odhlášením se bude uživateli zobrazovat okno s upozorněním a časovačem.

      Hodnota zásady se určuje v milisekundách.</translation>
<translation id="8339420913453596618">Druhý faktor je vypnut</translation>
<translation id="8344454543174932833">Importování záložek z výchozího prohlížeče při prvním spuštění</translation>
<translation id="8359734107661430198">Aktivovat API PříkladZastaraléFunkce do 2. 9. 2008</translation>
<translation id="8367209241899435947">Povolit v systému Windows nástroj Chrome Cleanup</translation>
<translation id="8369602308428138533">Prodleva vypnutí obrazovky při napájení ze sítě</translation>
<translation id="8371178326720637170">Umožňuje spravovaným rozšířením používat rozhraní Enterprise Hardware Platform API</translation>
<translation id="8374747520743832795">Hlásí hardwarové statistiky a identifikátory související s napájením.

      Pokud je tato zásada nastavena na hodnotu false, statistiky nebudou hlášeny.
      Pokud je nastavena na hodnotu true nebo nastavena není, statistiky hlášeny budou.</translation>
<translation id="8377433219608936819">
      Je-li tato zásada nastavená na hodnotu true, mají cloudové zásady v případě konfliktu přednost před zásadami počítače.
      Pokud je tato zásada nastavená na hodnotu false nebo není nakonfigurovaná, mají v případě konfliktu zásady počítače přednost před cloudovými zásadami.
      Další informace o prioritě zásad naleznete na stránce https://support.google.com/chrome?p=set_chrome_policies_for_devices.

Tato zásada je k dispozici jen v instancích systému Windows, které jsou připojené k doméně <ph name="MS_AD_NAME" />, nebo v instancích systému Windows 10 Pro nebo Enterprise, které jsou zaregistrované ke správě zařízení.</translation>
<translation id="8382184662529825177">Povolit použití vzdáleného ověření identity k ochraně obsahu v zařízení</translation>
<translation id="838870586332499308">Povolit datový roaming</translation>
<translation id="8390049129576938611">Zakáže v prohlížeči <ph name="PRODUCT_NAME" /> interní prohlížeč souborů PDF. Soubory PDF se budou stahovat a uživatel je bude moci otevřít ve výchozí aplikaci.

      Pokud tuto zásadu ponecháte nenastavenou nebo deaktivovanou, budou se soubory PDF otevírat pomocí pluginu PDF (pokud jej uživatel nezakáže).</translation>
<translation id="8396145449084377015">Tato zásada určuje, zda se mají načítat pravidla ze zásady SiteList prohlížeče Internet Explorer.

      Když je ponechána nenastavená nebo je nastavená na hodnotu false, <ph name="PRODUCT_NAME" /> zásadu <ph name="IEEM_SITELIST_POLICY" /> prohlížeče Internet Explorer jako zdroj pravidel pro přepínání prohlížečů nepoužívá.

      Když je nastavená na hodnotu true, <ph name="PRODUCT_NAME" /> čte zásadu <ph name="IEEM_SITELIST_POLICY" /> prohlížeče Internet Explorer a získává z ní adresu URL seznamu webů. <ph name="PRODUCT_NAME" /> poté seznam webů z dané adresy URL stáhne a pravidla použije, jako kdyby byla nakonfigurovaná pomocí zásady <ph name="SITELIST_POLICY_NAME" />.

      Další informace o zásadě <ph name="IEEM_SITELIST_POLICY" /> prohlížeče Internet Explorer: https://docs.microsoft.com/internet-explorer/ie11-deploy-guide/what-is-enterprise-mode</translation>
<translation id="8402079500086185021">Soubory PDF otevírat vždy externě</translation>
<translation id="8412312801707973447">Zda se budou provádět online kontroly OCSP/CRL</translation>
<translation id="8417305981081876834">Nastavit maximální délku kódu PIN pro odemknutí obrazovky</translation>
<translation id="841977920223099909">Ochrana hesla – spouštěč upozornění</translation>
<translation id="8424255554404582727">Nastavit výchozí otočení displeje, které se použije při každém restartu</translation>
<translation id="8426231401662877819">Otočit obrazovku ve směru hodinových ručiček o 90 stupňů</translation>
<translation id="8433186206711564395">Nastavení sítě</translation>
<translation id="8433423491036718210">Nakonfigurovat seznam podnikových přihlašovacích adres URL, na kterých by služba pro ochranu hesla měla pořizovat otisk hesla.</translation>
<translation id="8451988835943702790">Jako domovskou použít stránku Nová karta</translation>
<translation id="8459216513698220096">Určuje, zda a jak se zpracovávají zásady pro uživatele z objektu zásad skupiny (GPO) počítače.

      Pokud je tato zásada nastavena na hodnotu Výchozí nebo je ponechána nenastavená, čtou se zásady pro uživatele pouze z GPO uživatelů (GPO počítače se ignorují).

      Pokud je tato zásada nastavena na hodnotu Sloučit, zásady pro uživatele nastavené v GPO uživatele se sloučí se zásadami pro uživatele v GPO počítače (GPO počítače mají přednost).

      Pokud je tato zásada nastavena na hodnotu Nahradit, zásady pro uživatele v GPO uživatele se nahradí zásadami pro uživatele v GPO počítače (GPO uživatele jsou ignorovány).</translation>
<translation id="8465065632133292531">Parametry pro adresu URL dynamického vyhledávání používající metodu POST</translation>
<translation id="847472800012384958">Nepovolit zobrazení vyskakovacích oken žádným webovým stránkám</translation>
<translation id="8477885780684655676">TLS 1.0</translation>
<translation id="8483004350080020634">Před odesláním skriptům PAC (Proxy Auto Config), které prohlížeč <ph name="PRODUCT_NAME" /> používá ke zjištění proxy serveru, budou z adres URL se schématem https:// odstraněny části citlivé z hlediska zabezpečení a ochrany soukromí.

Když je tato zásada nastavena na hodnotu True, je tato bezpečnostní funkce zapnuta a z adres URL se schématem https:// se před odesláním do skriptu PAC odstraní potenciálně citlivé informace. Skript PAC tak nemůže získat přístup k údajům, které jsou běžně chráněny šifrovaným kanálem (jako jsou cesta a dotaz).

Když je tato zásada nastavena na hodnotu False, je tato bezpečnostní funkce vypnuta a skriptům PAC je tak implicitně umožněn přístup ke všem částem adres URL se schématem https://. Platí to pro všechny skripty PAC bez ohledu na zdroj (včetně skriptů, které byly načteny nezabezpečeným přenosem nebo objeveny nezabezpečeným způsobem pomocí protokolu WPAD).

Výchozí hodnota je True (bezpečnostní funkce je zapnuta).

Doporučujeme tuto zásadu nastavit na hodnotu True. Na hodnotu False ji nastavte pouze v případě, že způsobuje problémy s kompatibilitou s existujícími skripty PAC.

Ve verzi M75 bude tato zásada odstraněna.</translation>
<translation id="8484458986062090479">Umožňuje personalizovat seznam vzorů adres URL, které by měl vždy vykreslit hostitelský prohlížeč.

          Pokud tato zásada není nastavena, použije se pro všechny weby výchozí modul vykreslení určený zásadou ChromeFrameRendererSettings.

          Ukázkové vzory naleznete na stránce https://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="8489964335640955763">PluginVm</translation>
<translation id="8493645415242333585">Deaktivovat ukládání historie prohlížeče</translation>
<translation id="8499172469244085141">Výchozí nastavení (uživatelé mohou zásady přepsat)</translation>
<translation id="8507835864888987300">Nastavuje cílovou verzi pro automatické aktualizace.

      Určuje předponu cílové verze, na kterou by se měl systém <ph name="PRODUCT_OS_NAME" /> aktualizovat. Pokud je v zařízení spuštěna verze, která zadané předponě předchází, aktualizuje se na nejnovější verzi s danou předponou. Je-li v zařízení již nainstalována novější verze, závisí účinek na hodnotě zásady <ph name="DEVICE_ROLLBACK_TO_TARGET_VERSION_POLICY_NAME" />. Formát předpony funguje po částech, jak ukazuje následující příklad:

      "" (nebo nenakonfigurováno): aktualizovat na nejnovější dostupnou verzi.
      "1412.": aktualizovat na kteroukoliv podverzi verze 1412 (např. 1412.24.34 nebo 1412.60.2).
      "1412.2.": aktualizovat na kteroukoliv podverzi verze 1412.2 (např. 1412.2.34 nebo 1412.2.2).
      "1412.24.34": aktualizovat pouze na tuto konkrétní verzi.

      Upozornění: Konfigurovat omezení verzí se nedoporučuje, protože to uživatelům může zabránit v přijímání aktualizací softwaru a kritických oprav zabezpečení. Omezení aktualizací na konkrétní předponu verze uživatele může vystavit riziku.</translation>
<translation id="8519264904050090490">Adresy URL ručních výjimek spravovaného uživatele</translation>
<translation id="8538235451413605457">Konfiguruje požadavek na minimální povolenou verzi prohlížeče <ph name="PRODUCT_NAME" />. Nižší verze jsou považovány za zastaralé. Na zařízeních s nižšími verzemi se uživatelé nebudou moci přihlásit, dokud operační systém zařízení nebude aktualizován.
Pokud aktuální verze začne být považována za zastaralou během návštěvy uživatele, bude uživatel nuceně odhlášen.

Pokud tato zásada není nastavena, žádná omezení neplatí a uživatel se může přihlásit bez ohledu na verzi prohlížeče <ph name="PRODUCT_NAME" />.

Verzí v tomto případě může být přesná verze, například „61.0.3163.120“, nebo předpona verze, například „61.0“  </translation>
<translation id="8544375438507658205">Výchozí modul vykreslení HTML pro plugin <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="8544465954173828789">Povolení synchronizace zpráv SMS z telefonu do Chromebooku.</translation>
<translation id="8548832052135586762">Nastavuje tisk pouze na barvu, pouze černobílý nebo žádné omezení barevného režimu. Pokud zásada nebude nastavena, bude to považováno za žádné omezení.</translation>
<translation id="8549772397068118889">Při návštěvě webů mimo obsahové balíčky zobrazit upozornění</translation>
<translation id="8566842294717252664">Skrýt internetový obchod z karty Nová stránka a ze spouštěče aplikací</translation>
<translation id="857369585509260201">Podpora této zásady byla ukončena, použijte místo ní zásadu BrowserSignin.

Pokud je tato zásada nastavena na hodnotu true, uživatel se do prohlížeče <ph name="PRODUCT_NAME" /> před použitím musí přihlásit pomocí svého profilu. Výchozí hodnota zásady BrowserGuestModeEnabled také bude nastavena na hodnotu false. Existující nepřihlášené profily budou po aktivaci této zásady uzamčeny a nebudou přístupné. Další informace najdete v článku v centru nápovědy.

Pokud je tato zásada nastavena na hodnotu false nebo není nakonfigurována, může uživatel prohlížeč <ph name="PRODUCT_NAME" /> používat, aniž by se do něj přihlásil.</translation>
<translation id="8586528890725660268">Určuje, které tiskárny uživatel nesmí používat.

Tato zásada se použije, jen pokud je v zásadě <ph name="PRINTERS_BLACKLIST" /> vybrána možnost <ph name="BULK_PRINTERS_ACCESS_MODE" />.

Je-li tato zásada použita, bude mít uživatel k dispozici všechny tiskárny kromě těch, jejichž ID jsou v ní uvedena. ID musejí odpovídat polím „id“ a „guid“ v souboru, který je uveden v zásadě <ph name="BULK_PRINTERS_POLICY" />.
      </translation>
<translation id="8587229956764455752">Povolit vytváření nových uživatelských účtů</translation>
<translation id="8598350264853261122">Je-li tato zásada nastavena na hodnotu false, cizí uživatelé nebudou moci používat ARC.

      Pokud tato zásada není nastavena nebo je nastavena na hodnotu true, mohou ARC používat všichni uživatelé (není-li ARC zakázáno jiným způsobem).

      Změny této zásady se projeví jen v době, kdy ARC neběží, tj. při spouštění systému Chrome OS.</translation>
<translation id="8615400197788843468">Aktivuje ve službě G Suite funkci omezeného přihlašování prohlížeče <ph name="PRODUCT_NAME" /> a znemožní uživatelům toto nastavení změnit.

Pokud toto nastavení definujete, bude uživatel aplikace Google moci používat pouze pomocí účtů ze zadaných domén. (Chcete-li povolit účty v doménách gmail.com a googlemail.com, přidejte do seznamu domén hodnotu „consumer_accounts“ (bez uvozovek).)

Toto nastavení uživateli zabrání v přihlášení a přidání sekundárního účtu ve spravovaném zařízení, které vyžaduje ověření Google, pokud daný účet není uveden na výše zmíněném seznamu povolených domén.

Pokud toto nastavení ponecháte prázdné nebo nenakonfigurované, bude uživatel moci služby G Suite používat pomocí libovolného účtu.

Tato zásada způsobí, že bude k požadavkům HTTP a HTTPS odesílaným do domén google.com přidáno záhlaví X-GoogApps-Allowed-Domains popsané na stránce https://support.google.com/a/answer/1668854.

Uživatelé toto nastavení nemohou změnit ani přepsat.</translation>
<translation id="8631434304112909927">naposledy ve verzi <ph name="UNTIL_VERSION" /></translation>
<translation id="863319402127182273">U aplikací Android má tato zásada vliv pouze na vestavěný fotoaparát. Když je tato zásada nastavena na hodnotu True, je fotoaparát pro všechny aplikace Android bez výjimky zakázán.</translation>
<translation id="8649763579836720255">Zařízení se systémem Chrome OS mohou pomocí vzdáleného ověření identity (ověřeného přístupu) získat certifikát vydaný certifikační autoritou Chrome OS, který hodnotí, zda je zařízení vhodné k přehrání chráněného obsahu. Proces zahrnuje odeslání informací o podpoře hardwaru certifikační autoritě Chrome OS, která zařízení jedinečně identifikuje.

          Pokud zásadu nastavíte na hodnotu False, zařízení nebude u chráněného obsahu používat vzdálené ověření identity, a chráněný obsah proto nemusí být možné přehrát.

          Pokud zásadu nastavíte na hodnotu True nebo ji nenastavíte, u chráněného obsahu bude použito vzdálené ověření identity.</translation>
<translation id="8650974590712548439">Umístění v registru systému Windows pro klienty Windows:</translation>
<translation id="8654286232573430130">Určuje, které servery mají být umístěny na bílou listinu pro integrované ověření. Integrované ověření je povoleno pouze v případě, že <ph name="PRODUCT_NAME" /> obdrží výzvu ověřování z proxy serveru nebo jiného serveru, který je uveden v tomto seznamu povolených serverů.

Chcete-li zadat několik názvů serverů, oddělte je čárkami. Zástupné znaky (*) jsou povoleny.

Pokud zásada zůstane nenastavena, pokusí se <ph name="PRODUCT_NAME" /> zjistit, zda se server nachází v intranetu, a teprve poté bude reagovat na požadavky IWA. Pokud bude server zjištěn jako internet, bude <ph name="PRODUCT_NAME" /> požadavky IWA ignorovat.</translation>
<translation id="8672321184841719703">Cílová verze automatické aktualizace</translation>
<translation id="867410340948518937">U2F (Universal Second Factor)</translation>
<translation id="8682611302223077049">Umožňuje nastavit dobu v milisekundách, po kterou se uživatelům bude zobrazovat oznámení, že je třeba prohlížeč <ph name="PRODUCT_NAME" /> nebo zařízení se systémem <ph name="PRODUCT_OS_NAME" /> restartovat, aby bylo možné nainstalovat čekající aktualizaci.

      Během této doby bude uživatel opakovaně informován, že je potřeba nainstalovat aktualizaci. Na zařízeních se systémem <ph name="PRODUCT_OS_NAME" /> se oznámení o restartu zobrazuje na hlavním panelu systému, když je zjištěn upgrade. V prohlížečích <ph name="PRODUCT_NAME" /> se po uplynutí jedné třetiny lhůty pro oznámení změní nabídka aplikace na znamení, že je prohlížeč potřeba aktualizovat. Barva tohoto oznámení se změní po uplynutí dvou třetin lhůty a poté znovu po uplynutí celé lhůty. Další oznámení aktivovaná pomocí zásady <ph name="RELAUNCH_NOTIFICATION_POLICY_NAME" /> se řídí stejným časovým plánem.

      Pokud tuto zásadu nenastavíte, použije se pro systém <ph name="PRODUCT_OS_NAME" /> výchozí doba 345 600 000 milisekund (čtyři dny) a pro prohlížeč <ph name="PRODUCT_NAME" /> 604 800 000 milisekund (jeden týden).</translation>
<translation id="8685024486845674965">Ochrana hesla – upozornění je spouštěno opětovným použitím hesla</translation>
<translation id="8693243869659262736">Použít integrovaného klienta DNS</translation>
<translation id="8703488928438047864">Nahlásit stav panelu</translation>
<translation id="8704831857353097849">Seznam deaktivovaných pluginů</translation>
<translation id="8711086062295757690">Určuje klíčové slovo, které v adresním řádku spouští vyhledávání tohoto poskytovatele.

          Tato zásada je nepovinná. Pokud ji nenastavíte, žádné klíčové slovo poskytovatele vyhledávání neaktivuje.

          Tato zásada bude dodržována pouze v případě, že je aktivní zásada DefaultSearchProviderEnabled.</translation>
<translation id="8731693562790917685">Nastavení obsahu umožňují určit, jakým způsobem bude zpracováván obsah určitého typu (například soubory cookie, obrázky nebo JavaScript).</translation>
<translation id="8733448613597049197">Povoluje v prohlížeči <ph name="PRODUCT_NAME" /> rozšířené hlášení Bezpečnému prohlížení a znemožňuje uživatelům toto nastavení změnit.

      Rozšířené hlášení odesílá na servery Google část informací o systému a obsahu stránek s cílem pomoci rozpoznat nebezpečné aplikace a weby.

      Pokud je tato zásada nastavena na hodnotu true, budou se hlášení vytvářet a odesílat pokaždé, když to bude nutné (například při zobrazení vsunuté stránky s bezpečnostním upozorněním).

      Pokud je tato zásada nastavena na hodnotu false, hlášení se odesílat nebudou.

      Pokud je tato zásada nastavena na hodnotu true nebo false, uživatel toto nastavení nebude moci změnit.

      Pokud tuto zásadu ponecháte nenastavenou, uživatel nastavení bude moci změnit a rozhodnout se, zda tato hlášení chce odesílat, či nikoliv.

      Další informace o Bezpečném prohlížení najdete na stránce https://developers.google.com/safe-browsing.</translation>
<translation id="8736538322216687231">Vynutit minimální nastavení omezeného režimu na YouTube</translation>
<translation id="8749370016497832113">Aktivuje v prohlížeči <ph name="PRODUCT_NAME" /> mazání historie procházení a stahování a zabraňuje uživatelům, aby toto nastavení změnili.

     I když je tato zásada deaktivována, nelze zaručit, že bude historie procházení a stahování uchována: uživatelé mohou soubory upravovat nebo smazat přímo v databázi historie a také prohlížeč může některé nebo všechny položky historie kdykoliv smazat nebo archivovat.

      Pokud je toto nastavení aktivováno nebo není nastaveno, lze historii procházení a stahování smazat.

      Je-li nastavení deaktivováno, historii procházení nebo stahování smazat nelze.</translation>
<translation id="8758831693895931466">Aktivovat povinou registraci ke cloudové správě</translation>
<translation id="8759829385824155666">Povolené typy šifrování Kerberos</translation>
<translation id="8764119899999036911">Určuje, zda bude vygenerovaný hlavní název služby protokolu Kerberos založen na kanonickém názvu DNS, nebo na původním zadaném názvu.
         
        Pokud toto nastavení aktivujete, vyhledávání záznamů CNAME bude přeskočeno a bude použit zadaný název serveru.
       
        Pokud toto nastavení deaktivujete nebo nenastavíte, určí se kanonický název serveru prostřednictvím vyhledávání záznamů CNAME.</translation>
<translation id="8765776988041674792">Konfiguruje adresu URL pro změnu hesla (pouze schémata HTTP a HTTPS). Po zobrazení upozornění v prohlížeči bude služba pro ochranu hesel odesílat uživatele na tuto adresu URL, aby si změnili heslo.
      Aby prohlížeč <ph name="PRODUCT_NAME" /> na stránce pro změnu hesla mohl správně pořídit otisk nového hesla, měla by odpovídat pokynům na stránce https://www.chromium.org/developers/design-documents/create-amazing-password-forms.

      Pokud je toto nastavení zapnuté, bude služba pro ochranu hesel uživatele po zobrazení upozornění v prohlížeči odesílat na tuto adresu URL, aby si změnili heslo.
      Pokud je toto nastavení vypnuté nebo není nastavené, bude služba pro ochranu hesel uživatele za účelem změny hesla odesílat na adresu https://myaccounts.google.com.
      Tato zásada je k dispozici jen v instancích systému Windows, které jsou připojené k doméně <ph name="MS_AD_NAME" />, nebo v instancích systému Windows 10 Pro nebo Enterprise, které jsou zaregistrované ke správě zařízení.</translation>
<translation id="8782750230688364867">Určuje, na kolik procent bude prodloužena prodleva ztmavení obrazovky, pokud je zařízení v režimu prezentace.

Pokud je tato zásada nastavena, určuje, na kolik procent bude prodloužena prodleva ztmavení obrazovky, pokud je zařízení v režimu prezentace. Při prodloužení prodlevy ztmavení budou prodlouženy i prodlevy vypnutí, uzamčení obrazovky a nečinnosti tak, aby mezi nimi a prodlevou ztmavení zůstala stejná doba.

Není-li tato zásada nastavena, bude použita výchozí hodnota prodloužení.

Hodnota prodloužení musí být 100 % nebo více. Hodnoty, které by prodlevu ztmavení obrazovky oproti výchozí hodnotě zkrátily, nejsou povoleny.</translation>
<translation id="8798099450830957504">Výchozí</translation>
<translation id="8801680448782904838">Oznamovat uživateli, že je doporučen nebo vyžadován restart prohlížeče nebo zařízení</translation>
<translation id="8818173863808665831">Oznámí zeměpisnou polohu zařízení.

      Pokud tato zásada není nastavena, nebo je nastavena na hodnotu false, poloha oznamována nebude.</translation>
<translation id="8818768076343557335">Předvídat síťové akce u všech nemobilních sítí.
          (Od verze 50 ukončena podpora, od verze 52 odstraněno. Od verze 52 platí, že pokud je nastavena hodnota 1, bude se zásada chovat stejně, jako by byla nastavena hodnota 0 – síťové akce se budou předvídat u všech síťových připojení.)</translation>
<translation id="8825782996899863372">Ochrana hesla – upozornění je spouštěno opětovným použitím hesla na phishingové stránce</translation>
<translation id="8828766846428537606">Slouží ke konfiguraci výchozí domovské stránky v prohlížeči <ph name="PRODUCT_NAME" /> a brání uživatelům, aby nastavenou domovskou stránku měnili.

      Nastavení domovské stránky uživatele jsou zcela uzamčena pouze v případě, že jako domovskou stránku nastavíte buď stránku Nová karta, nebo adresu URL, kterou zadáte. Pokud adresu URL domovské stránky nezadáte, uživatel bude moci domovskou stránku změnit na stránku Nová karta, a to tím, že zadá řetězec „chrome://newtab“.</translation>
<translation id="8833109046074170275">Ověření prostřednictvím výchozího procesu GAIA</translation>
<translation id="8838303810937202360"><ph name="PRODUCT_OS_NAME" /> 
Pokud tato zásada není nakonfigurována nebo je hodnota nižší než 1 MB, <ph name="PRODUCT_OS_NAME" /> použije výchozí velikost mezipaměti.</translation>
<translation id="8858642179038618439">Vynutit Bezpečný režim YouTube</translation>
<translation id="8860342862142842017">Deaktivovat vynucování zásad Certificate Transparency pro seznam hodnot hash údajů subjectPublicKeyInfo</translation>
<translation id="8864975621965365890">Potlačuje oznámení o ukončení podpory, která se zobrazuje, když je web vykreslován pomocí pluginu <ph name="PRODUCT_FRAME_NAME" />.</translation>
<translation id="8867464911288727016">Zapne v prohlížeči <ph name="PRODUCT_NAME" /> integrovanou službu Překladač Google.

      Pokud toto nastavení aktivujete, bude <ph name="PRODUCT_NAME" /> uživatelům nabízet funkci překladu tím, že bude ve vhodných případech zobrazovat integrovanou lištu překladu a v kontextové nabídce otevírané kliknutím pravým tlačítkem bude zobrazovat možnost překladu.

      Pokud toto nastavení deaktivujete, budou veškeré integrované služby překladu zakázány.

      Pokud toto nastavení aktivujete nebo deaktivujete, uživatelé jej v prohlížeči <ph name="PRODUCT_NAME" /> nebudou moci změnit ani přepsat.

      Pokud toto nastavení ponecháte nenastavené, uživatelé se budou moci rozhodnout, zda tuto funkci chtějí používat.</translation>
<translation id="8870318296973696995">Domovská stránka</translation>
<translation id="8876188741456358123">Přepíše výchozí režim oboustranného tisku. Pokud režim není k dispozici, zásada bude ignorována.</translation>
<translation id="8882006618241293596">Blokovat plugin <ph name="FLASH_PLUGIN_NAME" /> na těchto webech</translation>
<translation id="890403179930035128">Vynutí povolení jazyků kontroly pravopisu. Neznámé jazyky v seznamu budou ignorovány.

      Pokud tuto zásadu povolíte, bude kontrola pravopisu kromě jazyků, pro které ji povolil uživatel, povolena také pro zadané jazyky.

      Pokud tuto zásadu nenastavíte nebo ji zakážete, bude platit nastavení kontroly pravopisu zadané uživatelem beze změny.

      Je-li kontrola pravopisu zakázána pomocí zásady SpellcheckEnabled, nebude mít tato zásada žádný účinek.

      V současné době jsou podporovány tyto jazyky: af, bg, ca, cs, da, de, el, en-AU, en-CA, en-GB, en-US, es, es-419, es-AR, es-ES, es-MX, es-US, et, fa, fo, fr, he, hi, hr, hu, id, it, ko, lt, lv, nb, nl, pl, pt-BR, pt-PT, ro, ru, sh, sk, sl, sq, sr, sv, ta, tg, tr, uk, vi.</translation>
<translation id="8906768759089290519">Aktivovat režim hosta</translation>
<translation id="8908294717014659003">Umožňuje nastavit, zda webové stránky smějí používat zařízení pro pořizování mediálního obsahu. Přístup k zařízením pro pořizování mediálního obsahu může být povolen ve výchozím nastavení, nebo se uživateli může zobrazit dotaz pokaždé, když nějaké webové stránky budou chtít použít zařízení pro pořízení mediálního obsahu.

          Pokud tuto zásadu nenastavíte, bude použita zásada PromptOnAccess a uživatel ji bude moci změnit.</translation>
<translation id="8909280293285028130">Udává dobu nečinnosti uživatele, po které bude obrazovka při napájení ze sítě uzamčena.

          Pokud je tato zásada nastavena na hodnotu větší než nula, jedná se o dobu, po kterou musí uživatel zůstat v nečinnosti, než systém <ph name="PRODUCT_OS_NAME" /> uzamkne obrazovku.

          Pokud je tato zásada nastavena na nulovou hodnotu, systém <ph name="PRODUCT_OS_NAME" /> obrazovku při nečinnosti uživatele neuzamkne.

          Není-li tato zásada nastavena, bude použita výchozí doba.

          Doporučený způsob zamykání obrazovky při nečinnosti je uzamčení obrazovky v režimu spánku a nastavení časové prodlevy pro přechod systému <ph name="PRODUCT_OS_NAME" /> do režimu spánku. Tuto zásadu doporučujeme použít pouze v případě, že chcete obrazovku zamknout o mnoho dříve, než nastane přechod do režimu spánku, nebo pokud nechcete režim spánku využívat vůbec.

          Hodnotu zásady zadávejte v milisekundách. Maximální hodnota je nižší než prodleva režimu spánku.</translation>
<translation id="891435090623616439">Zakódováno jako řetězec JSON, podrobnosti naleznete zde: <ph name="COMPLEX_POLICIES_URL" /></translation>
<translation id="8934944553121392674">Určuje, které tiskárny ze zásady <ph name="DEVICE_PRINTERS_POLICY" /> budou uživatelům dostupné.

      Stanovuje, která zásada přístupu se použije pro hromadnou konfiguraci tiskáren. Je-li vybrána možnost <ph name="PRINTERS_ALLOW_ALL" />, budou zobrazeny všechny tiskárny. Je-li vybrána možnost <ph name="PRINTERS_BLACKLIST" />, bude zakázán přístup k tiskárnám uvedeným v zásadě <ph name="DEVICE_PRINTERS_BLACKLIST" />. Je-li vybrána možnost <ph name="PRINTERS_WHITELIST" />, bude možné vybrat pouze tiskárny uvedené v zásadě <ph name="DEVICE_PRINTERS_WHITELIST" />.

      Pokud tato zásada není nastavena, předpokládá se použití možnosti <ph name="PRINTERS_ALLOW_ALL" />.
      </translation>
<translation id="8938932171964587769">Od verze M69 tato zásada již není podporována. Použijte namísto ní zásadu OverrideSecurityRestrictionsOnInsecureOrigin.

      Tato zásada určuje seznam zdrojů (adres URL) nebo vzorů názvů hostitelů (například „*.example.com“), na které se nebudou vztahovat bezpečnostní omezení nezabezpečených zdrojů.

      Cílem je umožnit organizacím vytvořit seznam povolených zdrojů pro starší aplikace, do kterých nelze implementovat protokol TLS, nebo nastavit zkušební server pro vývoj interních webových stránek, aby vývojáři mohli testovat funkce, které vyžadují zabezpečené kontexty, aniž by na testovacím serveru museli implementovat protokol TLS. Tato zásada také zabrání označení zdroje jako nezabezpečeného v omniboxu.

      Nastavení seznamu adres URL v této zásadě má stejný dopad jako nastavení příznaku příkazového řádku --unsafely-treat-insecure-origin-as-secure na čárkami oddělený seznam stejných adres URL. Je-li nastavena tato zásada, bude jí příznak příkazového řádku přepsán.

      Podpora této zásady byla ve verzi M69 ukončena a byla nahrazena zásadou OverrideSecurityRestrictionsOnInsecureOrigin. Pokud jsou nastaveny obě tyto zásady, zásada OverrideSecurityRestrictionsOnInsecureOrigin tuto zásadu přepíše.

      Další informace o bezpečných kontextech najdete na stránce https://www.w3.org/TR/secure-contexts/.
      </translation>
<translation id="8942616385591203339">Tato zásada určuje, zda je možné uživateli při prvním přihlášení zobrazit žádost o souhlas se synchronizací. Pokud žádost o souhlas se synchronizací u uživatele není potřeba, měla by být nastavena na hodnotu false.
      Pokud je nastavena na hodnotu false, žádost o souhlas se synchronizací se nebude zobrazovat.
      Pokud je nastavena na hodnotu true nebo není nastavena, žádost o souhlas se synchronizací se může zobrazit.</translation>
<translation id="8947415621777543415">Oznamovat polohu zařízení</translation>
<translation id="8951350807133946005">Nastavit adresář mezipaměti na disku</translation>
<translation id="8952317565138994125">Deaktivuje v prohlížeči <ph name="PRODUCT_NAME" /> synchronizaci dat pomocí synchronizačních služeb hostovaných na Googlu a zabrání uživatelům ve změně tohoto nastavení.

      Pokud toto nastavení aktivujete, uživatelé jej v prohlížeči <ph name="PRODUCT_NAME" /> nebudou moci změnit ani přepsat.

      Pokud tuto zásadu ponecháte nenastavenou, uživatel bude moci zvolit, zda chce službu Google Sync používat, či nikoliv.

      Chcete-li službu Google Sync úplně zakázat, doporučujeme vám zakázat ji v administrátorské konzoli Google.

      Tuto zásadu byste neměli aktivovat v případě, že je zásada <ph name="ROAMING_PROFILE_SUPPORT_ENABLED_POLICY_NAME" /> zapnuta na Povoleno. Obě se totiž týkají stejné funkce na straně klienta. V tomto případě je synchronizace hostovaná na Googlu zcela vypnuta.</translation>
<translation id="8955719471735800169">Zpět na začátek</translation>
<translation id="8959992920425111821">Výchozí konfigurace</translation>
<translation id="8960850473856121830">Vzory v tomto seznamu budou porovnány s bezpečnostními údaji o původu požadované adresy URL. Pokud bude nalezena shoda, přístup k zařízením pro záznam zvuku bude udělen bez vyzvání.

POZNÁMKA: Až do verze 45 byla tato zásada podporována pouze v režimu veřejného terminálu.</translation>
<translation id="8970205333161758602">Potlačení oznámení o ukončení podpory pluginu <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="8976248126101463034">Povolit ověřování gnubby pro hostitele vzdáleného přístupu</translation>
<translation id="8976531594979650914">Jako výchozí tiskárnu použít výchozí tiskárnu systému</translation>
<translation id="8992176907758534924">Nepovolit zobrazení obrázků žádným webovým stránkám</translation>
<translation id="9035964157729712237">ID rozšíření, která mají být vyňata ze seznamu zakázaných</translation>
<translation id="9042911395677044526">Umožňuje přenést nastavení sítě, která se uplatní pro jednotlivé uživatele v zařízení se systémem <ph name="PRODUCT_OS_NAME" />. Konfigurace sítě je řetězec ve formátu JSON, který se řídí definicí formátu Open Network Configuration popsanou na stránce <ph name="ONC_SPEC_URL" />.</translation>
<translation id="906631898352326790">
      Pokud tuto zásadu povolíte, každý z uvedených zdrojů v seznamu odděleném čárkami se spustí ve vlastním procesu. Budou izolovány i zdroje uvedené v subdoménách – např. pokud zadáte web https://example.com/, bude izolována také subdoména https://foo.example.com/, která je jeho součástí.
      Pokud tuto zásadu zakážete, budou zakázány zásady IsolateOrigins a SitePerProcess. Zásadu IsolateOrigins však uživatelé budou moci povolit ručně pomocí příznaků příkazového řádku.
      Pokud tuto zásadu nenakonfigurujete, uživatel toto nastavení bude moci změnit.
      V systému <ph name="PRODUCT_OS_NAME" /> je doporučeno nastavit na stejnou hodnotu také zásadu zařízení <ph name="DEVICE_LOGIN_SCREEN_ISOLATE_ORIGINS_POLICY_NAME" />. Pokud se hodnoty obou zásad nebudou shodovat, při zahájení uživatelské návštěvy může dojít k prodlevě, zatímco se bude přecházet na hodnotu nastavenou zásadou pro uživatele.

      POZNÁMKA: Tato zásada nefunguje na zařízeních Android. K aktivaci zásady IsolateOrigins na zařízeních Android použijte zásadu IsolateOriginsAndroid.
      </translation>
<translation id="9077227880520270584">Časovač automatického přihlášení k místnímu účtu na zařízení</translation>
<translation id="9084985621503260744">Určuje, zda aktivita videa ovlivňuje správu napájení</translation>
<translation id="9088433379343318874">Povolit poskytovatele obsahu pro dozorovaného uživatele</translation>
<translation id="9088444059179765143">Konfigurace metody automatického zjišťování časového pásma</translation>
<translation id="9094064873808699479">Vraťte se a zůstaňte u cílové verze, pokud je verze operačního systému novější než cílová. Pokuste se při vrácení přenést konfiguraci na úrovni zařízení (včetně přihlašovacích údajů k síti). Pokud obnovení dat není možné, proveďte vrácení a Powerwash (protože cílová verze nepodporuje obnovení dat nebo protože se jedná o změnu, která není zpětně kompatibilní).
          Podporováno u systému <ph name="PRODUCT_OS_NAME" /> verze 70 a vyšší. U starších klientů tato hodnota znamená, že vrácení zpět je zakázáno.</translation>
<translation id="9096086085182305205">Seznam povolených serverů pro ověřování</translation>
<translation id="9098553063150791878">Zásady pro ověření v protokolu HTTP</translation>
<translation id="9105265795073104888">Aplikace Android obdrží pouze část možností konfigurace proxy serveru. Aplikace Android se mohou samy rozhodnout, zda proxy server použijí. Použití proxy serveru u nich nelze vynutit.</translation>
<translation id="9106865192244721694">Povolit rozhraní WebUSB na těchto webech</translation>
<translation id="9112727953998243860">Konfigurační soubor podnikových tiskáren</translation>
<translation id="9112897538922695510">Umožňuje zaregistrovat seznam obslužných nástrojů protokolů. Tato zásada může být pouze doporučena. Vlastnost |protocol| musí být nastavena na schéma jako „mailto“ a vlastnost |url| musí být nastavena na vzorec adresy URL aplikace, která schéma zpracovává. Vzorec může obsahovat specifikátor „%s“, který (bude-li zadán) bude nahrazen zpracovanou adresou URL.

          Obslužné nástroje protokolů zaregistrované pomocí této zásady budou sloučeny s obslužnými nástroji zaregistrovanými uživatelem a k dispozici budou všechny. Obslužné nástroje protokolů nainstalované zásadou může uživatel přepsat tím, že nainstaluje nový výchozí obslužný nástroj, avšak nemůže je odstranit.</translation>
<translation id="9123211093995421438">Určuje minimální počet milníků systému <ph name="PRODUCT_OS_NAME" />, o které má být povoleno vrátit se ze stabilní verze kdykoliv zpět.

      Výchozí nastavení je u spotřebitelů 0 a u zaregistrovaných podnikových zařízení 4 (přibližně půl roku).

      Nastavení této zásady zabrání použití ochrany před vrácením zpět minimálně po zadaný počet milníků.

      Nastavení této zásady na nižší hodnotu má trvalý účinek: Zařízení NEMUSÍ být možné vrátit zpět na předchozí verze ani po přenastavení této zásady na vyšší hodnotu.

      Skutečné možnosti vrácení zpět mohou záviset také na modelu zařízení a opravách kritických chyb zabezpečení.</translation>
<translation id="913195841488580904">Blokování přístupu k seznamu adres URL</translation>
<translation id="9135033364005346124">Aktivovat proxy server služby <ph name="CLOUD_PRINT_NAME" /></translation>
<translation id="9136399279941091445">Intervaly, v nichž nebudou uplatňovány zadané zásady zařízení</translation>
<translation id="9147029539363974059">Odesílá systémové protokoly na server správy, což umožňuje jejich kontrolu ze strany administrátorů.

Pokud je zásada nastavena na hodnotu true, systémové protokoly budou odesílány. Pokud tuto zásadu nenakonfigurujete nebo ji nastavíte na hodnotu false, systémové protokoly odesílány nebudou.</translation>
<translation id="9150416707757015439">Tato zásada se již nepoužívá. Namísto ní prosím použijte zásadu IncognitoModeAvailability. 
      Povoluje anonymní režim v aplikaci <ph name="PRODUCT_NAME" />.

     Je-li toto nastavení aktivované nebo není nakonfigurované, uživatelé mohou otvírat webové stránky v anonymním režimu.

      Je-li toto nastavení deaktivované, uživatelé nemohou otvírat webové stránky v anonymním režimu.

     Pokud zásadu nenastavíte, toto nastavení se aktivuje a uživatelé budou moci používat anonymní režim.</translation>
<translation id="915194831143859291">Pokud je tato zásada nastavena na hodnotu false nebo není nastavena, systém <ph name="PRODUCT_OS_NAME" /> umožní uživateli vypnout zařízení.
Pokud je tato zásada nastavena na hodnotu true a uživatel vypne zařízení, spustí systém <ph name="PRODUCT_OS_NAME" /> restart. Systém <ph name="PRODUCT_OS_NAME" /> nahradí všechna tlačítka pro vypnutí v uživatelském rozhraní tlačítky pro restart. Pokud uživatel zařízení vypne pomocí vypínače, zařízení se automaticky restartovat nebude, a to ani v případě, že je tato zásada aktivována.</translation>
<translation id="9152473318295429890">Povolit kontextové návrhy souvisejících webových stránek</translation>
<translation id="9158929520101169054">Povolit v prohlížeči vícenásobné přihlášení</translation>
<translation id="9159126470527871268">Oznamuje uživateli, že je třeba restartovat prohlížeč <ph name="PRODUCT_NAME" /> nebo systém <ph name="PRODUCT_OS_NAME" />, aby bylo možné nainstalovat čekající aktualizaci.

      Toto nastavení zásady umožňuje, aby byl uživatel prostřednictvím oznámení informován, že je doporučeno nebo nutno restartovat prohlížeč nebo zařízení. Pokud zásada nebude nastavena, prohlížeč <ph name="PRODUCT_NAME" /> o potřebném restartování informuje uživatele pomocí drobných změn v nabídce, zatímco systém <ph name="PRODUCT_OS_NAME" /> o něm informuje prostřednictvím oznámení na hlavním panelu systému. Pokud je nastavena na hodnotu Doporučeno, bude se uživateli opakovaně zobrazovat upozornění, že je doporučen restart. Uživatel upozornění může odmítnout a tím restart odložit. Pokud je nastavena na hodnotu Povinné, bude se uživateli opakovaně zobrazovat upozornění, že po uplynutí lhůty pro oznámení bude vynucen restart prohlížeče. Výchozí lhůta je u prohlížeče <ph name="PRODUCT_NAME" /> sedm dní, u systému <ph name="PRODUCT_OS_NAME" /> čtyři dny a lze ji nakonfigurovat nastavením zásady <ph name="RELAUNCH_NOTIFICATION_PERIOD_POLICY_NAME" />.

      Relace uživatele bude po restartování obnovena.</translation>
<translation id="9165792353046089850">Umožňuje nastavit, zda weby mají povoleno získat přístup k připojeným zařízením USB. Přístup lze zcela zablokovat, nebo je možné uživatele požádat pokaždé, když chce web k připojeným zařízením USB získat přístup.

          Tuto zásadu lze pro konkrétní vzory adres URL přepsat pomocí zásad WebUsbAskForUrls a WebUsbBlockedForUrls.

          Pokud je tato zásada ponechána nenastavená, použije se hodnota „3“ a uživatel ji bude moci změnit.</translation>
<translation id="9167719789236691545">Zakázat v aplikaci Soubory v systému <ph name="PRODUCT_OS_NAME" /> přístup k Disku</translation>
<translation id="9187743794267626640">Zakázat připojení externího úložiště</translation>
<translation id="9197740283131855199">Procento, o které bude prodloužena prodleva ztmavení obrazovky, pokud uživatel po ztmavení provedete nějakou činnost</translation>
<translation id="9200828125069750521">Parametry pro adresu URL obrázku používající metodu POST</translation>
<translation id="920209539000507585">Vynucuje zapnutí nebo vypnutí záhlaví a zápatí v dialogovém okně tisku.

Pokud zásada není nastavena, uživatel se může rozhodnout, zda záhlaví a zápatí vytiskne.

Pokud je nastavena na false, možnost Záhlaví a zápatí není v dialogovém okně náhledu tisku vybrána a uživatel to nemůže změnit.

Pokud je nastavena na true, možnost Záhlaví a zápatí je v dialogovém okně náhledu tisku vybrána a uživatel to nemůže změnit.</translation>
<translation id="9210953373038593554">Konfiguruje typ ověření pro přihlášení pomocí technologie SAML.

      Když tato zásada není nastavena nebo je nastavena na možnost Default (hodnota 0), určuje chování při přihlašování pomocí technologie SAML prohlížeč na základě jiných faktorů. V nejzákladnějším případě se k ověření uživatele a ochraně dat uživatele uložených v mezipaměti používají hesla, která ručně zadávají uživatelé.

      Když je tato zásada nastavena na možnost ClientCertificate (hodnota 1), pro nově přidané uživatele, kteří se přihlašují pomocí technologie SAML, se používá ověření pomocí certifikátu klienta. Pro takové uživatele se nepoužívají žádná hesla a jejich místní data uložená v mezipaměti jsou chráněna pomocí odpovídajících kryptografických klíčů. Pomocí tohoto nastavení lze nakonfigurovat například ověřování uživatelů pomocí čipových karet. (Aplikace middleware pro čipové karty je potřeba nainstalovat pomocí zásady DeviceLoginScreenAppInstallList.)

      Tato zásada má vliv pouze na uživatele, kteří používají ověření pomocí technologie SAML.</translation>
<translation id="9213347477683611358">Slouží ke konfiguraci obrázku tapety na úrovni zařízení, který se bude zobrazovat na přihlašovací obrazovce, pokud se do zařízení dosud nepřihlásil žádný uživatel. Zásadu nastavíte zadáním adresy URL, ze které může zařízení se systémem Chrome OS obrázek tapety stáhnout, a kryptografické hodnoty hash k ověření integrity staženého obsahu. Obrázek musí být ve formátu JPEG a jeho velikost nesmí překročit 16 MB. Adresa URL musí být přístupná bez ověření. Obrázek tapety se stáhne a uloží do mezipaměti. Při každé změně adresy URL nebo hodnoty hash se obrázek stáhne znovu.

      Tuto zásadu je třeba zadat jako řetězec, který udává adresu URL a hodnotu hash ve formátu JSON. Příklad:
      {
        "url": "https://example.com/tapeta_zarizeni.jpg",
        "hash": "hashukazkovetapety"
      }

      Pokud je zásada tapety zařízení nastavena, zařízení se systémem Chrome OS stáhne obrázek tapety a použije jej na přihlašovací obrazovce, pokud se do zařízení dosud nepřihlásil žádný uživatel. Po přihlášení se použije zásada pro tapetu příslušného uživatele.

      Pokud zásada tapety zařízení není nastavena, zobrazený obrázek závisí na zásadě tapety uživatele (pokud je nastavena).</translation>
<translation id="9217154963008402249">Frekvence odesílání sledovacích síťových paketů</translation>
<translation id="922540222991413931">Konfigurovat zdroje instalací rozšíření, aplikací a uživatelských skriptů</translation>
<translation id="924557436754151212">Importování uložených hesel z výchozího prohlížeče při prvním spuštění</translation>
<translation id="930930237275114205">Nastavit adresář uživatelských dat pluginu <ph name="PRODUCT_FRAME_NAME" /> </translation>
<translation id="944817693306670849">Nastavení velikosti mezipaměti na disku</translation>
<translation id="981346395360763138">Služby určování polohy Google jsou vypnuty</translation>
<translation id="982497069985795632">Zapnout kontrolu pravopisu</translation>
<translation id="991560005425213776">Odesílat do nativních tiskáren uživatelské jméno a název souboru</translation>
</translationbundle>