<?xml version="1.0" ?>
<!DOCTYPE translationbundle>
<translationbundle lang="sk">
<translation id="1503959756075098984">ID rozšírení a adresy URL aktualizácií, ktoré sa majú nainštalovať na pozadí</translation>
<translation id="793134539373873765">Určuje, či sa pri aktualizovaní OS má použiť protokol p2p. Ak je táto možnosť nastavená na hodnotu True, zariadenia budú zdieľať aktualizácie a pokúsia sa ich preberať v sieti LAN, čím potenciálne znížia využitie a preťaženie šírky pásma. Ak sa aktualizácie nedajú vykonať v sieti LAN, zariadenie ich prevezme z aktualizačného servera. Ak je táto možnosť nastavená na hodnotu False alebo nie je nakonfigurovaná, protokol p2p sa nepoužije.</translation>
<translation id="2463365186486772703">Miestne nastavenie aplikácie</translation>
<translation id="1397855852561539316">Adresa URL návrhu predvoleného poskytovateľa vyhľadávania</translation>
<translation id="3347897589415241400">Predvolené správanie stránok, ktoré sa nenachádzajú v žiadnom obsahovom balíku.

          Toto pravidlo sa vzťahuje len na interné používanie prehliadača Chrome.</translation>
<translation id="7040229947030068419">Vzorová hodnota:</translation>
<translation id="1213523811751486361">Určuje adresu URL vyhľadávacieho nástroja, ktorý poskytuje návrhy pre vyhľadávanie. Adresa URL by mala obsahovať reťazec <ph name="SEARCH_TERM_MARKER"/>, ktorý bude počas posielania dopytu nahradený textom zadávaným používateľom.

          Toto pravidlo je voliteľné. Ak nebude nastavené, nepoužije sa žiadna adresa URL návrhu.

          Toto pravidlo bude dodržané len v prípade, ak je povolené pravidlo „DefaultSearchProviderEnabled“.</translation>
<translation id="6106630674659980926">Povoliť správcu hesiel</translation>
<translation id="7109916642577279530">Povolí alebo zamietne zaznamenávanie zvuku.

      Ak je toto pravidlo povolené alebo nenakonfigurované (predvolené), používateľovi sa zobrazí výzva
      na prístup k zaznamenávaniu zvuku. Výnimkou sú adresy URL, ktoré sú nakonfigurované
      v zozname AudioCaptureAllowedUrls a majú povolený prístup bez zobrazenia výzvy.

      Ak je pravidlo zakázané, používateľovi sa nikdy nezobrazí výzva a zaznamenávanie
      zvuku bude k dispozícii iba pre adresy URL, ktoré sú nakonfigurované v zozname AudioCaptureAllowedUrls.

      Toto pravidlo má vplyv na všetky typy zvukových vstupov, a nie len na vstavaný mikrofón.</translation>
<translation id="9150416707757015439">Toto pravidlo je zastarané. Použite namiesto neho pravidlo IncognitoModeAvailability.
      Povoľuje v prehliadači <ph name="PRODUCT_NAME"/> režim Inkognito.

      Ak je toto nastavenie povolené alebo nie je nakonfigurované, používatelia môžu otvárať webové stránky v režime Inkognito.

      Ak je toto nastavenie zakázané, používatelia nemôžu v režime Inkognito otvárať webové stránky.

      Ak toto pravidlo ponecháte nenastavené, povolí sa a používateľ bude môcť režim Inkognito použiť.</translation>
<translation id="4203389617541558220">Obmedzuje dobu, počas ktorej je zariadenie zapnuté, prostredníctvom naplánovania automatických reštartov.

      Keď je pravidlo nastavené, určuje dĺžku doby, počas ktorej je zariadenie zapnuté, a po ktorej uplynutí sa naplánuje automatický reštart.

      Keď pravidlo nie je nastavené, doba zapnutia zariadenia nie je obmedzená.

      Ak nastavíte toto pravidlo, používatelia ho nebudú môcť zmeniť ani prepísať.

      Automatický reštart sa naplánuje na vybratý čas, ale ak používateľ v danej chvíli zariadenie používa, môže sa reštart zariadenia odložiť až na 24 hodín.

      Poznámka: Automatické reštartovanie je v súčasnosti povolené, iba pokiaľ sa zobrazuje prihlasovacia obrazovka alebo prebieha relácia aplikácie v režime kiosku. Toto sa v budúcnosti zmení a pravidlo sa použije bez ohľadu na to, či prebieha relácia akéhokoľvek typu alebo nie.

      Hodnota pre pravidlo sa má zadať v sekundách. Hodnoty sa upravia tak, aby mali aspoň 3600 sekúnd (jedna hodina).</translation>
<translation id="5304269353650269372">Určuje časové obdobie bez zásahu používateľa, po ktorom sa pri napájaní zariadenia z batérie zobrazí okno s upozornením.

          Ak je pravidlo nastavené, určuje časové obdobie nečinnosti používateľa, po uplynutí ktorého aplikácia <ph name="PRODUCT_OS_NAME"/> zobrazí okno s upozornením, že sa vykoná akcia z dôvodu nečinnosti.

          Ak pravidlo nie je nastavené, okno s upozornením sa nezobrazí.

          Hodnota pravidla by mala byť stanovená v milisekundách. Hodnoty musia byť menšie alebo rovnaké ako oneskorenie z nečinnosti.</translation>
<translation id="7818131573217430250">Nastaviť predvolený stav režimu vysokého kontrastu na prihlasovacej obrazovke</translation>
<translation id="7614663184588396421">Zoznam zakázaných schém protokolu</translation>
<translation id="2309390639296060546">Predvolené nastavenie geolokácie</translation>
<translation id="1313457536529613143">Určuje percentuálnu hodnotu, o ktorú sa predĺži oneskorenie stmavenia obrazovky, keď sa zaznamená aktivita používateľa počas doby, keď je obrazovka stmavená, alebo krátko po vypnutí obrazovky.

          Ak je toto pravidlo nastavené, určuje percentuálnu hodnotu, o ktorú sa predĺži oneskorenie stmavenia obrazovky, keď sa zaznamená aktivita používateľa počas doby, keď je obrazovka stmavená, alebo krátko po vypnutí obrazovky. Po predĺžení oneskorenia stmavenia obrazovky sa oneskorenia pre vypnutie, uzamknutie a nečinnosť obrazovky prispôsobia tak, aby si zachovali rovnaké odstupy od stmavenia obrazovky ako pri pôvodnej konfigurácii.

          Ak je toto pravidlo nenastavené, použije sa predvolený škálovací faktor.

          Škálovací faktor musí mať hodnotu aspoň 100 %.</translation>
<translation id="7443616896860707393">Požiadavky typu cross-origin štandardu HTTP Basic Auth</translation>
<translation id="2337466621458842053">Umožňuje nastaviť zoznam vzorov adries URL určujúcich webové stránky, na ktorých sa môžu zobrazovať obrázky.

          Ak toto pravidlo ponecháte nenastavené, použije sa v prípade všetkých webových stránok globálna predvolená hodnota buď z pravidla „DefaultImagesSetting“ (ak je nastavené), alebo z osobnej konfigurácie používateľa.</translation>
<translation id="4680961954980851756">Povoliť automatické dopĺňanie</translation>
<translation id="5183383917553127163">Umožňuje určiť rozšírenia, ktorých sa netýka zoznam zakázaných rozšírení. Ak je v zozname uvedená hodnota *, znamená to, že sa v ňom nachádzajú všetky rozšírenia a používatelia môžu inštalovať len tie, ktoré sú uvedené v zozname povolených rozšírení. V predvolenom nastavení sú všetky rozšírenia povolené. Ak však boli všetky rozšírenia pridané do zoznamu zakázaných rozšírení pomocou pravidla, je možné toto pravidlo nahradiť pomocou zoznamu povolených rozšírení.</translation>
<translation id="5921888683953999946">Nastaví predvolený stav veľkého kurzora (funkcia na uľahčenie prístupu) na prihlasovacej obrazovke.

          Ak je toto pravidlo nastavené na hodnotu true, pri zobrazení prihlasovacej obrazovky sa povolí veľký kurzor.

          Ak je toto pravidlo nastavené na hodnotu false, pri zobrazení prihlasovacej obrazovky sa veľký kurzor zakáže.

          Ak nastavíte toto pravidlo, používatelia ho budú môcť dočasne prepísať povolením alebo zakázaním veľkého kurzora. Voľba používateľa však nie je trvalá a predvolené nastavenie sa obnoví zakaždým, keď sa znova zobrazí prihlasovacia obrazovka alebo používateľ bude na prihlasovacej obrazovke nečinný počas jednej minúty.

          Ak toto pravidlo ponecháte nenastavené, bude veľký kurzor pri prvom zobrazení prihlasovacej obrazovky zakázaný. Používatelia budú môcť veľký kurzor kedykoľvek povoliť alebo zakázať a jeho stav na prihlasovacej obrazovke sa zachová aj po zmene používateľov.</translation>
<translation id="3185009703220253572">od verzie <ph name="SINCE_VERSION"/></translation>
<translation id="2204753382813641270">Ovládať automatické skrývanie poličky</translation>
<translation id="3816312845600780067">Povoliť záchrannú klávesovú skratku pre automatické prihlásenie</translation>
<translation id="3214164532079860003">Ak je toto pravidlo povolené, domovská stránka bude importovaná z aktuálneho predvoleného prehliadača.

      Ak je zakázané, domovská stránka sa neimportuje.
      Ak nie je nastavené, môže sa používateľovi zobraziť výzva, či chce domovskú stránku importovať, alebo môže import prebehnúť automaticky.</translation>
<translation id="5330684698007383292">Povoliť doplnku <ph name="PRODUCT_FRAME_NAME"/> spracovávať nasledujúce typy obsahu</translation>
<translation id="6647965994887675196">Ak toto pravidlo nastavíte na hodnotu true, bude možné vytvárať a používať kontrolovaných používateľov.

          Ak toto pravidlo nenakonfigurujete alebo ho nastavíte na hodnotu false, bude vytváranie a prihlasovanie kontrolovaných používateľov zakázané. Všetci existujúci kontrolovaní používatelia budú skrytí.

          POZNÁMKA: Predvolené správanie pre zákaznícke a podnikové zariadenia sa líši. V zákazníckych zariadeniach budú kontrolovaní používatelia v predvolenom nastavení povolení, zatiaľ čo v podnikových zariadeniach budú zakázaní.</translation>
<translation id="69525503251220566">Parameter poskytujúci funkciu vyhľadávania podľa obrázka pre predvoleného poskytovateľa vyhľadávania</translation>
<translation id="5469825884154817306">Blokovať obrázky na týchto stránkach</translation>
<translation id="5827231192798670332">Zvolí stratégiu na uvoľnenie miesta na disku počas automatického čistenia</translation>
<translation id="8412312801707973447">Či sa majú vykonávať kontroly OCSP/CRL online</translation>
<translation id="6649397154027560979">Podpora tohto pravidla je ukončená. Použite namiesto neho pravidlo URLBlacklist.

      Zakáže v prehliadači <ph name="PRODUCT_NAME"/> schémy protokolov uvedené v zozname.

      Adresy URL so schémou z tohoto zoznamu sa nenačítajú ani sa na ne nebude dať prejsť.

      Ak je toto pravidlo nenastavené alebo je zoznam prázdny, bude sa dať v prehliadači <ph name="PRODUCT_NAME"/> pristupovať ku všetkým schémam.</translation>
<translation id="3213821784736959823">Ovláda, či sa v prehliadači <ph name="PRODUCT_NAME"/> používa vstavaný klient DNS.

      Ak je toto pravidlo nastavené na hodnotu True, vstavaný klient DNS sa použije (pokiaľ je k dispozícii).

      Ak je toto pravidlo nastavené na hodnotu False, vstavaný klient DNS sa nepoužije nikdy.

      Ak je toto pravidlo ponechané nenastavené, používatelia budú môcť ovládať používanie vstavaného klienta DNS pomocou úprav na adrese chrome://flags alebo určením príznaku v príkazovom riadku.</translation>
<translation id="2908277604670530363">Maximálny počet súčasných pripojení k serveru proxy</translation>
<translation id="556941986578702361">Ovláda nastavenie automatického skrývania poličky systému <ph name="PRODUCT_OS_NAME"/>.

      Ak je toto pravidlo nastavené na hodnotu AlwaysAutoHideShelf, polička sa bude skrývať automaticky.

      Ak je toto pravidlo nastavené na hodnotu NeverAutoHideShelf, polička sa nebude nikdy skrývať automaticky.

      Ak toto pravidlo nastavíte, používatelia ho nemôžu zmeniť ani nahradiť.

      Ak toto pravidlo ponecháte nenastavené, používatelia si môžu sami zvoliť, či sa bude polička skrývať automaticky.</translation>
<translation id="4838572175671839397">Obsahuje regulárny výraz, ktorý sa používa na určenie toho, ktorí používatelia sa môžu prihlásiť do prehliadača <ph name="PRODUCT_NAME"/>.

Ak sa používateľ pokúsi prihlásiť pomocou používateľského mena, ktoré sa nezhoduje s týmto vzorom, zobrazí sa príslušná chyba.

Ak toto pravidlo nie je nastavené alebo je prázdne, akýkoľvek používateľ sa môže prihlásiť do prehliadača <ph name="PRODUCT_NAME"/>.</translation>
<translation id="2892225385726009373">Keď je toto nastavenie povolené, <ph name="PRODUCT_NAME"/> vždy vykoná kontrolu odvolania certifikátov servera, ktoré sú úspešne overené a podpísané miestne nainštalovanými certifikátmi CA.

      Ak <ph name="PRODUCT_NAME"/> nedokáže získať informácie o stave odvolania, budú sa takéto certifikáty považovať za odvolané („ťažké zlyhanie“).

      Ak toto pravidlo nie je nastavené alebo ak je nastavené na hodnotu False, prehliadač Chrome použije existujúce nastavenia kontroly odvolania online.</translation>
<translation id="1438955478865681012">Slúži na konfiguráciu pravidiel súvisiacich s rozšíreniami. Používateľ nie je oprávnený inštalovať rozšírenia uvedené v zozname zakázaných rozšírení, ak sa nenachádzajú v zozname povolených rozšírení. V aplikácii <ph name="PRODUCT_NAME"/> môžete tiež vynútiť automatickú inštaláciu rozšírení, a to tak, že rozšírenia zadáte do zoznamu <ph name="EXTENSIONINSTALLFORCELIST_POLICY_NAME"/>. Zoznam zakázaných rozšírení má pred týmto zoznamom prioritu.</translation>
<translation id="3516856976222674451">Obmedzuje maximálnu dĺžku relácie používateľa.

      Keď je toto pravidlo nastavené, stanovuje maximálny čas, po uplynutí ktorého bude používateľ automaticky odhlásený a relácia sa ukončí. Používateľa o zostávajúcom čase informuje časovač na systémovom paneli.

      Ak toto pravidlo nastavené nie je, dĺžka relácie nie je obmedzená.

      Ak toto pravidlo nastavíte, používatelia ho nemôžu zmeniť ani nahradiť.

      Hodnota pravidla by mala byť uvedená v milisekundách. Hodnoty musia byť v rozsahu od 30 sekúnd do 24 hodín.</translation>
<translation id="9200828125069750521">Parametre pre adresu URL obrázkov, ktorá používa metódu POST</translation>
<translation id="2769952903507981510">Konfigurácia povinného názvu domény pre hostiteľov vzdialeného prístupu</translation>
<translation id="8294750666104911727">Stránky s prvkom X-UA-Compatible nastaveným na hodnotu chrome=1 sa obvykle vykreslia v rámci služby <ph name="PRODUCT_FRAME_NAME"/> bez ohľadu na pravidlo ChromeFrameRendererSettings.

          Ak toto nastavenie povolíte, na stránkach sa nebudú hľadať metaznačky.

          Ak toto nastavenie zakážete, na stránkach sa budú hľadať metaznačky.

          Ak toto pravidlo nenastavíte, na stránkach sa budú hľadať metaznačky.</translation>
<translation id="3478024346823118645">Vymazať údaje používateľa po odhlásení</translation>
<translation id="8668394701842594241">Určuje zoznam povolených doplnkov prehliadača <ph name="PRODUCT_NAME"/> a bráni používateľom toto nastavenie zmeniť.

      Ako zástupné znaky je možné použiť znaky „*“ a „?“. Znak „*“ slúži ako zástupný znak pre ľubovoľný počet znakov, zatiaľ čo znak „?“ určuje jeden voliteľný znak (môže teda zastupovať jeden ľubovoľný znak alebo chýbajúci znak). Znak zrušenia významu je „\“, takže ak chcete zadať samotné znaky „*“, „?“ alebo „\“, stačí pred ne umiestniť znak „\“.

      Uvedený zoznam doplnkov je v prehliadači <ph name="PRODUCT_NAME"/> použitý vždy, keď sú doplnky nainštalované. Doplnky sú v príkaze „about:plugins“ označené ako povolené a používatelia ich nemôžu zakázať. 

      Toto pravidlo nahrádza pravidlá DisabledPlugins a DisabledPluginsExceptions. 

      Ak toto pravidlo ponecháte nenastavené, používateľ môže zakázať ľubovoľný doplnok nainštalovaný v systéme.</translation>
<translation id="653608967792832033">Určuje dobu nečinnosti používateľa, po ktorej sa obrazovka pri napájaní z batérie uzamkne.

          Ak je toto pravidlo nastavené na hodnotu väčšiu ako nula, určuje dobu nečinnosti používateľa, po ktorej systém <ph name="PRODUCT_OS_NAME"/> obrazovku uzamkne.

          Ak je toto pravidlo nastavené na hodnotu nula, systém <ph name="PRODUCT_OS_NAME"/> neuzamkne obrazovku ani počas nečinnosti používateľa.

          Ak toto pravidlo nastavené nie je, použije sa predvolená doba.

          Odporúčaným spôsobom uzamknutia obrazovky pri nečinnosti je uzamknutie obrazovky v režime spánku a nastavenie doby, po uplynutí ktorej systém <ph name="PRODUCT_OS_NAME"/> prejde do režimu spánku. Toto pravidlo by sa malo používať len v prípade, ak chcete obrazovku uzamknúť oveľa skôr, než dôjde k prechodu do režimu spánku alebo ak nechcete režim spánku používať vôbec.

          Hodnota pravidla by mala byť uvedená v milisekundách. Hodnoty musia byť nižšie ako oneskorenie režimu nečinnosti.</translation>
<translation id="4157003184375321727">Hlásiť verziu operačného systému a firmvéru</translation>
<translation id="4752214355598028025">Keď používateľ prejde na stránky, ktoré sú nahlásené ako potenciálne škodlivé, služba Bezpečné prehliadanie zobrazí stránku s upozornením. Povolenie tohto nastavenia zabráni používateľom pokračovať zo stránky s upozornením na škodlivé stránky.

      Ak je toto nastavenie zakázané alebo ak nie je nakonfigurované, používatelia môžu pokračovať na nahlásené stránky aj po zobrazení upozornenia.</translation>
<translation id="5255162913209987122">Odporúča sa</translation>
<translation id="1861037019115362154">Určuje zoznam zakázaných doplnkov aplikácie <ph name="PRODUCT_NAME"/> a bráni používateľom toto nastavenie zmeniť.

      Ako zástupné znaky je možné použiť znaky „*“ a „?“. Znak „*“ slúži ako zástupný znak pre ľubovoľný počet znakov, zatiaľ čo znak „?“ určuje jeden voliteľný znak (môže teda zastupovať jeden ľubovoľný znak alebo znak chýbajúci). Znak zrušenia významu je „\“, takže ak chcete zadať samotné znaky „*“, „?“ alebo „\“, stačí pred nich umiestniť znak „\“.

      Ak toto nastavenie povolíte, doplnky uvedené v zozname nebudú v aplikácii <ph name="PRODUCT_NAME"/> nikdy použité. V príkaze „about:plugins“ sa doplnky zobrazia ako zakázané a používatelia ich nebudú môcť aktivovať.

      Toto pravidlo je možné nahradiť pravidlami EnabledPlugins a DisabledPluginsExceptions.

      Ak toto pravidlo ponecháte nenastavené, používateľ bude môcť použiť ľubovoľný doplnok nainštalovaný v systéme okrem doplnkov, ktoré sú nekompatibilne zakódované, zastarané alebo nebezpečné.</translation>
<translation id="9197740283131855199">Percentuálna hodnota, o ktorú sa predĺži oneskorenie stmavenia obrazovky, keď sa zaznamená aktivita používateľa po stmavení obrazovky</translation>
<translation id="1492145937778428165">Určuje interval v milisekundách, v ktorom sa budú službe správy zariadenia odosielať informačné žiadosti o pravidlách pre zariadenie.

      Nastavením tohto pravidla sa nahradí predvolená hodnota 3 hodiny. Platné hodnoty pre toto pravidlo sa pohybujú v rozmedzí od 1 800 000 (30 minút) do 86 400 000 (1 deň). Ak zadáte hodnoty mimo tento rozsah, použije sa príslušná medzná hodnota.

      Ak toto pravidlo ponecháte nenastavené, systém <ph name="PRODUCT_OS_NAME"/> použije predvolenú hodnotu 3 hodiny.</translation>
<translation id="3765260570442823273">Doba zobrazenia správy s upozornením na odhlásenie  z dôvodu nečinnosti</translation>
<translation id="7302043767260300182">Oneskorenie uzamknutia obrazovky pri používaní napájacieho zdroja</translation>
<translation id="7331962793961469250">Ak je nastavená možnosť True, na stránke Nová karta sa nezobrazia propagácie aplikácií v Internetovom obchode Chrome.

      Ak ju nastavíte na možnosť False alebo ju ponecháte nenastavenú, propagácie aplikácií v Internetovom obchode Chrome sa na stránke Nová karta budú zobrazovať</translation>
<translation id="7271085005502526897">Import domovskej stránky z predvoleného prehliadača pri prvom spustení</translation>
<translation id="6036523166753287175">Povoliť prechod cez bránu firewall v smere od hostiteľa vzdialeného prístupu</translation>
<translation id="1096105751829466145">Predvolený poskytovateľ vyhľadávania</translation>
<translation id="7567380065339179813">Povoliť doplnky na týchto stránkach</translation>
<translation id="4555850956567117258">Povoliť pre používateľa vzdialené overenie</translation>
<translation id="5966615072639944554">Rozšírenia s povolením používať vzdialené overenie API</translation>
<translation id="1617235075406854669">Povoliť odstránenie histórie prehliadača a preberania</translation>
<translation id="5290940294294002042">Určiť zoznam doplnkov, ktoré môže používateľ povoliť alebo zakázať</translation>
<translation id="3153348162326497318">Umožňuje určiť rozšírenia, ktoré používatelia NEMÔŽU nainštalovať. Ak sa v zozname zakázaných rozšírení vyskytuje rozšírenie, ktoré už bolo nainštalované, bude odstránené.

          Ak je v zozname uvedená hodnota „*“, znamená to, že sú zakázané všetky rozšírenia, ktoré nie sú explicitne uvedené v zozname povolených rozšírení.

          Ak toto pravidlo ponecháte nenastavené, používateľ bude môcť do prehliadača <ph name="PRODUCT_NAME"/> inštalovať ľubovoľné rozšírenia.</translation>
<translation id="3067188277482006117">Ak je pravidlo nastavené na hodnotu True, používateľ môže používať hardvér zariadení Chrome na diaľkové overenie svojej identity pre autoritu CA ochrany údajov prostredníctvom metódy chrome.enterprise.platformKeysPrivate.challengeUserKey() rozhrania Enterprise Platform Keys API.

          Ak je hodnota pravidla nastavená na možnosť False alebo pravidlo nie je nastavené vôbec, volania rozhrania API zlyhajú a nahlásia kód chyby.</translation>
<translation id="5809728392451418079">Nastaviť zobrazovaný názov pre miestne účty na zariadení</translation>
<translation id="1427655258943162134">Adresa alebo adresa URL servera proxy</translation>
<translation id="1827523283178827583">Použiť fixné servery proxy</translation>
<translation id="3021409116652377124">Zakázať nástroj na hľadanie doplnkov</translation>
<translation id="7236775576470542603">Nastaví predvolený typ lupy obrazovky, ktorý je povolený na prihlasovacej obrazovke.

          Ak je toto pravidlo nastavené, ovláda typ lupy obrazovky, ktorý je povolený pri zobrazení prihlasovacej obrazovky. Nastavenie pravidla na možnosť Žiadne zakáže lupy obrazovky.

          Ak toto pravidlo nastavíte, používatelia ho budú môcť dočasne prepísať povolením alebo zakázaním lupy obrazovky. Voľba používateľa však nie je trvalá a predvolené nastavenie sa obnoví zakaždým, keď sa znova zobrazí prihlasovacia obrazovka alebo používateľ bude na prihlasovacej obrazovke nečinný po dobu jednej minúty.

          Ak toto pravidlo ponecháte nenastavené, bude lupa obrazovky pri prvom zobrazení prihlasovacej obrazovky zakázaná. Používatelia budú môcť lupu obrazovky kedykoľvek povoliť alebo zakázať a jej stav na prihlasovacej obrazovke sa zachová aj po zmene používateľov.</translation>
<translation id="5423001109873148185">Ak je toto pravidlo povolené, vyhľadávacie nástroje budú importované z aktuálneho predvoleného prehliadača. Povolenie tohto pravidla má vplyv aj na dialógové okno importu.

      Ak je zakázané, predvolený vyhľadávací nástroj nebude importovaný.

      Ak nie je nastavené, môže sa používateľovi zobraziť výzva, či chce vyhľadávací nástroj importovať, alebo môže import prebehnúť automaticky.</translation>
<translation id="3288595667065905535">Kanál verzie</translation>
<translation id="2785954641789149745">Povolí funkciu Bezpečné prehliadanie prehliadača <ph name="PRODUCT_NAME"/> a zabráni používateľom zmeniť toto nastavenie.

      Ak toto nastavenie povolíte, bude Bezpečné prehliadanie vždy zapnuté.

      Ak toto nastavenie zakážete, bude Bezpečné prehliadanie vždy vypnuté.

      Ak toto pravidlo povolíte alebo zakážete, používatelia ho pomocou nastavenia „Povoliť ochranu pred phishingom a škodlivým softvérom“ v prehliadači <ph name="PRODUCT_NAME"/> nebudú môcť zmeniť.

      Ak toto pravidlo ponecháte nenastavené, funkcia bude povolená, ale používateľ to bude môcť zmeniť.</translation>
<translation id="268577405881275241">Povoliť funkciu servera proxy na kompresiu údajov</translation>
<translation id="8369602308428138533">Oneskorenie vypnutia obrazovky pri používaní napájacieho zdroja</translation>
<translation id="6513756852541213407">Umožňuje určiť server proxy, ktorý bude prehliadač <ph name="PRODUCT_NAME"/> používať, a bráni používateľom zmeniť nastavenia servera proxy.

          Ak sa rozhodnete server proxy vôbec nepoužívať a vždy sa pripájať priamo, všetky ostatné možnosti budú ignorované.

          Ak sa rozhodnete používať systémové nastavenia servera proxy alebo server proxy zisťovať automaticky, všetky ostatné možnosti budú ignorované.

          Ak zvolíte režim pevne daného servera proxy, môžete zvoliť ďalšie možnosti v častiach „Adresa alebo adresa URL servera proxy“ a „Zoznam pravidiel vynechania servera proxy oddelených čiarkami“.

          Ak sa rozhodnete použiť skript PAC servera proxy, je potrebné zadať v časti „Adresa URL súboru PAC servera proxy“ adresu URL.

          Podrobné príklady nájdete na tejto adrese:
          <ph name="PROXY_HELP_URL"/>

          Ak toto nastavenie povolíte, prehliadač <ph name="PRODUCT_NAME"/> bude ignorovať všetky možnosti týkajúce sa serverov proxy zadané pomocou príkazového riadka.

          Ak toto pravidlo ponecháte nenastavené, umožní to používateľom zvoliť si nastavenia proxy samostatne.</translation>
<translation id="7763311235717725977">Umožňuje vám nastaviť, či môžu webové stránky zobrazovať obrázky. Zobrazovanie obrázkov môže byť buď pre všetky webové stránky umožnené, alebo pre všetky webové stránky zamietnuté.

          Ak toto pravidlo ponecháte nenastavené, použije sa pravidlo „AllowImages“ a používateľ ho bude môcť zmeniť.</translation>
<translation id="5630352020869108293">Obnoviť poslednú reláciu</translation>
<translation id="2067011586099792101">Blokovať prístup ku stránkam mimo balíkov obsahu</translation>
<translation id="4980635395568992380">Typ údajov:</translation>
<translation id="3096595567015595053">Zoznam povolených doplnkov</translation>
<translation id="3048744057455266684">Ak je toto pravidlo nastavené a adresa URL vyhľadávania navrhnutá vo všeobecnom poli obsahuje tento parameter v reťazci dopytu alebo v identifikátore fragmentu, potom odporúčanie zobrazí hľadané výrazy a poskytovateľa vyhľadávania namiesto nespracovanej adresy URL vyhľadávania.

          Toto pravidlo je voliteľné. Ak nie je nastavené, nedôjde k žiadnej výmene hľadaných výrazov.

          Toto pravidlo sa rešpektuje len vtedy, ak je povolené pravidlo DefaultSearchProviderEnabled.</translation>
<translation id="5912364507361265851">Umožňuje používateľom zobraziť heslá v Správcovi hesiel</translation>
<translation id="510186355068252378">Zakazuje v prehliadači <ph name="PRODUCT_NAME"/> synchronizáciu údajov pomocou služieb synchronizácie hostených spoločnosťou Google a bráni používateľom toto nastavenie zmeniť.

      Ak toto nastavenie povolíte, používatelia ho v prehliadači <ph name="PRODUCT_NAME"/> nebudú môcť zmeniť ani prepísať.

      Ak toto pravidlo ponecháte nenastavené, Synchronizácia Google bude pre používateľov k dispozícii a zvolia si, či ju chcú alebo nechcú použiť.</translation>
<translation id="7953256619080733119">Spravované výnimky hostiteľov ručne nastavené používateľom</translation>
<translation id="7412982067535265896">Umožňuje vám nastaviť zoznam vzorov adries URL, pomocou ktorého určíte stránky, ktoré majú povolenie na nastavenie súborov cookie iba na jednu reláciu.

          Ak toto nastavenie ponecháte nenastavené, pre všetky stránky sa použije globálna predvolená hodnota, ktorá je určená buď pravidlom „DefaultCookiesSetting“ (ak je nastavené) alebo iným typom konfigurácie používateľa.

          Ak je pravidlo „RestoreOnStartup“ nastavené tak, aby sa obnovili adresy URL z predchádzajúcej relácie, nebude dodržané a súbory cookie pre príslušné stránky budú uložené trvalo.</translation>
<translation id="4807950475297505572">Odstránia sa najdlhšie neprihlásení používatelia, dokým sa neuvoľní dostatok voľného miesta</translation>
<translation id="8828766846428537606">Nakonfiguruje v prehliadači <ph name="PRODUCT_NAME"/> predvolenú domovskú stránku a zabráni ju používateľom zmeniť. Nastavenia domovskej stránky používateľa sú úplne uzamknuté len vtedy, ak nastavíte domovskú stránku na stránku Nová karta alebo na vopred určenú adresu URL domovskej stránky. Ak túto adresu URL neurčíte, používateľ bude stále môcť nastaviť domovskú stránku na stránku Nová karta pomocou príkazu „chrome://newtab“.</translation>
<translation id="2231817271680715693">Importovať históriu prehliadania z predvoleného prehliadača pri prvom spustení</translation>
<translation id="1353966721814789986">Stránky pri spustení</translation>
<translation id="7173856672248996428">Efemérny profil</translation>
<translation id="1841130111523795147">Umožní používateľovi prihlásiť sa do služby <ph name="PRODUCT_NAME"/> a zabraňuje používateľom toto nastavenie zmeniť.

      Ak toto pravidlo nastavíte, môžete nakonfigurovať, či má používateľ povolenie na prihlásenie do služby <ph name="PRODUCT_NAME"/>, alebo nemá.</translation>
<translation id="5564962323737505851">Konfiguruje správcu hesiel. Ak je správca hesiel povolený, môžete povoliť alebo zakázať, či môže používateľ uchovávať heslá formou čitateľného textu.</translation>
<translation id="4668325077104657568">Predvolené nastavenie obrázkov</translation>
<translation id="4492287494009043413">Zákaz zaznamenávania snímok obrazovky</translation>
<translation id="6368403635025849609">Povoliť jazyk JavaScript na týchto stránkach</translation>
<translation id="6074963268421707432">Nepovoliť žiadnym stránkam zobrazovať upozornenia na pracovnej ploche</translation>
<translation id="8614804915612153606">Zakáže automatickú aktualizáciu</translation>
<translation id="4834526953114077364">Odstránia sa najdlhšie neprihlásení používatelia (ktorí sa neprihlásili za posledné 3 mesiace), dokým sa neuvoľní dostatok voľného miesta</translation>
<translation id="382476126209906314">Konfigurácia predpony TalkGadget pre hostiteľov vzdialeného prístupu</translation>
<translation id="6561396069801924653">Zobraziť možnosti zjednodušenia prístupu v ponuke systémovej lišty</translation>
<translation id="8104962233214241919">Automaticky vybrať certifikáty klienta pre tieto webové stránky</translation>
<translation id="2906874737073861391">Zoznam rozšírení AppPack</translation>
<translation id="3758249152301468420">Zakázať Nástroje pre vývojárov</translation>
<translation id="8665076741187546529">Konfigurovať zoznam vynútene nainštalovaných rozšírení</translation>
<translation id="410478022164847452">Určuje dobu nečinnosti používateľa, po ktorej systém vykoná príslušnú akciu nečinnosti pri používaní napájacieho zdroja.

          Ak je toto pravidlo nastavené, určuje dobu nečinnosti používateľa, po ktorej systém <ph name="PRODUCT_OS_NAME"/> vykoná príslušnú akciu, ktorú je možné nakonfigurovať samostatne.

          Ak toto pravidlo nastavené nie je, použije sa predvolená doba.

          Hodnota pravidla by mala byť uvedená v milisekundách.</translation>
<translation id="1675391920437889033">Kontroluje, inštalácia ktorých typov aplikácií/rozšírení je povolená.

          Toto nastavenie pridáva na zoznam povolených položiek typy aplikácií/rozšírení, ktorých inštalácia je v prehliadači <ph name="PRODUCT_NAME"/> povolená. Hodnota predstavuje zoznam reťazcov, pričom by malo ísť o niektoré z týchto reťazcov: &quot;extension&quot;, &quot;theme&quot;, &quot;user_script&quot;, &quot;hosted_app&quot;, &quot;legacy_packaged_app&quot;, &quot;platform_app&quot;. Viac informácií o týchto typoch nájdete v dokumentácii k rozšíreniam prehliadača Chrome.

          Upozorňujeme, že toto pravidlo má vplyv aj na rozšírenia a aplikácie, ktorých inštalácia bude vynútená prostredníctvom príkazu ExtensionInstallForcelist.

          Ak je toto nastavenie nakonfigurované, typy rozšírení / aplikácií, ktoré nie sú na zozname, sa nenainštalujú.

          Ak je toto nastavenie ponechané nenakonfigurované, nebudú sa vynucovať žiadne obmedzenia týkajúce sa prijateľných typov rozšírení/aplikácií.</translation>
<translation id="6378076389057087301">Určuje, či prehrávanie zvuku ovplyvňuje správu napájania</translation>
<translation id="8818173863808665831">Nahlási geografickú polohu zariadenia.

      Ak toto pravidlo nie je nastavené alebo je nastavené na hodnotu false, poloha sa nahlasovať nebude.</translation>
<translation id="4899708173828500852">Povoliť Bezpečné prehliadanie</translation>
<translation id="4442582539341804154">Povoliť zámok, ak je zariadenie nečinné alebo pozastavené</translation>
<translation id="7719251660743813569">Určuje, či sa budú spoločnosti Google spätne nahlasovať metriky používania. Ak je pravidlo nastavené na hodnotu true, systém <ph name="PRODUCT_OS_NAME"/> bude nahlasovať metriky používania. Ak nie je nakonfigurované alebo je nastavené na hodnotu false, nahlasovanie metrík bude zakázané.</translation>
<translation id="2372547058085956601">Oneskorenie automatického prihlásenia do verejnej relácie.

      Ak nie je nastavené pravidlo |DeviceLocalAccountAutoLoginId|, nebude mať toto pravidlo žiadny vplyv. V opačnom prípade platí:

      Ak je toto pravidlo nastavené, určuje časové obdobie bez aktivity používateľa, ktoré musí uplynúť pred automatickým prihlásením do verejnej relácie stanovenej pravidlom |DeviceLocalAccountAutoLoginId|.

      Ak pravidlo nie je nastavené, použije sa pre časový limit hodnota 0 milisekúnd.

      Pravidlo sa stanovuje v milisekundách.</translation>
<translation id="7275334191706090484">Spravované záložky</translation>
<translation id="3570008976476035109">Blokovať doplnky na týchto stránkach</translation>
<translation id="8749370016497832113">Povolí v prehliadači <ph name="PRODUCT_NAME"/> odstránenie histórie prehliadača a preberania a zabraňuje používateľom toto nastavenie zmeniť.

      Aj keď je toto pravidlo zakázané, nedá sa zaručiť, že sa história prehliadania a preberania zachová: používatelia môžu súbory upravovať alebo odstraňovať priamo v databáze histórie a tiež prehliadač môže niektoré alebo všetky položky histórie kedykoľvek vymazať alebo uložiť do archívu.

      Ak je nastavenie povolené alebo nie je nastavené, história prehliadania a preberania sa dá odstrániť.

      Ak je nastavenie zakázané, história prehliadania a preberania sa odstrániť nedá.</translation>
<translation id="2884728160143956392">Povoliť na týchto stránkach súbory cookie platné len pre reláciu</translation>
<translation id="3021272743506189340">Ak je pravidlo nastavené na hodnotu True, zakáže v aplikácií Súbory systému OS Chrome synchronizáciu služby Disk Google pri používaní mobilného pripojenia. V tomto prípade sa budú údaje v službe Disk Google synchronizovať iba pri pripojení k sieti Wi-Fi alebo Ethernet.

          Ak je hodnota funkcie nastavená na možnosť False, používatelia budú môcť prenášať súbory do služby Disk Google prostredníctvom mobilných pripojení.</translation>
<translation id="4655130238810647237">Povoľuje alebo zakazuje úpravu záložiek v prehliadači <ph name="PRODUCT_NAME"/>.

      Ak toto nastavenie povolíte, bude možné záložky pridávať, odstraňovať alebo upravovať. Toto je predvolené nastavenie aj v prípade, ak bude toto pravidlo nenastavené.

      Ak ho zakážete, záložky nebude možné pridávať, odstraňovať ani upravovať. Existujúce záložky budú stále k dispozícii.</translation>
<translation id="3496296378755072552">Správca hesiel</translation>
<translation id="4372704773119750918">Nepovoliť podnikovému používateľovi byť súčasťou viacnásobného profilu (primárneho ani sekundárneho)</translation>
<translation id="2565967352111237512">Povoľuje funkciu anonymného hlásenia údajov týkajúcich sa používania a zlyhaní prehliadača <ph name="PRODUCT_NAME"/> spoločnosti Google a bráni používateľom toto nastavenie zmeniť.

      Ak toto nastavenie povolíte, spoločnosti Google budú odosielané anonymné správy týkajúce sa používania alebo zlyhaní.

      Ak toto nastavenie zakážete, anonymné správy týkajúce sa používania alebo zlyhania spoločnosti Google odosielané nebudú.

      Ak toto nastavenie povolíte alebo zakážete, používatelia ho v prehliadači <ph name="PRODUCT_NAME"/> nebudú môcť zmeniť ani prepísať.

      Ak toto pravidlo ponecháte nenastavené, nastaví sa to, čo používateľ zvolí počas inštalácie alebo pri prvom spustení.</translation>
<translation id="4784220343847172494">Ovláda správanie automatického čistenia na zariadeniach so systémom <ph name="PRODUCT_OS_NAME"/>. Automatické čistenie sa spustí s cieľom uvoľniť miesto na disku, keď množstvo voľného miesta dosiahne kritickú úroveň.

      Ak sa toto pravidlo nastaví na hodnotu RemoveLRU, automatické čistenie bude odstraňovať používateľov zo zariadenia v poradí od najdlhšie neprihláseného používateľa, dokým sa neuvoľní dostatok voľného miesta.

      Ak sa toto pravidlo nastaví na hodnotu RemoveLRUIfDormant, automatické čistenie bude odstraňovať používateľov, ktorí sa neprihlásili aspoň 3 mesiace v poradí od najdlhšie neprihláseného používateľa, dokým sa neuvoľní dostatok voľného miesta.

      Ak sa toto pravidlo nenastaví, automatické čistenie použije predvolenú vstavanú stratégiu, ktorá v súčasnosti predstavuje stratégiu RemoveLRUIfDormant.</translation>
<translation id="6256787297633808491">Príznaky v celom systéme, ktoré sa používajú pri spúšťaní prehliadača Chrome</translation>
<translation id="2516600974234263142">Umožňuje tlač v službe <ph name="PRODUCT_NAME"/> a zabraňuje používateľom zmeniť toto nastavenie.

      Ak je toto nastavenie povolené alebo nie je nakonfigurované, používatelia môžu tlačiť.

      Ak je toto nastavenie zakázané, používatelia v službe <ph name="PRODUCT_NAME"/> tlačiť nemôžu. Tlač je zakázaná v ponuke nástrojov, rozšíreniach, aplikáciách jazyka JavaScript a pod. Tlačiť môžete z doplnkov, ktoré pri tlači službu <ph name="PRODUCT_NAME"/> obchádzajú. Niektoré aplikácie Flash majú napríklad možnosť tlače v kontextovej ponuke, na ktoré sa tieto pravidlá nevzťahujú.</translation>
<translation id="9135033364005346124">Povoliť server proxy <ph name="CLOUD_PRINT_NAME"/></translation>
<translation id="4519046672992331730">Vo všeobecnom poli prehliadača <ph name="PRODUCT_NAME"/> povolí funkciu návrhov pre vyhľadávanie a bráni používateľom toto nastavenie zmeniť.

      Ak toto nastavenie povolíte, budú sa zobrazovať návrhy pre vyhľadávanie.

      Ak toto nastavenie zakážete, návrhy pre vyhľadávanie sa nikdy nezobrazia.

      Ak toto nastavenie povolíte alebo zakážete, používatelia ho v prehliadači <ph name="PRODUCT_NAME"/> nebudú môcť zmeniť ani prepísať.

      Ak toto pravidlo ponecháte nenastavené, povolí sa, no používateľ ho bude môcť zmeniť.</translation>
<translation id="6943577887654905793">Názov predvoľby v systéme Mac/Linux:</translation>
<translation id="6925212669267783763">Umožňuje nakonfigurovať adresár, ktorý prehliadač <ph name="PRODUCT_FRAME_NAME"/> použije na ukladanie údajov používateľa.

      Ak toto pravidlo nastavíte, prehliadač <ph name="PRODUCT_FRAME_NAME"/> bude používať zadaný adresár.

      Zoznam premenných, ktoré sa dajú použiť, nájdete na stránke http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables (iba v angličtine).

      Ak toto nastavenie ponecháte nenastavené, použije sa predvolený adresár profilu.</translation>
<translation id="8906768759089290519">Povoliť režim hosťa</translation>
<translation id="2168397434410358693">Oneskorenie režimu nečinnosti pri používaní napájacieho zdroja</translation>
<translation id="838870586332499308">Povoliť roaming pre dátové prenosy</translation>
<translation id="3234167886857176179">Toto je zoznam pravidiel, ktoré <ph name="PRODUCT_NAME"/> rešpektuje.

      Tieto nastavenia nemusíte meniť ručne! Prevezmite si šablóny na jednoduché použitie zo stránok
      <ph name="POLICY_TEMPLATE_DOWNLOAD_URL"/>.

      Zoznam podporovaných pravidiel je rovnaký pre prehliadače Chromium aj Google Chrome.

      Tieto pravidlá sú prísne určené na použitie pri konfigurovaní prehliadačov Chrome vnútri vašej organizácie. Použitie týchto pravidiel mimo vašej organizácie (napríklad vo verejne distribuovanom programe) nie je povolené a programy môžu byť službou Google a dodávateľmi antivírusového softvéru označené ako škodlivý softvér.

      Poznámka: Od verzie 28 prehliadača Chrome sa pravidlá načítajú v systéme Windows priamo z rozhrania API Group Policy. Pravidlá, ktoré sú ručne zapísané do databázy Registry, sa budú ignorovať. Podrobnosti nájdete na adrese http://crbug.com/259236.</translation>
<translation id="2292084646366244343"><ph name="PRODUCT_NAME"/> môže na opravu pravopisných chýb používať webovú službu spoločnosti Google. Ak je toto nastavenie povolené, služba sa používa neustále. Ak je nastavenie zakázané, služba sa nepoužíva nikdy.

      Kontrolu pravopisu je stále možné vykonať pomocou prevzatého slovníka. Toto pravidlo sa vzťahuje iba na používanie služieb online.

      Ak toto nastavenie nie je nakonfigurované, používatelia môžu zvoliť, či službu na kontrolu pravopisu chcú použiť alebo nie.</translation>
<translation id="8782750230688364867">Určuje percentuálnu hodnotu, o ktorú sa predĺži oneskorenie stmavenia obrazovky, keď je zariadenie v režime prezentácie.

          Ak je toto pravidlo nastavené, určuje percentuálnu hodnotu, o ktorú sa predĺži oneskorenie stmavenia obrazovky, keď je zariadenie v režime prezentácie. Po predĺžení oneskorenia stmavenia obrazovky sa oneskorenia pre vypnutie, uzamknutie a nečinnosť obrazovky prispôsobia tak, aby si zachovali rovnaké odstupy od stmavenia obrazovky ako pri pôvodnej konfigurácii.

          Ak je toto pravidlo nenastavené, použije sa predvolený škálovací faktor.

          Škálovací faktor musí mať hodnotu aspoň 100 %. Hodnoty, ktoré by oneskorenie stmavenia obrazovky v režime prezentácie skrátili na dobu kratšiu ako je bežné oneskorenie stmavenia obrazovky, nie sú povolené.</translation>
<translation id="254524874071906077">Nastaviť Chrome ako predvolený prehliadač</translation>
<translation id="8764119899999036911">Určuje, či bude vygenerovaný hlavný názov služby protokolu Kerberos založený na kanonickom názve DNS alebo na pôvodnom zadanom názve.

          Ak toto nastavenie povolíte, vyhľadávanie záznamov CNAME sa preskočí a použije sa zadaný názov servera.

          Ak toto nastavenie zakážete alebo ho ponecháte nenastavené, kanonický názov servera sa určí prostredníctvom vyhľadávania záznamov CNAME.</translation>
<translation id="5056708224511062314">Lupa obrazovky je vypnutá</translation>
<translation id="4377599627073874279">Povoliť všetkým stránkam zobrazovať obrázky</translation>
<translation id="7195064223823777550">Určuje, aká akcia sa má vykonať, keď používateľ zavrie veko.

          Ak je toto pravidlo nastavené, určuje akciu, ktorú systém <ph name="PRODUCT_OS_NAME"/> vykoná, keď používateľ zavrie veko.

          Ak toto pravidlo nastavené nie je, vykoná sa predvolená akcia, ktorou je režim spánku.

          Ak zvolíte prechod do režimu spánku, môžete nastaviť, či má systém <ph name="PRODUCT_OS_NAME"/> pred prechodom do režimu spánku obrazovku uzamknúť alebo nie.</translation>
<translation id="3915395663995367577">Adresa URL súboru PAC servera proxy</translation>
<translation id="2144674628322086778">Povoliť podnikovému používateľovi byť súčasťou primárneho aj sekundárneho viacnásobného profilu (predvolené správanie)</translation>
<translation id="1022361784792428773">ID rozšírení, ktorých inštalácia by mala byť používateľovi zakázaná (alebo hodnota * pre všetky)</translation>
<translation id="5499375345075963939">Toto pravidlo je aktívne iba v režime predaja.

      Keď je hodnota pravidla nastavená a nerovná sa 0, aktuálne prihlásený používateľ ukážky bude automaticky odhlásený po uplynutí zadanej dĺžky nečinnosti.

      Hodnota pravidla musí byť zadaná v milisekundách.</translation>
<translation id="7683777542468165012">Obnovenie dynamického pravidla</translation>
<translation id="1160939557934457296">Zakázať pokračovanie zo stránky s upozornením Bezpečného prehliadania</translation>
<translation id="8987262643142408725">Zakázať delenie záznamov protokolu SSL</translation>
<translation id="4529945827292143461">Prispôsobte si zoznam vzorov adries URL, ktoré by mali byť vždy vykresľované hostiteľským prehliadačom.

          Ak toto pravidlo nenastavíte, pre všetky webové stránky sa použije predvolený vykresľovací modul (ako je určené pravidlom „ChromeFrameRendererSettings“).

          Príklady vzorov nájdete na stránke http://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="8044493735196713914">Hlásiť režim spustenia zariadenia</translation>
<translation id="2746016768603629042">Podpora tohto pravidla je ukončená. Použite namiesto neho pravidlo DefaultJavaScriptSetting.

      Umožňuje zakázať jazyk JavaScript v prehliadači <ph name="PRODUCT_NAME"/>.

      Ak je toto nastavenie zakázané, webové stránky nebudú môcť používať jazyk JavaScript a používateľ toto nastavenie nebude môcť zmeniť.

      Ak toto pravidlo ponecháte nenastavené, webové stránky budú môcť používať jazyk JavaScript, ale používateľ bude môcť toto nastavenie zmeniť.</translation>
<translation id="1942957375738056236">Tu môžete zadať adresu URL servera proxy.

          Toto pravidlo sa prejaví len v prípade, ak ste v časti „Zvoľte spôsob konfigurácie nastavení servera proxy“ zvolili ručné nastavenia servera proxy.

          Ak ste zvolili akýkoľvek iný režim nastavenia pravidiel proxy, mali by ste toto pravidlo ponechať nenastavené.

          Viac možností a podrobné príklady nájdete na adrese:
          <ph name="PROXY_HELP_URL"/></translation>
<translation id="6076008833763548615">Zakazuje pripojenie externého ukladacieho priestoru.

      Ak je toto pravidlo nastavené na hodnotu True, externý ukladací priestor sa nezobrazí v prehliadači súborov.

      Toto pravidlo sa vzťahuje na všetky typy pamäťových médií, ako sú prenosné disky USB, externé pevné disky, karty SD a ďalšie typy pamäťových kariet, optické ukladacie priestory a pod. Na interný ukladací priestor sa nevzťahuje, takže súbory uložené v priečinku Prevzaté súbory je možné otvoriť. Toto pravidlo tiež nemá žiadny vplyv na službu Disk Google.

      Ak je toto nastavenie zakázané alebo nie je nakonfigurované, používatelia môžu vo svojom zariadení používať všetky podporované typy externých ukladacích priestorov.</translation>
<translation id="6936894225179401731">Určuje maximálny počet súbežných pripojení k serveru proxy.

      Niektoré servery proxy nemôžu spracovať veľký počet súbežných pripojení na jedného klienta, čo sa dá vyriešiť nastavením tohto pravidla na nižšiu hodnotu.

      Hodnota tohto pravidla by mala byť nižšia ako 100 a vyššia ako 6. Predvolená hodnota je 32.

      Niektoré webové aplikácie sú známe tým, že v dôsledku zablokovaných žiadostí GET využívajú mnoho pripojení. Zníženie hodnoty pod 32 môže viesť k zablokovaniu sieťových funkcií prehliadača v prípade, ak je otvorených príliš veľa takýchto webových aplikácií. Zníženie hodnoty pod predvolenú hodnotu je na vlastné riziko.

      Ak toto pravidlo ponecháte nenastavené, použije sa predvolená hodnota (32).</translation>
<translation id="5395271912574071439">Povoľuje zakrývanie hostiteľov vzdialeného prístupu počas nadviazaného spojenia.

          Ak je toto nastavenie povolené, fyzické zariadenia vstupu a výstupu hostiteľa budú počas prebiehajúceho vzdialeného spojenia zakázané.

          Ak je toto nastavenie zakázané alebo nenastavené, miestni aj vzdialení používatelia môžu počas zdieľania komunikovať s hostiteľom.</translation>
<translation id="4894257424747841850">Nahlásenie zoznamu používateľov zariadenia, ktorí sa nedávno prihlásili.

      Ak sa toto pravidlo nenastaví alebo sa nastaví na hodnotu False, používatelia sa nenahlásia.</translation>
<translation id="1426410128494586442">Áno</translation>
<translation id="4897928009230106190">Určuje parametre, ktoré sa použijú pri hľadaní návrhov pomocou metódy POST. Pozostáva z párov názov/hodnota oddelených čiarkami. Ak je hodnota parameter šablóny, napr. hodnota {searchTerms} v príklade vyššie, bude nahradená údajmi skutočných vyhľadávaných výrazov.

          Toto pravidlo je voliteľné. Ak nie je nastavené, žiadosť o vyhľadávanie návrhu sa odošle pomocou metódy GET.

          Toto pravidlo sa rešpektuje iba v prípade, ak je povolené pravidlo DefaultSearchProviderEnabled.</translation>
<translation id="4962195944157514011">Určuje adresu URL vyhľadávacieho nástroja používaného pri predvolenom vyhľadávaní. Adresa URL by mala obsahovať reťazec <ph name="SEARCH_TERM_MARKER"/>, ktorý bude počas posielania dopytu nahradený používateľom hľadanými výrazmi.

          Táto možnosť musí byť nastavená v prípade, že je povolené pravidlo „DefaultSearchProviderEnabled“ a bude dodržané len v takom prípade.</translation>
<translation id="6009903244351574348">Umožňuje doplnku <ph name="PRODUCT_FRAME_NAME"/> spracovávať uvedené typy obsahu.

          Ak toto pravidlo nie je nastavené, použije sa pre všetky webové stránky predvolený vykresľovací modul (ako je určené pravidlom „ChromeFrameRendererSettings“).</translation>
<translation id="3381968327636295719">V predvolenom nastavení použiť hosťovský prehliadač</translation>
<translation id="3627678165642179114">Povoliť alebo zakázať webovú službu kontroly pravopisu</translation>
<translation id="6520802717075138474">Importovať vyhľadávacie nástroje z predvoleného prehliadača pri prvom spustení</translation>
<translation id="4039085364173654945">Kontroluje, či má vnorený obsah tretej strany na stránke povolenie zobrazovať kontextové dialógové okno s protokolom HTTP Basic Auth.

          Táto funkcia je zvyčajne zakázaná kvôli ochrane pred phishingom (neoprávneným získavaním údajov). Ak toto pravidlo nie je nastavené, je zakázané a vnorenému obsahu tretej strany sa nepovolí zobrazovať kontextové dialógové okno s protokolom HTTP Basic Auth.</translation>
<translation id="4946368175977216944">Určuje príznaky, ktoré sa použijú pri spúšťaní prehliadača Chrome. Určené príznaky sa pred spustením prehliadača Chrome použijú aj na prihlasovacej obrazovke.</translation>
<translation id="7447786363267535722">Povoľuje v prehliadači <ph name="PRODUCT_NAME"/> ukladať heslá a používať uložené heslá.

          Ak toto nastavenie povolíte, prehliadač <ph name="PRODUCT_NAME"/> si môže heslá zapamätať a ponúknuť ich automaticky pri ďalšom prihlásení na stránkach.

          Ak toto nastavenie zakážete, používatelia si heslá nebudú môcť uložiť ani nebudú môcť použiť už uložené heslá.

          Ak toto nastavenie povolíte alebo zakážete, používatelia ho v prehliadači <ph name="PRODUCT_NAME"/> nebudú môcť zmeniť ani prepísať.

          Ak toto pravidlo ponecháte nenastavené, povolí sa, ale používateľ to bude môcť zmeniť.</translation>
<translation id="1138294736309071213">Toto pravidlo je aktívne iba v režime určenom pre predaj.

      Určuje čas, ktorý musí uplynúť pred zobrazením šetriča obrazovky na prihlasovacej obrazovke v režime určenom pre predaj.

      Hodnota pre toto pravidlo by mala byť zadaná v milisekundách.</translation>
<translation id="6368011194414932347">Konfigurovať adresu URL domovskej stránky</translation>
<translation id="2877225735001246144">Zakázať hľadanie záznamov CNAME pri absolvovaní overenia Kerberos</translation>
<translation id="9120299024216374976">Určuje, ktoré časové pásmo sa má v zariadení použiť. Používatelia môžu prepísať stanovené časové pásmo pre aktuálnu reláciu. Po odhlásení sa však nastaví späť na pôvodne určené časové pásmo. V prípade zadania nesprávnej hodnoty je pravidlo namiesto toho stále aktivované pomocou možnosti GMT. Ak reťazec zostane prázdny, bude sa pravidlo ignorovať.

      Ak sa toto pravidlo nepoužíva, aktuálne aktívne časové pásmo zostane platné aj naďalej. Používatelia ho však môžu zmeniť a zmena bude trvalá. Zmena jedným používateľom preto ovplyvní aj prihlasovaciu obrazovku všetkých ostatných používateľov.

      Pôvodné časové pásmo v nových zariadeniach je nastavené na hodnotu US/Pacific (americký/tichomorský čas).

      Formát hodnoty je stanovený podľa názvov časových pásiem v databáze IANA Time Zone Database (pozrite si stránku http://en.wikipedia.org/wiki/List_of_tz_database_time). Väčšina časových pásiem sa konkrétne udáva ako continent/large_city (kontinent/veľké mesto) alebo ocean/large_city (oceán/veľké mesto).</translation>
<translation id="3646859102161347133">Nastavenie typu lupy obrazovky</translation>
<translation id="3528000905991875314">Povoliť alternatívne chybové stránky</translation>
<translation id="1283072268083088623">Určuje, ktoré schémy overenia totožnosti pomocou protokolu HTTP bude prehliadač <ph name="PRODUCT_NAME"/> podporovať.

          Zadať môžete hodnoty „basic“, „ntlm“ a „negotiate“. Ak chcete zadať viacero hodnôt, oddeľte ich čiarkami.

          Ak toto pravidlo ponecháte nenastavené, použijú sa všetky štyri schémy.</translation>
<translation id="4914647484900375533">Povolí funkciu Dynamické vyhľadávanie prehliadača <ph name="PRODUCT_NAME"/> a zabráni používateľom zmeniť toto nastavenie.


      Ak toto nastavenie povolíte, bude Dynamické vyhľadávanie prehliadača <ph name="PRODUCT_NAME"/> vždy zapnuté.


      Ak toto nastavenie zakážete, bude Dynamické vyhľadávanie prehliadača <ph name="PRODUCT_NAME"/> vždy vypnuté.


      Ak toto pravidlo povolíte alebo zakážete, používatelia ho nebudú môcť zmeniť.


      Ak toto pravidlo ponecháte nenastavené, používatelia si budú môcť vybrať, či chcú funkciu používať alebo nie.

      Toto nastavenie sa v prehliadači Chrome 29 a vyšších verziách už nenachádza.</translation>
<translation id="6114416803310251055">zamietnuté</translation>
<translation id="8493645415242333585">Zakázať ukladanie histórie prehliadača</translation>
<translation id="5319306267766543020">Konfiguruje správu napájania v systéme <ph name="PRODUCT_OS_NAME"/>.

      Tieto pravidlá vám umožňujú nakonfigurovať, ako sa systém <ph name="PRODUCT_OS_NAME"/> správa po určitej dobe nečinnosti používateľa.</translation>
<translation id="2747783890942882652">Konfiguruje povinný názov domény hostiteľa, ktorý bude uvedený pri hostiteľoch vzdialeného prístupu, a bráni používateľom, aby ho zmenili.

          Ak je toto nastavenie povolené, hostitelia môžu byť zdieľaní iba prostredníctvom účtov zaregistrovaných v danom názve domény.

          Ak je toto nastavenie zakázané alebo nie je nastavené, hostiteľov je možné zdieľať prostredníctvom ľubovoľného účtu.</translation>
<translation id="6417861582779909667">Umožňuje nastaviť zoznam vzorov adries URL určujúcich webové stránky, ktoré nemôžu nastavovať súbory cookie.

          Ak toto pravidlo ponecháte nenastavené, použije sa v prípade všetkých webových stránok globálna predvolená hodnota buď z pravidla „DefaultCookiesSetting“ (ak je nastavené), alebo z osobnej konfigurácie používateľa.</translation>
<translation id="5457296720557564923">Povoliť stránkam prístup ku štatistikám využitia pamäte jazykom JavaScript.

      Toto nastavenie sprístupní štatistiky pamäte z panela Profiles v Nástrojoch pre vývojárov samotnej webovej stránke.</translation>
<translation id="5776485039795852974">Opýtať sa vždy, keď chcú stránky zobrazovať upozornenia na pracovnej ploche</translation>
<translation id="5047604665028708335">Povoliť prístup ku stránkam mimo balíkov obsahu</translation>
<translation id="5052081091120171147">Ak je toto pravidlo povolené, história prehliadania bude importovaná z aktuálneho predvoleného prehliadača. Povolenie tohto pravidla má vplyv aj na dialógové okno importu.

      Ak je zakázané, história prehliadania nebude importovaná.

      Ak nie je nastavené, môže sa používateľovi zobraziť výzva, či chce históriu prehliadania importovať, alebo môže import prebehnúť automaticky.</translation>
<translation id="6786747875388722282">Rozšírenia</translation>
<translation id="7132877481099023201">Adresy URL, ktorým bude udelený prístup k zariadeniam na zaznamenávanie videa bez zobrazenia výzvy</translation>
<translation id="8947415621777543415">Nahlasovať polohu zariadenia</translation>
<translation id="1655229863189977773">Nastaviť veľkosť vyrovnávacej pamäte disku v bajtoch</translation>
<translation id="6376842084200599664">Umožňuje zadať zoznam rozšírení, ktoré sa nainštalujú na pozadí bez interakcie používateľa.

          Jednotlivé položky zoznamu predstavujú reťazec, ktorý obsahuje ID rozšírenia a adresu URL aktualizácie oddelené dvojbodkou (<ph name="SEMICOLON"/>). ID rozšírenia je reťazec 32 písmen, ktorý môžete nájsť napríklad na stránke <ph name="CHROME_EXTENSIONS_LINK"/> v režime vývojára. Adresa URL aktualizácie by mala smerovať na dokument XML s manifestom aktualizácie v súlade s návodom na stránke <ph name="LINK_TO_EXTENSION_DOC1"/>. Upozorňujeme, že adresa URL aktualizácie uvedená v tomto pravidle sa použije iba pri počiatočnej inštalácii a pri následných aktualizáciách rozšírenia sa použije aktualizovaná adresa URL uvedená v manifeste rozšírenia.

          Prehliadač <ph name="PRODUCT_NAME"/> prijme v prípade každej položky rozšírenie určené ID rozšírenia z aktualizačnej služby umiestnenej na zadanej adrese URL aktualizácie a nainštaluje ho na pozadí.

          Položka <ph name="EXTENSION_POLICY_EXAMPLE"/> napríklad nainštaluje rozšírenie <ph name="EXTENSION_POLICY_EXAMPLE_EXTENSION_NAME"/> z bežnej adresy URL aktualizácie pre Internetový obchod Chrome. Viac informácií o rozšíreniach nájdete na adrese: <ph name="LINK_TO_EXTENSION_DOC2"/>.

          Používatelia nebudú môcť odinštalovať rozšírenia, ktoré sú určené v tomto pravidle. Ak z tohto zoznamu odstránite niektoré z rozšírení, prehliadač <ph name="PRODUCT_NAME"/> ho automaticky odinštaluje. Rozšírenia uvedené v tomto zozname sa tiež automaticky pridajú na bielu listinu pre inštaláciu a nastavenie ExtensionsInstallBlacklist na ne nebude mať vplyv.

          Ak toto pravidlo ponecháte nenastavené, bude môcť používateľ v prehliadači <ph name="PRODUCT_NAME"/> nainštalovať ktorékoľvek rozšírenie.</translation>
<translation id="6899705656741990703">Automaticky zisťovať nastavenia servera proxy</translation>
<translation id="8382184662529825177">Povoliť použitie vzdialeného overenia na ochranu obsahu pre zariadenie</translation>
<translation id="7003334574344702284">Ak je toto pravidlo povolené, uložené heslá sú importované z predchádzajúceho predvoleného prehliadača. Povolenie tohto pravidla má vplyv aj na dialógové okno importu.

      Ak je zakázané, uložené heslá nebudú importované.

      Ak nie je nastavené, môže sa používateľovi zobraziť výzva, či chce uložené heslá importovať, alebo môže import prebehnúť automaticky.</translation>
<translation id="6258193603492867656">Určuje, či má generovaný hlavný názov služby protokolu Kerberos zahŕňať neštandardný port.

          Ak toto nastavenie povolíte a zadáte neštandardný port (t.j. iný port ako 80 či 443), zahrnie sa do vygenerovaného hlavného názvu služby protokolu Kerberos.

          Ak toto nastavenie zakážete alebo ho ponecháte nenastavené, port sa do vygenerovaného hlavného názvu služby protokolu Kerberos v žiadnom prípade nezahrnie.</translation>
<translation id="3236046242843493070">Vzory adries URL na povolenie zdrojov inštalácie rozšírenia, aplikácie a skriptov používateľa</translation>
<translation id="2498238926436517902">Poličku vždy skrývať automaticky</translation>
<translation id="253135976343875019">Oneskorenie upozornenia na nečinnosť pri napájaní zo siete</translation>
<translation id="480987484799365700">Ak sa povolí toto pravidlo, vynúti prepnutie profilu do efemérneho režimu. Ak sa pravidlo určí ako pravidlo pre operačný systém (napr. pravidlo GPO v systéme Windows), bude platiť pre každý profil v systéme; ak sa pravidlo nastaví ako cloudové pravidlo, bude platiť iba pre profil prihlásený pomocou spravovaného účtu.

      V tomto režime sa údaje profilu zachovajú na disku iba počas relácie používateľa. Funkcie, ako sú história prehliadania, rozšírenia a ich údaje, webové údaje, napr. súbory cookie a webové databázy, sa po zavretí prehliadača nezachovajú. To však používateľovi nezabráni ručne prevziať ľubovoľné údaje na disk, uložiť stránky a tlačiť ich.

      Ak používateľ povolil synchronizáciu, všetky tieto údaje sa zachovajú v profile synchronizácie rovnako ako v prípade bežných profilov. Režim inkognito bude tiež k dispozícii (ak ho toto pravidlo výslovne nezakáže).

      Ak sa toto pravidlo zakáže alebo ponechá nenastavené, po prihlásení sa použijú bežné profily.</translation>
<translation id="6997592395211691850">Toto pravidlo určuje, či sa pre miestne dôveryhodné ukotvenia vyžadujú kontroly OCSP/CRL online</translation>
<translation id="152657506688053119">Zoznam alternatívnych adries URL pre predvoleného poskytovateľa vyhľadávania</translation>
<translation id="8992176907758534924">Zakázať všetkým stránkam zobrazovať obrázky</translation>
<translation id="262740370354162807">Povolí odoslanie dokumentov do služby <ph name="CLOUD_PRINT_NAME"/></translation>
<translation id="7717938661004793600">Konfigurujte funkcie zjednodušenia prístupu v systéme <ph name="PRODUCT_OS_NAME"/>.</translation>
<translation id="5182055907976889880">Konfigurácia služby Disk Google v systéme <ph name="PRODUCT_OS_NAME"/>.</translation>
<translation id="8704831857353097849">Zoznam zakázaných doplnkov</translation>
<translation id="8391419598427733574">Hlásiť verziu operačného systému a firmvéru registrovaných zariadení. Ak je toto nastavenie nastavené na hodnotu True, registrované zariadenia budú pravidelne hlásiť verziu operačného systému a firmvéru. Ak nastavené nie je, alebo je nastavené na hodnotu False, informácie o verzii nebudú nahlásené.</translation>
<translation id="467449052039111439">Otvoriť zoznam adries URL</translation>
<translation id="5883015257301027298">Predvolené nastavenie súborov cookie</translation>
<translation id="5017500084427291117">Umožňuje zablokovať prístup k adresám URL uvedeným v zozname.

      Toto pravidlo bráni používateľom načítať webové stránky zo zoznamu zakázaných adries URL.

      Adresa URL má formát „schéma://hostiteľ:port/cesta“.
      Ako schému je možné zvoliť http, https alebo ftp. Blokovaný bude len zvolený typ schémy. Ak schému neuvediete, budú blokované všetky schémy.
      Hostiteľom môže byť názov hostiteľa alebo adresa IP. Blokovaná bude aj subdoména názvu hostiteľa. Ak chcete zabrániť blokovaniu subdomén, zadajte pred názov hostiteľa bodku „.“.  Špeciálny názov hostiteľa „*“ zablokuje všetky domény.
      Ako port je možné zvoliť platné číslo portu v rozpätí od 1 do 65 535. Ak port neuvediete, budú blokované všetky porty.
      Ak je určená voliteľná cesta, budú blokované iba cesty s príslušnou predponou.

      Výnimky môžu byť definované v pravidle zoznamu povolených adries URL. Počet záznamov v tomto pravidle je obmedzený na 1 000. Všetky ďalšie záznamy budú ignorované.

      Ak toto pravidlo nie je nastavené, do zoznamu zakázaných adries URL sa nebudú v prehliadači pridávať žiadne adresy URL.</translation>
<translation id="2762164719979766599">Určuje zoznam miestnych účtov na zariadení, ktoré sa majú zobrazovať na obrazovke prihlásenia.

      Každá položka v zozname určuje identifikátor, ktorý sa používa interne na rozpoznanie odlišných miestnych účtov na zariadení.</translation>
<translation id="8955719471735800169">Späť na začiatok</translation>
<translation id="2534584045044686957">Konfiguruje veľkosť vyrovnávacej pamäte, ktorú bude aplikácia <ph name="PRODUCT_NAME"/> používať na ukladanie súborov do vyrovnávacej pamäte na disku.

     Ak toto pravidlo nastavíte, aplikácia <ph name="PRODUCT_NAME"/> bude zadanú veľkosť vyrovnávacej pamäte používať bez ohľadu na to, či používateľ zadal príznak --media-cache-size, alebo nie.

      Ak je hodnota pravidla nastavená na 0, použije sa predvolená veľkosť vyrovnávacej pamäte a používateľ ju nebude môcť zmeniť.

      Ak pravidlo nenastavíte, použije sa predvolená veľkosť vyrovnávacej pamäte a používatelia ju budú môcť prepísať zadaním príznaku --media-cache-size.</translation>
<translation id="3723474915949495925">Určuje zoznam doplnkov, ktoré môže používateľ v aplikácii <ph name="PRODUCT_NAME"/> povoliť alebo zakázať.

      Ako zástupné znaky je možné použiť znaky „*“ a „?“. Znak „*“ slúži ako zástupný znak pre niekoľko ľubovoľných znakov, zatiaľ čo znak „?“ zastupuje jeden znak (môže zastupovať ľubovoľný znak alebo tiež žiadny znak). Riadiaci znak je „\“, ak teda chcete zadať znaky „*“, „?“ alebo „\“ ako také, stačí pred ne umiestniť znak „\“. 

      Ak toto nastavenie povolíte, doplnky uvedené v zozname bude možné použiť v aplikácii <ph name="PRODUCT_NAME"/>. Používatelia ich budú môcť povoliť alebo zakázať na stránke about:plugins, a to aj v prípade, že bude určitý doplnok zodpovedať vzoru v pravidle DisabledPlugins. Používatelia budú môcť povoliť a zakázať tiež doplnky, ktoré nezodpovedajú žiadnym vzorom v pravidlách DisabledPlugins, DisabledPluginsExceptions a EnabledPlugins.

      Toto pravidlo má umožniť prísne zaraďovanie doplnkov na zoznam zakázaných doplnkov v prípade, že zoznam pravidla DisabledPlugins obsahuje položky so zástupnými znakmi (napríklad znak „*“ slúžiaci na zakázanie všetkých doplnkov alebo znak „*Java*“ slúžiaci na zakázanie všetkých doplnkov Java), avšak správca chce niektoré konkrétne verzie povoliť (napr. „IcedTea Java 2.3“).

      Ak pravidlo nenastavíte, všetky doplnky, ktoré zodpovedajú vzoru v pravidle DisabledPlugins, budú uzamknuté ako zakázané a používatelia ich nebudú môcť povoliť.</translation>
<translation id="4557134566541205630">Predvolená adresa URL stránky novej karty poskytovateľa vyhľadávania</translation>
<translation id="546726650689747237">Oneskorenie zníženia jasu obrazovky pri používaní napájacieho zdroja</translation>
<translation id="4988291787868618635">Akcia po určitej dobe nečinnosti</translation>
<translation id="7260277299188117560">Protokol p2p na automatické aktualizácie je povolený</translation>
<translation id="5316405756476735914">Umožňuje nastaviť, či môžu webové stránky nastavovať miestne údaje. Nastavenie miestnych údajov sa dá buď pre všetky webové stránky umožniť, alebo ho pre všetky webové stránky zamietnuť.

          Ak toto pravidlo ponecháte nenastavené, použije sa pravidlo „AllowCookies“ a používateľ to bude môcť zmeniť.</translation>
<translation id="4250680216510889253">Nie</translation>
<translation id="1522425503138261032">Povoliť stránkam sledovať fyzickú polohu používateľov</translation>
<translation id="6467433935902485842">Umožňuje nastaviť zoznam vzorov adries URL určujúcich webové stránky, ktoré nemôžu spúšťať doplnky.

          Ak toto pravidlo ponecháte nenastavené, použije sa v prípade všetkých webových stránok globálna predvolená hodnota buď z pravidla „DefaultPluginsSetting“ (ak je nastavené), alebo z osobnej konfigurácie používateľa.</translation>
<translation id="4423597592074154136">Ručne určiť nastavenia servera proxy</translation>
<translation id="209586405398070749">Stabilná verzia</translation>
<translation id="8170878842291747619">Povoľuje v prehliadači <ph name="PRODUCT_NAME"/> integrovanú službu Prekladač Google.

      Ak toto nastavenie povolíte, prehliadač <ph name="PRODUCT_NAME"/> zobrazí integrovaný panel s nástrojmi ponúkajúci preklad príslušnej stránky tam, kde je to vhodné.

      Ak toto nastavenie zakážete, používateľom sa panel prekladu nezobrazí nikdy.

      Ak toto nastavenie povolíte alebo zakážete, používatelia nebudú môcť toto nastavenie v prehliadači <ph name="PRODUCT_NAME"/> zmeniť ani prepísať.

      Ak je toto nastavenie ponechané nenastavené, používateľ sa môže rozhodnúť, či túto funkciu použiť chce alebo nechce.</translation>
<translation id="9035964157729712237">ID rozšírení, ktoré majú byť zo zoznamu zakázaných rozšírení vyňaté</translation>
<translation id="8244525275280476362">Maximálne oneskorenie načítania po zrušení platnosti pravidla</translation>
<translation id="8587229956764455752">Povoliť vytváranie nových používateľských účtov</translation>
<translation id="7417972229667085380">Percento predĺženia oneskorenia režimu nečinnosti v režime prezentácie (podpora je ukončená)</translation>
<translation id="3964909636571393861">Umožňuje prístup k zoznamu adries URL</translation>
<translation id="3450318623141983471">Hlási stav prepínača režimu pre vývojárov pri spustení zariadenia. Ak toto pravidlo nie je nastavené, alebo je nastavené na hodnotu False, stav prepínača režimu pre vývojárov sa hlásiť nebude.</translation>
<translation id="1811270320106005269">Povolí uzamknutie v prípade, ak sú zariadenia nečinné alebo pozastavené.

      Ak toto nastavenie povolíte, pri pokuse o odomknutie zariadenia a prebudenie z režimu spánku sa používateľom zobrazí výzva na zadanie hesla.

      Ak toto nastavenie zakážete, používatelia budú môcť zariadenie prebudiť z režimu spánku aj bez hesla.

      Ak toto nastavenie povolíte alebo zakážete, používatelia ho v systéme <ph name="PRODUCT_OS_NAME"/> nebudú môcť zmeniť ani prepísať.

      Ak toto nastavenie ponecháte nenastavené, používateľ si bude môcť zvoliť, či chce, aby sa mu pri pokuse o odomknutie zariadenia zobrazovala výzva na zadanie hesla, alebo nie.</translation>
<translation id="6022948604095165524">Akcia pri spustení</translation>
<translation id="9042911395677044526">Umožňuje preniesť konfiguráciu siete, ktorá sa použije pre jednotlivých používateľov v zariadení so systémom <ph name="PRODUCT_OS_NAME"/>. Konfigurácia siete je reťazec vo formáte JSON, ktorý sa riadi definíciou formátu Open Network Configuration uvedenou na adrese <ph name="ONC_SPEC_URL"/></translation>
<translation id="7128918109610518786">Zoznam identifikátorov aplikácií, ktoré sa v <ph name="PRODUCT_OS_NAME"/> na paneli spustenia zobrazujú ako pripnuté.

      Ak je toto pravidlo nakonfigurované, tieto aplikácie sú pevne dané a používateľ ich nemôže zmeniť.

      Ak toto pravidlo nastavené nie je, používateľ zoznam aplikácií v spúšťači zmeniť môže.</translation>
<translation id="1679420586049708690">Verejná relácia pre automatické prihlásenie</translation>
<translation id="7625444193696794922">Určuje, aký kanál verzie by mal byť v zariadení uzamknutý.</translation>
<translation id="2552966063069741410">Časové pásmo</translation>
<translation id="2240879329269430151">Umožňuje nastaviť, či môžu webové stránky zobrazovať kontextové okná. Zobrazovanie kontextových okien je možné pre všetky webové stránky buď umožniť, alebo zamietnuť.

          Ak toto pravidlo ponecháte nenastavené, použije sa pravidlo „BlockPopups“ a používateľ ho bude môcť zmeniť.</translation>
<translation id="2529700525201305165">Obmedzenie používateľov, ktorí sa môžu prihlásiť do prehliadača <ph name="PRODUCT_NAME"/></translation>
<translation id="8971221018777092728">Časovač automatického prihlásenia do verejnej relácie</translation>
<translation id="8285435910062771358">Lupa v režime na celú obrazovku je povolená</translation>
<translation id="5141670636904227950">Nastaviť predvolený typ lupy obrazovky, ktorý je povolený na prihlasovacej obrazovke</translation>
<translation id="3864818549971490907">Predvolené nastavenie doplnkov</translation>
<translation id="7151201297958662315">Určuje, či sa má proces prehliadača <ph name="PRODUCT_NAME"/> spustiť po prihlásení do operačného systému a či má ostať spustený aj po zatvorení posledného okna prehliadača. Aplikácie na pozadí tak môžu ostať aktívne. Proces na pozadí zobrazí na systémovom paneli ikonu, pomocou ktorej ho môžete kedykoľvek ukončiť.

      Ak je toto pravidlo nastavené na hodnotu true, režim na pozadí je povolený a používateľ ho nemôže ovládať pomocou nastavení prehliadača.

      Ak je toto pravidlo nastavené na hodnotu false, režim na pozadí je zakázaný a používateľ ho nemôže ovládať pomocou nastavení prehliadača.

     Ak je toto pravidlo nenastavené, režim na pozadí je na začiatku zakázaný a používateľ ho môže ovládať pomocou nastavení prehliadača.</translation>
<translation id="4320376026953250541">Microsoft Windows XP SP2 alebo novší</translation>
<translation id="5148753489738115745">Umožňuje nastaviť dodatočné parametre, ktoré doplnok <ph name="PRODUCT_FRAME_NAME"/> pri spúšťaní aplikácie <ph name="PRODUCT_NAME"/> použije.

          Ak toto pravidlo nie je nastavené, použije sa predvolený príkazový riadok.</translation>
<translation id="2646290749315461919">Umožňuje nastaviť, či môžu webové stránky sledovať fyzickú polohu používateľa. Sledovanie fyzickej polohy používateľa sa dá nakonfigurovať tak, že bude v predvolenom nastavení umožnené alebo zamietnuté. Tiež je možné nastaviť, aby sa pri pokuse webových stránok o sledovanie fyzickej polohy používateľovi zobrazila výzva.

          Ak toto pravidlo ponecháte nenastavené, použije sa pravidlo „AskGeolocation“ a používateľ ho bude môcť zmeniť.</translation>
<translation id="6394350458541421998">Toto pravidlo sa prestalo používať v systéme <ph name="PRODUCT_OS_NAME"/> verzie 29. Použite namiesto neho pravidlo PresentationScreenDimDelayScale.</translation>
<translation id="5770738360657678870">Verzia pre vývojárov (môže byť nestabilná)</translation>
<translation id="2959898425599642200">Pravidlá vynechania servera proxy</translation>
<translation id="228659285074633994">Určuje časové obdobie bez zásahu používateľa, po ktorom sa pri napájaní zariadenia zo siete zobrazí okno s upozornením.

          Ak je pravidlo nastavené, určuje časové obdobie nečinnosti používateľa, po uplynutí ktorého aplikácia <ph name="PRODUCT_OS_NAME"/> zobrazí okno s upozornením, že sa vykoná akcia z dôvodu nečinnosti.

          Ak pravidlo nie je nastavené, okno s upozornením sa nezobrazí.

          Hodnota pravidla by mala byť stanovená v milisekundách. Hodnoty musia byť menšie alebo rovnaké ako oneskorenie z nečinnosti.</translation>
<translation id="1098794473340446990">Hlásiť časy aktivity zariadenia. Ak je toto nastavenie nastavené na hodnotu True, registrované zariadenia budú hlásiť časové obdobia, kedy používateľ zariadenie aktívne používa. Ak nastavené nie je, alebo je nastavené na hodnotu False, časy aktivity zariadenia sa nebudú zaznamenávať ani hlásiť.</translation>
<translation id="7937766917976512374">Povoliť alebo zakázať zaznamenávanie videa</translation>
<translation id="427632463972968153">Určuje parametre, ktoré sa použijú pri hľadaní obrázkov pomocou metódy POST. Pozostáva z párov názov/hodnota oddelených čiarkami. Ak je hodnota parameter šablóny, napr. hodnota {imageThumbnail} v príklade vyššie, bude nahradená údajmi skutočnej miniatúry obrázkov.

          Toto pravidlo je voliteľné. Ak nie je nastavené, žiadosť o vyhľadávanie obrázka sa odošle pomocou metódy GET.

          Toto pravidlo sa rešpektuje iba v prípade, ak je povolené pravidlo DefaultSearchProviderEnabled.</translation>
<translation id="8818646462962777576">Vzory v tomto zozname sa porovnajú s pôvodom
      zabezpečenia adresy URL, ktorá poslala žiadosť. Ak sa nájde zhoda,
      prístup k zariadeniam na zaznamenávanie zvuku sa udelí bez výzvy.

      POZNÁMKA: Toto pravidlo je v súčasnosti podporované iba v režime kiosku.</translation>
<translation id="489803897780524242">Parameter kontrolujúci umiestnenie vyhľadávacích výrazov pre predvoleného poskytovateľa vyhľadávania</translation>
<translation id="316778957754360075">Toto nastavenie sa prestalo používať v prehliadači <ph name="PRODUCT_NAME"/> verzie 29. Odporúčaným spôsobom na nastavenie zbierok rozšírení/aplikácií hostených organizáciou je zahrnúť stránky hostiace balíky CRX do zoznamu ExtensionInstallSources a vložiť na webovú stránku priame odkazy na balíky. Spúšťač pre danú webovú stránku je možné vytvoriť pomocou pravidla ExtensionInstallForcelist.</translation>
<translation id="6401669939808766804">Odhlásiť používateľa</translation>
<translation id="4826326557828204741">Akcia, ktorá sa má vykonať po uplynutí určitého času nečinnosti počas prevádzky na batérii</translation>
<translation id="7912255076272890813">Nakonfigurovať povolené typy aplikácií/rozšírení</translation>
<translation id="817455428376641507">Umožňuje pristupovať k adresám URL uvedeným v zozname, ktoré predstavujú výnimky pre zoznam zakázaných adries URL.

      Informácie o formáte položiek v zozname nájdete v popise pravidla na zablokovanie adries URL.

      Toto pravidlo umožňuje otvárať výnimky pre zoznamy zakázaných adries URL. Na zoznam zakázaných položiek môžete napríklad pridať položku „*“, ktorá zablokuje všetky žiadosti, a pomocou tohto pravidla následne môžete povoliť prístup k obmedzenému zoznamu adries URL. Môže sa použiť na otváranie určitých schém, subdomén a ďalších domén, portov alebo konkrétnych ciest.

      O povolení alebo zablokovaní adresy URL rozhodne najkonkrétnejší filter. Biela listina má prednosť pred zoznamom zakázaných položiek.

      Toto pravidlo je obmedzené na 1 000 položiek. Ostatné položky sa budú ignorovať.

      Ak toto pravidlo ponecháte nenastavené, nebudú k dispozícii žiadne výnimky pre zoznam zakázaných adries uvedený v rámci pravidla URLBlacklist.</translation>
<translation id="4163644371169597382">Správcovia IT spravujúci podnikové zariadenia môžu pomocou tohto pravidla povoliť alebo zakázať používateľom uplatniť ponuky pri registrácii systému Chrome OS.

      Ak je toto pravidlo nastavené na hodnotu True alebo je ponechané bez nastavenia, používatelia si pri registrácii systému Chrome OS budú môcť uplatniť ponuky.

      Ak je toto pravidlo nastavené na hodnotu False, používatelia si nebudú môcť uplatniť ponuky.</translation>
<translation id="8148901634826284024">Povolí režim vysokého kontrastu (funkcia na uľahčenie prístupu).

      Ak toto nastavenie povolíte, bude režim vysokého kontrastu vždy zapnutý.

      Ak toto nastavenie zakážete, bude režim vysokého kontrastu vždy vypnutý.

      Ak toto pravidlo povolíte alebo zakážete, používatelia ho nebudú môcť zmeniť.

      Ak toto pravidlo ponecháte nenastavené, režim vysokého kontrastu bude spočiatku zakázaný, ale používateľ to bude môcť kedykoľvek zmeniť.</translation>
<translation id="6177482277304066047">Nastavuje cieľovú verziu automatických aktualizácií.

      Určuje predponu cieľovej verzie, na ktorú sa má systém <ph name="PRODUCT_OS_NAME"/> aktualizovať. Ak zariadenie obsahuje staršiu verziu, ako určuje predpona, bude systém aktualizovaný na poslednú verziu s danou predponou. Ak už zariadenie obsahuje novšiu verziu, nestane sa nič (t.j. nedôjde k prechodu na nižšiu verziu) a zariadenie zostane pri existujúcej verzii. Formát predpony funguje na základe komponentu, ako ukazuje nasledujúci príklad:

      &quot;&quot; (alebo nie je nakonfigurované): aktualizovať na najnovšiu dostupnú verziu.
      &quot;1412.&quot;: aktualizovať na ľubovoľnú podverziu verzie 1412 (napr. 1412.24.34 alebo 1412.60.2)
      &quot;1412.2.&quot;: aktualizovať na ľubovolnú podverziu verzie 1412.2 (napr. 1412.2.34 alebo 1412.2.2)
      &quot;1412.24.34&quot;: aktualizovať iba na túto konkrétnu verziu</translation>
<translation id="8102913158860568230">Predvolené nastavenie mediálneho streamu</translation>
<translation id="6641981670621198190">Zakázať podporu rozhrania API pre grafiku 3D</translation>
<translation id="7929480864713075819">Povoliť nahlasovanie informácií o pamäti (veľkosť hromady kódu JavaScript) stránke</translation>
<translation id="5703863730741917647">Určte akciu, ktorá sa má uskutočniť po uplynutí určitého času nečinnosti.

          Upozorňujeme, že podpora tohto pravidla bola ukončená a v budúcnosti sa odstráni.

          Toto pravidlo poskytuje záložnú hodnotu pre konkrétnejšie pravidlá <ph name="IDLEACTIONAC_POLICY_NAME"/> a <ph name="IDLEACTIONBATTERY_POLICY_NAME"/>. Ak je pravidlo nastavené, jeho hodnota sa použije v prípade, keď nie je nastavené zodpovedajúce konkrétnejšie pravidlo.

          Keď toto pravidlo nie je nastavené, správanie konkrétnejších pravidiel nebude ovplyvnené.</translation>
<translation id="5997543603646547632">Používať v predvolenom nastavení 24-hodinový formát hodín</translation>
<translation id="7003746348783715221">Predvoľby prehliadača <ph name="PRODUCT_NAME"/></translation>
<translation id="4723829699367336876">Povoliť prechod cez bránu firewall v smere od klienta vzdialeného prístupu</translation>
<translation id="6367755442345892511">Či má byť kanál na vydávanie nových verzií konfigurovateľný používateľom</translation>
<translation id="3868347814555911633">Toto pravidlo je aktívne iba v režime predaja.

      Zoznam rozšírení, ktoré sa automaticky nainštalujú pre používateľa ukážky v zariadeniach v režime predaja. Tieto rozšírenia sa uložia v zariadení a po inštalácii môžu byť nainštalované v režime offline.

      Každý záznam v zozname obsahuje adresár, ktorý musí zahŕňať ID rozšírenia v poli „extension-id“ a jeho adresu URL pre aktualizácie v poli „update-url“.</translation>
<translation id="9096086085182305205">Zoznam povolených overovacích serverov</translation>
<translation id="4980301635509504364">Povolí alebo zamietne zaznamenávanie videa.

      Ak je toto pravidlo povolené alebo nenakonfigurované (predvolené), používateľovi sa zobrazí výzva
      na prístup k zaznamenávaniu videa. Výnimkou sú adresy URL, ktoré sú nakonfigurované
      v zozname VideoCaptureAllowedUrls a majú povolený prístup bez zobrazenia výzvy.

      Ak je pravidlo zakázané, používateľovi sa nikdy nezobrazí výzva a zaznamenávanie
      videa bude k dispozícii iba pre adresy URL, ktoré sú nakonfigurované v zozname VideoCaptureAllowedUrls.

      Toto pravidlo má vplyv na všetky typy vstupov videa, a nie len na vstavanú kameru.</translation>
<translation id="7063895219334505671">Povoliť na týchto stránkach kontextové okná</translation>
<translation id="4052765007567912447">Určuje, či môžu používatelia zobraziť heslá v správcovi hesiel formou čitateľného textu.

          Ak toto nastavenie zakážete, v okne správcu hesiel nebude možné zobraziť uložené heslá formou čitateľného textu.

          Ak toto nastavenie povolíte alebo ho nenastavíte, používatelia budú môcť v správcovi hesiel zobraziť uložené heslá formou čitateľného textu.</translation>
<translation id="5936622343001856595">Vynucuje vyhľadávanie dopytov vo Vyhľadávaní Google na webe pomocou aktívneho Bezpečného vyhľadávania a zabraňuje používateľom toto nastavenie zmeniť.

      Ak toto nastavenie povolíte, Bezpečné vyhľadávanie bude vo Vyhľadávaní Google vždy aktívne.

      Ak toto nastavenie zakážete alebo nenastavíte žiadnu hodnotu, Bezpečné vyhľadávanie vo Vyhľadávaní Google vynucované nebude.</translation>
<translation id="6017568866726630990">Zobrazí systémové dialógové okno tlače namiesto ukážky tlače.

      Ak je toto nastavenie povolené a používateľ chce stránku vytlačiť, prehliadač <ph name="PRODUCT_NAME"/> otvorí systémové dialógové okno tlače namiesto vstavanej ukážky tlače.

      Ak toto pravidlo nastavené nie je alebo je nastavené na hodnotu False, príkazy na tlač spustia obrazovku ukážky tlače.</translation>
<translation id="7933141401888114454">Povoliť vytváranie kontrolovaných používateľov</translation>
<translation id="2824715612115726353">Povoliť režim inkognito</translation>
<translation id="1057535219415338480">Povolí predvídanie siete v prehliadači <ph name="PRODUCT_NAME"/> a zabráni používateľom toto nastavenie zmeniť.

      Toto pravidlo ovláda spoločne s predbežným načítaním servera DNS aj predbežné pripojenie pomocou protokolu TCP a technológie SSL a predbežné vykreslenie webových stránok. Názov pravidla je založený na predbežnom načítaní servera DNS z historických dôvodov.

      Ak toto nastavenie povolíte alebo zakážete, používatelia ho v prehliadači <ph name="PRODUCT_NAME"/> nebudú môcť prepísať.

      Ak toto pravidlo ponecháte nenastavené, nastavenie bude povolené, ale používateľ ho bude môcť zmeniť.</translation>
<translation id="4541530620466526913">Miestne účty na zariadení</translation>
<translation id="5815129011704381141">Automaticky reštartovať po aktualizácii</translation>
<translation id="1757688868319862958">Povolí produktu <ph name="PRODUCT_NAME"/> spustiť doplnky, ktoré vyžadujú autorizáciu. Ak toto nastavenie povolíte, budú doplnky, ktoré nie sú zastarané, nepretržite spustené. Ak je toto nastavenie zakázané alebo nie je nastavené, používatelia budú požiadaní, aby povolili spustenie doplnkov, ktoré vyžadujú autorizáciu. Ide o doplnky, ktoré môžu ohroziť bezpečnosť.</translation>
<translation id="6392973646875039351">Povoľuje v prehliadači <ph name="PRODUCT_NAME"/> funkciu Automatické dopĺňanie a umožňuje používateľom automaticky dopĺňať polia webových formulárov pomocou uložených údajov (napr. adresa alebo číslo kreditnej karty).

      Ak toto nastavenie zakážete, používatelia nebudú mať k funkcii Automatické dopĺňanie prístup.

      Ak toto nastavenie povolíte alebo nenastavíte žiadnu hodnotu, funkcia Automatické dopĺňanie zostane pod kontrolou používateľa. Vďaka tomu si budú môcť používatelia nakonfigurovať profily tejto funkcie a podľa vlastného úsudku ich vypínať alebo zapínať.</translation>
<translation id="6157537876488211233">Zoznam pravidiel vynechania servera proxy oddelených čiarkami</translation>
<translation id="7788511847830146438">Podľa profilu</translation>
<translation id="2516525961735516234">Určuje, či prehrávanie videa ovplyvňuje správu napájania.

          Ak je toto pravidlo nastavené na hodnotu True alebo nie je nastavené, prehrávanie videa sa nepovažuje za nečinnosť používateľa. Zabráni to oneskoreniu režimu nečinnosti a zníženia jasu, vypnutiu a uzamknutiu obrazovky a nevykonajú sa príslušné akcie.

          Ak je toto pravidlo nastavené na hodnotu False, prehrávanie videa sa považuje za nečinnosť používateľa.</translation>
<translation id="3965339130942650562">Časový limit pred odhlásením nečinného používateľa</translation>
<translation id="5814301096961727113">Nastaviť predvolený stav hlasovej odozvy na prihlasovacej obrazovke</translation>
<translation id="9084985621503260744">Určuje, či prehrávanie videa ovplyvňuje správu napájania</translation>
<translation id="7091198954851103976">Vždy spustí doplnky, ktoré vyžadujú autorizáciu</translation>
<translation id="1708496595873025510">Nastaviť obmedzenie pre načítanie počiatočnej hodnoty variácie</translation>
<translation id="8870318296973696995">Domovská stránka</translation>
<translation id="1240643596769627465">Určuje adresu URL vyhľadávacieho nástroja, ktorý poskytuje výsledky dynamického vyhľadávania. Adresa URL by mala obsahovať reťazec <ph name="SEARCH_TERM_MARKER"/>, ktorý bude počas posielania dopytu nahradený textom zadávaným používateľom.

          Toto pravidlo je voliteľné. Ak ho nenastavíte, nebudú sa vám zobrazovať žiadne výsledky dynamického vyhľadávania.

          Toto pravidlo bude dodržané len v prípade, ak je povolené pravidlo „DefaultSearchProviderEnabled“.</translation>
<translation id="6693751878507293182">Ak tu nastavíte na hodnotu povolené, automatické vyhľadávanie a inštalovanie chýbajúcich doplnkov bude v prehliadači <ph name="PRODUCT_NAME"/> zakázané.

      Ak túto možnosť nastavíte ako zakázanú alebo ju ponecháte nenastavenú, nástroj na vyhľadávanie doplnkov bude aktívny.</translation>
<translation id="2650049181907741121">Akcia pri zavretí veka</translation>
<translation id="7880891067740158163">Umožňuje uviesť zoznam vzorov adries URL webových stránok, pre ktoré by mal prehliadač <ph name="PRODUCT_NAME"/> automaticky vybrať certifikáty klienta (ak webová stránka certifikát vyžaduje).

          Ak toto pravidlo ponecháte nenastavené, automatický výber sa nevykoná pre žiadnu webovú stránku.</translation>
<translation id="3866249974567520381">Popis</translation>
<translation id="5192837635164433517">Povoľuje využívať alternatívne chybové stránky vopred definované v prehliadači <ph name="PRODUCT_NAME"/> (napr. webová stránka sa nenašla) a bráni používateľom toto nastavenie zmeniť.

      Ak toto nastavenie povolíte, budú sa používať alternatívne chybové stránky.

      Ak toto nastavenie zakážete, alternatívne chybové stránky sa používať nebudú.

      Ak toto nastavenie povolíte alebo zakážete, používatelia ho v prehliadači <ph name="PRODUCT_NAME"/> nebudú môcť zmeniť ani prepísať.

      Ak bude toto nastavenie ponecháte nenastavené, povolí sa, no používateľ to bude môcť zmeniť.</translation>
<translation id="2236488539271255289">Nepovoliť žiadnym stránkam nastaviť miestne údaje</translation>
<translation id="4467952432486360968">Blokovať súbory cookie tretej strany</translation>
<translation id="1305864769064309495">Slovník s mapovaním adries URL na boolovské identifikátory, ktoré určujú, či bude prístup k hostiteľovi povolený (true) alebo zablokovaný (false).

          Toto pravidlo sa vzťahuje iba na interné používanie prehliadača Chrome.</translation>
<translation id="5586942249556966598">Nevykonať žiadnu akciu</translation>
<translation id="131353325527891113">Zobraziť používateľské mená na prihlasovacej obrazovke</translation>
<translation id="5317965872570843334">Povoľuje použitie serverov typu STUN a relay, keď sa vzdialení klienti pokúšajú nadviazať spojenie s týmto počítačom.

          Ak je toto nastavenie povolené, vzdialení klienti môžu vyhľadať tieto počítače a pripojiť sa k nim aj v prípade, že sú oddelení bránou firewall.

          Ak je toto nastavenie zakázané a brána firewall filtruje odchádzajúce pripojenia cez protokol UDP, povolí tento počítač iba pripojenia z klientskych počítačov v rámci miestnej siete.

          Ak toto pravidlo ponecháte nenastavené, nastavenie sa povolí.</translation>
<translation id="4057110413331612451">Povoliť podnikovému používateľovi byť iba primárnym používateľom s viacnásobným profilom</translation>
<translation id="5365946944967967336">Zobraziť tlačidlo Domov na paneli s nástrojmi</translation>
<translation id="3709266154059827597">Konfigurovať zoznam rozšírení, ktorých inštalácia je zakázaná</translation>
<translation id="8451988835943702790">Použiť stránku Nová karta ako domovskú stránku</translation>
<translation id="4617338332148204752">Preskočiť kontrolu metaznačiek v rámci služby <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="8469342921412620373">Povoľuje použiť predvoleného poskytovateľa vyhľadávania.

          Ak toto nastavenie povolíte, pri zadaní textu (ktorý nie je adresou) do všeobecného poľa sa vykoná predvolené vyhľadávanie.

          Nastavením zvyšku predvolených pravidiel vyhľadávania môžete určiť predvoleného poskytovateľa vyhľadávania, ktorý sa má použiť.

          Ak ich nenastavíte, používateľ si bude môcť zvoliť predvoleného poskytovateľa. Ak toto nastavenie zakážete, pri zadaní textu (ktorý nie je adresou URL) do všeobecného poľa neprebehne žiadne vyhľadávanie.

          Ak nastavenie povolíte alebo zakážete, používatelia nebudú môcť v prehliadači <ph name="PRODUCT_NAME"/> dané nastavenie zmeniť ani prekonať.

          Ak toto pravidlo ponecháte nenastavené, povolí sa predvolený poskytovateľ vyhľadávania a používateľ bude môcť nastaviť zoznam poskytovateľov vyhľadávania.</translation>
<translation id="4791031774429044540">Povolí veľký kurzor (funkcia na uľahčenie prístupu).

      Ak toto pravidlo povolíte, bude veľký kurzor vždy zapnutý.

      Ak toto pravidlo zakážete, bude veľký kurzor vždy vypnutý.

      Ak toto pravidlo povolíte alebo zakážete, používatelia ho nebudú môcť prepísať.

      Ak toto pravidlo ponecháte nenastavené, veľký kurzor bude spočiatku zakázaný, ale používateľ to bude môcť kedykoľvek zmeniť.</translation>
<translation id="2633084400146331575">Povoliť hlasovú odozvu</translation>
<translation id="8731693562790917685">Nastavenia obsahu umožňujú určiť, akým spôsobom bude spracovávaný obsah určitého typu (napríklad súbory cookie, obrázky alebo kód JavaScript).</translation>
<translation id="2411919772666155530">Blokovať upozornenia na týchto webových stránkach</translation>
<translation id="6923366716660828830">Určuje názov predvoleného poskytovateľa vyhľadávania. Ak sa pole nevyplní alebo bude pravidlo ponechané nenastavené, použije sa názov hostiteľa určený adresou URL vyhľadávania.

          Toto pravidlo sa vezme do úvahy len v prípade, ak je povolené pravidlo „DefaultSearchProviderEnabled“.</translation>
<translation id="4869787217450099946">Určuje, či sú povolené uzamknutia obrazovky v aktívnom režime. Rozšírenia môžu o uzamknutie obrazovky v aktívnom režime požiadať prostredníctvom rozhrania API na správu napájania pre rozšírenia.

          Ak je toto pravidlo nastavené na hodnotu True alebo nie je nastavené vôbec, uzamknutia obrazovky v aktívnom režime budú pre správu napájania povolené.

          Ak je toto pravidlo nastavené na hodnotu False, budú sa žiadosti o uzamknutie obrazovky v aktívnom režime ignorovať.</translation>
<translation id="467236746355332046">Podporované funkcie:</translation>
<translation id="7632724434767231364">Názov knižnice GSSAPI</translation>
<translation id="3038323923255997294">Po uzavretí prehliadača <ph name="PRODUCT_NAME"/> ponechať aplikácie na pozadí spustené</translation>
<translation id="8909280293285028130">Určuje dobu nečinnosti používateľa, po ktorej sa obrazovka pri používaní napájacieho zdroja uzamkne.

          Ak je toto pravidlo nastavené na hodnotu väčšiu ako nula, určuje dobu nečinnosti používateľa, po ktorej systém <ph name="PRODUCT_OS_NAME"/> obrazovku uzamkne.

          Ak je toto pravidlo nastavené na hodnotu nula, systém <ph name="PRODUCT_OS_NAME"/> obrazovku pri nečinnosti používateľa neuzamkne.

          Ak toto pravidlo nastavené nie je, použije sa predvolená doba.

          Odporúčaným spôsobom uzamknutia obrazovky pri nečinnosti je uzamknutie obrazovky v režime spánku a nastavenie doby, po ktorej systém <ph name="PRODUCT_OS_NAME"/> prejde do režimu spánku. Toto pravidlo by sa malo používať len v prípade, ak chcete obrazovku uzamknúť oveľa skôr, než dôjde k prechodu do režimu spánku alebo ak nechcete režim spánku používať vôbec.

          Hodnota pravidla by mala byť uvedená v milisekundách. Hodnoty musia byť nižšie ako oneskorenie režimu nečinnosti.</translation>
<translation id="7651739109954974365">Určuje, či bude v zariadení povolený roaming pre dátové prenosy. Ak je pravidlo nastavené na hodnotu true, roaming pre dátové prenosy bude povolený. Ak ho ponecháte nenakonfigurované alebo ho nastavíte na hodnotu false, roaming pre dátové prenosy nebude k dispozícii.</translation>
<translation id="6244210204546589761">Adresy URL otvárané pri spustení</translation>
<translation id="7468416082528382842">Umiestnenie v registri systému Windows:</translation>
<translation id="1808715480127969042">Blokovať súbory cookie na týchto webových stránkach</translation>
<translation id="1908884158811109790">Zakázať v aplikácii Súbory systému OS Chrome používanie služby Disk Google prostredníctvom mobilných pripojení</translation>
<translation id="7340034977315324840">Hlásiť časy aktivity zariadenia</translation>
<translation id="4928632305180102854">Určuje, či v systéme <ph name="PRODUCT_OS_NAME"/> bude možné vytvárať nové používateľské účty. Ak toto pravidlo nastavíte na hodnotu false, do zariadenia sa nebudú môcť prihlásiť používatelia, ktorí ešte nemajú účet.

      Ak je toto pravidlo nastavené na hodnotu true, alebo je nenakonfigurované, bude možné vytvárať nové používateľské účty (za predpokladu, že daný používateľ nie je zablokovaný pravidlom <ph name="DEVICEUSERWHITELISTPROTO_POLICY_NAME"/>).</translation>
<translation id="4389091865841123886">Konfigurácia vzdialeného overenia s použitím mechanizmu TPM.</translation>
<translation id="3518214502751233558">Zadajte, či oneskorenia správy napájania a limit dĺžky relácie sa majú spustiť iba po počiatočnej aktivite používateľa v relácii</translation>
<translation id="8256688113167012935">Ovláda názov účtu, ktorý systém <ph name="PRODUCT_OS_NAME"/> zobrazí na obrazovke prihlásenia pre zodpovedajúci miestny účet na zariadení.

      Ak je toto pravidlo nastavené, obrazovka prihlásenia použije stanovený reťazec pri prihlásení založenom na obrázku pre zodpovedajúci miestny účet na zariadení.

      Ak je toto pravidlo ponechané nenastavené, systém <ph name="PRODUCT_OS_NAME"/> použije ID e-mailového účtu pre miestny účet na zariadení ako meno, ktoré zobrazí na obrazovke prihlásenia.

      Toto pravidlo sa v prípade bežných používateľských účtov ignoruje.</translation>
<translation id="267596348720209223">Určuje kódovanie znakov podporovaných poskytovateľom vyhľadávania. Kódovania sú kódové stránky, napríklad UTF-8, GB2312 alebo ISO-8859-1. Budú vyskúšané v uvedenom poradí.

          Toto pravidlo je voliteľné. Ak nebude nastavené, použije sa predvolené kódovanie (UTF-8).

          Toto pravidlo bude dodržané len v prípade, ak je povolené pravidlo „DefaultSearchProviderEnabled“.</translation>
<translation id="1349276916170108723">Ak je pravidlo nastavené na hodnotu True, zakáže v aplikácií Súbory systému OS Chrome synchronizáciu služby Disk Google. V tomto prípade sa do služby Disk Google neodovzdajú žiadne údaje.

          Ak je pravidlo nastavené na hodnotu False alebo nie je nastavené vôbec, používatelia môžu do služby Disk Google prenášať údaje.</translation>
<translation id="1964634611280150550">Režim inkognito je zakázaný</translation>
<translation id="5971128524642832825">Zakázať v aplikácii Súbory systému OS Chrome službu Disk Google</translation>
<translation id="1847960418907100918">Určuje parametre, ktoré sa použijú pri okamžitom vyhľadávaní pomocou metódy POST. Pozostáva z párov názov/hodnota oddelených čiarkami. Ak je hodnota parameter šablóny, napr. hodnota {searchTerms} v príklade vyššie, bude nahradená údajmi skutočných vyhľadávaných výrazov.

          Toto pravidlo je voliteľné. Ak nie je nastavené, žiadosť o okamžité vyhľadávanie sa odošle pomocou metódy GET.

          Toto pravidlo sa rešpektuje iba v prípade, ak je povolené pravidlo DefaultSearchProviderEnabled.</translation>
<translation id="1454846751303307294">Umožňuje nastaviť zoznam vzorov adries URL určujúcich webové stránky, ktoré nemôžu spúšťať kód JavaScript.

          Ak toto pravidlo ponecháte nenastavené, použije sa v prípade všetkých webových stránok globálna predvolená hodnota buď z pravidla „DefaultJavaScriptSetting“ (ak je nastavené), alebo z osobnej konfigurácie používateľa.</translation>
<translation id="538108065117008131">Povoliť doplnku <ph name="PRODUCT_FRAME_NAME"/> spracovávať tieto typy obsahu.</translation>
<translation id="2312134445771258233">Umožňuje konfigurovať stránky, ktoré sa načítavajú pri spustení. Ak ste v časti „Akcie pri spustení“ nezvolili možnosť „Otvoriť zoznam adries URL“, položky v zozname „Adresy URL otvárané pri spustení“ sa ignorujú.</translation>
<translation id="243972079416668391">Určte akciu, ktorá sa má uskutočniť po uplynutí určitého času nečinnosti počas prevádzky s napájaním.

          Keď je toto pravidlo nastavené, určuje akciu, ktorú <ph name="PRODUCT_OS_NAME"/> vykoná, keď používateľ zostane nečinný počas časového obdobia stanoveného časom nečinnosti, ktorý sa dá nakonfigurovať samostatne.

          Keď nie je toto pravidlo nastavené, vykoná sa predvolená akcia – pozastavenie.

          Ak dôjde k pozastaveniu, <ph name="PRODUCT_OS_NAME"/> je možné samostatne nakonfigurovať, aby pred pozastavením obrazovku buď zamkol, alebo nezamkol.</translation>
<translation id="7750991880413385988">Otvoriť stránku Nová karta</translation>
<translation id="741903087521737762">Umožňuje určiť správanie pri spustení.

          Ak zvolíte možnosť Otvoriť stránku Nová karta, otvorí sa pri spustení produktu <ph name="PRODUCT_NAME"/> stránka Nová karta.

          Ak zvolíte možnosť Obnoviť poslednú reláciu, otvoria sa adresy, ktoré boli otvorené pri poslednom zavretí produktu <ph name="PRODUCT_NAME"/>, a relácia prehliadača sa obnoví v stave, v akom ste ju opustili.
          Zvolením tejto možnosti zakážete niektoré nastavenia, ktoré sú závislé od relácií alebo vykonávajú akcie pri zavretí prehliadača (napr. vymazanie údajov prehliadania pri ukončení alebo obmedzení súborov cookie len na reláciu).

          Ak zvolíte možnosť Otvoriť zoznam adries, otvoria sa pri spustení produktu <ph name="PRODUCT_NAME"/> adresy uvedené v zozname Adresy URL otvárané pri spustení.

          Ak toto nastavenia povolíte, používatelia ho v produkte <ph name="PRODUCT_NAME"/> nemôžu zmeniť ani prepísať.

          Ak toto nastavenie zakážete, je to to isté, ako keby ste ho nenakonfigurovali. Používatelia ho v produkte <ph name="PRODUCT_NAME"/> budú môcť zmeniť.</translation>
<translation id="8161570238552664224">Povoliť prehrávanie zvuku.

      Ak je toto pravidlo nastavené na hodnotu false (neplatí), výstup zvuku nebude počas prihlásenia používateľa v zariadení k dispozícii.

      Toto pravidlo ovplyvňuje všetky typy výstupov zvuku (nielen vstavané reproduktory). Toto pravidlo tiež zakazuje zvukové funkcie zjednodušenia. Ak používateľ vyžaduje čítačku obrazovky, toto pravidlo nepovoľujte.

      Ak je toto pravidlo nastavené na hodnotu true (platí) alebo nie je nakonfigurované, používatelia môžu vo svojom zariadení používať všetky podporované výstupy zvuku.</translation>
<translation id="5761030451068906335">Nakonfiguruje nastavenia servera proxy pre prehliadač <ph name="PRODUCT_NAME"/>. Toto pravidlo ešte nie je pripravené na používanie, preto ho radšej nepoužívajte.</translation>
<translation id="3006443857675504368">Zobrazí v systéme <ph name="PRODUCT_OS_NAME"/> možnosti zjednodušenia prístupu v ponuke systému.

          Ak je pravidlo nastavené na hodnotu true, v ponuke systémovej lišty sa vždy zobrazia možnosti zjednodušenia prístupu.

          Ak je pravidlo nastavené na hodnotu false, možnosti zjednodušenia prístupu sa v ponuke systémovej lišty nikdy nezobrazia.

          Ak pravidlo nastavíte, používatelia ho nebudú môcť zmeniť ani prepísať.

          Ak pravidlo zostane nenastavené, možnosti zjednodušenia prístupu sa v ponuke systémovej lišty nezobrazia. Používatelia ich však budú môcť sprístupniť prostredníctvom stránky Nastavenia.</translation>
<translation id="8344454543174932833">Importovanie záložiek z predvoleného prehliadača pri prvom spustení</translation>
<translation id="1019101089073227242">Nastaviť adresár používateľských údajov</translation>
<translation id="5826047473100157858">Určuje, či môže používateľ v prehliadači <ph name="PRODUCT_NAME"/> otvoriť stránky v režime Inkognito.

      Ak vyberiete možnosť „Povolené“ alebo bude pravidlo ponechané nenastavené, stránky sa v režime Inkognito budú dať otvoriť.

      Ak vyberiete možnosť „Zakázané“, stránky v režime Inkognito nebude možné otvoriť.

      Ak vyberiete možnosť „Vynútené“, stránky bude možné otvoriť LEN v režime Inkognito.</translation>
<translation id="2988031052053447965">Skryje na stránke Nová karta a v spúšťači systému Chrome OS aplikáciu Internetový obchod Chrome a odkaz na pätu stránky.

      Ak je pravidlo nastavené na hodnotu true, ikony sa skryjú.

      Ak je pravidlo nastavené na hodnotu false alebo ak nie je nastavené, ikony budú viditeľné.</translation>
<translation id="5085647276663819155">Zakázať ukážku pred tlačou</translation>
<translation id="8672321184841719703">Cieľová verzia automatickej aktualizácie</translation>
<translation id="1689963000958717134">Umožňuje preniesť konfiguráciu siete, ktorá sa použije pre všetkých používateľov v zariadení so systémom <ph name="PRODUCT_OS_NAME"/>. Konfigurácia siete je reťazec vo formáte JSON, ktorý sa riadi definíciou formátu Open Network Configuration uvedenou na adrese <ph name="ONC_SPEC_URL"/></translation>
<translation id="6699880231565102694">Povolenie dvojfázového overenia totožnosti pre hostiteľov vzdialeného prístupu</translation>
<translation id="2030905906517501646">Kľúčové slovo predvoleného poskytovateľa vyhľadávania</translation>
<translation id="3072045631333522102">Šetrič obrazovky, ktorý sa má použiť na prihlasovacej obrazovke v režime určenom pre predaj</translation>
<translation id="4550478922814283243">Povoliť alebo zakázať overenie bez použitia kódu PIN</translation>
<translation id="7712109699186360774">Vždy sa opýtať, keď sa stránky snažia získať prístup ku kamere alebo mikrofónu</translation>
<translation id="350797926066071931">Povoliť službu Translate</translation>
<translation id="3711895659073496551">Režim spánku</translation>
<translation id="4010738624545340900">Povolenie vyvolania dialógových okien na výber súborov</translation>
<translation id="4518251772179446575">Opýtať sa vždy, keď chcú stránky sledovať fyzickú polohu používateľa</translation>
<translation id="402759845255257575">Nepovoliť žiadnym stránkam spúšťať kód JavaScript</translation>
<translation id="5457924070961220141">Umožňuje konfigurovať vykresľovací modul HTML, keď je nainštalovaný doplnok <ph name="PRODUCT_FRAME_NAME"/>.
          V predvolenom nastavení, ktoré sa používa v prípade, ak je toto pravidlo ponechané nenastavené, môže vykresľovanie vykonávať hostiteľský prehliadač. Toto nastavenie však môžete prepísať a namiesto toho vykresľovať stránky HTML pomocou doplnku <ph name="PRODUCT_FRAME_NAME"/>.</translation>
<translation id="706669471845501145">Povoliť webovým stránkam zobrazovať upozornenia na pracovnej ploche</translation>
<translation id="7529144158022474049">Rozptylový faktor automatických aktualizácií</translation>
<translation id="2188979373208322108">Povoľuje v prehliadači <ph name="PRODUCT_NAME"/> panel so záložkami.

      Ak toto nastavenie povolíte, prehliadač <ph name="PRODUCT_NAME"/> zobrazí panel so záložkami.

      Ak toto nastavenie zakážete, používateľom sa panel so záložkami nikdy nezobrazí.

      Ak toto nastavenie povolíte alebo zakážete, používatelia ho v prehliadači <ph name="PRODUCT_NAME"/> nebudú môcť zmeniť ani prepísať.

      Ak je toto nastavenie ponechané nenastavené, používateľ sa môže rozhodnúť, či túto funkciu použiť chce alebo nechce.</translation>
<translation id="5475361623548884387">Povoliť tlač</translation>
<translation id="7287359148642300270">Určuje, ktoré servery majú byť umiestnené na bielu listinu pre integrované overenie totožnosti. Integrované overenie totožnosti je povolené iba v prípade, ak <ph name="PRODUCT_NAME"/> dostane výzvu na overenie zo servera proxy alebo iného servera, ktorý je uvedený v tomto zozname povolených serverov.

          Ak chcete zadať niekoľko názvov serverov, oddeľte ich čiarkami. Zástupné znaky (*) sú povolené.

          Ak pravidlo zostane nenastavené, prehliadač Chrome sa najprv pokúsi zistiť, či sa server nachádza v sieti intranet, a až potom bude reagovať na žiadosti IWA. Ak sa zistí, že je server v sieti internet, prehliadač Chrome bude žiadosti IWA ignorovať.</translation>
<translation id="3653237928288822292">Ikona predvoleného poskytovateľa vyhľadávania</translation>
<translation id="2872961005593481000">Vypnúť</translation>
<translation id="4445684791305970001">Zakáže Nástroje pre vývojárov a konzolu JavaScript.

      Ak toto nastavenie povolíte, nebude možné pristupovať k nástrojom pre vývojárov ani kontrolovať prvky webových stránok. Zakázané budú tiež všetky klávesové skratky a položky klasických či kontextových ponúk, pomocou ktorých je možné nástroje pre vývojárov alebo konzolu kódu JavaScript otvoriť.

      Ak túto možnosť nastavíte ako zakázanú alebo ju ponecháte nenastavenú, umožní to používateľovi použiť Nástroje pre vývojárov a konzolu JavaScript.</translation>
<translation id="9203071022800375458">Zakazuje zaznamenávanie snímok obrazovky.

      Ak je pravidlo povolené, nie je možné zaznamenávať snímky obrazovky pomocou klávesových skratiek ani rozhraní API rozšírení.

      Ak je zakázané alebo ak nie je nastavené, zaznamenávania snímok obrazovky je povolené.</translation>
<translation id="5697306356229823047">Nahlásiť používateľov zariadenia</translation>
<translation id="8649763579836720255">Zariadenia OS Chrome môžu používať vzdialené overenie (overený prístup) na získanie certifikátu vydaného certifikačnou autoritou OS Chrome, ktorý potvrdzuje, že zariadenie môže prehrávať chránený obsah. Tento proces zahrnuje odoslanie informácií o hardvére certifikačnej autorite OS Chrome, ktoré dané zariadenie jedinečne identifikujú.

          Ak je toto nastavenie nastavené na hodnotu False, dané zariadenie nepoužije vzdialené overenie na ochranu obsahu a pravdepodobne nebude môcť prehrávať chránený obsah.

          Ak je toto nastavenie nastavené na hodnotu True alebo je ponechané nenastavené, vzdialené overenie sa môže použiť na ochranu obsahu.</translation>
<translation id="4632343302005518762">Povoliť doplnku <ph name="PRODUCT_FRAME_NAME"/> spracovávať uvedené typy obsahu</translation>
<translation id="13356285923490863">Názov pravidla</translation>
<translation id="557658534286111200">Povolí alebo zakáže úpravu záložiek</translation>
<translation id="5378985487213287085">Umožňuje nastaviť, či môžu webové stránky zobrazovať upozornenia na pracovnej ploche. Zobrazovanie upozornení na pracovnej ploche je možné nakonfigurovať tak, že bude v predvolenom nastavení buď umožnené, alebo zamietnuté. Tiež je možné nastaviť, aby sa pri pokuse webových stránok o zobrazenie upozornení na pracovnej ploche zobrazila používateľovi výzva.

          Ak bude toto nastavenie ponechané nenastavené, použije sa pravidlo „AskNotifications“ a používateľ ho bude môcť zmeniť.</translation>
<translation id="2386362615870139244">Povoliť uzamknutie obrazovky v aktívnom režime</translation>
<translation id="6908640907898649429">Slúži na konfiguráciu predvoleného poskytovateľa vyhľadávania. Môžete zvoliť predvoleného poskytovateľa vyhľadávania pre používateľa alebo predvolené vyhľadávanie zakázať.</translation>
<translation id="6544897973797372144">Ak je toto pravidlo nastavené na možnosť True a pravidlo ChromeOsReleaseChannel nie je určené, používatelia budú môcť v zariadení meniť kanál na vydávanie nových verzií. Ak je toto pravidlo nastavené na možnosť False, zariadenie bude uzamknuté v kanáli, v ktorom bolo naposledy nastavené.

      Kanál vybratý používateľom bude prepísaný pravidlom ChromeOsReleaseChannel, avšak ak je kanál pravidla stabilnejší ako kanál nainštalovaný v zariadení, kanál sa zmení až potom, čo bude stabilnejší kanál vo vyššej verzii ako kanál nainštalovaný v zariadení.</translation>
<translation id="389421284571827139">Umožňuje zadať server proxy, ktorý bude prehliadač <ph name="PRODUCT_NAME"/> používať, a bráni používateľom zmeniť nastavenia servera proxy.

      Ak sa rozhodnete server proxy nikdy nepoužívať a vždy sa pripájať ručne, budú všetky ostatné možnosti ignorované.

      Ak zvolíte možnosť automatického zisťovania servera proxy, budú všetky ostatné možnosti ignorované.

      Podrobné príklady nájdete na adrese:
      <ph name="PROXY_HELP_URL"/>

      Ak toto nastavenie povolíte, prehliadač <ph name="PRODUCT_NAME"/> bude ignorovať všetky možnosti týkajúce sa serverov proxy zadané pomocou príkazového riadka.

      Ak toto pravidlo ponecháte nenastavené, umožní to používateľom zvoliť si server proxy samostatne.</translation>
<translation id="681446116407619279">Podporované schémy overenia</translation>
<translation id="4027608872760987929">Povoliť predvoleného poskytovateľa vyhľadávania</translation>
<translation id="2223598546285729819">Predvolené nastavenie upozornení</translation>
<translation id="6158324314836466367">Názov Internetového obchodu pre podniky (podpora je ukončená)</translation>
<translation id="3984028218719007910">Určuje, či má systém <ph name="PRODUCT_OS_NAME"/> po odhlásení zachovať miestne údaje o účte. Ak je toto pravidlo nastavené na hodnotu true, systém <ph name="PRODUCT_OS_NAME"/> nebude uchovávať žiadne trvalé účty a všetky údaje z relácií používateľov budú po odhlásení odstránené. Ak je toto pravidlo nastavené na hodnotu false, alebo nie je nakonfigurované, zariadenie môže uchovávať (zašifrované) miestne údaje používateľa.</translation>
<translation id="3793095274466276777">Slúži na konfiguráciu kontroly predvoleného prehliadača v prehliadači <ph name="PRODUCT_NAME"/> a bráni používateľom toto nastavenie zmeniť. Ak toto nastavenie povolíte, prehliadač <ph name="PRODUCT_NAME"/> pri spustení vždy skontroluje, či je predvoleným prehliadačom, a ak to bude možné, automaticky sa registruje. Ak je toto nastavenie zakázané, prehliadač <ph name="PRODUCT_NAME"/> nebude kontrolovať, či je predvoleným prehliadačom, a zakáže používateľské ovládacie prvky na nastavenie tejto možnosti. Ak toto nastavenie nebolo nakonfigurované, prehliadač <ph name="PRODUCT_NAME"/> umožní používateľovi určiť, či ho chce nastaviť ako predvolený prehliadač a či sa v prípade, ak ním nie je, majú používateľovi zobraziť upozornenia.</translation>
<translation id="3504791027627803580">Určuje adresu URL vyhľadávacieho nástroja použitého na poskytovanie vyhľadávania obrázkov. Žiadosti o vyhľadávanie sa budú odosielať pomocou metódy GET. Ak je nastavené pravidlo DefaultSearchProviderImageURLPostParams, budú žiadosti o vyhľadávanie obrázkov používať namiesto toho metódu POST.

          Toto pravidlo je voliteľné. Ak nie je nastavené, nepoužije sa žiadne vyhľadávanie obrázkov.

          Toto pravidlo sa rešpektuje iba v prípade, ak je povolené pravidlo DefaultSearchProviderEnabled.</translation>
<translation id="7529100000224450960">Umožňuje nastaviť zoznam vzorov adries URL určujúcich webové stránky, ktoré môžu otvárať kontextové okná.

          Ak toto pravidlo ponecháte nenastavené, použije sa v prípade všetkých webových stránok globálna predvolená hodnota buď z pravidla „DefaultPopupsSetting“ (ak je nastavené), alebo z osobnej konfigurácie používateľa.</translation>
<translation id="6155936611791017817">Nastaviť predvolený stav veľkého kurzora na prihlasovacej obrazovke</translation>
<translation id="1530812829012954197">Vždy vykresliť nasledujúce vzory adries URL v hostiteľskom prehliadači</translation>
<translation id="9026000212339701596">Slovník s mapovaním hostiteľov na boolovské identifikátory, ktoré určujú, či bude prístup k hostiteľovi povolený (true) alebo zablokovaný (false).

          Toto pravidlo sa vzťahuje iba na interné používanie prehliadača Chrome.</translation>
<translation id="913195841488580904">Blokovať prístup k zoznamu adries URL</translation>
<translation id="3292147213643666827">Umožňuje prehliadaču <ph name="PRODUCT_NAME"/> fungovať ako server proxy medzi službou <ph name="CLOUD_PRINT_NAME"/> a staršími tlačiarňami pripojenými k počítaču.

      Ak je toto nastavenie povolené alebo nebolo nakonfigurované, používatelia môžu povoliť server proxy pre tlač z cloudu prostredníctvom overenia totožnosti pomocou účtu Google.

      Ak je toto nastavenie zakázané, používatelia nebudú môcť povoliť server proxy a počítač nebude môcť zdieľať pripojené tlačiarne so službou <ph name="CLOUD_PRINT_NAME"/>.</translation>
<translation id="6373222873250380826">Ak je pravidlo nastavené na hodnotu true, zakáže automatické aktualizácie.

      Ak je toto nastavenie nenakonfigurované, alebo je nastavené na hodnotu false, budú zariadenia so systémom <ph name="PRODUCT_OS_NAME"/> automaticky kontrolovať aktualizácie.</translation>
<translation id="6190022522129724693">Predvolené nastavenie kontextových okien</translation>
<translation id="847472800012384958">Zakázať všetkým stránkam zobrazovať kontextové okná</translation>
<translation id="4733471537137819387">Pravidlá týkajúce sa integrovaného overenia pomocou protokolu HTTP</translation>
<translation id="8951350807133946005">Nastaviť adresár diskovej vyrovnávacej pamäte</translation>
<translation id="603410445099326293">Parametre pre adresu URL návrhov, ktorá používa metódu POST</translation>
<translation id="2592091433672667839">Doba nečinnosti pred zobrazením šetriča obrazovky na prihlasovacej obrazovke v režime určenom pre predaj</translation>
<translation id="166427968280387991">Server proxy</translation>
<translation id="2805707493867224476">Povoliť všetkým webovým stránkam zobrazovať kontextové okná</translation>
<translation id="1727394138581151779">Blokovať všetky doplnky</translation>
<translation id="8118665053362250806">Nastaví veľkosť vyrovnávacej pamäte disku média</translation>
<translation id="7079519252486108041">Blokovať kontextové okná na týchto webových stránkach</translation>
<translation id="1859633270756049523">Obmedziť dĺžku relácie</translation>
<translation id="7433714841194914373">Povoliť Dynamické vyhľadávanie</translation>
<translation id="4983201894483989687">Povoliť spúšťanie zastaraných doplnkov</translation>
<translation id="443665821428652897">Po vypnutí prehliadača vymazať údaje stránok (zastarané)</translation>
<translation id="3823029528410252878">Zakáže v prehliadači <ph name="PRODUCT_NAME"/> funkciu ukladania histórie prehliadania a bráni používateľom toto nastavenie zmeniť.

      Ak je toto nastavenie povolené, história prehliadania sa nebude ukladať.

      Ak je toto nastavenie zakázané alebo nenastavené, história prehliadania sa ukladať bude.</translation>
<translation id="7295019613773647480">Povoliť kontrolovaných používateľov</translation>
<translation id="2759224876420453487">Ovládať správanie používateľa v relácii viacerých profilov</translation>
<translation id="3844092002200215574">Umožňuje nakonfigurovať adresár, ktorý bude prehliadač <ph name="PRODUCT_NAME"/> používať na ukladanie súborov vo vyrovnávacej pamäti na disku.

      Ak nastavíte toto pravidlo, prehliadač <ph name="PRODUCT_NAME"/> bude používať zadaný adresár bez ohľadu na to, či používateľ uviedol príznak '--disk-cache-dir'.

      Zoznam premenných, ktoré sa dajú použiť, nájdete na stránke http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables (iba v angličtine).

      Ak toto pravidlo ponecháte nenastavené, použije sa predvolený adresár pre vyrovnávaciu pamäť a používateľ ho bude môcť prepísať pomocou príznaku príkazového riadku „--disk-cache-dir“.</translation>
<translation id="3034580675120919256">Umožní nastaviť, či môžu webové stránky spúšťať kód JavaScript. Spúšťanie kódu JavaScript sa dá pre všetky webové stránky buď umožniť, alebo naopak zamietnuť.

          Ak toto pravidlo ponecháte nenastavené, použije sa pravidlo „AllowJavaScript“ a používateľ to bude môcť zmeniť.</translation>
<translation id="193900697589383153">Pridá na systémový panel tlačidlo odhlásenia.

      Ak je toto nastavenie povolené, na systémovom paneli sa počas aktívnej relácie zobrazuje veľké červené tlačidlo odhlásenia (pokiaľ nie je obrazovka uzamknutá).

      Ak je toto nastavenie zakázané alebo nie je nastavené, na systémovom paneli sa nezobrazuje žiadne veľké červené tlačidlo odhlásenia.</translation>
<translation id="5111573778467334951">Určte akciu, ktorá sa má uskutočniť po uplynutí určitého času nečinnosti počas prevádzky na batérii.

          Keď je toto pravidlo nastavené, určuje akciu, ktorú <ph name="PRODUCT_OS_NAME"/> vykoná, keď používateľ zostane nečinný počas časového obdobia stanoveného časom nečinnosti, ktorý sa dá nakonfigurovať samostatne.

          Keď nie je toto pravidlo nastavené, vykoná sa predvolená akcia – pozastavenie.

          Ak dôjde k pozastaveniu, <ph name="PRODUCT_OS_NAME"/> je možné samostatne nakonfigurovať, aby pred pozastavením obrazovku buď zamkol, alebo nezamkol.</translation>
<translation id="3195451902035818945">Toto pravidlo určuje, či by malo byť delenie záznamov protokolu SSL zakázané. Delenie záznamov je náhradné riešenie pre slabé stránky protokolov SSL 3.0 a TLS 1.0. U niektorých serverov HTTPS a serverov proxy však môže spôsobiť problémy s kompatibilitou. Ak toto pravidlo nie je nastavené, alebo je nastavené na hodnotu False, delenie záznamov sa použije u pripojení SSL / TLS, ktoré používajú šifrovacie nástroje CBC.</translation>
<translation id="6903814433019432303">Toto pravidlo je aktívne iba v režime určenom pre predaj.

      Určuje súbor adries URL, ktoré sa majú načítať po spustení ukážkovej relácie. Toto pravidlo prepíše akékoľvek ďalšie mechanizmy, ktoré slúžia na nastavenie počiatočných adries URL, a tak sa môže použiť iba v reláciách, ktoré nie sú spojené s konkrétnym používateľom.</translation>
<translation id="5868414965372171132">Konfigurácia siete na úrovni používateľa</translation>
<translation id="8519264904050090490">Spravované výnimky adries URL ručne nastavené používateľom</translation>
<translation id="4480694116501920047">Vynútenie Bezpečného vyhľadávania</translation>
<translation id="465099050592230505">Adresa URL Internetového obchodu pre podniky (podpora je ukončená)</translation>
<translation id="1221359380862872747">Po prihlásení v režime ukážky načítať zadané adresy URL</translation>
<translation id="2431811512983100641">Určuje, či má byť povolené rozšírenie certifikátov TLS typu domain-bound.

      Toto nastavenie slúži na povolenie rozšírenia certifikátov TLS typu domain-bound na testovacie účely.  Toto experimentálne nastavenie bude v budúcnosti odstránené.</translation>
<translation id="8711086062295757690">Určuje kľúčové slovo, ktoré vo všeobecnom poli spúšťa vyhľadávanie tohto poskytovateľa. Toto pravidlo je voliteľné.

          Ak nebude nastavené, poskytovateľ vyhľadávania nebude aktivovaný pomocou žiadneho kľúčového slova.

          Toto pravidlo sa vezme do úvahy len v prípade, ak je povolené pravidlo „DefaultSearchProviderEnabled“.</translation>
<translation id="5774856474228476867">Adresa URL vyhľadávania predvoleného poskytovateľa vyhľadávania</translation>
<translation id="4650759511838826572">Zakázať schémy protokolu adresy URL</translation>
<translation id="7831595031698917016">Určuje maximálne oneskorenie v milisekundách medzi prijatím zrušenia platnosti pravidla a načítaním nového pravidla zo služby správy zariadenia.

      Nastavenie tohto pravidla prepíše predvolenú hodnotu 5 000 milisekúnd. Platné hodnoty pre toto pravidlo sú v rozsahu od 1 000 (1 sekunda) do 300 000 (5 minút). Všetky hodnoty mimo tohto rozsahu budú upravené k zodpovedajúcej hranici.

      Ak toto pravidlo nenastavíte, <ph name="PRODUCT_NAME"/> použije predvolenú hodnotu 5 000 milisekúnd.</translation>
<translation id="8099880303030573137">Oneskorenie režimu nečinnosti pri napájaní z batérie</translation>
<translation id="2761483219396643566">Oneskorenie upozornenia na nečinnosť pri napájaní z batérie</translation>
<translation id="5058056679422616660">Dáta automatických aktualizácií systému <ph name="PRODUCT_OS_NAME"/> je možné prevziať prostredníctvom protokolu HTTP namiesto HTTPS. Umožňuje to transparentné ukladanie prevzatí HTTP do vyrovnávacej pamäte HTTP.

      Ak je toto pravidlo nastavené na hodnotu True, systém <ph name="PRODUCT_OS_NAME"/> sa pokúsi prevziať dáta automatických aktualizácií prostredníctvom protokolu HTTP. Ak je pravidlo nastavené na hodnotu False alebo je ponechané nenastavené, na prevzatie dát automatických aktualizácií sa použije protokol HTTPS.</translation>
<translation id="1468307069016535757">Nastaví predvolený stav režimu vysokého kontrastu (funkcia na uľahčenie prístupu) na prihlasovacej obrazovke.

          Ak je toto pravidlo nastavené na hodnotu true, pri zobrazení prihlasovacej obrazovky sa povolí režim vysokého kontrastu.

          Ak je toto pravidlo nastavené na hodnotu false, pri zobrazení prihlasovacej obrazovky sa režim vysokého kontrastu zakáže.

          Ak nastavíte toto pravidlo, používatelia ho budú môcť dočasne prepísať povolením alebo zakázaním režimu vysokého kontrastu. Voľba používateľa však nie je trvalá a predvolené nastavenie sa obnoví zakaždým, keď sa znova zobrazí prihlasovacia obrazovka alebo používateľ bude na prihlasovacej obrazovke nečinný po dobu jednej minúty.

          Ak toto pravidlo ponecháte nenastavené, bude režim vysokého kontrastu pri prvom zobrazení prihlasovacej obrazovky zakázaný. Používatelia budú môcť režim vysokého kontrastu kedykoľvek povoliť alebo zakázať a jeho stav na prihlasovacej obrazovke sa zachová aj po zmene používateľov.</translation>
<translation id="602728333950205286">Adresa URL dynamického vyhľadávania predvoleného poskytovateľa vyhľadávania</translation>
<translation id="3030000825273123558">Povoliť hlásenia o metrikách</translation>
<translation id="8465065632133292531">Parametre pre adresu URL okamžitého vyhľadávania, ktorá používa metódu POST</translation>
<translation id="6659688282368245087">Určuje formát hodín použitý na zariadení.

      Toto pravidlo konfiguruje formát hodín použitý na prihlasovacej obrazovke, ktorý sa tiež predvolene použije pre relácie používateľov. Používatelia môžu tento formát hodín vo svojom účte stále prepísať.

      Ak nie je pravidlo nastavené na hodnotu True, zariadenie použije 24-hodinový formát hodín. Ak je pravidlo nastavené na hodnotu False, zariadenie použije 12-hodinový formát hodín.

      Ak je pravidlo ponechané nenastavené, zariadenie použije predvolený 24-hodinový formát hodín.</translation>
<translation id="6559057113164934677">Nepovoliť žiadnym stránkam používať kameru a mikrofón</translation>
<translation id="7273823081800296768">Ak je toto nastavenie povolené alebo nie je nakonfigurované, používatelia môžu aktivovať párovanie klientov a hostiteľov v čase pripojenia, čím predídu opakovanému zadávaniu kódu PIN.

          Ak je toto nastavenie zakázané, nebude táto funkcia k dispozícii.</translation>
<translation id="1675002386741412210">Podporované na:</translation>
<translation id="1608755754295374538">Adresy URL, ktorým bude udelený prístup k zariadeniam na zachytávanie zvuku bez zobrazenia výzvy</translation>
<translation id="3547954654003013442">Nastavenia servera proxy</translation>
<translation id="5921713479449475707">Povoliť prevzatia automatických aktualizácií prostredníctvom protokolu HTTP</translation>
<translation id="4482640907922304445">Zobrazí tlačidlo Domovská stránka na paneli s nástrojmi prehliadača <ph name="PRODUCT_NAME"/>.

      Ak toto nastavenie povolíte, tlačidlo Domovská stránka sa bude vždy zobrazovať.

      Ak toto nastavenie zakážete, tlačidlo Domovská stránka sa nikdy nezobrazí.

      Ak toto nastavenie povolíte alebo zakážete, používatelia ho v prehliadači <ph name="PRODUCT_NAME"/> nebudú môcť zmeniť ani prepísať.

      Ak toto nastavenie ponecháte nenastavené, umožní to používateľovi zvoliť, či chce tlačidlo Domovská stránka zobraziť.</translation>
<translation id="2518231489509538392">Povoliť prehrávanie zvuku</translation>
<translation id="8146727383888924340">Povoliť používateľom uplatniť ponuky pri registrácii systému OS Chrome</translation>
<translation id="7301543427086558500">Určuje zoznam alternatívnych adries URL, ktoré sa môžu použiť na extrahovanie hľadaných výrazov z vyhľadávacích nástrojov. Adresy URL by mali obsahovať značku <ph name="SEARCH_TERM_MARKER"/>, ktorá sa použije na extrahovanie hľadaných výrazov.

          Toto pravidlo je nepovinné. Ak ho nenastavíte, nepoužijú sa na extrahovanie hľadaných výrazov žiadne alternatívne adresy URL.

          Toto pravidlo sa použije iba v prípade, že je povolené pravidlo DefaultSearchProviderEnabled.</translation>
<translation id="436581050240847513">Hlásiť sieťové rozhrania zariadenia</translation>
<translation id="6282799760374509080">Povoliť alebo zakázať zaznamenávanie zvuku</translation>
<translation id="8864975621965365890">Potlačí výzvu o zamietnutie, ktorá sa zobrazí pri vykreslení stránky rámcom <ph name="PRODUCT_FRAME_NAME"/>.</translation>
<translation id="3264793472749429012">Kódovania predvoleného poskytovateľa vyhľadávania</translation>
<translation id="285480231336205327">Povoliť režim s vysokým kontrastom</translation>
<translation id="5366977351895725771">Ak toto pravidlo nastavíte na hodnotu false, bude vytváranie a prihlasovanie kontrolovaných používateľov zakázané. Všetci existujúci kontrolovaní používatelia budú stále k dispozícii.

          Ak toto pravidlo nenakonfigurujete alebo ho nastavíte na hodnotu true, tento používateľ bude môcť vytvárať a spravovať kontrolovaných používateľov.</translation>
<translation id="8101760444435022591">Vzhľadom na skutočnosť, že kontroly zrušenia typu soft-fail neposkytujú z hľadiska bezpečnosti žiadne efektívne výhody, sú v predvolenom nastavení prehliadača <ph name="PRODUCT_NAME"/> verzie 19 a novších zakázané. Ak toto pravidlo nastavíte na hodnotu true, obnoví sa predchádzajúca konfigurácia a začnú sa vykonávať kontroly OCSP/CLR online.

      Ak pravidlo nenastavíte alebo ho nastavíte na hodnotu false, prehliadač Chrome verzie 19 a novších nebude vykonávať kontroly zrušenia online.</translation>
<translation id="5469484020713359236">Umožňuje nastaviť zoznam vzorov adries URL určujúcich webové stránky, ktoré môžu nastavovať súbory cookie.

          Ak toto pravidlo ponecháte nenastavené, použije sa v prípade všetkých webových stránok globálna predvolená hodnota buď z pravidla „DefaultCookiesSetting“ (ak je nastavené), alebo z osobnej konfigurácie používateľa.</translation>
<translation id="1504431521196476721">Diaľkové overenie</translation>
<translation id="1881299719020653447">Skryť internetový obchod z karty Nová stránka a zo spúšťača aplikácií</translation>
<translation id="930930237275114205">Nastaviť adresár na údaje používateľov pre aplikáciu <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="244317009688098048">Povolí záchrannú klávesovú skratku pre automatické prihlásenie.

      Ak je toto pravidlo nastavené na hodnotu True alebo nie je nastavené vôbec a účet na miestnom zariadení je nastavený na automatické prihlásenie s nulovým oneskorením, systém <ph name="PRODUCT_OS_NAME"/> bude prijímať klávesovú skratku Ctrl+Alt+S, ktorá umožňuje obísť automatické prihlásenie a okamžite zobraziť prihlasovaciu obrazovku.

      Ak je toto pravidlo nastavené na hodnotu False, automatické prihlásenie s nulovým oneskorením (ak je nakonfigurované) sa nedá obísť.</translation>
<translation id="5208240613060747912">Umožňuje nastaviť zoznam vzorov adries URL určujúcich webové stránky, ktoré nemôžu zobrazovať upozornenia.

          Ak toto pravidlo ponecháte nenastavené, použije sa v prípade všetkých webových stránok globálna predvolená hodnota buď z pravidla „DefaultNotificationsSetting“ (ak je nastavené), alebo z osobnej konfigurácie používateľa.</translation>
<translation id="346731943813722404">Toto pravidlo určuje, či oneskorenia správy napájania a limit dĺžky relácie sa majú spustiť iba po zaznamenaní prvej aktivity používateľa v relácii.

          Ak je toto pravidlo nastavené na hodnotu True, oneskorenia správy napájania a limit dĺžky relácie sa nespustia po zaznamenaní prvej aktivity používateľa v relácii.

          Ak je toto pravidlo nastavené na hodnotu False alebo nastavené nie je, oneskorenia správy napájania a limit dĺžky relácie sa spustia hneď na začiatku relácie.</translation>
<translation id="4600786265870346112">Povoliť veľký kurzor</translation>
<translation id="8592105098257899882">Slúži na konfiguráciu veľkosti vyrovnávacej pamäte, ktorú bude prehliadač <ph name="PRODUCT_NAME"/> používať na ukladanie súborov vo vyrovnávacej pamäti na disk.

      Ak toto pravidlo nastavíte, prehliadač <ph name="PRODUCT_NAME"/> použije zadanú veľkosť vyrovnávacej pamäte bez ohľadu na to, či používateľ zadal príznak  „--disk-cache-size“ alebo nie.

      Ak bude hodnota tohto pravidla 0, použije sa predvolená veľkosť vyrovnávacej pamäte, no používateľ to nebude môcť zmeniť.

      Ak toto pravidlo nenastavíte, použije sa predvolená veľkosť a používateľ to bude môcť prekonať zadaním príznaku „--disk-cache-size“.</translation>
<translation id="5887414688706570295">Konfiguruje predponu TalkGadget, ktorú budú používať hostitelia vzdialeného prístupu, a bráni používateľom, aby ju zmenili.

          Ak je táto predpona určená, pridá sa pred základný názov modulu TalkGadget, čím vznikne celý názov domény TalkGadget. Základný názov domény TalkGadget je „.talkgadget.google.com“.

          Ak je toto nastavenie povolené, budú hostitelia pri pristupovaní k doméne TalkGadget používať vlastný názov domény namiesto predvoleného názvu.

          Ak je toto nastavenie zakázané alebo nie je nastavené, pre všetkých hostiteľov sa použije predvolený názov domény TalkGadget (chromoting-host.talkgadget.google.com).

          Nastavenie tohto pravidla nemá žiadny vplyv na klientov so vzdialeným prístupom, ktorí budú k doméne TalkGadget pristupovať vždy pomocou adresy chromoting-client.talkgadget.google.com.</translation>
<translation id="5765780083710877561">Popis:</translation>
<translation id="6915442654606973733">Povolí hlasovú odozvu (funkcia na uľahčenie prístupu).

      Ak toto pravidlo nastavíte na hodnotu true, bude hlasová odozva vždy zapnutá.

      Ak toto pravidlo nastavíte na hodnotu false, bude hlasová odozva vždy vypnutá.

      Ak toto pravidlo povolíte alebo zakážete, používatelia ho nebudú môcť zmeniť ani prepísať.

      Ak toto pravidlo ponecháte nenastavené, hlasová odozva bude spočiatku zakázaná, ale používateľ to bude môcť kedykoľvek zmeniť.</translation>
<translation id="7796141075993499320">Umožňuje nastaviť zoznam vzorov adries URL určujúcich webové stránky, ktoré môžu spúšťať doplnky.

          Ak toto pravidlo ponecháte nenastavené, použije sa v prípade všetkých webových stránok globálna predvolená hodnota buď z pravidla „DefaultPluginsSetting“ (ak je nastavené), alebo z osobnej konfigurácie používateľa.</translation>
<translation id="3809527282695568696">Ak je ako akcia pri spustení začiarknuté políčko „Otvoriť zoznam adries URL“, umožní vám to zvoliť zoznam adries URL, ktoré sa otvoria. Ak je možnosť ponechaná nenastavená, pri spustení sa neotvorí žiadna adresa URL.

          Toto pravidlo funguje len v prípade, ak je pravidlo „RestoreOnStartup“ nastavené na možnosť „RestoreOnStartupIsURLs“.</translation>
<translation id="649418342108050703">Zakáže podporu rozhrania API pre grafiku 3D.

      Ak toto nastavenie povolíte, zabránite webovým stránkam v prístupe ku grafickému procesoru (GPU). Webové stránky nebudú môcť pristupovať k rozhraniu API WebGL a doplnky nebudú môcť využiť rozhranie API Pepper 3D.

      Ak toto nastavenie zakážete alebo ho ponecháte nenastavené, umožníte webovým stránkam používať rozhranie API WebGL a doplnkom umožníte používať rozhranie API Pepper 3D. Predvolené nastavenia prehliadača však aj naďalej môžu vyžadovať postúpenie argumentov príkazového riadka. V opačnom prípade môžu použitie rozhraní API znemožniť.</translation>
<translation id="2077273864382355561">Oneskorenie vypnutia obrazovky pri napájaní z batérie</translation>
<translation id="909184783177222836">Správa napájania</translation>
<translation id="3417418267404583991">Ak je toto pravidlo nastavené na hodnotu true alebo je nenakonfigurované, systém <ph name="PRODUCT_OS_NAME"/> povolí prihlásenie hostí. Prihlásenia hostí predstavujú relácie anonymných používateľov a nevyžadujú heslo.

      Ak je toto pravidlo nastavené na hodnotu false, systém <ph name="PRODUCT_OS_NAME"/> nepovolí spustenie relácií hosťa.</translation>
<translation id="8329984337216493753">Toto pravidlo je aktívne iba v režime určenom pre predaj.

      Ak je zadané pravidlo DeviceIdleLogoutTimeout, určuje toto pravidlo dobu zobrazenia poľa s upozornením a odpočítavaním, ktoré sa používateľovi zobrazí predtým, než dôjde k odhláseniu.

      Hodnota pre toto pravidlo by mala byť zadaná v milisekundách.</translation>
<translation id="237494535617297575">Umožňuje nastaviť zoznam vzorov adries URL určujúcich webové stránky, na ktorých sa môžu zobrazovať upozornenia.

          Ak toto pravidlo ponecháte nenastavené, použije sa v prípade všetkých webových stránok globálna predvolená hodnota buď z pravidla „DefaultNotificationsSetting“ (ak je nastavené), alebo z osobnej konfigurácie používateľa.</translation>
<translation id="7258823566580374486">Povoliť blokovanie hostiteľov so vzdialeným prístupom</translation>
<translation id="5560039246134246593">Pridá parameter k načítaniu počiatočnej hodnoty variácie v prehliadači <ph name="PRODUCT_NAME"/>.

      Ak je pravidlo stanovené, pridá sa k adrese URL parameter dopytu s názvom „obmedziť“, ktorý sa použije na načítanie počiatočnej hodnoty variácie. Hodnota parametra bude predstavovať hodnotu stanovenú v tomto pravidle.

      Ak pravidlo stanovené nie je, adresa URL počiatočnej hodnoty variácie sa nezmení.</translation>
<translation id="944817693306670849">Nastaviť veľkosť vyrovnávacej pamäte disku</translation>
<translation id="8544375438507658205">Predvolený vykresľovací modul HTML pre doplnok <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="2371309782685318247">Určuje interval v milisekundách, v ktorom budú službe správy zariadenia odosielané žiadosti o informácie o pravidlách pre používateľov.

      Nastavením tohto pravidla bude prepísaná predvolená hodnota 3 hodiny. Platné hodnoty pre toto pravidlo sa pohybujú v rozmedzí od 1 800 000 (30 minút) do 86 400 000 (1 deň). Namiesto hodnôt mimo tento rozsah bude použitá príslušná medzná hodnota.

      Ak toto nastavenie ponecháte nenastavené, v prehliadači <ph name="PRODUCT_NAME"/> sa použije predvolená hodnota 3 hodiny.</translation>
<translation id="2571066091915960923">Povoliť alebo zakázať kompresiu dát servera proxy a zabrániť používateľom toto nastavenie zmeniť.

      Ak toto nastavenie povolíte alebo zakážete, nemôžu ho používateľa zmeniť ani prepísať.

      Ak pravidlo ponecháte nenastavené, bude si môcť používateľ vybrať, či chce funkciu kompresie dát servera proxy použiť.</translation>
<translation id="7424751532654212117">Zoznam výnimiek zo zoznamu zakázaných doplnkov</translation>
<translation id="6233173491898450179">Nastaviť adresár na preberanie</translation>
<translation id="78524144210416006">Nakonfigurujte správu napájania na prihlasovacej obrazovke v programe <ph name="PRODUCT_OS_NAME"/>.

      Toto nastavenie umožňuje nakonfigurovať, ako sa <ph name="PRODUCT_OS_NAME"/> správa, keď nastane určitý čas nečinnosti používateľa pri zobrazenej prihlasovacej obrazovke. Toto pravidlo ovláda viacero nastavení. Jednotlivé sémantiky a rozsahy hodnôt nájdete uvedené pri zodpovedajúcich pravidlách, ktoré ovládajú správu napájania v rámci relácie. Jediné odchýlky od týchto pravidiel sú nasledovné:
      * Akcie, ktoré sa majú uskutočniť pri nečinnosti alebo zavretí veka, nesmú ukončiť reláciu.
      * Predvolená akcia uskutočnená pri nečinnosti počas prevádzky s napájaním je vypnutie.

      Pravidlo by malo byť špecifikované ako reťazec, ktorý vyjadruje jednotlivé nastavenia vo formáte JSON v súlade s nasledujúcou schémou:
      {
        &quot;type&quot;: &quot;object&quot;,
        &quot;properties&quot;: {
          &quot;AC&quot;: {
            &quot;description&quot;: &quot;Nastavenia správy napájania, ktoré sa vzťahujú iba na prevádzku s napájaním&quot;,
            &quot;type&quot;: &quot;object&quot;,
            &quot;properties&quot;: {
              &quot;Delays&quot;: {
                &quot;type&quot;: &quot;object&quot;,
                &quot;properties&quot;: {
                  &quot;ScreenDim&quot;: {
                    &quot;description&quot;: &quot;Časové obdobie v milisekundách bez vstupu používateľa, po uplynutí ktorého sa stlmí obrazovka&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;ScreenOff&quot;: {
                    &quot;description&quot;: &quot;Časové obdobie v milisekundách bez vstupu používateľa, po uplynutí ktorého sa vypne obrazovka&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;Idle&quot;: {
                    &quot;description&quot;: &quot;Časové obdobie v milisekundách bez vstupu používateľa, po uplynutí ktorého sa vykoná akcia nečinnosti&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  }
                }
              },
              &quot;IdleAction&quot;: {
                &quot;description&quot;: &quot;Akcia, ktorá sa má vykonať po uplynutí času nečinnosti&quot;,
                &quot;enum&quot;: [ &quot;Suspend&quot;, &quot;Shutdown&quot;, &quot;DoNothing&quot; ]
              }
            }
          },
          &quot;Battery&quot;: {
            &quot;description&quot;: &quot;Nastavenia správy napájania, ktoré sa vzťahujú iba na prevádzku na batérii&quot;,
            &quot;type&quot;: &quot;object&quot;,
            &quot;properties&quot;: {
              &quot;Delays&quot;: {
                &quot;type&quot;: &quot;object&quot;,
                &quot;properties&quot;: {
                  &quot;ScreenDim&quot;: {
                    &quot;description&quot;: &quot;Časové obdobie v milisekundách bez vstupu používateľa, po uplynutí ktorého sa stlmí obrazovka&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;ScreenOff&quot;: {
                    &quot;description&quot;: &quot;Časové obdobie v milisekundách bez vstupu používateľa, po uplynutí ktorého sa vypne obrazovka&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;Idle&quot;: {
                    &quot;description&quot;: &quot;Časové obdobie v milisekundách bez vstupu používateľa, po uplynutí ktorého sa vykoná akcia nečinnosti&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  }
                }
              },
              &quot;IdleAction&quot;: {
                &quot;description&quot;: &quot;Akcia, ktorá sa má vykonať po uplynutí času nečinnosti&quot;,
                &quot;enum&quot;: [ &quot;Suspend&quot;, &quot;Shutdown&quot;, &quot;DoNothing&quot; ]
              }
            }
          },
          &quot;LidCloseAction&quot;: {
            &quot;description&quot;: &quot;Akcia, ktorá sa má vykonať po zavretí veka&quot;,
            &quot;enum&quot;: [ &quot;Suspend&quot;, &quot;Shutdown&quot;, &quot;DoNothing&quot; ]
          },
          &quot;UserActivityScreenDimDelayScale&quot;: {
            &quot;description&quot;: &quot;Percentá, podľa ktorých sa upraví miera oneskorenia stlmenia obrazovky, keď sa zaznamená aktivita používateľa pri stlmenej obrazovke alebo v krátkom čase po vypnutí obrazovky&quot;,
            &quot;type&quot;: &quot;integer&quot;,
            &quot;minimum&quot;: 100
          }
        }
      }

      Ak sa toto nastavenie nešpecifikuje, použije sa predvolená hodnota.

      Ak sa toto pravidlo nenastaví, pre všetky nastavenia sa použijú predvolené hodnoty.</translation>
<translation id="8908294717014659003">Umožňuje nastaviť, či webové stránky budú môcť používať zariadenia na zaznamenávanie médií. Prístup k zariadeniam na zaznamenávanie médií môže byť povolený v predvolenom nastavení alebo sa používateľovi môže zobraziť dopyt zakaždým, keď nejaké webové stránky budú chcieť použiť zariadenie na zaznamenávanie médií.

          Ak toto pravidlo nenastavíte, použije sa pravidlo PromptOnAccess a používateľ ho bude môcť zmeniť.</translation>
<translation id="2299220924812062390">Určiť zoznam povolených doplnkov</translation>
<translation id="328908658998820373">Povoliť režim celej obrazovky.

      Toto pravidlo ovláda dostupnosť režimu celej obrazovky, v ktorom je celé používateľské rozhranie prehliadača <ph name="PRODUCT_NAME"/> skryté a zobrazuje sa iba obsah webu.

      Ak je toto pravidlo nastavené na hodnotu True alebo nie je nakonfigurované, používateľ, aplikácie a rozšírenia s vhodnými povoleniami môžu vstúpiť do režimu celej obrazovky.

      Ak je toto pravidlo nastavené na hodnotu False, do režimu celej obrazovky nemôžu vstúpiť ani používatelia, ani aplikácie či rozšírenia.

      Keď je režim celej obrazovky zakázaný, je na všetkých platformách okrem systému <ph name="PRODUCT_OS_NAME"/> zakázaný aj režim verejného terminálu.</translation>
<translation id="4325690621216251241">Pridať na systémový panel tlačidlo odhlásenia</translation>
<translation id="924557436754151212">Import uložených hesiel z predvoleného prehliadača pri prvom spustení</translation>
<translation id="1465619815762735808">Kliknutím prehrať</translation>
<translation id="7227967227357489766">Definuje zoznam používateľov, ktorí majú povolenie prihlásiť sa do zariadenia. Položky majú formát <ph name="USER_WHITELIST_ENTRY_FORMAT"/>, napríklad <ph name="USER_WHITELIST_ENTRY_EXAMPLE"/>. Ak chcete povoliť všetkých používateľov z niektorej domény, použite položky vo formáte <ph name="USER_WHITELIST_ENTRY_WILDCARD"/>.

      Ak toto pravidlo nenakonfigurujete, budú sa môcť do zariadenia prihlásiť všetci používatelia. Upozorňujeme, že pri vytvorení nového používateľa je potrebné náležite nakonfigurovať aj pravidlo <ph name="DEVICEALLOWNEWUSERS_POLICY_NAME"/>.</translation>
<translation id="8135937294926049787">Určuje dobu nečinnosti používateľa, po ktorej sa obrazovka pri používaní napájacieho zdroja uzamkne.

          Ak je toto pravidlo nastavené na hodnotu väčšiu ako nula, určuje dobu nečinnosti používateľa, po ktorej systém <ph name="PRODUCT_OS_NAME"/> obrazovku vypne.

          Ak je toto pravidlo nastavené na hodnotu nula, systém <ph name="PRODUCT_OS_NAME"/> obrazovku pri nečinnosti používateľa nevypne.

          Ak toto pravidlo nastavené nie je, použije sa predvolená doba.

          Hodnota pravidla by mala byť uvedená v milisekundách. Hodnoty musia byť nižšie alebo rovnaké ako oneskorenie režimu nečinnosti.</translation>
<translation id="1897365952389968758">Povoliť všetkým webovým stránkam spúšťať jazyk JavaScript</translation>
<translation id="5244714491205147861">Správa napájania na prihlasovacej obrazovke</translation>
<translation id="922540222991413931">Konfigurácia zdrojov inštalácie rozšírenia, aplikácie a skriptov používateľa</translation>
<translation id="7323896582714668701">Dodatočné parametre príkazového riadka pre <ph name="PRODUCT_NAME"/></translation>
<translation id="6931242315485576290">Zakázať synchronizáciu údajov so servermi Google</translation>
<translation id="7006788746334555276">Nastavenia obsahu</translation>
<translation id="63659515616919367">Ovládať správanie používateľa v relácií viacerých profilov na zariadeniach so systémom <ph name="PRODUCT_OS_NAME"/>.

      Ak je toto pravidlo nastavené na hodnotu MultiProfileUserBehaviorUnrestricted, môže byť používateľ v relácii viacerých profilov primárnym alebo sekundárnym používateľom.

      Ak je toto pravidlo nastavené na hodnotu MultiProfileUserBehaviorMustBePrimary, môže byť používateľ v relácii viacerých profilov iba primárnym používateľom.

      Ak je toto pravidlo nastavené na hodnotu MultiProfileUserBehaviorNotAllowed, používateľ nemôže byť súčasťou relácie viacerých profilov.

      Ak toto nastavenie nastavíte, používatelia ho nebudú môcť zmeniť ani prepísať.

      Ak dôjde k zmene nastavenia počas prihlásenia používateľa do relácie viacerých profilov, u všetkých používateľov budú v danej relácii skontrolované zodpovedajúce nastavenia. Ak sa zistí, že sa v relácii nachádza používateľ, ktorý to už nemá povolené, celá relácia sa zavrie.

      Ak sa pravidlo ponechá nenastavené, použije sa predvolená hodnota MultiProfileUserBehaviorUnrestricted.</translation>
<translation id="5142301680741828703">Vždy vykreslovať nasledujúce vzory adries URL v doplnku <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="4625915093043961294">Konfigurovať zoznam rozšírení, ktorých inštalácia je povolená</translation>
<translation id="187819629719252111">Umožňuje pristupovať k miestnym súborom v počítači tým, že prehliadaču <ph name="PRODUCT_NAME"/> umožní zobrazenie dialógových okien na výber súboru.

      Ak toto nastavenie povolíte, používatelia budú môcť otvárať dialógové okná na výber súboru obvyklým spôsobom.

      Ak toto nastavenie zakážete a používateľ vykoná akciu, po ktorej by sa mu v obvyklom prípade zobrazilo dialógové okno na výber súboru (napríklad import záložiek, odovzdávanie súborov, ukladanie odkazov a pod.), zobrazí sa mu namiesto tohto dialógového okna správa a prehliadač sa zachová, ako keby používateľ v dialógovom okne na výber súboru klikol na možnosť Zrušiť.

      Ak toto nastavenie nenastavíte, používatelia budú môcť otvárať dialógové okná na výber súboru obvyklým spôsobom.</translation>
<translation id="4507081891926866240">Umožňuje prispôsobiť zoznam vzorov adries URL, ktoré by mal doplnok <ph name="PRODUCT_FRAME_NAME"/> vždy vykresliť.

          Ak toto pravidlo nenastavíte, bude pre všetky webové stránky použitý predvolený vykresľovací modul (ako je určené pravidlom „ChromeFrameRendererSettings“).

          Ukážkové vzory nájdete na adrese http://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="3101501961102569744">Zvoľte spôsob konfigurácie nastavení servera proxy</translation>
<translation id="1803646570632580723">Zoznam pripnutých aplikácií, ktoré sa zobrazujú v spúšťači</translation>
<translation id="1062011392452772310">Povoliť pre zariadenie vzdialené overenie</translation>
<translation id="7774768074957326919">Použiť systémové nastavenia servera proxy</translation>
<translation id="3891357445869647828">Povoliť kód JavaScript</translation>
<translation id="868187325500643455">Povoliť všetkým webovým stránkam automatické spúšťanie doplnkov</translation>
<translation id="7421483919690710988">Nastaviť veľkosť vyrovnávacej pamäte média v bajtoch</translation>
<translation id="5226033722357981948">Určiť, či má byť nástroj na vyhľadávanie doplnkov zakázaný</translation>
<translation id="4890209226533226410">Nastaví typ lupy obrazovky, ktorý je povolený.


          Ak je toto pravidlo nastavené, ovláda typ lupy obrazovky, ktorý je povolený. Nastavenie pravidla na možnosť Žiadne zakáže lupy obrazovky.



          Ak toto pravidlo nastavíte, používatelia ho nebudú môcť zmeniť ani prepísať.


          Ak toto pravidlo ponecháte nenastavené, bude lupa obrazovky spočiatku zakázaná. Používatelia budú môcť lupu obrazovky kedykoľvek povoliť.</translation>
<translation id="3428247105888806363">Povolenie predpovede siete</translation>
<translation id="3460784402832014830">Určuje adresu URL, ktorú použije vyhľadávací nástroj na poskytnutie stránky Nová karta.

          Toto pravidlo je voliteľné. Ak sa nenastaví, neposkytne sa žiadna stránka Nová karta.

          Toto pravidlo sa rešpektuje iba v prípade, ak je povolené pravidlo DefaultSearchProviderEnabled.</translation>
<translation id="6145799962557135888">Umožňuje nastaviť zoznam vzorov adries URL určujúcich webové stránky, ktoré môžu spúšťať kód JavaScript.

          Ak toto pravidlo ponecháte nenastavené, použije sa v prípade všetkých webových stránok globálna predvolená hodnota buď z pravidla „DefaultJavaScriptSetting“ (ak je nastavené), alebo z osobnej konfigurácie používateľa.</translation>
<translation id="2757054304033424106">Typy rozšírení/aplikácií, ktorých inštalácia je povolená</translation>
<translation id="7053678646221257043">Ak je toto pravidlo povolené, záložky budú importované z aktuálneho predvoleného prehliadača. Povolenie tohto pravidla má vplyv aj na dialógové okno importu.

      Ak je zakázané, nebudú importované žiadne záložky.

      Ak nie je nastavené, môže sa používateľovi zobraziť výzva, či chce domovskú stránku importovať alebo či má import prebehnúť automaticky.</translation>
<translation id="5757829681942414015">Umožňuje nakonfigurovať adresár, ktorý bude prehliadač <ph name="PRODUCT_NAME"/> používať na ukladanie údajov používateľa.

      Ak nastavíte toto pravidlo, prehliadač <ph name="PRODUCT_NAME"/> bude používať zadaný adresár bez ohľadu na to, či používateľ uviedol príznak „--user-data-dir“.

      Zoznam premenných, ktoré sa dajú použiť, nájdete na stránke http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables (iba v angličtine).

      Ak toto pravidlo ponecháte nenastavené, použije sa predvolená cesta profilu a používateľ ju bude môcť prepísať pomocou príznaku príkazového riadku „--user-data-dir“.</translation>
<translation id="5067143124345820993">Zoznam používateľov s povolením na prihlásenie</translation>
<translation id="2514328368635166290">Určuje adresu URL ikony predvoleného poskytovateľa vyhľadávania.

          Toto pravidlo je voliteľné. Ak nebude nastavené, pri poskytovateľovi vyhľadávania sa nezobrazí žiadna ikona.

          Toto pravidlo bude dodržané len v prípade, ak je povolené pravidlo „DefaultSearchProviderEnabled“.</translation>
<translation id="7194407337890404814">Názov predvoleného poskytovateľa vyhľadávania</translation>
<translation id="1843117931376765605">Frekvencia obnovenia pravidiel pre používateľov</translation>
<translation id="5535973522252703021">Zoznam povolených serverov delegovania protokolu Kerberos</translation>
<translation id="9187743794267626640">Zákaz pripojenia externého ukladacieho priestoru</translation>
<translation id="6353901068939575220">Určuje parametre, ktoré sa použijú vyhľadávaní adresy URL pomocou metódy POST. Pozostáva z párov názov/hodnota oddelených čiarkami. Ak je hodnota parameter šablóny, napr. hodnota {searchTerms} v príklade vyššie, bude nahradená údajmi skutočných vyhľadávaných výrazov.

          Toto pravidlo je voliteľné. Ak nie je nastavené, žiadosť o vyhľadávanie sa odošle pomocou metódy GET.

          Toto pravidlo sa rešpektuje iba v prípade, ak je povolené pravidlo DefaultSearchProviderEnabled.</translation>
<translation id="5307432759655324440">Dostupnosť režimu Inkognito</translation>
<translation id="4056910949759281379">Zakázať protokol SPDY</translation>
<translation id="3808945828600697669">Určiť zoznam zakázaných doplnkov</translation>
<translation id="4525521128313814366">Umožňuje nastaviť zoznam vzorov adries URL určujúcich webové stránky, ktoré nemôžu zobrazovať obrázky.

          Ak toto pravidlo ponecháte nenastavené, použije sa v prípade všetkých webových stránok globálna predvolená hodnota buď z pravidla „DefaultImagesSetting“ (ak je nastavené), alebo z osobnej konfigurácie používateľa.</translation>
<translation id="8499172469244085141">Predvolené nastavenia (používatelia ich môžu nahradiť)</translation>
<translation id="8693243869659262736">Použiť vstavaného klienta DNS</translation>
<translation id="3072847235228302527">Nastaviť Zmluvné podmienky pre miestny účet v zariadení</translation>
<translation id="5523812257194833591">Verejná relácia, do ktorej sa zariadenie po oneskorení automaticky prihlási.

      Ak je pravidlo nastavené, zariadenie sa po uplynutí určitého časového obdobia nečinnosti používateľa na prihlasovacej obrazovke automaticky prihlási do určenej relácie. Verejná relácia už musí byť nakonfigurovaná (prečítajte si časť |DeviceLocalAccounts|).

      Ak pravidlo nastavené nie je, automatické prihlásenie nenastane.</translation>
<translation id="5983708779415553259">Predvolené správanie pre webové stránky, ktoré sa nenachádzajú v žiadnom obsahovom balíku</translation>
<translation id="3866530186104388232">Ak je toto pravidlo nastavené na hodnotu pravda alebo je nenakonfigurované, systém <ph name="PRODUCT_OS_NAME"/> na prihlasovacej obrazovke zobrazí existujúcich používateľov a umožní vybrať jedného z nich. Ak je pravidlo nastavené na hodnotu false, systém <ph name="PRODUCT_OS_NAME"/> použije pri prihlásení výzvu na zadanie používateľského mena a hesla.</translation>
<translation id="2098658257603918882">Povoliť hlásenie údajov týkajúcich sa používania a zlyhaní</translation>
<translation id="2324547593752594014">Umožní prihlásenie do prehliadača Chrome</translation>
<translation id="172374442286684480">Povoliť všetkým webovým stránkam nastavovať miestne údaje</translation>
<translation id="1151353063931113432">Povoliť obrázky na týchto webových stránkach</translation>
<translation id="1297182715641689552">Použiť skript servera proxy vo formáte PAC</translation>
<translation id="2976002782221275500">Určuje dobu nečinnosti používateľa, po ktorej sa pri napájaní z batérie zníži jas obrazovky.

          Ak je toto pravidlo nastavené na hodnotu väčšiu ako nula, určuje dobu nečinnosti používateľa, po ktorej systém <ph name="PRODUCT_OS_NAME"/> zníži jas obrazovky.

          Ak je toto pravidlo nastavené na hodnotu nula, systém <ph name="PRODUCT_OS_NAME"/> jas obrazovky pri nečinnosti používateľa nezníži.

          Ak toto pravidlo nastavené nie je, použije sa predvolená doba.

          Hodnota pravidla by mala byť uvedená v milisekundách. Hodnoty musia byť nižšie alebo rovnaké ako oneskorenie vypnutia obrazovky (pokiaľ je nastavené) a oneskorenie režimu nečinnosti.</translation>
<translation id="8631434304112909927">po verziu <ph name="UNTIL_VERSION"/></translation>
<translation id="7469554574977894907">Povoliť návrhy pre vyhľadávanie</translation>
<translation id="4906194810004762807">Frekvencia obnovenia pravidiel pre zariadenie</translation>
<translation id="8922668182412426494">Servery, na ktoré môže <ph name="PRODUCT_NAME"/> delegovať poverenia.

          Ak chcete zadať niekoľko názvov serverov, oddeľte ich čiarkami. Zástupné znaky (*) sú povolené.

          Ak pravidlo nenastavíte, prehliadač Chrome nebude delegovať poverenia používateľov ani v prípade, ak je server v sieti intranet.</translation>
<translation id="1398889361882383850">Umožňuje nastaviť, či môžu webové stránky automaticky spúšťať doplnky. Automatické spúšťanie doplnkov môže byť pre všetky webové stránky povolené alebo zakázané.

          Možnosť Kliknutím prehrať umožňuje spúšťať doplnky, ale používateľ musí na ne predtým kliknúť.

          Ak sa toto pravidlo ponechá nenastavené, použije sa možnosť AllowPlugins (povoliť doplnky) a používateľ to bude môcť zmeniť.</translation>
<translation id="7974114691960514888">Toto pravidlo už nie je podporované.

          Povoľuje použitie serverov typu STUN a relay pri pripájaní sa k vzdialenému klientskemu programu.

          Ak je toto nastavenie povolené, môžete tento počítač vyhľadať a pripojiť sa k počítačom vzdialeného hostiteľa aj v prípade, ak sú oddelené bránou firewall.

          Ak je toto nastavenie zakázané a brána firewall filtruje odchádzajúce pripojenia cez protokol UDP, môže sa tento počítač pripojiť len k počítačom hostiteľa v rámci miestnej siete.</translation>
<translation id="7694807474048279351">Naplánuje automatické reštartovanie po použití aktualizácie systému <ph name="PRODUCT_OS_NAME"/>.

      Ak je toto pravidlo nastavené na hodnotu true, automatické reštartovanie sa naplánuje vždy, keď sa použije aktualizácia systému <ph name="PRODUCT_OS_NAME"/> a dokončenie procesu aktualizácie bude vyžadovať reštartovanie. Automatické reštartovanie sa naplánuje na vybratý čas, ale ak používateľ v danej chvíli zariadenie používa, môže sa reštart zariadenia odložiť až o 24 hodín.

      Ak je toto pravidlo nastavené na hodnotu false, nenaplánuje sa po použití aktualizácie systému <ph name="PRODUCT_OS_NAME"/> žiadne automatické reštartovanie. Proces aktualizácie sa dokončí pri ďalšom reštartovaní zariadenia.

      Ak nastavíte toto pravidlo, používatelia ho nebudú môcť prepísať ani zmeniť.

     Poznámka: Automatické reštartovanie je v súčasnosti povolené, iba pokiaľ sa zobrazuje prihlasovacia obrazovka alebo prebieha relácia aplikácie v režime kiosku. Toto sa v budúcnosti zmení a pravidlo sa použije bez ohľadu na to, či prebieha relácia akéhokoľvek typu alebo nie.</translation>
<translation id="5511702823008968136">Povoliť panel so záložkami</translation>
<translation id="5105313908130842249">Oneskorenie uzamknutia obrazovky pri napájaní z batérie</translation>
<translation id="7882585827992171421">Toto pravidlo je aktívne iba v režime určenom pre predaj.

      Určuje identifikátor rozšírenia, ktoré sa má použiť ako šetrič obrazovky na prihlasovacej obrazovke. Rozšírenie musí byť súčasťou balíka AppPack, ktorý bol pre túto doménu nakonfigurovaný v rámci pravidla DeviceAppPack.</translation>
<translation id="7736666549200541892">Povolí rozšírenie certifikátov TLS typu domain-bound</translation>
<translation id="1796466452925192872">Umožní vám určiť, ktoré adresy URL majú povolenie inštalovať rozšírenia, aplikácie a motívy.

V prehliadači Chrome 21 je inštalácia rozšírení, aplikácií a skriptov používateľa pochádzajúcich z iných zdrojov ako z Internetového obchodu Chrome náročnejšia. Používatelia mohli predtým kliknúť na odkaz na súbor *.crx a prehliadač Chrome by im po niekoľkých upozorneniach ponúkol možnosť inštalácie tohto súboru. Takéto súbory musia byť v prehliadači Chrome 21 prevzaté a presunuté na stránku s nastaveniami prehliadača Chrome. Toto nastavenie umožňuje, aby mali určité adresy URL starší a jednoduchší proces inštalácie.

Každá položka v tomto zozname predstavuje vzor spárovaný s rozšírením (pozri stránku http://code.google.com/chrome/extensions/match_patterns.html). Používatelia budú môcť jednoducho inštalovať položky z akejkoľvek adresy URL, ktorá sa zhoduje s položkou v tomto zozname.

Zoznam nepovolených položiek ExtensionInstallBlacklist je tomuto pravidlu nadradený. Rozšírenie na zozname nepovolených položiek nebude nainštalované ani vtedy, ak bude zo stránok, ktoré sú uvedené v tomto zozname.</translation>
<translation id="2113068765175018713">Obmedziť časové obdobie prevádzky zariadenia automatickým reštartovaním</translation>
<translation id="7848840259379156480">Umožňuje konfigurovať vykresľovací modul HTML počas inštalácie doplnku <ph name="PRODUCT_FRAME_NAME"/>. V predvolenom nastavení môže vykresľovanie vykonávať hostiteľský prehliadač, toto nastavenie však môžete prekonať a namiesto toho vykresľovať stránky HTML pomocou doplnku <ph name="PRODUCT_FRAME_NAME"/>.</translation>
<translation id="186719019195685253">Akcia, ktorá sa má vykonať po uplynutí určitého času nečinnosti počas prevádzky s napájaním</translation>
<translation id="7890264460280019664">Nahlásiť serveru zoznam sieťových rozhraní s typmi a adresami hardvéru.

      Ak pravidlo nie je nastavené alebo je nastavené na hodnotu False, zoznam rozhraní sa nenahlási.</translation>
<translation id="4121350739760194865">Zabraňuje tomu, aby sa propagácie aplikácií zobrazovali na stránke Nová karta</translation>
<translation id="2127599828444728326">Povoliť upozornenia na týchto webových stránkach</translation>
<translation id="3973371701361892765">Poličku nikdy neskrývať automaticky</translation>
<translation id="7635471475589566552">Slúži na konfiguráciu miestneho nastavenia aplikácie v prehliadači <ph name="PRODUCT_NAME"/> a bráni používateľom miestne nastavenie zmeniť.

      Ak toto nastavenie povolíte, prehliadač <ph name="PRODUCT_NAME"/> bude používať zvolené miestne nastavenie. Ak nebude nakonfigurované miestne nastavenie podporované, prehliadač namiesto toho použije nastavenie en-US.

      Ak je toto nastavenie zakázané alebo nenastavené, prehliadač <ph name="PRODUCT_NAME"/> použije preferované miestne nastavenie určené používateľom (ak je nakonfigurované) alebo miestne nastavenie systému alebo záložné nastavenie en-US.</translation>
<translation id="2948087343485265211">Určuje, či prehrávanie zvuku ovplyvňuje správu napájania.

          Ak je toto pravidlo nastavené na hodnotu True alebo nie je nastavené, prehrávanie zvuku sa nepovažuje za nečinnosť používateľa. Zabráni to dosiahnutiu oneskorenia režimu nečinnosti a nevykoná sa príslušná akcia. Bez ohľadu na prehrávanie zvuku však po stanovenej dobe dôjde ku zníženiu jasu, vypnutiu a uzamknutiu obrazovky.

          Ak je toto pravidlo nastavené na hodnotu False, prehrávanie zvuku sa považuje za nečinnosť používateľa.</translation>
<translation id="7842869978353666042">Konfigurácia možností služby Disk Google</translation>
<translation id="718956142899066210">Typy pripojenia, pre ktoré sú povolené aktualizácie</translation>
<translation id="1734716591049455502">Konfigurovať možnosti vzdialeného prístupu</translation>
<translation id="7336878834592315572">Uchovať súbory cookie počas trvania relácie</translation>
<translation id="7715711044277116530">Percento predĺženia oneskorenia stmavenia obrazovky v režime prezentácie</translation>
<translation id="8777120694819070607">Umožňuje prehliadaču <ph name="PRODUCT_NAME"/> spúšťať zastarané doplnky. Ak toto nastavenie povolíte, zastarané doplnky budú použité ako normálne. Ak toto nastavenie zakážete, zastarané doplnky nebude možné použiť a používateľom sa ani nezobrazí žiadosť o povolenie spustenia doplnku. Ak toto nastavenie nie je nakonfigurované, používateľom sa pri spustení zastaraného doplnku zobrazí žiadosť o povolenie tejto akcie.</translation>
<translation id="2629448496147630947">Konfigurácia možností vzdialeného prístupu v aplikácii <ph name="PRODUCT_NAME"/>. Ak nie je nainštalovaná webová aplikácia Remote Access (Vzdialený prístup), budú tieto funkcie ignorované.</translation>
<translation id="1310699457130669094">Tu môžete zadať adresu URL súboru PAC servera proxy.

          Toto pravidlo sa prejaví len v prípade, ak ste v časti „Zvoľte spôsob konfigurácie nastavení servera proxy“ zvolili ručné nastavenia servera proxy.

          Ak ste zvolili akýkoľvek iný režim nastavenia pravidiel servera proxy, mali by ste toto pravidlo ponechať nenastavené.

          Podrobné príklady nájdete na adrese:
          <ph name="PROXY_HELP_URL"/></translation>
<translation id="1509692106376861764">Toto pravidlo sa prestalo používať v prehliadači <ph name="PRODUCT_NAME"/> verzie 29.</translation>
<translation id="5464816904705580310">Umožňuje nakonfigurovať nastavenia pre spravovaných používateľov.</translation>
<translation id="3219421230122020860">Režim inkognito je dostupný</translation>
<translation id="7690740696284155549">Umožňuje nakonfigurovať adresár, ktorý bude prehliadač <ph name="PRODUCT_NAME"/> používať na ukladanie prevzatých súborov.

      Ak nastavíte toto pravidlo, prehliadač <ph name="PRODUCT_NAME"/> bude používať zadaný adresár bez ohľadu na to, či používateľ určil takýto adresár alebo povolil príznak na zobrazenie výzvy na zadanie umiestnenia pre prevzaté položky pri každom preberaní.

      Zoznam premenných, ktoré sa dajú použiť, nájdete na stránke http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables (iba v angličtine).

      Ak toto pravidlo ponecháte nenastavené, použije sa predvolený adresár pre prevzaté súbory a používateľ ho bude môcť zmeniť.</translation>
<translation id="7381326101471547614">Zakáže v prehliadači <ph name="PRODUCT_NAME"/> použitie protokolu SPDY. Ak je toto pravidlo povolené, protokol SPDY nebude v prehliadači <ph name="PRODUCT_NAME"/> k dispozícii. Zakázaním tohto pravidla použitie protokolu SPDY umožníte. Ak toto pravidlo ponecháte nenastavené, protokol SPDY bude k dispozícii.</translation>
<translation id="2208976000652006649">Parametre pre adresu URL vyhľadávania, ktorá používa metódu POST</translation>
<translation id="1583248206450240930">Používať v predvolenom nastavení doplnok <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="1047128214168693844">Nepovoliť žiadnym stránkam sledovať fyzickú polohu používateľov</translation>
<translation id="4101778963403261403">Slúži na konfiguráciu typu predvolenej domovskej stránky v prehliadači <ph name="PRODUCT_NAME"/> a bráni používateľom zmeniť predvoľby domovskej stránky. Ako domovskú stránku je možné nastaviť adresu URL, ktorú určíte, alebo stránku Nová karta.

          Ak toto nastavenie povolíte, bude ako domovská stránka vždy použitá stránka Nová karta a adresa URL domovskej stránky bude ignorovaná.

          Ak toto nastavenie zakážete, karta Nová stránka sa používateľovi ako domovská stránka nikdy nezobrazí (ak nie je adresa URL domovskej stránky nastavená na hodnotu „chrome://newtab“).

          Ak toto nastavenie povolíte alebo zakážete, používatelia nebudú môcť zmeniť v prehliadači <ph name="PRODUCT_NAME"/> typ domovskej stránky.

          Ak toto pravidlo ponecháte nenastavené, umožní to používateľovi samostatne zvoliť, či karta Nová stránka má byť domovskou stránkou.</translation>
<translation id="8970205333161758602">Potlačiť výzvu o zamietnutie od rámca <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="3273221114520206906">Predvolené nastavenie kódu JavaScript</translation>
<translation id="4025586928523884733">Blokuje súbory cookie tretej strany.

      Povolenie tejto možnosti zabráni nastavovaniu súborov cookie prvkami webovej stránky, ktoré nepochádzajú z domény v paneli s adresou prehliadača.

      Zakázanie tejto možnosti povolí nastavovanie súborov cookie prvkami webovej stránky, ktoré nepochádzajú z domény v paneli s adresou prehliadača, a zabráni používateľom dané nastavenie zmeniť.

      Ak toto pravidlo ponecháte nenastavené, súbory cookie tretích strán sa povolia, no používateľ to bude môcť zmeniť.</translation>
<translation id="6810445994095397827">Blokovať jazyk JavaScript na týchto webových stránkach</translation>
<translation id="6672934768721876104">Toto pravidlo je zastarané, použite namiesto neho režim ProxyMode.

          Umožňuje zadať server proxy, ktorý bude prehliadač <ph name="PRODUCT_NAME"/> používať, a bráni používateľom meniť nastavenia servera proxy.

          Ak sa rozhodnete server proxy nepoužívať vôbec a vždy sa pripájať priamo, budú všetky ostatné možnosti ignorované.

          Ak sa rozhodnete používať systémové nastavenia servera proxy alebo server proxy zisťovať automaticky, budú všetky ostatné možnosti ignorované.

          Ak zvolíte možnosť ručného nastavenia servera proxy, môžete zvoliť ďalšie možnosti v častiach „Adresa (alebo adresa URL) servera proxy“, „Adresa URL súboru PAC servera proxy“ a „Zoznam pravidiel vynechania servera proxy oddelených čiarkami“.

          Podrobné príklady nájdete na adrese:
          <ph name="PROXY_HELP_URL"/>

          Ak toto nastavenie povolíte, prehliadač <ph name="PRODUCT_NAME"/> bude ignorovať všetky možnosti týkajúce sa proxy zadané pomocou príkazového riadka.

          Ak ponecháte toto pravidlo nenastavené, umožní to používateľovi zmeniť nastavenia proxy samostatne.</translation>
<translation id="3780152581321609624">Do hlavného názvu služby protokolu Kerberos zahrnúť neštandardný port</translation>
<translation id="1749815929501097806">Nastavuje Zmluvné podmienky, ktoré musí používateľ prijať pred začatím relácie prostredníctvom miestneho účtu v zariadení.

      Ak je toto pravidlo nastavené, systém <ph name="PRODUCT_OS_NAME"/> prevezme pri začatí relácie prostredníctvom miestneho účtu v zariadení Zmluvné podmienky a zobrazí ich používateľovi.

      Ak toto pravidlo nastavené nie je, Zmluvné podmienky sa nezobrazia.

      Toto pravidlo byť malo byť nastavené ako adresa URL, z ktorej systém <ph name="PRODUCT_OS_NAME"/> môže Zmluvné podmienky prevziať. Zmluvné podmienky musia byť uložené vo formáte čistého textu, zobrazované ako typ MIME „text/plain“. Nie sú povolené žiadne značky.</translation>
<translation id="2660846099862559570">Nikdy nepoužívať server proxy</translation>
<translation id="1435659902881071157">Konfigurácia siete na úrovni zariadenia</translation>
<translation id="2131902621292742709">Oneskorenie zníženia jasu obrazovky pri napájaní z batérie</translation>
<translation id="5781806558783210276">Určuje dobu nečinnosti používateľa, po ktorej systém pri napájaní z batérie vykoná príslušnú akciu.

          Ak je toto pravidlo nastavené, určuje dobu nečinnosti používateľa, po ktorej systém <ph name="PRODUCT_OS_NAME"/> vykoná príslušnú akciu. Túto akciu je možné nakonfigurovať samostatne.

          Ak toto pravidlo nastavené nie je, použije sa predvolená doba.

          Hodnota pravidla by mala byť uvedená v milisekundách.</translation>
<translation id="5512418063782665071">Adresa URL domovskej stránky</translation>
<translation id="2948381198510798695">Pri hostiteľoch v uvedenom zozname prehliadač <ph name="PRODUCT_NAME"/> vynechá všetky servery proxy.

          Toto pravidlo sa prejaví len v prípade, ak ste v časti „Zvoľte spôsob konfigurácie nastavení servera proxy“ zvolili ručné nastavenia servera proxy.

          Ak ste zvolili akýkoľvek iný režim nastavenia pravidiel proxy, mali by ste toto pravidlo ponechať nenastavené.

          Viac podrobných príkladov nájdete na adrese:
          <ph name="PROXY_HELP_URL"/></translation>
<translation id="6658245400435704251">Určí počet sekúnd, o koľko môže zariadenie náhodne zdržať preberanie aktualizácie odvtedy, čo bola aktualizácia odoslaná na server. Zariadenie môže čakať určitý čas a sa pokúsiť o určitý počet kontrol aktualizácií. Oneskorenie je obmedzené nemenným maximálnym časovým intervalom tak, aby zariadenie nečakalo na prevzatie aktualizácie donekonečna.</translation>
<translation id="523505283826916779">Nastavenia zjednodušenia prístupu</translation>
<translation id="1948757837129151165">Pravidlá pre overenie pomocou protokolu HTTP</translation>
<translation id="5946082169633555022">Verzia beta</translation>
<translation id="7187256234726597551">Ak je toto pravidlo nastavené na hodnotu true, pre zariadenia sa povolí vzdialené overenie a certifikát sa automaticky vygeneruje a odovzdá na server na správu zariadení.

          Ak je pravidlo nastavené na hodnotu false alebo je nenastavené, nevygeneruje sa žiadny certifikát a volania rozhrania API rozšírenia enterprise.platformKeysPrivate zlyhajú.</translation>
<translation id="5242696907817524533">Konfiguruje zoznam spravovaných záložiek.

      Pravidlo pozostáva zo zoznamu záložiek a každá záložka predstavuje slovník obsahujúci „názov“ a cieľovú „adresu URL“ záložky.

      Tieto záložky sú umiestnené do priečinka Spravované záložky v  časti Mobilné záložky. Používateľ nemôže tieto záložky zmeniť.

      Keď je toto pravidlo nastavené, pri otvorení zobrazenia záložiek sa v prehliadači Chrome zobrazí predvolený priečinok Spravované záložky.

      Spravované záložky sa nesynchronizujú do účtu používateľa.</translation>
<translation id="8303314579975657113">Určuje, ktorá knižnica GSSAPI sa má použiť na overenie totožnosti protokolu HTTP. Môžete nastaviť buď len názov knižnice, alebo úplnú cestu.

          Ak nenastavíte žiadnu možnosť, prehliadač <ph name="PRODUCT_NAME"/> použije predvolený názov knižnice.</translation>
<translation id="8549772397068118889">Upozorniť na návštevu stránky, ktorá je mimo balíkov obsahu</translation>
<translation id="7749402620209366169">Povoľuje dvojfázové overenie totožnosti pre hostiteľov vzdialeného prístupu namiesto kódu PIN zadaného používateľom.

          Ak je toto nastavenie povolené, používatelia musia pri pristupovaní k hostiteľovi zadať platný dvojfázový kód.

          Ak je toto nastavenie zakázané alebo nie je nastavené, dvojfázové overenie totožnosti nebude povolené a namiesto neho bude použitá predvolená možnosť – používateľom zadaný kód PIN.</translation>
<translation id="7329842439428490522">Určuje dobu nečinnosti používateľa, po ktorej sa obrazovka pri napájaní z batérie vypne.

          Ak je toto pravidlo nastavené na hodnotu väčšiu ako nula, určuje dobu nečinnosti používateľa, po ktorej systém <ph name="PRODUCT_OS_NAME"/> obrazovku vypne.

          Ak je toto pravidlo nastavené na hodnotu nula, systém <ph name="PRODUCT_OS_NAME"/> obrazovku pri nečinnosti používateľa nevypne.

          Ak toto pravidlo nastavené nie je, použije sa predvolená doba.

          Hodnota pravidla by mala byť uvedená v milisekundách. Hodnoty musia byť nižšie alebo rovnaké ako oneskorenie režimu nečinnosti.</translation>
<translation id="384743459174066962">Umožňuje nastaviť zoznam vzorov adries URL určujúcich webové stránky, ktoré nemôžu otvárať kontextové okná.

          Ak toto pravidlo ponecháte nenastavené, použije sa v prípade všetkých webových stránok globálna predvolená hodnota buď z pravidla „DefaultPopupsSetting“ (ak je nastavené), alebo z osobnej konfigurácie používateľa.</translation>
<translation id="5645779841392247734">Povoliť súbory cookie na týchto webových stránkach</translation>
<translation id="4043912146394966243"> Typy pripojení, ktoré je možné používať na aktualizáciu operačného systému. Aktualizácie operačného systému môžu vzhľadom na objem dát významne zaťažovať pripojenie a môžu sa účtovať ďalšie poplatky.
      Podporované identifikátory typu pripojenia sú „ethernet“, „wifi“, „wimax“, „bluetooth“ a „cellular“.</translation>
<translation id="6652197835259177259">Nastavenia miestne spravovaných používateľov</translation>
<translation id="3243309373265599239">Určuje dobu nečinnosti používateľa, po ktorej sa pri používaní napájacieho zdroja zníži jas obrazovky.

          Ak je toto pravidlo nastavené na hodnotu väčšiu ako nula, určuje dobu nečinnosti používateľa, po ktorej systém <ph name="PRODUCT_OS_NAME"/> zníži jas obrazovky.

          Ak je toto pravidlo nastavené na hodnotu nula, systém <ph name="PRODUCT_OS_NAME"/> jas obrazovky pri nečinnosti používateľ nezníži.

          Ak toto pravidlo nastavené nie je, použije sa predvolenú dobu.

          Hodnota pravidla by mala byť uvedená v milisekundách. Hodnoty musia byť nižšie alebo rovnaké ako oneskorenie vypnutia obrazovky (pokiaľ je nastavené) a oneskorenie režimu nečinnosti.</translation>
<translation id="3859780406608282662">Pridá parameter k načítavaniu kanála Variácie systému <ph name="PRODUCT_OS_NAME"/>.

      Ak je pravidlo určené, pridá k adrese URL na načítanie kanála Variácie parameter dopytu s názvom „restrict&quot;. Hodnotou parametra bude hodnota, ktorá sa určí v tomto pravidle.

      Ak pravidlo nie je určené, adresa URL na načítanie kanála Variácie sa neupraví.</translation>
<translation id="7049373494483449255">Povoľuje prehliadaču <ph name="PRODUCT_NAME"/> odosielať dokumenty na tlač do služby <ph name="CLOUD_PRINT_NAME"/>. Poznámka: Toto pravidlo sa týka len podpory služby <ph name="CLOUD_PRINT_NAME"/> v prehliadači <ph name="PRODUCT_NAME"/>. To však používateľom nebráni v tom, aby odosielali tlačové úlohy na webových stránkach.

      Ak je toto nastavenie povolené alebo nie je nakonfigurované, môžu používatelia tlačiť zo služby <ph name="CLOUD_PRINT_NAME"/> pomocou dialógového okna tlače prehliadača <ph name="PRODUCT_NAME"/>.

      Ak je toto nastavenie zakázané, tlač zo služby <ph name="CLOUD_PRINT_NAME"/> pomocou dialógového okna tlače prehliadača <ph name="PRODUCT_NAME"/> nie je pre používateľov možná</translation>
<translation id="4088589230932595924">Vynútený režim inkognito</translation>
<translation id="5862253018042179045">Nastaví predvolený stav hlasovej odozvy (funkcia na uľahčenie prístupu) na prihlasovacej obrazovke.

          Ak je toto pravidlo nastavené na hodnotu true, pri zobrazení prihlasovacej obrazovky sa povolí hlasová odozva.

          Ak je toto pravidlo nastavené na hodnotu false, pri zobrazení prihlasovacej obrazovky sa hlasová odozva zakáže.

          Ak nastavíte toto pravidlo, používatelia ho budú môcť dočasne prepísať povolením alebo zakázaním hlasovej odozvy. Voľba používateľa však nie je trvalá a predvolené nastavenie sa obnoví zakaždým, keď sa znova zobrazí prihlasovacia obrazovka alebo používateľ bude na prihlasovacej obrazovke nečinný po dobu jednej minúty.

          Ak toto pravidlo ponecháte nenastavené, bude hlasová odozva pri prvom zobrazení prihlasovacej obrazovky zakázaná. Používatelia budú môcť hlasovú odozvu kedykoľvek povoliť alebo zakázať a jej stav na prihlasovacej obrazovke sa zachová aj po zmene používateľov.</translation>
<translation id="8197918588508433925">Toto pravidlo určuje, pre ktoré rozšírenia bude povolené vzdialené prihlásenie pomocou metódy chrome.enterprise.platformKeysPrivate.challengeUserKey() rozhrania Enterprise Platform Keys API. Aby mohli rozšírenia používať toto rozhranie API, musia byť pridané do tohto zoznamu.

          Ak sa rozšírenie na zozname nenachádza alebo zoznam nie je vytvorený, volania rozhrania API zlyhajú a nahlásia kód chyby.</translation>
<translation id="7649638372654023172">Konfiguruje adresu URL predvolenej domovskej stránky v prehliadači <ph name="PRODUCT_NAME"/> a bráni používateľom, aby ju zmenili.

          Domovská stránka je stránka, ktorá sa otvorí po kliknutí na tlačidlo Domovská stránka. Stránky, ktoré sa otvoria pri spustení, ovládajú pravidlá RestoreOnStartup.

          Domovskou stránkou môže byť adresa URL, ktorú tu zadáte, alebo stránka Nová karta. Ak vyberiete stránku Nová karta, bude sa toto pravidlo ignorovať.

          Ak povolíte toto nastavenie, používatelia nebudú môcť zmeniť adresu URL domovskej stránky prehliadača <ph name="PRODUCT_NAME"/>, avšak budú môcť ako domovskú stránku zvoliť stránku Nová karta.

          Ak toto pravidlo nenastavíte, používatelia budú môcť zvoliť domovskú stránku sami v prípade, že nebude nastavené ani pravidlo HomepageIsNewTabPage.</translation>
<translation id="4858735034935305895">Povoliť režim celej obrazovky</translation>
</translationbundle>