<?xml version="1.0" ?>
<!DOCTYPE translationbundle>
<translationbundle lang="cs">
<translation id="1503959756075098984">ID rozšíření a adresy URL aktualizací, které se mají nainstalovat na pozadí</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="2463365186486772703">Jazyk aplikace</translation>
<translation id="1397855852561539316">URL výchozího vyhledávače pro návrhy</translation>
<translation id="3347897589415241400">Výchozí chování pro weby, které nejsou v žádném obsahovém balíčku.

          Tato zásada je určena k internímu použití prohlížečem Chrome.</translation>
<translation id="7040229947030068419">Ukázková hodnota:</translation>
<translation id="1213523811751486361">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"/>, který bude během dotazování nahrazen textem zadávaným uživatelem.

          Tato zásada je nepovinná. Pokud ji nenastavíte, nebude adresa URL pro návrhy použita.

          Zásada bude dodržována pouze v případě, že je aktivní zásada DefaultSearchProviderEnabled.</translation>
<translation id="6106630674659980926">Aktivovat správce hesel</translation>
<translation id="7109916642577279530">Povoluje nebo zakazuje záznam zvuku.

Pokud je tato zásada aktivována nebo není nakonfigurována (výchozí nastavení), uživatel bude vyzván k udělení přístupu pro záznam zvuku (s výjimkou adres URL nakonfigurovaných v seznamu AudioCaptureAllowedUrls, kterým bude přístup udělen bez vyzvání).

Pokud je tato zásada deaktivována, uživateli se výzva nikdy nezobrazí a záznam zvuku bude k dispozici pouze u adres URL uvedených na seznamu AudioCaptureAllowedUrls.

Tato zásada ovlivňuje kromě integrovaného mikrofonu i všechny ostatní zvukové vstupy.</translation>
<translation id="7267809745244694722">Mediální klávesy ve výchozím nastavení slouží jako funkční klávesy</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="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 relace 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 relace 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="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="7818131573217430250">Nastavení výchozího stavu režimu vysokého kontrastu na přihlašovací obrazovce</translation>
<translation id="7614663184588396421">Seznam deaktivovaných schémat protokolu</translation>
<translation id="2309390639296060546">Výchozí nastavení geolokace</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="7443616896860707393">Požadavky typu cross-origin standardu HTTP Basic Auth</translation>
<translation id="2337466621458842053">Umožňuje nastavit seznam vzorů adres URL pro webové stránky, které mají povoleno zobrazovat obrázky.

          Pokud zásadu nenastavíte, použije se pro všechny webové stránky globální výchozí hodnota buď ze zásady DefaultImagesSetting (pokud je nastavena), nebo z osobního nastavení uživatele.</translation>
<translation id="4680961954980851756">Aktivovat Automatické vyplňování</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="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="3185009703220253572">od verze <ph name="SINCE_VERSION"/></translation>
<translation id="5298412045697677971">Konfigurace obrázku avatara uživatele

      Tato zásada umožňuje nakonfigurovat obrázek avatara, který na přihlašovací obrazovce představuje uživatele. Zásadu nastavíte zadáním adresy URL, ze které systém <ph name="PRODUCT_OS_NAME"/> může obrázek avatara stáhnout, a kryptografické hodnoty hash, která slouží k ověření integrity staženého obsahu. Obrázek musí být ve formátu JPEG a jeho velikost nesmí překročit 512 kB. Adresa URL musí být přístupná bez nutnosti autentizace.

      Obrázek avatara se stáhne a uloží do mezipaměti. Obrázek se stáhne znovu pokaždé, když se adresa URL nebo hodnota hash změní.

      Tuto zásadu je třeba zadat jako řetězec, který udává adresu URL a hodnotu hash ve formátu JSON, a to podle následujícího schématu:
      {
        &quot;type&quot;: &quot;object&quot;,
        &quot;properties&quot;: {
          &quot;url&quot;: {
            &quot;description&quot;: &quot;Adresa URL, ze které lze obrázek avatara stáhnout&quot;,
            &quot;type&quot;: &quot;string&quot;
          },
          &quot;hash&quot;: {
            &quot;description&quot;: &quot;Hodnota hash SHA-256 obrázku avatara&quot;,
            &quot;type&quot;: &quot;string&quot;
          }
        }
      }
      Pokud tuto zásadu nastavíte, systém <ph name="PRODUCT_OS_NAME"/> obrázek avatara stáhne a použije.

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

      Pokud zásadu nenastavíte, uživatel bude moci sám zvolit, jaký obrázek avatara jej bude na přihlašovací obrazovce představovat.</translation>
<translation id="2204753382813641270">Řídit automatické skrývání skladu</translation>
<translation id="3816312845600780067">Aktivovat nouzovou klávesovou zkratku pro automatické přihlášení</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="5330684698007383292">Umožnit pluginu <ph name="PRODUCT_FRAME_NAME"/> zpracovávat následující typy obsahu</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="69525503251220566">Parametr poskytující funkci vyhledávání podle obrázku pro výchozího poskytovatele vyhledávání</translation>
<translation id="5469825884154817306">Blokovat obrázky na těchto stránkách</translation>
<translation id="8412312801707973447">Zda se budou provádět online kontroly OCSP/CRL</translation>
<translation id="2482676533225429905">Zasílání nativních zpráv</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="3213821784736959823">Řídí, zda se v prohlížeči <ph name="PRODUCT_NAME"/> používá integrovaný klient DNS.

      Pokud je tato zásada nastavena na hodnotu true, bude použit integrovaný klient DNS (pokud je k dispozici).

      Pokud je tato zásada nastavena na hodnotu false, integrovaný klient DNS nikdy použit nebude.

      Pokud tato zásada není nastavená, uživatelé budou moci změnit, zda bude použit integrovaný klient DNS, úpravou příznaku chrome://flags nebo zadáním příznaku příkazového řádku.</translation>
<translation id="2908277604670530363">Maximální počet současných připojení k proxy serveru</translation>
<translation id="556941986578702361">Řídí automatické skrývání skladu systému <ph name="PRODUCT_OS_NAME"/>.

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

      Pokud je tato zásada nastavena na hodnotu NeverAutoHideShelf, sklad 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í skladu sami.</translation>
<translation id="4838572175671839397">Obsahuje regulární výraz určující uživatele, kteří se mohou přihlásit do prohlížeče <ph name="PRODUCT_NAME"/>.

      Pokud se uživatel pokusí přihlásit pomocí uživatelského jména, které se neshoduje s tímto vzorem, zobrazí se příslušná chybová zpráva.

      Pokud tato zásada není nastavena nebo je prázdná, může se do prohlížeče <ph name="PRODUCT_NAME"/> přihlásit libovolný uživatel.</translation>
<translation id="2892225385726009373">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č Chrome použije existující online nastavení kontroly odvolání.</translation>
<translation id="3516856976222674451">Omezuje maximální délku trvání uživatelské relace.

      Když je tato zásada nastavena, udává dobu, po jejímž uplynutí bude uživatel automaticky odhlášen a relace ukončena. O zbývajícím čase uživatele informuje ukazatel odpočtu na hlavním panelu systému.

      Když tato zásada nastavena není, relace může trvat neomezeně dlouho.

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

      Hodnotu zásady je třeba zadat v milisekundách. Hodnoty se mohou pohybovat v rozmezí od 30 sekund do 24 hodin.</translation>
<translation id="9200828125069750521">Parametry pro adresu URL obrázku používající metodu POST</translation>
<translation id="2769952903507981510">Konfigurovat povinný název domény pro hostitele vzdáleného přístupu</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="3478024346823118645">Při odhlášení smazat uživatelská data</translation>
<translation id="8668394701842594241">Určuje seznam aktivovaných pluginů aplikace <ph name="PRODUCT_NAME"/> a brání uživatelům, aby toto nastavení změnili.

            Jako zástupné znaky lze použít znaky „*“ a „?“. Znak „*“ slouží jako zástupný znak pro několik libovolných znaků, zatímco znak „?“ zastupuje jeden znak (může zastupovat libovolný znak nebo také žádný znak). Řídicí znak je „\“, pokud tedy chcete zadat znaky „*“, „?“ nebo „\“ jako takové, stačí před ně umístit znak „\“.

      Pokud jsou pluginy uvedené v seznamu nainstalovány, budou v aplikaci <ph name="PRODUCT_NAME"/> vždy použity. Na stránce about:plugins jsou tyto pluginy označeny jako aktivní a uživatelé je nemohou deaktivovat.

      Tato zásada přepisuje zásady DisabledPlugins a DisabledPluginsExceptions.

      Pokud zásadu nenastavíte, mohou uživatelé deaktivovat jakékoliv pluginy nainstalované v systému.</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="979541737284082440">(Tento dokument může obsahovat zásady, které jsou určeny pro pozdější verze aplikace <ph name="PRODUCT_NAME"/>. Tyto zásady se mohou bez předchozího upozornění změnit. Seznam podporovaných zásad je pro Chromium a Google Chrome stejný.)

      Tato nastavení není třeba měnit ručně. Na adrese <ph name="POLICY_TEMPLATE_DOWNLOAD_URL"/> si můžete stáhnout snadno použitelné šablony.

      Tyto zásady jsou určeny pouze ke konfiguraci interních instancí prohlížeče Chrome v organizaci. Použití zásad mimo organizaci (např. ve veřejně distribuovaném programu) je považováno za malware a pravděpodobně takto bude společností Google a dodavateli antivirového softwaru označeno.

      Poznámka: Od verze <ph name="PRODUCT_NAME"/> 28 se zásady v systémech Windows načítají přímo z rozhraní Group Policy API. Zásady ručně zapsané do registru budou ignorovány. Podrobnosti naleznete na stránkách http://crbug.com/259236.

      Od verze <ph name="PRODUCT_NAME"/> 35 se u pracovních stanic, které jsou přidány do domény Active Directory, zásady načítají přímo z registru. V ostatních případech se zásady načítají z objektu zásad skupiny (GPO).</translation>
<translation id="4157003184375321727">Hlásit verzi operačního systému a firmwaru</translation>
<translation id="5255162913209987122">Doporučuje se</translation>
<translation id="1861037019115362154">Určuje seznam deaktivovaných pluginů aplikace <ph name="PRODUCT_NAME"/> a brání uživatelům, aby toto nastavení změnili.

            Jako zástupné znaky lze použít znaky „*“ a „?“. Znak „*“ slouží jako zástupný znak pro několik libovolných znaků, zatímco znak „?“ zastupuje jeden znak (může zastupovat libovolný znak nebo také žádný znak). Řídicí znak je „\“, pokud tedy chcete zadat znaky „*“, „?“ nebo „\“ jako takové, stačí před ně umístit znak „\“.

     Pokud toto nastavení aktivujete, pluginy uvedené v seznamu nebudou v aplikaci <ph name="PRODUCT_NAME"/> nikdy použity. Na stránce about:plugins se pluginy zobrazí jako deaktivované a uživatelé je nebudou moci aktivovat.

      Tuto zásadu lze přepsat pomocí zásad EnabledPlugins a DisabledPluginsExceptions.

      Pokud zásadu nenastavíte, mohou uživatelé používat všechny pluginy nainstalované v systému, kromě pluginů nekompatibilních, zastaralých nebo nebezpečných.</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="1492145937778428165">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 rozmezí od 1800000 (30 minut) do 86400000 (1 den). Místo hodnot mimo tento rozsah bude použita příslušná mezní hodnota.

      Pokud tuto zásadu nenastavíte, bude systém <ph name="PRODUCT_OS_NAME"/> používat výchozí hodnotu, což jsou 3 hodiny.</translation>
<translation id="3765260570442823273">Doba zobrazení zprávy s upozorněním na odhlášení z důvodu nečinnosti</translation>
<translation id="7302043767260300182">Prodleva uzamčení obrazovky při napájení ze sítě</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="7271085005502526897">Importování domovské stránky z výchozího prohlížeče při prvním spuštění</translation>
<translation id="6036523166753287175">Povolení přechodu přes bránu firewall z hostitele vzdáleného připojení</translation>
<translation id="1096105751829466145">Výchozí poskytovatel vyhledávání</translation>
<translation id="7567380065339179813">Povolit pluginy na těchto stránkách</translation>
<translation id="4555850956567117258">Aktivuje vzdálené ověření identity uživatele</translation>
<translation id="5966615072639944554">Rozšíření, která mohou používat rozhraní API vzdáleného ověření identity</translation>
<translation id="1617235075406854669">Aktivovat smazání historie prohlížeče a stahování</translation>
<translation id="5290940294294002042">Určete seznam pluginů, které uživatel může povolit nebo zakázat</translation>
<translation id="3153348162326497318">Umožňuje určit rozšíření, která uživatelé NEMOHOU nainstalovat. Pokud se na seznamu zakázaných vyskytne rozšíření, které již bylo nainstalováno, bude odebráno.

          Pokud je na seznamu zakázaných rozšíření uvedena hodnota *, znamená to, že jsou zakázána všechna rozšíření, která nejsou explicitně uvedena na seznamu povolených rozšíření.

         Pokud zásadu nenastavíte, mohou uživatelé v aplikaci <ph name="PRODUCT_NAME"/> instalovat libovolná rozšíření.</translation>
<translation id="3067188277482006117">Pokud má hodnotu true, uživatel může pomocí hardwaru, který je součástí zařízení Chrome, vzdáleně sdělit svou identitu funkci Privacy CA prostřednictvím rozhraní Enterprise Platform Keys API chrome.enterprise.platformKeysPrivate.challengeUserKey().

          Pokud má tato zásada hodnotu false nebo není nastavena, volání rozhraní API se nezdaří a zobrazí se kód chyby.</translation>
<translation id="5809728392451418079">Nastavit viditelný název pro místní účty v zařízení</translation>
<translation id="1427655258943162134">Adresa (nebo adresa URL) proxy serveru</translation>
<translation id="1827523283178827583">Použít pevně dané servery proxy</translation>
<translation id="3021409116652377124">Deaktivovat nástroj pro vyhledávání pluginů</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="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="3288595667065905535">Kanál verzí</translation>
<translation id="2785954641789149745">Aktivuje funkci prohlížeče <ph name="PRODUCT_NAME"/> 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 aktivována, ale uživatelé budou moci nastavení změnit.</translation>
<translation id="268577405881275241">Aktivace funkce datové komprese proxy serveru</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="8369602308428138533">Prodleva vypnutí obrazovky při napájení ze sítě</translation>
<translation id="6513756852541213407">Umožňuje určit proxy server, který bude aplikace <ph name="PRODUCT_NAME"/> používat, a brání uživatelům, aby nastavení proxy serveru změnili.

          Pokud se rozhodnete proxy server nikdy nepoužívat a vždy se připojovat přímo, budou všechny ostatní možnosti ignorovány.

         Pokud se rozhodnete používat systémová nastavení proxy serveru nebo proxy server zjišťovat automaticky, budou všechny ostatní možnosti ignorovány.

         Pokud zvolíte režim pevně daného proxy serveru, můžete zvolit další možnosti v částech „Adresa (nebo adresa URL) proxy serveru“ a „Seznam pravidel vynechání proxy serveru oddělených čárkami“.

          Pokud se rozhodnete použít skript PAC proxy serveru, je nutné zadat v části „Adresa URL souboru PAC proxy serveru“ adresu URL.

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

          Pokud toto nastavení aktivujete, bude aplikace <ph name="PRODUCT_NAME"/> ignorovat veškeré možnosti týkající se serverů proxy zadané pomocí příkazového řádku.

          Pokud zásadu nenastavíte, mohou uživatelé zvolit nastavení serverů proxy podle svého uvážení.</translation>
<translation id="7763311235717725977">Umožňuje nastavit, zda mají webové stránky povoleno zobrazovat obrázky. Zobrazování obrázků lze buď povolit všem webovým stránkám, nebo je všem webovým stránkám zakázat.

          Pokud tuto zásadu nenastavíte, bude použita zásada AllowImages a uživatelé ji budou moci změnit.</translation>
<translation id="5630352020869108293">Obnovit poslední relaci</translation>
<translation id="2067011586099792101">Blokování přístupu k webům mimo obsahové balíčky</translation>
<translation id="4980635395568992380">Typ údajů:</translation>
<translation id="3096595567015595053">Seznam aktivovaných pluginů</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="5912364507361265851">Umožnit uživatelům zobrazit hesla ve Správci hesel</translation>
<translation id="5318185076587284965">Povolit použití předávacích serverů hostitelem vzdáleného přístupu</translation>
<translation id="510186355068252378">Deaktivuje synchronizaci dat v aplikaci <ph name="PRODUCT_NAME"/> prováděnou pomocí synchronizačních služeb hostovaných společností Google a znemožní uživatelům toto nastavení měnit.

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

       Pokud zásadu nenastavíte, budou si uživatelé moci vybrat, zda chtějí službu Google Sync použít, či nikoliv.</translation>
<translation id="7953256619080733119">Hostitelské servery ručních výjimek spravovaného uživatele</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="8789506358653607371">Povolí režim celé obrazovky.

      Tato zásada řídí dostupnost režimu celé obrazovky, ve kterém je veškeré uživatelské rozhraní prohlížeče <ph name="PRODUCT_NAME"/> skryto a zobrazuje se pouze obsah webu.

      Pokud tuto zásadu nenakonfigurujete nebo ji nastavíte na hodnotu true, uživatelé, aplikace a rozšíření s příslušnými oprávněními budou moci režim celé obrazovky aktivovat.

      Pokud zásadu nastavíte na hodnotu false, žádný uživatel, aplikace ani rozšíření nebude moci přejít do režimu celé obrazovky.

      Pro všechny platformy s výjimkou systému <ph name="PRODUCT_OS_NAME"/> platí, že je-li zakázán režim celé obrazovky, není k dispozici režim veřejného terminálu.</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="2231817271680715693">Importování historie prohlížení z výchozího prohlížeče při prvním spuštění</translation>
<translation id="1353966721814789986">Stránky otevírané při spuštění</translation>
<translation id="7173856672248996428">Dočasný profil</translation>
<translation id="1841130111523795147">Umožní uživateli přihlásit se do <ph name="PRODUCT_NAME"/> a zabraňuje uživatelům toto nastavení změnit.

      Pokud zásadu nastavíte, můžete nakonfigurovat, zda má uživatel oprávnění k přihlášení do <ph name="PRODUCT_NAME"/> či nikoliv.</translation>
<translation id="5564962323737505851">Slouží ke konfiguraci správce hesel. Pokud je správce hesel aktivní, můžete se rozhodnout, zda uživatelům povolíte zobrazovat hesla jako čitelný text.</translation>
<translation id="4668325077104657568">Výchozí nastavení obrázků</translation>
<translation id="4492287494009043413">Zakázat pořizování snímků obrazovky</translation>
<translation id="6368403635025849609">Povolit JavaScript na těchto stránkách</translation>
<translation id="6074963268421707432">Nepovolovat žádnému webu zobrazovat oznámení na ploše</translation>
<translation id="8614804915612153606">Zakáže automatické aktualizace</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="382476126209906314">Konfigurovat předponu TalkGadget pro hostitele vzdáleného přístupu</translation>
<translation id="6561396069801924653">Zobrazit možnosti usnadnění přístupu v nabídce panelu systému</translation>
<translation id="8104962233214241919">Automatický výběr certifikátů klienta u těchto webů</translation>
<translation id="2906874737073861391">Seznam rozšíření AppPack</translation>
<translation id="4386578721025870401">Omezení doby, po kterou se uživatel ověřený pomocí technologie SAML může přihlásit offline.

      Při přihlašování může Chrome OS k ověření použít server (online) nebo heslo uložené v mezipaměti (offline).

      Pokud je tato zásada nastavena na hodnotu -1, může se uživatel ověřovat offline neomezeně dlouho. Pokud je tato zásada nastavena na jinou hodnotu, udává hodnota dobu od posledního ověření online, po jejímž uplynutí musí uživatel znovu použít ověření online.

      Pokud tuto zásadu ponecháte nenastavenou, <ph name="PRODUCT_OS_NAME"/> použije se výchozí časový limit a uživatel bude muset znovu použít online ověření po 14 dnech.

      Tato zásada má vliv pouze na uživatele, kteří provedli ověření pomocí technologie SAML.

      Hodnota této zásady se zadává v sekundách.</translation>
<translation id="3758249152301468420">Deaktivovat nástroje pro vývojáře</translation>
<translation id="8665076741187546529">Konfigurace seznamu rozšíření, jejichž instalace je vynucena</translation>
<translation id="2386768843390156671">Umožňuje instalaci hostitelů zasílání nativních zpráv na úrovni uživatele.


          Pokud je toto nastavení povoleno, <ph name="PRODUCT_NAME"/> povoluje použití hostitelů zasílání nativních zpráv nainstalovaných na úrovni uživatele.

          Pokud je toto nastavení zakázáno, <ph name="PRODUCT_NAME"/> bude používat pouze hostitele zasílání nativních zpráv nainstalované na úrovni systému.

          Pokud je tato zásada ponechána nenastavená, <ph name="PRODUCT_NAME"/>
          bude použití hostitelů zasílání nativních zpráv na úrovni uživatele povolovat.</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="6598235178374410284">Obrázek avatara uživatele</translation>
<translation id="1675391920437889033">Řídí, jaké typy aplikací nebo rozšíření lze instalovat.

          Toto nastavení vytvoří seznam povolených rozšíření nebo aplikací, které lze nainstalovat do prohlížeče <ph name="PRODUCT_NAME"/>. 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 Chrome.

          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í nakonfigurované, typy rozšíření a aplikací, které nejsou na seznamu uvedeny, nebudou nainstalovány.

          Pokud je toto nastavení ponecháno nenakonfigurované, nebudou ohledně přijatelných typů rozšíření a aplikací vynucena žádná omezení.</translation>
<translation id="6378076389057087301">Určuje, zda aktivita zvukových zařízení ovlivňuje správu napájení</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="4899708173828500852">Aktivovat Bezpečné prohlížení</translation>
<translation id="4442582539341804154">Aktivovat zámek, pokud jsou zařízení nečinná nebo pozastavená</translation>
<translation id="7719251660743813569">Určuje, zda se budou Googlu nahlašovat metriky využití. Je-li tato zásada nastavena na hodnotu True, bude systém <ph name="PRODUCT_OS_NAME"/> hlásit metriky využití. Pokud není nastavena, nebo je nastavena na hodnotu False, budou hlášení o metrikách vypnuta.</translation>
<translation id="2372547058085956601">Prodleva automatického přihlášení do veřejné relace.

      Pokud není nastavena zásada |DeviceLocalAccountAutoLoginId|, nebude mít tato zásada žádný vliv. V opačném případě platí:

      Je-li zásada nastavena, určuje dobu bez aktivity uživatele, která musí uplynout před automatickým přihlášením do veřejné relace stanovené v zásadě |DeviceLocalAccountAutoLoginId|.

      Pokud zásada není nastavena, použije se pro časový limit hodnota 0 milisekund.

      Zásada se stanovuje v milisekundách.</translation>
<translation id="7275334191706090484">Spravované záložky</translation>
<translation id="3570008976476035109">Blokovat pluginy na těchto stránkách</translation>
<translation id="8749370016497832113">Aktivuje v prohlížeči <ph name="PRODUCT_NAME"/> mazání historie prohlížení 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 prohlížení 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 prohlížení a stahování smazat.

      Je-li nastavení deaktivováno, historii prohlížení nebo stahování smazat nelze.</translation>
<translation id="2884728160143956392">Povolit soubory cookie pouze pro relaci na těchto stránkách</translation>
<translation id="3021272743506189340">Pokud má hodnotu true, deaktivuje při používání mobilního připojení synchronizaci Disku Google s aplikací Soubory systému Chrome OS. Data v tomto případě budou synchronizována, pouze když budete připojeni prostřednictvím sítě Wi-Fi nebo Ethernet.

          Pokud má tato zásada hodnotu False nebo není nastavena, uživatelé budou moci přenášet soubory na Disk Google prostřednictvím mobilního připojení.</translation>
<translation id="4655130238810647237">Povolí nebo zakáže v aplikaci <ph name="PRODUCT_NAME"/> editaci záložek.

      Pokud toto nastavení aktivujete, bude možné přidávat či odebírat záložky nebo je měnit. Toto je výchozí nastavení také v případě, že zásada není nastavena.

      Pokud toto nastavení deaktivujete, záložky nebude možné přidávat, odebírat ani měnit. Stávající záložky budou i nadále k dispozici.</translation>
<translation id="3496296378755072552">Správce hesel</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="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="2565967352111237512">Aktivuje funkci anonymního odesílání dat týkajících se využití nebo selhání aplikace <ph name="PRODUCT_NAME"/> společnosti Google a brání uživatelům, aby toto nastavení změnili.

     Pokud toto nastavení aktivujete, společnosti Google budou odesílány anonymní zprávy týkající se využití nebo selhání.

     Pokud toto nastavení deaktivujete, anonymní zprávy týkající se využití nebo selhání společnosti Google odesílá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, bude použito nastavení, které uživatel zvolí při instalaci nebo při prvním spuštění.</translation>
<translation id="6256787297633808491">Příznaky v celém systému, které se uplatňují při spouštění Chromu</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="9135033364005346124">Aktivovat proxy server služby <ph name="CLOUD_PRINT_NAME"/></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="6943577887654905793">Název nastavení v systémech Mac/Linux:</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="6925212669267783763">Nastavuje adresář, do kterého bude doplněk <ph name="PRODUCT_FRAME_NAME"/> ukládat uživatelská data.

      Doplněk <ph name="PRODUCT_FRAME_NAME"/> bude ukládat stažené soubory do adresáře nastaveného pomocí této zásady.

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

      Není-li tato zásada nastavena, budou data ukládána do výchozího adresáře profilu.</translation>
<translation id="8906768759089290519">Aktivovat režim hosta</translation>
<translation id="348495353354674884">Aktivovat virtuální klávesnici</translation>
<translation id="2168397434410358693">Prodleva nečinnosti při napájení ze sítě</translation>
<translation id="838870586332499308">Povolit datový roaming</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="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="254524874071906077">Nastavit Chrome jako výchozí prohlížeč</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="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="5056708224511062314">Deaktivace lupy</translation>
<translation id="4377599627073874279">Povolit všem webům zobrazování všech obrázků</translation>
<translation id="7195064223823777550">Určuje akci, která bude provedena při zavření víka.

          Pokud je tato zásada nastavena, určuje akci, kterou systém <ph name="PRODUCT_OS_NAME"/> provede při zavření víka zařízení.

          Není-li tato zásada nastavena, bude provedena výchozí akce (přechod do režimu spánku).

          Pokud je zvolenou akcí přechod do režimu spánku, můžete zvlášť nastavit, zda má systém <ph name="PRODUCT_OS_NAME"/> před přechodem do tohoto režimu uzamknout obrazovku, nebo ne.</translation>
<translation id="3915395663995367577">Adresa URL souboru PAC proxy serveru</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="6064943054844745819">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. Znovu budou aktivovány funkce odpovídající značkám uvedeným v seznamu, který určuje tato zásada.

      Aktuálně jsou definovány následující značky:
      – ShowModalDialog_EffectiveUntil20150430

      Pokud tato zásada není nastavena nebo je seznam prázdný, všechny zastaralé funkce webové platformy zůstanou deaktivovány.</translation>
<translation id="3805659594028420438">Povolit rozšíření certifikátů TLS vázaných na doménu (zastaralé)</translation>
<translation id="5499375345075963939">Tato zásada je aktivní pouze v režimu prodeje.

      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="7683777542468165012">Dynamická aktualizace zásad</translation>
<translation id="1160939557934457296">Zakázat pokračování ze stránky s upozorněním Bezpečného prohlížení</translation>
<translation id="8987262643142408725">Zakázat dělení záznamů protokolu SSL</translation>
<translation id="4529945827292143461">Umožňuje personalizovat seznam vzorů adres URL, které by měl vždy vykreslit hostitelský prohlížeč.

          Pokud není zásada nastavena, bude pro všechny webové stránky použit výchozí vykreslovací modul, jak je určeno zásadou ChromeFrameRendererSettings.

          Ukázkové vzory naleznete na stránce http://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="8044493735196713914">Hlásit režim spuštění zařízení</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="1942957375738056236">Zde můžete zadat adresu URL 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 pro nastavení zásad proxy zvolili jakýkoliv jiný režim, neměli byste tuto zásadu nastavovat.

          Další možnosti a podrobné příklady naleznete na následující adrese:
          <ph name="PROXY_HELP_URL"/></translation>
<translation id="6076008833763548615">Zakazuje připojení externího úložiště.

      Je-li tato zásada nastavena na hodnotu True, externí úložiště nebude zobrazeno v prohlížeči souborů.

      Tato zásada se vztahuje na všechny typy paměťových médií, například na jednotky USB flash, externí harddisky, SD karty a další typy paměťových karet, optická úložiště apod. Na interní úložiště se nevztahuje, tudíž soubory uložené ve složce Stažené soubory lze i přesto otevřít. Tato zásada také nemá žádný vliv na Disk Google.

      Je-li toto nastavení vypnuto, nebo není nakonfigurováno, uživatelé mohou ve svém zařízení používat všechny podporované typy externích úložišť.</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="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="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="1426410128494586442">Ano</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="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="4962195944157514011">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.

          Tato možnost musí být nastavena, pokud je aktivní zásada DefaultSearchProviderEnabled, a bude dodržována pouze v takovém případě.</translation>
<translation id="6009903244351574348">Umožňuje pluginu <ph name="PRODUCT_FRAME_NAME"/> zpracovávat následující typy obsahu. 
         
         Pokud není zásada nastavena, použije se pro všechny webové stránky výchozí modul vykreslení, jak je určeno zásadou ChromeFrameRendererSettings.</translation>
<translation id="3381968327636295719">Používat ve výchozím nastavení hostitelský prohlížeč</translation>
<translation id="3627678165642179114">Povolit nebo zakázat webovou službu kontroly pravopisu</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="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="4946368175977216944">Určuje příznaky, které mají být pro Chrome použity při spouštění Chromu. Určené příznaky se před spuštěním Chromu uplatňují i na přihlašovací obrazovce.</translation>
<translation id="7447786363267535722">Aktivuje v aplikaci <ph name="PRODUCT_NAME"/> funkce ukládání hesel a použití uložených hesel.

          Pokud toto nastavení aktivujete, uživatelé si budou v prohlížeči <ph name="PRODUCT_NAME"/> moci uložit hesla a nechat prohlížeč, aby hesla automaticky zadal při příštím přihlášení k webu.

         Pokud toto nastavení deaktivujete, uživatelé nebudou moci ukládat hesla ani používat hesla, která již byla uložena.

         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="1138294736309071213">Tato zásada je aktivní pouze v režimu prodeje.

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

      Hodnota zásady se určuje v milisekundách.</translation>
<translation id="6368011194414932347">Konfigurace adresy URL domovské stránky</translation>
<translation id="2877225735001246144">Deaktivovat vyhledání záznamů CNAME při vyjednávání ověření protokolu Kerberos</translation>
<translation id="9120299024216374976">Určuje, které časové pásmo se má v zařízení použít. Uživatelé mohou stanovené časové pásmo v aktuální relaci přepsat. Po odhlášení se však nastaví zpět na původně určené časové pásmo. Je-li zadána nesprávná hodnota, zásada se i tak aktivuje a použije pásmo GMT. Pokud řetězec zůstane prázdný, bude zásada ignorována.

      Pokud se zásada nepoužívá, zůstane i nadále platné aktuální aktivní časové pásmo. Uživatelé je však budou moci změnit a změna bude trvalá. Změna provedená jedním uživatelem proto ovlivní přihlašovací obrazovku i všechny ostatní uživatele.

      Časové pásmo je v nových zařízeních nastaveno na americký tichomořský čas.

      Formát hodnot je stanoven podle názvu časových pásem v databázi „IANA Time Zone Database“ (viz http://en.wikipedia.org/wiki/Tz_database). Většina časových pásem se udává jako kontinent/velké_město nebo oceán/velké_město.</translation>
<translation id="3646859102161347133">Nastavení typu lupy</translation>
<translation id="3528000905991875314">Aktivovat alternativní chybové stránky</translation>
<translation id="1283072268083088623">Určuje, která schémata ověření pomocí protokolu HTTP bude aplikace <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 zásadu nenastavíte, použijí se všechna čtyři schémata.</translation>
<translation id="1017967144265860778">Správa možností napájení na přihlašovací obrazovce</translation>
<translation id="4914647484900375533">Aktivuje funkci prohlížeče <ph name="PRODUCT_NAME"/> Dynamický režim a brání uživatelům, aby toto nastavení změnili.

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 toto nastavení aktivujete nebo deaktivujete, uživatelé jej 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 Chrome verze 29 a novějších verzí bylo toto nastavení odebráno.</translation>
<translation id="6114416803310251055">zastaralé</translation>
<translation id="8493645415242333585">Deaktivovat ukládání historie prohlížeče</translation>
<translation id="2747783890942882652">Slouží ke konfiguraci povinného názvu hostitelské domény, který bude uveden u hostitelů vzdáleného přístupu, a brání uživatelům, aby jej změnili.

          Je-li toto nastavení zapnuto, hostitelé smějí být sdíleni jen prostřednictvím účtů zaregistrovaných v daném názvu domény.

          Je-li toto nastavení vypnuto nebo není-li nastaveno, hostitele lze sdílet prostřednictvím libovolného účtu.</translation>
<translation id="6417861582779909667">Umožňuje nastavit seznam vzorů adres URL webových stránek, které nemají povoleno nastavovat soubory cookie.

         Pokud 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.</translation>
<translation id="5776485039795852974">Dotázat se vždy, když se webové stránky snaží zobrazit oznámení na ploše</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 prohlížení 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 prohlížení 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="6786747875388722282">Rozšíření</translation>
<translation id="7132877481099023201">Adresy URL, kterým bude udělen přístup pro záznam videa bez zobrazení výzvy</translation>
<translation id="8947415621777543415">Oznamovat polohu zařízení</translation>
<translation id="1655229863189977773">Nastavit velikost diskové mezipaměti v bajtech</translation>
<translation id="3358275192586364144">Aktivuje v prohlížeči <ph name="PRODUCT_NAME"/> optimalizaci WPAD a brání uživatelům, aby toto nastavení změnili.

      Povolení této možnosti způsobí, že Chrome u serverů WPAD s DNS čeká kratší dobu.

Pokud tuto zásadu ponecháte nenastavenou, bude tato možnost aktivována a uživatel to nebude moci změnit.</translation>
<translation id="6376842084200599664">Umožňuje určit seznam rozšíření, která budou nainstalována na pozadí bez interakce s uživatelem.

          Každá položka seznamu obsahuje ID rozšíření a adresu URL pro aktualizace. Tyto hodnoty jsou odděleny středníkem (<ph name="SEMICOLON"/>). ID rozšíření je řetězec 32 písmen, který naleznete např. na adrese <ph name="CHROME_EXTENSIONS_LINK"/> v režimu pro vývojáře. Adresa URL pro aktualizace by měla vést na dokument Update Manifest ve formátu XML popsaný na adrese <ph name="LINK_TO_EXTENSION_DOC1"/>. Adresa URL pro aktualizace nastavená pomocí této zásady bude použita pouze při první instalaci rozšíření. Další aktualizace rozšíření budou instalovány z adresy URL pro aktualizace uvedené v manifestu rozšíření.

          Prohlížeč <ph name="PRODUCT_NAME"/> stáhne jednotlivá rozšíření určená hodnotou ID rozšíření ze zadané adresy URL aktualizační služby a nainstaluje je na pozadí.

          Příklad: Zásada <ph name="EXTENSION_POLICY_EXAMPLE"/> nainstaluje rozšíření <ph name="EXTENSION_POLICY_EXAMPLE_EXTENSION_NAME"/> ze standardní adresy URL Internetového obchodu Chrome. Další informace o hostování rozšíření naleznete na adrese <ph name="LINK_TO_EXTENSION_DOC2"/>.

          Rozšíření nainstalovaná pomocí této zásady nemohou uživatelé odinstalovat. Pokud rozšíření z tohoto seznamu odeberete, bude prohlížečem <ph name="PRODUCT_NAME"/> automaticky odinstalováno. Rozšíření uvedená v tomto seznamu jsou také automaticky přidána na seznam povolených rozšíření a zásada ExtensionsInstallBlacklist je neovlivňuje.

          Není-li tato zásada nastavena na konkrétní hodnotu, uživatel může z prohlížeče <ph name="PRODUCT_NAME"/> odinstalovat libovolné rozšíření.</translation>
<translation id="6899705656741990703">Zjistit nastavení proxy serveru automaticky</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="8382184662529825177">Povolit použití vzdáleného ověření identity k ochraně obsahu v zařízení</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="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="3236046242843493070">Vzory adres URL, ze kterých je možné instalovat rozšíření, aplikace a uživatelské skripty</translation>
<translation id="2498238926436517902">Vždy automaticky skrýt sklad</translation>
<translation id="253135976343875019">Prodleva upozornění na nečinnost při napájení ze sítě</translation>
<translation id="480987484799365700">Je-li tato zásada aktivována, vynucuje, aby se profil přepnul do dočasného režimu. Je-li tato zásada uvedena jako zásada operačního systému (např. GPO ve Windows), bude použita na všechny profily v systému. Je-li nastavena jako cloudová zásada, bude použita pouze na profil, do kterého je přihlášen klientský účet.

      V tomto režimu zůstávají data profilu na disku jen po dobu trvání relace uživatele. Po zavření prohlížeče nebudou uchovány funkce jako historie prohlížeče, rozšíření a jejich data, data webů (např. soubory cookie) ani webové databáze. To však uživatelům nezabraňuje v ručním stahování dat na disk nebo 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 není nastavena, uživatelé se přihlásí do běžných profilů.</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="152657506688053119">Seznam alternativních adres URL výchozího poskytovatele vyhledávání</translation>
<translation id="8992176907758534924">Nepovolit zobrazení obrázků žádným webovým stránkám</translation>
<translation id="262740370354162807">Povolí odesílání dokumentů do služby <ph name="CLOUD_PRINT_NAME"/></translation>
<translation id="7717938661004793600">Konfiguruje funkce usnadnění přístupu v systému <ph name="PRODUCT_OS_NAME"/>.</translation>
<translation id="5182055907976889880">Konfigurace Disku Google v systému <ph name="PRODUCT_OS_NAME"/></translation>
<translation id="8704831857353097849">Seznam deaktivovaných pluginů</translation>
<translation id="467449052039111439">Otevřít seznam adres URL</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="5883015257301027298">Výchozí nastavení souborů cookie</translation>
<translation id="5017500084427291117">Blokuje přístup k adresám URL uvedeným v seznamu.

      Tato zásada zabraňuje uživatelům načítat webové stránky ze zakázaných adres URL.

      Adresa URL má formát „schéma://hostitel:port/cesta“.
      Jako schéma lze zvolit http, https nebo ftp. Bude zablokován pouze tento typ schématu. Pokud není určeno žádné schéma, budou zablokována všechna schémata.
      Jako hostitele lze zvolit název hostitele nebo IP adresu. Budou blokovány i subdomény názvu hostitele. Chcete-li blokování subdomén zamezit, přidejte před název hostitele tečku (.). Všechny domény lze zablokovat pomocí zvláštního názvu hostitele „*“.
      Jako port lze zvolit platné číslo portu v rozmezí od 1 do 65535. Není-li uvedeno, budou zablokovány všechny porty.
      Je-li uvedena volitelná cesta, budou zablokovány pouze cesty, které začínají stejně.

      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.
     
       Není-li zásada nastavena, nebude v prohlížeči zakázána žádná adresa URL.</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="8955719471735800169">Zpět na začátek</translation>
<translation id="4557134566541205630">Výchozí adresa URL stránky nové karty poskytovatele vyhledávání</translation>
<translation id="546726650689747237">Prodleva snížení jasu obrazovky při napájení ze sítě</translation>
<translation id="4988291787868618635">Akce prováděná po určité době nečinnosti</translation>
<translation id="7260277299188117560">Automatické aktualizace pomocí sítě p2p aktivovány</translation>
<translation id="5316405756476735914">Umožňuje nastavit, 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.

          Není-li zásada nastavena, bude použita zásada AllowCookies a uživatelé ji budou moci změnit.</translation>
<translation id="4250680216510889253">Ne</translation>
<translation id="1522425503138261032">Umožňuje webovým stránkám sledovat fyzickou polohu uživatele</translation>
<translation id="6467433935902485842">Umožňuje nastavit seznam vzorů adres URL stránek, které nemají povoleno spouštět pluginy.

           Pokud zásadu nenastavíte, použije se pro všechny webové stránky globální výchozí hodnota buď ze zásady DefaultPluginsSetting (pokud je nastavena), nebo z osobního nastavení uživatele.</translation>
<translation id="4423597592074154136">Zadat nastavení proxy serveru ručně</translation>
<translation id="209586405398070749">Stabilní verze</translation>
<translation id="8170878842291747619">Aktivuje v aplikaci<ph name="PRODUCT_NAME"/> integrovanou službu Překladač Google.

      Pokud toto nastavení aktivujete, zobrazí aplikace <ph name="PRODUCT_NAME"/> integrovanou lištu nástrojů, která uživateli nabídne překlad stránky (pokud je to na místě).

      Pokud toto nastavení deaktivujete, překladová lišta se uživatelům nezobrazí v žádné situaci.

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

      Pokud nastavení neupravíte, mohou si uživatelé vybrat, zda bude funkci používat, či nikoliv.</translation>
<translation id="9035964157729712237">ID rozšíření, která mají být vyňata ze seznamu zakázaných</translation>
<translation id="8244525275280476362">Maximální zpoždění načítání po zneplatnění zásady</translation>
<translation id="8587229956764455752">Povolit vytváření nových uživatelských účtů</translation>
<translation id="7417972229667085380">Procento prodloužení prodlevy režimu nečinnosti v režimu prezentace (podpora ukončena)</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="3964909636571393861">Umožňuje přístup do seznamu adres URL</translation>
<translation id="1811270320106005269">Aktivuje zámek, pokud jsou zařízení se systémem <ph name="PRODUCT_OS_NAME"/> nečinná nebo pozastavená.

      Pokud toto nastavení aktivujete a uživatelé budou chtít zařízení odemknout a probudit z režimu spánku, budou vyzváni k zadání hesla.

      Pokud toto nastavení deaktivujete, uživatelé budou moci probudit zařízení z režimu spánku i bez hesla.

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

      Není-li zásada nastavena, mohou si uživatelé vybrat, zda chtějí být vyzváni k zadání hesla k odemčení zařízení, nebo nikoliv.</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="6022948604095165524">Akce při spuštění</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="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="1679420586049708690">Veřejná relace pro automatické přihlášení</translation>
<translation id="5836064773277134605">Omezí rozsah portů UDP používaný hostitelem vzdáleného přístupu.</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="2552966063069741410">Časové pásmo</translation>
<translation id="3788662722837364290">Nastavení řízení spotřeby při neaktivitě uživatele</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="2529700525201305165">Omezit uživatele, kteří se mohou přihlásit do prohlížeče <ph name="PRODUCT_NAME"/></translation>
<translation id="8971221018777092728">Časovač automatického přihlášení do veřejné relace</translation>
<translation id="8285435910062771358">Aktivace lupy pro celou obrazovku</translation>
<translation id="5141670636904227950">Nastavení výchozího typu lupy, který je aktivován na přihlašovací obrazovce</translation>
<translation id="3864818549971490907">Výchozí nastavení pluginů</translation>
<translation id="7151201297958662315">Určuje, zda se má proces <ph name="PRODUCT_NAME"/> zahájit při spuštění operačního systému a zda má zůstat spuštěný i po zavření posledního okna prohlížeče. Aplikace na pozadí tak mohou zůstat aktivní.

      Je-li zásada nastavena na hodnotu True, je režim na pozadí aktivní a nemůže být ovládán uživatelem v nastavení prohlížeče.

      Je-li zásada nastavena na hodnotu False, je režim na pozadí neaktivní a nemůže být ovládán uživatelem v nastavení prohlížeče.

      Pokud zásada není nastavena, je režim na pozadí zpočátku neaktivní a může být ovládán uživatelem v nastavení prohlížeče.</translation>
<translation id="4320376026953250541">Microsoft Windows XP SP2 nebo novější</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="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="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="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="5770738360657678870">Verze pro vývojáře (mohou být nestabilní)</translation>
<translation id="2959898425599642200">Pravidla vynechání proxy serveru</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="1327466551276625742">Povolit zobrazení výzvy ke konfiguraci sítě v režimu offline</translation>
<translation id="7937766917976512374">Povolit nebo zakázat záznam videa</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="8818646462962777576">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: Tato zásada je v současnosti podporována pouze v režimu veřejného terminálu.</translation>
<translation id="489803897780524242">Parametr nastavující nahrazení vyhledávacích dotazů pro výchozího poskytovatele vyhledávání</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="6401669939808766804">Odhlášení 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="7912255076272890813">Konfigurovat povolené typy aplikací nebo rozšíření</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="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="2201555246697292490">Konfigurace seznamu povolených hostitelů zasílání nativních zpráv</translation>
<translation id="6177482277304066047">Nastavuje cílovou verzi automatické aktualizace.

      Určuje předponu cílové verze, na kterou se má <ph name="PRODUCT_OS_NAME"/> aktualizovat. Pokud zařízení obsahuje starší verzi, než jakou určuje předpona, bude systém aktualizován na poslední verzi s danou předponou. Jestliže zařízení již obsahuje novější verzi, nestane se nic (tj. nedojde k přechodu na nižší verzi) a zařízení zůstane u stávající verze. Formát předpony funguje na základě komponent, jak ukazuje následující příklad:

      &quot;&quot; (nebo není nastaveno): aktualizovat na nejnovější dostupnou verzi,
      &quot;1412.&quot;: aktualizovat na libovolnou podverzi verze 1412 (např. 1412.24.34 nebo 1412.60.2),
      &quot;1412.2.&quot;: aktualizovat na libovolnou podverzi verze 1412.2 (nebo 1412.2.34 nebo 1412.2.2),
      &quot;1412.24.34&quot;: aktualizovat pouze na tuto konkrétní verzi.</translation>
<translation id="8102913158860568230">Výchozí nastavení mediálního přenosu</translation>
<translation id="6641981670621198190">Deaktivovat podporu rozhraní API pro 3D grafiku</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="1265053460044691532">Omezit dobu, po kterou se uživatel ověřený pomocí technologie SAML může přihlásit offline</translation>
<translation id="5703863730741917647">Určuje akci, která bude provedena po určité době nečinnosti.

          Tato zásada již není podporována a v budoucnu bude odebrána.

          Tato zásada poskytuje záložní hodnotu pro konkrétnější zásady <ph name="IDLEACTIONAC_POLICY_NAME"/> a <ph name="IDLEACTIONBATTERY_POLICY_NAME"/>. Pokud je tato zásada nastavena, její hodnota bude použita, jestliže nebude nastavena konkrétnější zásada.

          Pokud tato zásada nastavena není, chování konkrétnějších zásad nebude ovlivněno.</translation>
<translation id="5997543603646547632">Ve výchozím nastavení použít 24hodinový formát</translation>
<translation id="7003746348783715221">Nastavení prohlížeče <ph name="PRODUCT_NAME"/></translation>
<translation id="4723829699367336876">Povolení přechodu přes bránu firewall z klienta vzdáleného připojení</translation>
<translation id="2744751866269053547">Registrace obslužných nástrojů protokolů</translation>
<translation id="6367755442345892511">Zda má být kanál verzí nastavitelný uživatelem</translation>
<translation id="3868347814555911633">Tato zásada je aktivní pouze v režimu prodeje.

      Seznam rozšíření, která se automaticky nainstalují pro uživatele ukázky v zařízeních v režimu prodeje. 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="9096086085182305205">Seznam povolených serverů pro ověřování</translation>
<translation id="4980301635509504364">Povoluje nebo zakazuje záznam videa.

Pokud je tato zásada aktivní nebo není nakonfigurována (výchozí nastavení), uživatel bude vyzván k udělení přístupu pro záznam videa (s výjimkou adres URL nakonfigurovaných v seznamu VideoCaptureAllowedUrls, kterým bude přístup udělen bez vyzvání).

Pokud je tato zásada deaktivována, uživateli se výzva nikdy nezobrazí a záznam videa bude k dispozici pouze u adres URL uvedených na seznamu VideoCaptureAllowedUrls.

Tato zásada ovlivňuje kromě integrované webové kamery i všechny ostatní vstupy videa.</translation>
<translation id="7063895219334505671">Povolit na těchto stránkách vyskakovací okna</translation>
<translation id="3756011779061588474">Blokovat režim pro vývojáře</translation>
<translation id="4052765007567912447">Určuje, zda mohou uživatelé ve správci hesel zobrazit hesla jako čitelný text.

         Pokud toto nastavení deaktivujete, v okně správce hesel nebude možné zobrazit uložená hesla jako čitelný text.

          Pokud tuto zásadu aktivujete nebo ji nenastavíte, uživatelé budou ve správci hesel moci zobrazit uložená hesla jako čitelný text.</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="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="7933141401888114454">Povolit vytváření dozorovaných uživatelů</translation>
<translation id="2824715612115726353">Povolit anonymní režim</translation>
<translation id="1057535219415338480">Aktivuje předvídání síťových akcí v prohlížeči <ph name="PRODUCT_NAME"/> a zabraňuje uživatelům ve změně tohoto nastavení.

      Kromě předběžného načítání záznamů DNS ovlivňuje tato zásada také předběžná připojení TCP a SSL a předběžné vykreslování webových stránek. Název této zásady odkazuje na předběžné načítání záznamů DNS pouze z historických důvodů.

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

      Není-li tato zásada nastavena na konkrétní hodnotu, bude předvídání síťových akcí aktivováno, ale uživatelé budou moci nastavení změnit.</translation>
<translation id="4541530620466526913">Místní účty v zařízení</translation>
<translation id="5815129011704381141">Automaticky restartovat po aktualizaci</translation>
<translation id="1757688868319862958">Umožňuje službě <ph name="PRODUCT_NAME"/> spustit pluginy, které vyžadují autorizaci. Pokud toto nastavení povolíte, budou pluginy, které nejsou zastaralé, stále spuštěny. Je-li toto nastavení zakázáno nebo není nastaveno, uživatelé budou požádáni, aby povolili spuštění pluginů, které vyžadují autorizaci. Jedná se o pluginy, které mohou ohrozit bezpečnost.</translation>
<translation id="6392973646875039351">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í uložených informací (například adresa nebo číslo platební karty). 
  
       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="6157537876488211233">Seznam pravidel vynechání proxy serveru oddělených čárkami</translation>
<translation id="7788511847830146438">Podle profilu</translation>
<translation id="2516525961735516234">Určuje, zda aktivita videa ovlivňuje správu napájení

         Pokud je tato zásada nastavena na hodnotu true nebo není nastavena vůbec, není přehrávání videa považováno za nečinnost uživatele. V takovém případě nebudou dosaženy prodlevy režimu nečinnosti ani snížení jasu, vypnutí a uzamčení obrazovky a nebudou provedeny příslušné akce.

          Pokud je tato zásada nastavena na hodnotu false, přehrávání videa je považováno za nečinnost uživatele.</translation>
<translation id="3965339130942650562">Časový limit před odhlášením nečinného uživatele</translation>
<translation id="5814301096961727113">Nastavení výchozího stavu hlasové odezvy na přihlašovací obrazovce</translation>
<translation id="1950814444940346204">Aktivace zastaralých funkcí webové platformy</translation>
<translation id="9084985621503260744">Určuje, zda aktivita videa ovlivňuje správu napájení</translation>
<translation id="7091198954851103976">Vždy spustit pluginy, které vyžadují autorizaci.</translation>
<translation id="1708496595873025510">Nastavit omezení pro načítání počáteční hodnoty variace</translation>
<translation id="8870318296973696995">Domovská stránka</translation>
<translation id="1240643596769627465">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 při odesílání dotazu nahrazen textem, který do daného okamžiku zadal uživatel.

          Tato zásada je nepovinná. Pokud není nastavena, nebudou se zobrazovat výsledky dynamického vyhledávání.

          Zásada je dodržována pouze v případě, že je aktivní zásada DefaultSearchProviderEnabled.</translation>
<translation id="6693751878507293182">Pokud toto nastavení aktivujete, budou automatické vyhledávání a instalace chybějících pluginů v aplikaci <ph name="PRODUCT_NAME"/> zakázány.

      Pokud tuto možnost deaktivujete nebo nenastavíte, bude nástroj pro vyhledávání pluginů aktivní.</translation>
<translation id="2650049181907741121">Akce při zavření víka</translation>
<translation id="7880891067740158163">Umožňuje stanovit seznam vzorů adres URL, u kterých má aplikace <ph name="PRODUCT_NAME"/> automaticky vybrat certifikáty klienta, pokud web požaduje certifikát.

          Není-li zásada nastavena, nebude se automatické vybírání provádět na žádných webových stránkách.</translation>
<translation id="3866249974567520381">Popis</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="2236488539271255289">Nepovolovat nastavení místních dat žádným webům</translation>
<translation id="4467952432486360968">Blokovat soubory cookie třetích stran</translation>
<translation id="1305864769064309495">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 Chrome.</translation>
<translation id="5586942249556966598">Nedělat nic</translation>
<translation id="131353325527891113">Zobrazit uživatelská jména na přihlašovací obrazovce</translation>
<translation id="5365946944967967336">Zobrazit na liště tlačítko Domů</translation>
<translation id="3709266154059827597">Konfigurace seznamu zakázaných položek instalace rozšíření</translation>
<translation id="1933378685401357864">Obrázek tapety</translation>
<translation id="8451988835943702790">Jako domovskou použít stránku Nová karta</translation>
<translation id="4617338332148204752">Přeskočení kontroly metaznaček ve službě <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="8469342921412620373">Umožňuje využívat výchozího poskytovatele vyhledávání.

          Pokud toto nastavení aktivujete a uživatel zadá do adresního řádku text, který není adresou URL, bude provedeno vyhledávání pomocí výchozího poskytovatele vyhledávání.

          Výchozího poskytovatele vyhledávání lze určit nastavením ostatních zásad výchozího vyhledávání. Pokud tyto zásady ponecháte prázdné, bude výchozího poskytovatele moci zvolit uživatel.

          Pokud toto nastavení deaktivujete a uživatel do adresního řádku zadá jiný text než adresu URL, nebude provedeno žádné vyhledávání.

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

          Není-li zásada nastavena, aktivuje se výchozí poskytovatel vyhledávání a uživatelé budou moci nastavit seznam poskytovatelů vyhledávání.</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="2633084400146331575">Aktivovat hlasovou odezvu</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="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="2411919772666155530">Blokovat upozornění na těchto stránkách</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="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="4869787217450099946">Určuje, zda je povoleno uzamčení obrazovky při probuzení. Uzamčení obrazovky při probuzení mohou být rozšířeními vyžádána prostřednictvím rozhraní API pro správu napájení.

          Pokud má tato zásada má hodnotu true nebo není nastavena, bude se správa napájení řídit nastavením uzamčení obrazovky při probuzení.

          Pokud má tato zásada hodnotu false, budou požadavky na uzamčení obrazovky při probuzení ignorovány.</translation>
<translation id="467236746355332046">Podporované funkce:</translation>
<translation id="5447306928176905178">Povolit hlášení informací o paměti (velikost haldy JavaScriptu) stránce (podpora byla ukončena)</translation>
<translation id="7632724434767231364">Název knihovny GSSAPI</translation>
<translation id="3038323923255997294">Po ukončení prohlížeče <ph name="PRODUCT_NAME"/> nechat aplikace na pozadí spuštěné</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="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="6244210204546589761">Adresy URL otevírané při spuštění</translation>
<translation id="7468416082528382842">Umístění v registru systému Windows:</translation>
<translation id="1808715480127969042">Blokovat soubory cookie na těchto stránkách</translation>
<translation id="1908884158811109790">Zakáže v aplikaci Soubory systému Chrome OS používání Disku Google prostřednictvím mobilních připojení</translation>
<translation id="7340034977315324840">Hlásit časy aktivity zařízení</translation>
<translation id="4928632305180102854">Určuje, zda v systému <ph name="PRODUCT_OS_NAME"/> bude možné vytvářet nové uživatelské účty. Pokud je tato zásada nastavena na hodnotu False, uživatelé, kteří ještě nemají účet, se nebudou moci přihlásit.

      Pokud je zásada nastavena na hodnotu True nebo není nastavena, bude možné vytvářet nové uživatelské účty za předpokladu, že přihlášení uživatele není blokováno zásadou <ph name="DEVICEUSERWHITELISTPROTO_POLICY_NAME"/>.</translation>
<translation id="4389091865841123886">Konfiguruje vzdálené ověření identity pomocí mechanismu TPM.</translation>
<translation id="9175109938712007705">Protože online kontroly odvolání s příznakem soft-fail neposkytují žádný skutečný bezpečnostní přínos, jsou v aplikaci <ph name="PRODUCT_NAME"/> od verze 19 ve výchozím nastavení deaktivovány. Pokud tuto zásadu nastavíte na hodnotu true, předchozí chování se obnoví a budou se provádět online kontroly OCSP/CRL.

      Pokud tato zásada není nastavena nebo je nastavena na hodnotu false, nebude Chrome ve verzi 19 a novějších verzích provádět online kontroly odvolání.</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="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="1349276916170108723">Pokud má hodnotu True, deaktivuje synchronizaci aplikace Soubory systému Chrome OS s Diskem Google. Žádná data se v tomto případě nebudou nahrávat na Disk Google.

          Pokud má tato zásada hodnotu False nebo není nastavena, uživatelé budou moci přenášet soubory na Disk Google.</translation>
<translation id="1964634611280150550">Anonymní režim zakázán</translation>
<translation id="5971128524642832825">V aplikaci Soubory systému Chrome OS deaktivuje Disk</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="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="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="538108065117008131">Umožňuje pluginu <ph name="PRODUCT_FRAME_NAME"/> zpracovávat následující typy obsahu.</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="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é relace.

      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 relace se účastnit, bude relace 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="243972079416668391">Akce, která bude provedena, pokud bude dosaženo limitu doby nečinnosti při provozu na síťové napájení.

          Pokud je tato zásada nastavena, udává akci, kterou operační systém <ph name="PRODUCT_OS_NAME"/> provede, když doba nečinnosti uživatele dosáhne zadaného limitu (ten lze nastavit zvlášť).

          Není-li tato zásada nastavena, bude provedena výchozí akce (přechod do režimu spánku).

          Pokud je zvolenou akcí přechod do režimu spánku, můžete zvlášť nastavit, zda má systém <ph name="PRODUCT_OS_NAME"/> před přechodem do tohoto režimu uzamknout obrazovku, nebo ne.</translation>
<translation id="7750991880413385988">Otevřít stránku Nová karta</translation>
<translation id="5761030451068906335">Nakonfiguruje nastavení proxy serveru pro službu <ph name="PRODUCT_NAME"/>.

      Tato zásada zatím není připravena k použití. Nepoužívejte ji prosím.</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="1019101089073227242">Nastavit adresář uživatelských dat</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="2988031052053447965">Skryje na stránce Nová karta a ve spouštěči aplikace Chrome OS 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 není nastavena, budou ikony viditelné.</translation>
<translation id="5085647276663819155">Deaktivovat náhled tisku</translation>
<translation id="8672321184841719703">Cílová verze automatické aktualizace</translation>
<translation id="553658564206262718">Konfigurace řízení spotřeby při neaktivitě uživatele.

          Tato zásada udává několik nastavení strategie řízení spotřeby pro případ, že uživatel přestane být aktivní.

          Lze nastavit čtyři typy akcí:
          * Pokud uživatel nebude aktivní po dobu uvedenou v nastavení |ScreenDim|, obrazovka se ztlumí.
          * Pokud uživatel nebude aktivní po dobu uvedenou v nastavení |ScreenOff|, obrazovka se vypne.
          * Pokud uživatel nebude aktivní po dobu uvedenou v nastavení |IdleWarning|, zobrazí se dialog s upozorněním, že bude provedena akce nastavená pro případ nečinnosti.
          * Pokud uživatel nebude aktivní po dobu uvedenou v nastavení |Idle|, bude provedena akce nastavená v možnosti |IdleAction|.

          Hodnoty prodlev se pro všechny výše uvedené akce nastavují v milisekundách. Za účelem spuštění příslušné akce je třeba nastavit hodnotu vyšší než nula. Pokud je prodleva nastavena na nulu, systém <ph name="PRODUCT_OS_NAME"/> příslušnou akci neprovede.

          Pokud některou z výše uvedených prodlev nenastavíte, použije se pro ni výchozí nastavení.
          Hodnota |ScreenDim| bude snížena tak, aby nepřevyšovala hodnotu |ScreenOff|. Hodnoty |ScreenOff| a |IdleWarning| budou sníženy tak, aby nepřevyšovaly hodnotu |Idle|.

          Možnost |IdleAction| lze nastavit na jednu z následujících čtyř možných akcí:
          * |Suspend|
          * |Logout|
          * |Shutdown|
          * |DoNothing|

          Když hodnota |IdleAction| není nastavena, bude provedena výchozí akce (pozastavení).

          K dispozici jsou také samostatná nastavení pro napájení ze sítě a z baterie.
          </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="6699880231565102694">Povolit dvoufázové ověření pro hostitele vzdáleného přístupu</translation>
<translation id="2030905906517501646">Klíčové slovo výchozího poskytovatele vyhledávání</translation>
<translation id="3072045631333522102">Spořič obrazovky, který bude použit na přihlašovací obrazovce v režimu prodeje</translation>
<translation id="4550478922814283243">Aktivovat nebo deaktivovat ověřování bez kódu PIN</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="350797926066071931">Aktivovat Překladač</translation>
<translation id="3711895659073496551">Pozastavit</translation>
<translation id="4010738624545340900">Povolit zobrazování dialogových oken pro výběr souboru</translation>
<translation id="4518251772179446575">Dotázat se vždy, když se webové stránky snaží sledovat fyzickou polohu uživatele</translation>
<translation id="402759845255257575">Nepovolovat spouštění JavaScriptu žádnému webu</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="706669471845501145">Povolit webovým stránkám zobrazovat upozornění na ploše</translation>
<translation id="7529144158022474049">Faktor zpoždění automatické aktualizace</translation>
<translation id="2188979373208322108">Aktivuje v aplikaci <ph name="PRODUCT_NAME"/> panel záložek.

      Pokud toto nastavení aktivujete, zobrazí aplikace <ph name="PRODUCT_NAME"/> panel záložek.

      Pokud toto nastavení deaktivujete, panel záložek se uživatelům nezobrazí.

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

      Pokud nastavení neupravíte, mohou se uživatelé rozhodnout, zda budou funkci využívat, či nikoliv.</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="5475361623548884387">Povolit tisk</translation>
<translation id="7287359148642300270">Určuje, které servery mají být umístěny na seznam povolených pro integrované ověření. Integrované ověření je povoleno pouze v případě, že <ph name="PRODUCT_NAME"/> obdrží výzvu ověřování ze proxy serveru nebo jiného serveru, které jsou uvedeny 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 Chrome 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 Chrome požadavky IWA ignorovat.</translation>
<translation id="3653237928288822292">Ikona výchozího poskytovatele vyhledávání</translation>
<translation id="4721232045439708965">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í <ph name="PRODUCT_NAME"/> stránka Nová karta.

          Pokud vyberete možnost Obnovit poslední relaci, otevřou se adresy, které byly otevřené při posledním ukončení <ph name="PRODUCT_NAME"/>, a relace 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í <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 <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 <ph name="PRODUCT_NAME"/> budou moci změnit.</translation>
<translation id="2872961005593481000">Vypnout</translation>
<translation id="4445684791305970001">Deaktivuje nástroje pro vývojáře a konzoli JavaScriptu.

      Pokud toto nastavení aktivujete, nebude možné přistupovat k nástrojům 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 nenastavíte, umožníte uživatelům používat nástroje pro vývojáře nebo konzoli JavaScript.</translation>
<translation id="9203071022800375458">Zakazuje pořizování snímků obrazovky.

      Je-li zásada povolena, nelze pořizovat snímky obrazovky pomocí klávesových zkratek ani rozhraní API rozšíření.

      Je-li zakázána, nebo není nastavena, pořizování snímků obrazovky je povoleno.</translation>
<translation id="5697306356229823047">Hlásit uživatele zařízení</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="4632343302005518762">Umožnit pluginu <ph name="PRODUCT_FRAME_NAME"/> zpracovávat uvedené typy obsahu</translation>
<translation id="13356285923490863">Název zásady</translation>
<translation id="557658534286111200">Povolí nebo zakáže úpravy záložek</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="2386362615870139244">Povolit uzamčení obrazovky při probuzení</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="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="389421284571827139">Umožňuje zadat proxy server, který bude aplikací <ph name="PRODUCT_NAME"/> používán, a brání uživatelům měnit nastavení proxy serveru.

      Pokud se rozhodnete proxy server nikdy nepoužívat a vždy se připojovat přímo, budou všechny ostatní možnosti ignorovány.

      Pokud zvolíte možnost automatického zjišťování proxy serveru, budou všechny ostatní možnosti ignorovány.

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

      Pokud toto nastavení aktivujete, bude aplikace <ph name="PRODUCT_NAME"/> ignorovat veškeré možnosti týkající se proxy serveru zadané pomocí příkazového řádku.

      Pokud tyto zásady nenastavíte, umožníte uživatelům nastavovat proxy server dle jejich uvážení.</translation>
<translation id="681446116407619279">Podporovaná schémata ověření</translation>
<translation id="4027608872760987929">Aktivovat výchozího poskytovatele vyhledávání</translation>
<translation id="2223598546285729819">Výchozí nastavení oznámení</translation>
<translation id="6158324314836466367">Název podnikového úložiště aplikací (podpora ukončena)</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 relace 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="3793095274466276777">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 registruje.

      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 nastavení této možnosti.

      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í.</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="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="6155936611791017817">Nastavení výchozího stavu velkého kurzoru na přihlašovací obrazovce</translation>
<translation id="1530812829012954197">Následující vzory adres URL vykreslit vždy v hostitelském prohlížeči</translation>
<translation id="9026000212339701596">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 Chrome.</translation>
<translation id="913195841488580904">Blokování přístupu k seznamu adres URL</translation>
<translation id="5461308170340925511">Nakonfiguruje zásady související s rozšířeními. Uživatel nebude moci instalovat rozšíření na seznamu zakázaných rozšíření, pokud nebudou autorizována. U aplikace <ph name="PRODUCT_NAME"/> také můžete vynutit automatickou instalaci rozšíření jejich zadáním do zásady <ph name="EXTENSIONINSTALLFORCELIST_POLICY_NAME"/>. Rozšíření, jejichž instalace je vynucena, budou nainstalována bez ohledu na to, zda jsou uvedena na seznamu zakázaných.</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="6373222873250380826">Pokud je tato zásada nastavena na hodnotu True, budou automatické aktualizace zakázány.

      Zařízení se systémem <ph name="PRODUCT_OS_NAME"/> automaticky kontrolují aktualizace, pokud zásada není nastavena nebo je nastavena na hodnotu False.</translation>
<translation id="6190022522129724693">Výchozí nastavení vyskakovacích oken</translation>
<translation id="847472800012384958">Nepovolit zobrazení vyskakovacích oken žádným webovým stránkám</translation>
<translation id="4733471537137819387">Zásady související s integrovaným ověřením pomocí protokolu HTTP</translation>
<translation id="8501011084242226370">Určuje seznam pluginů, které uživatel v <ph name="PRODUCT_NAME"/> může povolit nebo zakázat.

      Zástupnými znaky „*“ a „?“ lze nahradit sekvenci libovolných znaků.Znak „*“ odpovídá libovolnému počtu znaků a znak „?“ určuje jeden volitelný znak (tj. odpovídá jednomu nebo žádnému znaku). Řídicí znak je „\“, pokud tedy chcete hledat skutečné znaky „*“ nebo „?“, musíte před ně vložit znak „\“.

      Pokud toto nastavení aktivujete, specifikovaný seznam pluginů může být v <ph name="PRODUCT_NAME"/> použit. Uživatelé mohou plugin aktivovat nebo deaktivovat na stránce about:plugins i v případě, že odpovídá vzoru v seznamu DisabledPlugins. Uživatelé mohou také aktivovat a deaktivovat pluginy, které neodpovídají žádnému vzoru v seznamu DisabledPlugins, DisabledPluginsExceptions ani EnabledPlugins

      Táto zásada má umožnit striktní zakázání pluginů tam, kde seznam DisabledPlugins obsahuje zástupné znaky, jako například deaktivovat všechny pluginy „*“ nebo deaktivovat všechny pluginy Java „'*Java*“, avšak správce chce určité verze povolit (například „IcedTea Java 2.3“). Tuto konkrétní verzi lze určit v této zásadě.

      Upozorňujeme, že je třeba zadat výjimku pro název pluginu i pro název skupiny pluginů. Jednotlivé skupiny pluginů se na stránce about:plugins zobrazují v samostatných sekcích a každá sekce může obsahovat jeden nebo více pluginů. Plugin Shockwave Flash například patří do skupiny Adobe Flash Player. Pokud má být vyloučen ze seznamu zakázaných, musí být v seznamu výjimek uvedeny oba názvy.

      Pokud tato zásada není nastavena, bude jakýkoliv plugin, který odpovídá vzoru v seznamu DisabledPlugins, uzamčen jako deaktivovaný a uživatelé jej nebudou moci aktivovat.</translation>
<translation id="8951350807133946005">Nastavit adresář mezipaměti na disku</translation>
<translation id="603410445099326293">Parametry pro adresu URL návrhu, která používá metodu POST</translation>
<translation id="2592091433672667839">Doba nečinnosti před zobrazením spořiče obrazovky na přihlašovací obrazovce v režimu prodeje</translation>
<translation id="166427968280387991">Proxy server</translation>
<translation id="2805707493867224476">Povolit všem webům zobrazovat vyskakovací okna</translation>
<translation id="1727394138581151779">Blokovat všechny pluginy</translation>
<translation id="8118665053362250806">Nastaví velikost mezipaměti médií na disku</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="7079519252486108041">Blokovat vyskakovací okna na těchto webech</translation>
<translation id="1859633270756049523">Omezit délku trvání relace</translation>
<translation id="7433714841194914373">Aktivovat Dynamický režim</translation>
<translation id="4983201894483989687">Povolit spouštění zastaralých pluginů</translation>
<translation id="443665821428652897">Po vypnutí prohlížeče vymazat data webů (zastaralé)</translation>
<translation id="3823029528410252878">Deaktivuje v aplikaci <ph name="PRODUCT_NAME"/> funkci historie prohlížení a brání uživatelům, aby toto nastavení změnili.

      Pokud je toto nastavení aktivováno, historie prohlížení nebude ukládána.

      Pokud je toto nastavení deaktivováno nebo není nakonfigurováno, historie prohlížení se bude ukládat.</translation>
<translation id="7295019613773647480">Aktivovat dozorovaného uživatele</translation>
<translation id="2759224876420453487">Řízení chování uživatele v multiprofilové relaci</translation>
<translation id="3844092002200215574">Nastavuje adresář, do kterého bude prohlížeč <ph name="PRODUCT_NAME"/> ukládat soubory diskové mezipaměti.

      Prohlížeč <ph name="PRODUCT_NAME"/> bude ukládat diskovou mezipaměť do adresáře nastaveného pomocí této zásady bez ohledu na to, zda uživatel zadal pomocí parametru --disk-cache-dir jiný adresář.

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

      Není-li tato zásada nastavena, budou soubory ukládány do výchozího adresáře mezipaměti a uživatel bude moci tento adresář změnit pomocí parametru příkazového řádku --disk-cache-dir.</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="193900697589383153">Přidá na hlavní panel systému tlačítko pro odhlášení.

      Pokud je tato zásada aktivovaná, na hlavním panelu systému se v případě, že je relace aktivní a obrazovka není uzamčená, zobrazí velké červené tlačítko pro odhlášení.

      Pokud je tato zásada deaktivovaná nebo není nastavená, velké červené tlačítko pro odhlášení se na hlavním panelu systému nezobrazí.</translation>
<translation id="5111573778467334951">Akce, která bude provedena, pokud bude dosaženo limitu doby nečinnosti při provozu na baterii.

          Pokud je tato zásada nastavena, udává akci, kterou operační systém <ph name="PRODUCT_OS_NAME"/> provede, když doba nečinnosti uživatele dosáhne zadaného limitu (ten lze nastavit zvlášť).

          Není-li tato zásada nastavena, bude provedena výchozí akce (přechod do režimu spánku).

          Pokud je zvolenou akcí přechod do režimu spánku, můžete zvlášť nastavit, zda má systém <ph name="PRODUCT_OS_NAME"/> před přechodem do tohoto režimu uzamknout obrazovku, nebo ne.</translation>
<translation id="3195451902035818945">Určuje, zda by mělo být dělení záznamů protokolu SSL zakázáno. Dělení záznamů je náhradní řešení pro slabé stránky protokolů SSL 3.0 a TLS 1.0. U některých serverů HTTPS a serverů proxy však může způsobit problémy s kompatibilitou.

      Pokud zásada není nastavena, nebo je nastavena na hodnotu False, použije se dělení záznamů u připojení SSL/TLS, která používají šifrovací nástroje CBC.</translation>
<translation id="6903814433019432303">Tato zásada je aktivní pouze v režimu prodeje.

      Určuje soubor adres URL, které se načtou po zahájení ukázkové relace. Tato zásada přepíše ostatní mechanismy pro nastavení úvodní adresy URL a může být tedy uplatněna pouze u relace, která není přiřazena konkrétnímu uživateli.</translation>
<translation id="5868414965372171132">Konfigurace sítě na úrovni uživatele</translation>
<translation id="8519264904050090490">Adresy URL ručních výjimek spravovaného uživatele</translation>
<translation id="4480694116501920047">Vynutit Bezpečné vyhledávání</translation>
<translation id="465099050592230505">Adresa URL podnikového úložiště aplikací (podpora ukončena)</translation>
<translation id="2006530844219044261">Správa možností napájení</translation>
<translation id="1221359380862872747">Načíst konkrétní adresy URL při přihlášení do ukázky</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="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="5774856474228476867">Adresa URL vyhledávání výchozího poskytovatele vyhledávání</translation>
<translation id="4650759511838826572">Deaktivovat schémata protokolu adresy URL</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="8099880303030573137">Prodleva nečinnosti při napájení z baterie</translation>
<translation id="1709037111685927635">Konfiguruje obrázek tapety.

      Tato zásada umožňuje nakonfigurovat obrázek tapety, který se zobrazuje na ploše a na pozadí přihlašovací obrazovky uživatele. Zásadu nastavíte zadáním adresy URL, ze které může <ph name="PRODUCT_OS_NAME"/> obrázek tapety stáhnout, a kryptografické hodnoty hash, která slouží 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 nutnosti autentizace.

      Obrázek tapety se stáhne a uloží do mezipaměti. Obrázek se stáhne znovu pokaždé, když se adresa URL nebo hodnota hash změní.

      Tuto zásadu je třeba zadat jako řetězec, který udává adresu URL a hodnotu hash ve formátu JSON, a to podle následujícího schématu:
      {
        &quot;type&quot;: &quot;object&quot;,
        &quot;properties&quot;: {
          &quot;url&quot;: {
            &quot;description&quot;: &quot;Adresa URL, ze které lze obrázek tapety stáhnout&quot;,
            &quot;type&quot;: &quot;string&quot;
          },
          &quot;hash&quot;: {
            &quot;description&quot;: &quot;Hodnota hash SHA-256 obrázku avatara&quot;,
            &quot;type&quot;: &quot;string&quot;
          }
        }
      }

      Pokud tuto zásadu nastavíte, systém <ph name="PRODUCT_OS_NAME"/> obrázek tapety stáhne a použije.

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

      Pokud je tato zásada ponechána nenastavená, uživatel si může zvolit, jaký obrázek bude mít zobrazený na ploše a na pozadí přihlašovací obrazovky.</translation>
<translation id="2761483219396643566">Prodleva upozornění na nečinnost při napájení z baterie</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="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="602728333950205286">Adresa URL dynamického vyhledávání výchozího poskytovatele vyhledávání</translation>
<translation id="3030000825273123558">Povolit hlášení o metrikách</translation>
<translation id="8465065632133292531">Parametry pro adresu URL dynamického vyhledávání používající metodu POST</translation>
<translation id="6559057113164934677">Nedovolit žádnému webu používat kameru a mikrofon</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="1675002386741412210">Podpora:</translation>
<translation id="1608755754295374538">Adresy URL, kterým bude udělen přístup pro záznam zvuku bez zobrazení výzvy</translation>
<translation id="3547954654003013442">Nastavení proxy serveru</translation>
<translation id="5921713479449475707">Povolení stahování automatických aktualizací prostřednictvím protokolu HTTP</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="2518231489509538392">Povolit přehrávání zvuku</translation>
<translation id="8146727383888924340">Povolit uživatelům uplatnit při registraci systému Chrome OS nabídky</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="436581050240847513">Odesílat informace o síťových rozhraních zařízení</translation>
<translation id="6282799760374509080">Povolit nebo zakázat záznam zvuku</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="3264793472749429012">Kódování výchozího poskytovatele vyhledávání</translation>
<translation id="285480231336205327">Aktivovat vysoce kontrastní režim</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="5469484020713359236">Umožňuje nastavit seznam vzorů adres URL webových stránek, které mohou nastavovat soubory cookie.

         Pokud 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.</translation>
<translation id="1504431521196476721">Vzdálené ověření identity</translation>
<translation id="1881299719020653447">Skrýt internetový obchod z karty Nová stránka a ze spouštěče aplikace</translation>
<translation id="930930237275114205">Nastavit adresář uživatelských dat pluginu <ph name="PRODUCT_FRAME_NAME"/> </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="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="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 relace 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 relace začnou běžet ihned po zahájení relace.</translation>
<translation id="4600786265870346112">Aktivovat velký kurzor</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="1103860406762205913">Aktivuje staré webové přihlašování.</translation>
<translation id="5765780083710877561">Popis:</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="7796141075993499320">Umožňuje nastavit seznam vzorů adres URL určujících stránky, které mohou spouštět pluginy.
          
          Pokud zásadu nenastavíte, použije se pro všechny webové stránky globální výchozí hodnota buď ze zásady DefaultPluginsSetting (pokud je nastavena), nebo z osobního nastavení uživatele.</translation>
<translation id="3809527282695568696">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.

          Tato zásada funguje pouze v případě, že je zásada RestoreOnStartup nastavena na RestoreOnStartupIsURLs.</translation>
<translation id="649418342108050703">Deaktivuje podporu pro rozhraní API pro 3D grafiku.

      Aktivací tohoto nastavení zabráníte webovým stránkám v přístupu ke grafickému procesoru (GPU). Webové stránky nebudou moci přistupovat k rozhraní WebGL API a pluginy nebudou moci využít rozhraní Pepper 3D API. 
      
      Pokud toto nastavení deaktivujete, umožníte webovým stránkám využívat rozhraní WebGL API a pluginům umožníte využívat rozhraní Pepper 3D API. Výchozí nastavení prohlížeče však mohou k použití těchto rozhraní API i nadále vyžadovat předání argumentů příkazového řádku.</translation>
<translation id="2077273864382355561">Prodleva vypnutí obrazovky při napájení z baterie</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="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é relace 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="8329984337216493753">Tato zásada je aktivní pouze v režimu prodeje.

      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="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="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="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="7258823566580374486">Povolit blokování uživatelského rozhraní hostitelů vzdáleného přístupu</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="944817693306670849">Nastavení velikosti mezipaměti na disku</translation>
<translation id="8544375438507658205">Výchozí modul vykreslení HTML pro plugin <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="2371309782685318247">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 tuto zásadu nenastavíte, použije <ph name="PRODUCT_NAME"/> výchozí hodnotu, což jsou 3 hodiny.</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="2170233653554726857">Povolení optimalizace WPAD</translation>
<translation id="7424751532654212117">Seznam výjimek ze seznamu deaktivovaných pluginů</translation>
<translation id="6233173491898450179">Nastavit adresář pro stahování</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="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="2299220924812062390">Zadat seznam aktivovaných pluginů</translation>
<translation id="4325690621216251241">Přidat na hlavní panel systému tlačítko pro odhlášení</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="1465619815762735808">Spustit kliknutím</translation>
<translation id="7227967227357489766">Určuje seznam uživatelů, kteří se do zařízení mohou přihlásit. Položky jsou ve tvaru <ph name="USER_WHITELIST_ENTRY_FORMAT"/>, například <ph name="USER_WHITELIST_ENTRY_EXAMPLE"/>. Chcete-li v doméně povolit libovolné uživatele, použijte položky ve tvaru <ph name="USER_WHITELIST_ENTRY_WILDCARD"/>.

      Pokud tato zásada není nastavena, budou se do zařízení moci přihlásit všichni uživatelé. (K vytváření nových uživatelů je však i v tomto případě potřeba správné nastavení zásady <ph name="DEVICEALLOWNEWUSERS_POLICY_NAME"/>.)</translation>
<translation id="2521581787935130926">Zobrazovat na liště záložek zástupce aplikací</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="1897365952389968758">Povolit všem webům spouštět JavaScript</translation>
<translation id="922540222991413931">Konfigurovat zdroje instalací rozšíření, aplikací a uživatelských skriptů</translation>
<translation id="7323896582714668701">Dodatečné parametry příkazového řádku pro <ph name="PRODUCT_NAME"/></translation>
<translation id="6931242315485576290">Deaktivovat synchronizaci dat se servery Google</translation>
<translation id="1330145147221172764">Povolit klávesnici na obrazovce</translation>
<translation id="7006788746334555276">Nastavení obsahu</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="5142301680741828703">Následující vzory adres URL vykreslovat vždy v pluginu <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="4625915093043961294">Konfigurovat seznam povolených pro instalaci rozšíření</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="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="4507081891926866240">Umožňuje personalizovat seznam vzorů adres URL, které by měl plugin <ph name="PRODUCT_FRAME_NAME"/> vždy vykreslit.

          Pokud není zásada nastavena, použije se pro všechny webové stránky výchozí modul vykreslení, jak je určeno zásadou ChromeFrameRendererSettings.

          Ukázkové vzory naleznete na adrese http://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="3101501961102569744">Zvolit způsob konfigurace nastavení proxy serveru</translation>
<translation id="1803646570632580723">Seznam připnutých aplikací, které se zobrazují ve spouštěči</translation>
<translation id="1062011392452772310">Povolit vzdálené ověření identity zařízení</translation>
<translation id="7774768074957326919">Použít systémová nastavení proxy serveru</translation>
<translation id="3891357445869647828">Povolit JavaScript</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="6774533686631353488">Povolit hostitele zasílání nativních zpráv na úrovni uživatele (nainstalované bez oprávnění správce).</translation>
<translation id="868187325500643455">Povolit automatické spouštění pluginů všem webům</translation>
<translation id="7421483919690710988">Nastavit velikost diskové mezipaměti médií v bajtech</translation>
<translation id="5226033722357981948">Určuje, zda má být deaktivován nástroj pro vyhledávání pluginů</translation>
<translation id="7234280155140786597">Názvy zakázaných hostitelů zasílání nativních zpráv (nebo * pro vše)</translation>
<translation id="4890209226533226410">Nastavuje typ lupy, který je aktivován.

Pokud je tato zásada nastavena, ovládá typ lupy, který je aktivní. Nastavíte-li zásadu na hodnotu Žádné, lupa se deaktivuje. 

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

Pokud ji ponecháte nenastavenou, lupa bude ve výchozím nastavení deaktivována, ale uživatelé ji budou moci kdykoli aktivovat.</translation>
<translation id="3428247105888806363">Aktivovat předvídání akcí sítě</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="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="2757054304033424106">Typy rozšíření nebo aplikací, které mohou být nainstalovány</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="5757829681942414015">Nastavuje adresář, do kterého bude prohlížeč <ph name="PRODUCT_NAME"/> ukládat uživatelská data.

      Prohlížeč <ph name="PRODUCT_NAME"/> bude ukládat uživatelská data do adresáře nastaveného pomocí této zásady bez ohledu na to, zda uživatel zadal pomocí parametru --user-data-dir jiný adresář.

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

      Není-li tato zásada nastavena, bude data ukládána do výchozího adresáře profilu a uživatel bude moci tento adresář změnit pomocí parametru příkazového řádku --user-data-dir.</translation>
<translation id="5067143124345820993">Seznam povolených uživatelů k přihlášení</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="7194407337890404814">Název výchozího poskytovatele vyhledávání</translation>
<translation id="1843117931376765605">Obnovovací frekvence zásad pro uživatele</translation>
<translation id="5535973522252703021">Seznam povolených serverů pro delegování ověření protokolu Kerberos</translation>
<translation id="9187743794267626640">Zakázat připojení externího úložiště</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="5307432759655324440">Dostupnost anonymního režimu</translation>
<translation id="4056910949759281379">Deaktivovat protokol SPDY</translation>
<translation id="3808945828600697669">Určit seznam deaktivovaných pluginů</translation>
<translation id="4525521128313814366">Umožňuje nastavit seznam vzorů adres URL webových stránek, které nemají povoleno zobrazovat obrázky.

          Pokud zásadu nenastavíte, použije se pro všechny webové stránky globální výchozí hodnota buď ze zásady DefaultImagesSetting (pokud je nastavena), nebo z osobního nastavení uživatele.</translation>
<translation id="8499172469244085141">Výchozí nastavení (uživatelé mohou zásady přepsat)</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="8693243869659262736">Použít integrovaného klienta DNS</translation>
<translation id="3072847235228302527">Nastavit smluvní podmínky pro účet v zařízení</translation>
<translation id="5523812257194833591">Veřejná relace, do které se zařízení po prodlevě automaticky přihlásí.

      Pokud je zásada nastavena, zařízení se po uplynutí určité doby nečinnosti uživatele na přihlašovací obrazovce automaticky přihlásí do určené relace. Veřejná relace již musí být nakonfigurována (viz |DeviceLocalAccounts|).

      Pokud zásada nastavena není, k automatickému přihlášení nedojde.</translation>
<translation id="5983708779415553259">Výchozí chování pro stránky, které nejsou součástí žádného obsahového balíčku</translation>
<translation id="3866530186104388232">Pokud je tato zásada nastavena na hodnotu True nebo není nastavena, zobrazí systém <ph name="PRODUCT_OS_NAME"/> na přihlašovací obrazovce existující uživatele a umožní vybrat jednoho z nich. Je-li tato zásada nastavena na hodnotu False, zobrazí systém <ph name="PRODUCT_OS_NAME"/> výzvu k zadání uživatelského jména a hesla.</translation>
<translation id="7384902298286534237">Umožňuje nastavit seznam vzorů adres URL stránek, které mají povoleno nastavovat soubory cookie pouze pro relaci.

           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.

          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="2098658257603918882">Aktivovat odesílání dat o využití nebo selhání</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="2324547593752594014">Umožnit přihlášení do Chromu</translation>
<translation id="172374442286684480">Umožnit nastavení místních dat všem webům</translation>
<translation id="1151353063931113432">Povolit obrázky na těchto stránkách</translation>
<translation id="1297182715641689552">Použít skript proxy serveru ve formátu PAC</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="8631434304112909927">naposledy ve verzi <ph name="UNTIL_VERSION"/></translation>
<translation id="7469554574977894907">Aktivovat návrhy pro vyhledávání</translation>
<translation id="4906194810004762807">Obnovovací frekvence zásad pro zařízení</translation>
<translation id="8922668182412426494">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, Chrome nebude delegovat přihlašovací údaje uživatelů ani v případě, že server bude zjištěn jako intranet.</translation>
<translation id="1398889361882383850">Umožňuje nastavit, zda weby budou moci automaticky spouštět pluginy. Automatické spouštění pluginů lze pro všechny weby povolit, nebo zakázat.

          Funkce Spustit kliknutím dovoluje spouštění pluginů, avšak uživatel na ně musí nejdříve kliknout.

          Pokud zásada není nastavena, použije se zásada „AllowPlugins“ a uživatelé ji budou moci změnit.</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="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 relace 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 relace libovolného typu.</translation>
<translation id="5511702823008968136">Aktivovat panel záložek</translation>
<translation id="5105313908130842249">Prodleva uzamčení obrazovky při napájení z baterie</translation>
<translation id="7882585827992171421">Tato zásada je aktivní pouze v režimu prodeje.

      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="1796466452925192872">Umožňuje určit, které adresy mohou instalovat rozšíření, aplikace a motivy.

          Počínaje prohlížečem Chrome 21 je instalace rozšíření, aplikací a uživatelských skriptů z jiných zdrojů než z Internetového obchodu Chrome náročnější. Dříve mohli uživatelé kliknout na odkaz na soubor *.crx a prohlížeč Chrome jim po několika upozorněních nabídl možnost instalace tohoto souboru. V prohlížeči Chrome 21 je třeba takové soubory stáhnout a přesunout na stránku s nastaveními prohlížeče Chrome. Toto nastavení umožňuje určitým webovým adresám starší a jednodušší proces instalace.

          Každá položka v tomto seznamu představuje vzor odpovídající typu rozšíření (viz stránky http://code.google.com/chrome/extensions/match_patterns.html). Uživatelé budou moci jednoduše instalovat položky z jakékoli adresy, která odpovídá položce v tomto seznamu. V těchto vzorech musí být povoleno umístění souboru *.crx i stránka, ze které bude zahájeno stahování (tj. zdroj odkazu).

          Seznam zakázaných položek ExtensionInstallBlacklist je této zásadě nadřazen. Rozšíření v seznamu zakázaných položek nebude nainstalováno ani v případě, že bude pocházet ze stránek, které jsou uvedeny v tomto seznamu.</translation>
<translation id="2113068765175018713">Omezit provozní dobu zařízení automatickým restartováním</translation>
<translation id="4224610387358583899">Prodlevy uzamčení obrazovky</translation>
<translation id="5388730678841939057">Zvolí strategii pro uvolnění místa na disku při automatickém čištění (zastaralé)</translation>
<translation id="7848840259379156480">Umožňuje konfigurovat modul vykreslení obsahu HTML, pokud je nainstalován plugin <ph name="PRODUCT_FRAME_NAME"/>.
      Ve výchozím nastavení vykresluje obsah 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="186719019195685253">Akce, která bude provedena, pokud bude dosaženo limitu doby nečinnosti při provozu na síťové napájení</translation>
<translation id="197143349065136573">Aktivuje staré webové přihlašování.

Toto nastavení je užitečné pro zákazníky z firem, které používají řešení SSO, jež dosud není kompatibilní s novým okamžitým přihlašováním.
Pokud toto nastavení aktivujete, použije se staré webové přihlašování.
Pokud toto nastavení deaktivujete nebo ho ponecháte nenastavené, ve výchozím nastavení se použije nové okamžité přihlašování. Uživatelé mohou staré webové přihlašování aktivovat prostřednictvím příznaku příkazového řádku --enable-web-based-signin.

Až bude okamžité přihlašování podporovat všechny přihlašovací procesy SSO, toto experimentální nastavení bude odstraněno.</translation>
<translation id="4121350739760194865">Zabraňuje zobrazování propagace aplikací na stránce Nová karta</translation>
<translation id="2127599828444728326">Povolit na těchto stránkách oznámení</translation>
<translation id="3973371701361892765">Nikdy automaticky neskrývat sklad</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="2948087343485265211">Určuje, zda aktivita zvukových zařízení ovlivňuje správu napájení.

          Pokud je tato zásada nastavena na hodnotu true nebo není nastavena vůbec, není přehrávání zvuku považováno za nečinnost uživatele. V takovém případě nebude dosažena prodleva režimu nečinnosti a nebude provedena úsporná akce. Bez ohledu na aktivitu zvukových zařízení však po stanovené době dojde ke snížení jasu, vypnutí a uzamčení obrazovky.

          Pokud je tato zásada nastavena na hodnotu false, přehrávání zvuku je považováno za nečinnost uživatele.</translation>
<translation id="7842869978353666042">Konfigurace možností Disku Google</translation>
<translation id="718956142899066210">Typy připojení, pro které jsou povoleny aktualizace</translation>
<translation id="1734716591049455502">Konfigurace možností vzdáleného přístupu</translation>
<translation id="7336878834592315572">Uchovat soubory cookie po dobu trvání relace</translation>
<translation id="7715711044277116530">Procento prodloužení prodlevy ztmavení obrazovky v režimu prezentace</translation>
<translation id="8777120694819070607">Umožňuje prohlížeči <ph name="PRODUCT_NAME"/> spouštět zastaralé pluginy.

      Pokud toto nastavení aktivujete, budou zastaralé pluginy použity jako normální pluginy.

      Pokud toto nastavení deaktivujete, zastaralé pluginy nebude možné použít a uživatelům se u nich nezobrazí ani žádost o oprávnění ke spuštění.

      Pokud toto nastavení není nakonfigurováno, uživatelům se při spouštění zastaralého pluginu zobrazí žádost o oprávnění k této akci.</translation>
<translation id="2629448496147630947">Konfigurace možností vzdáleného přístupu v prohlížeči <ph name="PRODUCT_NAME"/>.

      Není-li nainstalována webová aplikace Vzdálený přístup, jsou tyto funkce ignorovány.</translation>
<translation id="4001275826058808087">Administrátoři IT spravující podniková zařízení mohou pomocí této zásady 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="1310699457130669094">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, neměli byste tuto zásadu nastavovat.

          Podrobné příklady naleznete na následující adrese:
          <ph name="PROXY_HELP_URL"/></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="5464816904705580310">Konfigurace nastavení pro spravované uživatele</translation>
<translation id="3219421230122020860">Anonymní režim dostupný</translation>
<translation id="7690740696284155549">Nastavuje adresář, do kterého bude prohlížeč <ph name="PRODUCT_NAME"/> ukládat stažené soubory.

      Prohlížeč <ph name="PRODUCT_NAME"/> bude ukládat stažené soubory do adresáře nastaveného pomocí této zásady bez ohledu na to, zda uživatel vybral jiný adresář nebo nastavil, aby se před každým stahováním zobrazil dotaz na cílové umístění.

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

      Není-li tato zásada nastavena, budou soubory ukládány do výchozího adresáře a uživatel bude moci tento adresář změnit.</translation>
<translation id="7381326101471547614">Zakáže v aplikaci <ph name="PRODUCT_NAME"/> použití protokolu SPDY.

      Pokud je zásada aktivní, nebude protokol SPDY v aplikaci <ph name="PRODUCT_NAME"/> k dispozici.

      Pokud zásadu deaktivujete, umožníte využívání protokolu SPDY. 

      Pokud zásadu nenastavíte, bude protokol SPDY k dispozici.</translation>
<translation id="2208976000652006649">Parametry adresy URL vyhledávání používající metodu POST</translation>
<translation id="1583248206450240930">Ve výchozím nastavení používat plugin <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="1047128214168693844">Nepovolovat sledování fyzické polohy žádným webovým stránkám</translation>
<translation id="4101778963403261403">Slouží ke konfiguraci typu výchozí domovské stránky v aplikaci <ph name="PRODUCT_NAME"/> a brání uživatelům, aby nastavení domovské stránky měnili. Jako domovskou stránku lze nastavit adresu URL, kterou zadáte, nebo stránku Nová karta.

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

         Pokud toto nastavení deaktivujete, stránka Nová karta se uživateli jako domovská stránka nikdy nezobrazí (pokud není adresa URL domovské stránky nastavena jako řetězec chrome://newtab).

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

           Pokud zásadu nenastavíte, mohou uživatelé zvolit, zda chtějí stránku nová karta nastavit jako domovskou stránku.</translation>
<translation id="8970205333161758602">Potlačení oznámení o ukončení podpory pluginu <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="3273221114520206906">Výchozí nastavení JavaScriptu</translation>
<translation id="4025586928523884733">Blokuje soubory cookie třetích stran.

      Aktivací tohoto nastavení zabráníte tomu, aby prvky webové stránky, které nepocházejí z domény uvedené v adresním řádku prohlížeče, nastavovaly soubory cookie.

       Deaktivací tohoto nastavení umožníte, aby prvky webové stránky, které nepocházejí z domény uvedené v adresním řádku prohlížeče, mohly nastavovat soubory cookie.

     Pokud zásadu nenastavíte, budou soubory cookie třetích stran povoleny, uživatelé však budou moci toto nastavení změnit.</translation>
<translation id="4604931264910482931">Konfigurace seznamu zakázaných položek zasílání nativních zpráv</translation>
<translation id="6810445994095397827">Blokovat JavaScript na těchto stránkách</translation>
<translation id="6672934768721876104">Tato zásada se již nepoužívá. Namísto ní prosím použijte zásadu ProxyMode.

          Umožňuje zadat proxy server, který bude aplikací <ph name="PRODUCT_NAME"/> používán, a brání uživatelům měnit nastavení proxy serveru.

          Pokud se rozhodnete proxy server nikdy nepoužívat a vždy se připojovat přímo, budou všechny ostatní možnosti ignorovány.

          Pokud se rozhodnete používat systémová nastavení proxy serveru nebo proxy server zjišťovat automaticky, budou všechny ostatní možnosti ignorovány.

         Pokud zvolíte možnost ručního nastavení proxy serveru, můžete zvolit další možnosti v částech „Adresa (nebo adresa URL) proxy serveru“, „Adresa URL souboru PAC proxy serveru“ a „Seznam pravidel vynechání proxy serveru oddělených čárkami“.

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

          Pokud toto nastavení aktivujete, bude aplikace <ph name="PRODUCT_NAME"/> ignorovat veškeré možnosti týkající se serverů proxy zadané pomocí příkazového řádku.

          Pokud zásadu nenastavíte, mohou uživatelé zvolit nastavení proxy podle svého uvážení.</translation>
<translation id="3780152581321609624">Zahrnout do hlavního názvu služby protokolu Kerberos nestandardní port</translation>
<translation id="1749815929501097806">Nastavuje smluvní podmínky, které musí uživatel přijmout před zahájením relace 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í relace 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="2623014935069176671">Počkat na první aktivitu uživatele</translation>
<translation id="2660846099862559570">Nikdy nepoužívat proxy server</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="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 relace. 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í relace.
      * 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="1435659902881071157">Konfigurace sítě na úrovni zařízení</translation>
<translation id="8071636581296916773">Povolí použití synchronizačních serverů, když se vzdálené klienty pokoušejí navázat připojení k tomuto počítači.

          Pokud je toto nastavení povoleno a není k dispozici přímé připojení (například z důvodu omezení firewallu), mohou se vzdálené klienty k tomuto počítači připojit pomocí synchronizačních serverů.
          Upozorňujeme, že pokud je zakázána zásada <ph name="REMOTEACCESSHOSTFIREWALLTRAVERSAL_POLICY_NAME"/>, bude tato zásada ignorována.
          Pokud tato zásada není nastavena, bude nastavení aktivováno.</translation>
<translation id="2131902621292742709">Prodleva snížení jasu obrazovky při napájení z baterie</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="5512418063782665071">Adresa URL domovské stránky</translation>
<translation id="2948381198510798695">U hostitelů v tomto seznamu vynechá aplikace <ph name="PRODUCT_NAME"/> všechny servery proxy.

          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, neměli byste tuto zásadu nastavovat.

          Podrobnější příklady naleznete na následující adrese:
          <ph name="PROXY_HELP_URL"/></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="102492767056134033">Nastavuje výchozí stav softwarové klávesnice na přihlašovací obrazovce.</translation>
<translation id="523505283826916779">Nastavení usnadnění přístupu</translation>
<translation id="1948757837129151165">Zásady pro ověření pomocí protokolu HTTP</translation>
<translation id="5946082169633555022">Verze beta</translation>
<translation id="7187256234726597551">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.platformKeysPrivate se nezdaří.</translation>
<translation id="5242696907817524533">Konfiguruje seznam spravovaných záložek.

      Tato zásada je seznam záložek. Každá záložka představuje slovník obsahující název záložky a cílovou adresu URL.

      Tyto záložky jsou umístěny ve složce Spravované záložky v části Mobilní záložky. Uživatel tyto záložky nemůže měnit.

      Když je tato zásada nastavena, složka Spravované záložky se při zobrazení záložek v prohlížeči Chrome otevře jako výchozí.

      Spravované záložky nejsou synchronizovány s uživatelským účtem.</translation>
<translation id="6757375960964186754">Řídí zobrazení možností usnadnění přístupu v systémové nabídce systému <ph name="PRODUCT_OS_NAME"/>.

          Pokud je tato zásada nastavena na hodnotu true, na panelu systémové nabídky se vždy zobrazí možnosti usnadnění přístupu.

          Pokud je zásada nastavena na hodnotu false, možnosti usnadnění přístupu se na panelu systémové nabídky nikdy nezobrazí.

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

          Není-li tato zásada nastavena, možnosti usnadnění přístupu se na panelu systémové nabídky nezobrazí, avšak uživatelé je mohou zpřístupnit na stránce Nastavení.</translation>
<translation id="8303314579975657113">Určuje knihovnu GSSAPI, která bude použita pro ověření pomocí protokolu HTTP. Nastavit lze buď pouze název knihovny, nebo celou cestu. 

          Pokud nezadáte žádné nastavení, použije aplikace <ph name="PRODUCT_NAME"/> výchozí název knihovny.</translation>
<translation id="8549772397068118889">Při návštěvě webů mimo obsahové balíčky zobrazit upozornění</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="6698424063018171973">Omezuje rozsah portů UDP používaný hostitelem vzdáleného připojení na tomto počítači.

          Pokud je tato zásada ponechána nenastavená nebo je nastavena na prázdný řetězec, bude hostitel vzdáleného připojení moci použít libovolný dostupný port. Výjimkou je případ, kdy je zakázána zásada <ph name="REMOTEACCESSHOSTFIREWALLTRAVERSAL_POLICY_NAME"/>. V tomto případě hostitel vzdáleného připojení použije porty UDP v rozsahu 12400–12409.</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="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="5645779841392247734">Povolit soubory cookie na těchto stránkách</translation>
<translation id="4043912146394966243"> 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="6652197835259177259">Nastavení místně spravovaných uživatelů</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="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="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="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="4088589230932595924">Anonymní režim je povinný.</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="8197918588508433925">Tato zásada určuje povolená rozšíření, která mohou ke vzdálenému ověření identity použít rozhraní Enterprise Platform Keys API chrome.enterprise.platformKeysPrivate.challengeUserKey(). Rozšíření oprávněná používat rozhraní API musí být přidána do tohoto seznamu.

          Pokud rozšíření není na seznamu nebo seznam není nastaven, volání rozhraní API se nezdaří a zobrazí se kód chyby.</translation>
<translation id="2811293057593285123">Když uživatel přejde na web, který je označen jako potenciálně škodlivý, služba Bezpečné prohlížení zobrazí 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 označený web.</translation>
<translation id="7649638372654023172">Slouží ke konfiguraci webové adresy výchozí domovské stránky v prohlížeči <ph name="PRODUCT_NAME"/> a brání uživatelům, aby ji změnili.

          Domovská stránka je stránka, která se otevře po kliknutí na tlačítko Domovská stránka. Stránky, které se otevřou při spuštění, jsou prověřovány zásadami RestoreOnStartup.

          Domovskou stránkou může být adresa, kterou zde zadáte, nebo stránka Nová karta. Zvolíte-li stránku Nová karta, bude tato zásada ignorována.

          Pokud toto nastavení aktivujete, uživatelé nebudou moci změnit adresu domovské stránky prohlížeče <ph name="PRODUCT_NAME"/>, avšak budou moci jako domovskou stránku zvolit stránku Nová karta.

          Pokud tuto zásadu nenastavíte, uživatelé budou moci zvolit domovskou stránku sami v případě, že nebude nastavena ani zásada HomepageIsNewTabPage.</translation>
<translation id="3806576699227917885">Umožňuje přehrávat zvuky.

      Pokud je tato zásada nastavena na hodnotu false, nebude během přihlášení uživatele zvukový výstup v zařízení k dispozici.

      Tato zásada ovlivňuje všechny typy zvukových výstupů, nejen zabudované reproduktory. Zásada zablokuje i zvukové funkce usnadnění přístupu. Pokud uživatel potřebuje čtečku obrazovky, tuto zásadu nepovolujte.

      Pokud je zásada nastavena na hodnotu true nebo není nastavena, mohou uživatelé v zařízení používat všechny podporované typy zvukových výstupů.</translation>
<translation id="6517678361166251908">Povolit ověřování gnubby</translation>
<translation id="4858735034935305895">Povolení režimu celé obrazovky</translation>
</translationbundle>