<?xml version="1.0" ?>
<!DOCTYPE translationbundle>
<translationbundle lang="pl">
<translation id="1503959756075098984">Identyfikatory rozszerzeń i adresy URL aktualizacji, które mają być instalowane dyskretnie</translation>
<translation id="793134539373873765">Określa, czy do pobierania aktualizacji systemu operacyjnego ma być używana sieć P2P. Jeśli w tej opcji ustawisz wartość Prawda, urządzenia będą dzieliły aktualizacje w sieci LAN i próbowały pobierać je z tej sieci, co może zmniejszyć wykorzystanie i obciążenie łącza internetowego. Jeśli aktualizacje nie będą dostępne w sieci LAN, urządzenie przełączy się na pobieranie aktualizacji z serwera. Jeśli ustawisz w tej opcji wartość Fałsz, sieć P2P nie będzie używana.</translation>
<translation id="2463365186486772703">Język aplikacji</translation>
<translation id="1397855852561539316">Adres URL usługi propozycji od domyślnego dostawcy wyszukiwania</translation>
<translation id="3347897589415241400">Domyślne zachowanie dla witryn nie jest zawarte w żadnym pakiecie treści.

          Ta zasada jest przeznaczona do użytku wewnętrznego w Chrome.</translation>
<translation id="7040229947030068419">Przykładowa wartość:</translation>
<translation id="1213523811751486361">Określa URL wyszukiwarki dostarczającej sugestie wyszukiwania. URL powinien zawierać ciąg „<ph name="SEARCH_TERM_MARKER"/>”, który w trakcie przesyłania zapytania zostanie zastąpiony tekstem dotychczas wpisanym przez użytkownika. Ta zasada jest opcjonalna. Jeśli nie zostanie ustawiona, URL sugestii nie będzie używany. Ta zasada jest stosowana tylko wówczas, gdy jest włączona zasada „DefaultSearchProviderEnabled”.</translation>
<translation id="6106630674659980926">Włącz menedżera haseł</translation>
<translation id="7109916642577279530">Zezwala na przechwytywanie dźwięku lub tego zabrania.

      Jeśli ta zasada jest włączona lub nie jest skonfigurowana (ustawienie domyślne),
      użytkownik jest pytany o pozwolenie na przechwytywanie dźwięku, chyba że dany URL
      jest na liście AudioCaptureAllowedUrls – wtedy pozwolenie jest udzielane bez pytania.

      Gdy zasada jest wyłączona, użytkownik nigdy nie jest pytany, a przechwytywanie dźwięku
      jest dostępne tylko dla stron, których adresy URL są na liście AudioCaptureAllowedUrls.

      Zasada dotyczy wszystkich typów wejść audio, a nie tylko wbudowanego mikrofonu.</translation>
<translation id="9150416707757015439">Ta zasada została wycofana z użycia. Zamiast niej użyj IncognitoModeAvailability. Włącza ona tryb incognito w <ph name="PRODUCT_NAME"/>. Jeśli ustawienie jest włączone lub nieskonfigurowane, użytkownicy mogą otwierać strony internetowe w trybie incognito. Wyłączenie ustawienia uniemożliwia użytkownikom otwieranie stron internetowych w tym trybie. W przypadku nieskonfigurowania tej zasady ustawienie zostanie włączone, a użytkownicy będą mogli używać trybu incognito.</translation>
<translation id="4203389617541558220">Ogranicza czas działania urządzenia przez planowanie automatycznych ponownych uruchomień.

      Ustawienie tej zasady pozwala określić czas działania urządzenia. Po jego upływie następuje zaplanowane automatyczne ponowne uruchomienie.

      Jeśli zasada nie jest ustawiona, czas działania urządzenia jest nieograniczony.

      Gdy ją ustawisz, użytkownicy nie mogą jej zmienić ani zastąpić.

      Automatyczne ponowne uruchomienie jest zaplanowane na wybrany czas, ale może zostać opóźnione nawet o 24 godziny, gdy użytkownik akurat korzysta z urządzenia.

      Uwaga: automatyczne ponowne uruchomienia obecnie działają tylko wtedy, gdy jest pokazywany ekran logowania lub trwa sesja aplikacji kiosku. W przyszłości to się zmieni i zasada będzie obowiązywała zawsze, niezależnie od tego, czy trwa sesja określonego typu.

      Wartość zasady należy podać w sekundach. Musi ona wynosić co najmniej 3600 (jedna godzina).</translation>
<translation id="5304269353650269372">Określa czas bez wprowadzenia danych przez użytkownika, po którym wyświetlane jest okno dialogowe ostrzeżenia przy zasilaniu z baterii.

          Gdy ta zasada jest ustawiona, określa wymagany czas nieaktywności użytkownika przed wyświetleniem w <ph name="PRODUCT_OS_NAME"/> okna dialogowego z ostrzeżeniem informującym, że zostanie wykonana odpowiednia czynność.

          Gdy ta zasada nie jest ustawiona, ostrzeżenie nie jest wyświetlane.

          Wartość dla zasady należy podać w milisekundach. Wartości są ograniczane, tak aby nie przekraczały wartości opóźnienia nieaktywności.</translation>
<translation id="7818131573217430250">Ustaw domyślny stan trybu wysokiego kontrastu na ekranie logowania</translation>
<translation id="7614663184588396421">Lista wyłączonych schematów protokołów</translation>
<translation id="2309390639296060546">Domyślne ustawienie geolokalizacji</translation>
<translation id="1313457536529613143">Określa wartość procentową skalowania opóźnienia przyciemnienia ekranu, gdy aktywność użytkownika zostanie wykryta po przyciemnieniu lub wkrótce po wyłączeniu ekranu.

          Ustawienie tej zasady pozwala określić wartość procentową skalowania opóźnienia przyciemnienia ekranu, gdy aktywność użytkownika zostanie wykryta po przyciemnieniu lub wkrótce po wyłączeniu ekranu. Skalowanie opóźnienia przyciemnienia powoduje, że opóźnienia wyłączenia i zablokowania ekranu oraz opóźnienie bezczynności są tak dostosowywane, by zachować pierwotnie ustawione odstępy od opóźnienia przyciemnienia ekranu.

          Jeśli zasada nie jest ustawiona, obowiązuje domyślny współczynnik skalowania.

          Współczynnik skalowania musi wynosić co najmniej 100%.</translation>
<translation id="7443616896860707393">Monity o podstawowe uwierzytelnienie HTTP pochodzące z innych witryn</translation>
<translation id="2337466621458842053">Umożliwia skonfigurowanie listy wzorcowych URL-i określających witryny, w których mogą być wyświetlane obrazy. Jeśli ta zasada nie zostanie skonfigurowana, dla wszystkich witryn będzie używana globalna wartość domyślna pochodząca z zasady „DefaultImagesSettings” (jeśli została skonfigurowana) lub z osobistej konfiguracji użytkownika.</translation>
<translation id="4680961954980851756">Włącz autouzupełnianie</translation>
<translation id="5183383917553127163">Umożliwia określenie rozszerzeń, których nie obejmuje czarna lista. Wartość * na czarnej liście oznacza dodanie do niej wszystkich rozszerzeń i zezwolenie użytkownikom na instalowanie wyłącznie rozszerzeń wymienionych na białej liście. Domyślnie wszystkie rozszerzenia znajdują się na białej liście, jeśli jednak za pomocą zasady wszystkie rozszerzenia dodano do czarnej listy, białej listy można użyć do zmodyfikowania tej zasady.</translation>
<translation id="5921888683953999946">Ustawia domyślny stan funkcji ułatwień dostępu w postaci dużego kursora na ekranie logowania.

          Jeśli ta zasada ma wartość „prawda”, po wyświetleniu ekranu logowania duży kursor jest włączony.

          Jeśli ma ona wartość „fałsz”, po wyświetleniu ekranu logowania taki kursor jest wyłączony.

          Gdy ją ustawisz, użytkownicy mogą ją chwilowo zastąpić, włączając lub wyłączając duży kursor. Wybór użytkownika nie jest jednak trwały i wartość domyślna jest przywracana po ponownym wyświetleniu ekranu logowania lub wtedy, gdy użytkownik przez minutę będzie nieaktywny na tym ekranie.

          Jeśli zasada pozostanie nieustawiona, po pierwszym wyświetleniu ekranu logowania duży kursor jest wyłączony. Użytkownicy mogą go w każdej chwili włączyć lub wyłączyć i jego stan na ekranie logowania jest trwały dla wszystkich użytkowników.</translation>
<translation id="3185009703220253572">od wersji <ph name="SINCE_VERSION"/></translation>
<translation id="2204753382813641270">Steruj autoukrywaniem półki</translation>
<translation id="3816312845600780067">Włącz automatyczne logowanie skrótem klawiszowym</translation>
<translation id="3214164532079860003">W przypadku włączenia ta zasada wymusza zaimportowanie strony startowej z bieżącej przeglądarki domyślnej. Jeśli zasada będzie wyłączona, strona startowa nie zostanie zaimportowana. Jeśli ta zasada nie zostanie ustawiona, użytkownik może zobaczyć pytanie, czy zaimportować stronę, lub importowanie może odbyć się automatycznie.</translation>
<translation id="5330684698007383292">Zezwalaj <ph name="PRODUCT_FRAME_NAME"/> na obsługę tych typów treści</translation>
<translation id="6647965994887675196">Jeśli ta zasada ma wartość „prawda”, można tworzyć użytkowników nadzorowanych i logować się jako oni.

          Jeśli ma ona wartość „fałsz” lub nie jest skonfigurowana, tworzenie użytkowników nadzorowanych i logowanie się jako oni jest wyłączone. Wszyscy istniejący użytkownicy nadzorowani zostają ukryci.

          UWAGA: działanie domyślne różni się na urządzeniach dla użytkowników indywidualnych i dla firm. Na tych pierwszych funkcja użytkowników nadzorowanych jest domyślnie włączona, a na drugich – wyłączona.</translation>
<translation id="69525503251220566">Parametr udostępniający funkcję wyszukiwania obrazem dla domyślnego dostawcy wyszukiwania</translation>
<translation id="5469825884154817306">Blokuj grafiki w tych witrynach</translation>
<translation id="5827231192798670332">Wybiera strategię stosowaną do zwalniania miejsca na dysku podczas automatycznego czyszczenia</translation>
<translation id="8412312801707973447">Czy wykonywane jest sprawdzanie OCSP/CRL online</translation>
<translation id="6649397154027560979">Ta zasada została wycofana, zamiast niej użyj URLBlacklist.

      Wyłącza wymienione schematy protokołów w <ph name="PRODUCT_NAME"/>.

      Adresów URL zgodnych ze schematem na tej liście nie można wczytywać ani otwierać.

      Jeśli ta zasada pozostanie nieustawiona lub lista jest pusta, wszystkie schematy są dostępne w <ph name="PRODUCT_NAME"/>.</translation>
<translation id="3213821784736959823">Określa, czy w <ph name="PRODUCT_NAME"/> jest używany wbudowany klient DNS.

      W przypadku włączenia tej opcji będzie używany wbudowany klient DNS (jeśli będzie dostępny).

      Jeśli ta opcja zostanie wyłączona, wbudowany klient DNS w ogóle nie będzie używany.

      W przypadku nieskonfigurowania tego ustawienia użytkownicy będą mogli wybrać, czy używać wbudowanego klienta DNS. W tym celu trzeba edytować chrome://flags lub podać opcje wiersza poleceń.</translation>
<translation id="2908277604670530363">Maksymalna liczba jednoczesnych połączeń z serwerem proxy</translation>
<translation id="556941986578702361">Steruje autoukrywaniem półki <ph name="PRODUCT_OS_NAME"/>.

      W przypadku ustawienia wartości „AlwaysAutoHideShelf” półka zawsze będzie ukrywana automatycznie.

      Jeśli zostanie ustawiona wartość „NeverAutoHideShelf”, półka nigdy nie będzie ukrywana automatycznie.

      W przypadku ustawienia tej zasady, użytkownicy nie będą mogli jej zmienić ani nadpisać.

      Jeśli ta opcja pozostanie nieustawiona, półka będzie ukrywana automatycznie.</translation>
<translation id="4838572175671839397">Zawiera wyrażenie regularne służące do określania, którzy użytkownicy mogą logować się w <ph name="PRODUCT_NAME"/>.

      Jeśli użytkownik o nazwie niepasującej do tego wzorca spróbuje się zalogować, zostanie wyświetlony odpowiedni komunikat o błędzie.

      Jeśli ta zasada pozostanie nieustawiona lub pusta, każdy użytkownik będzie mógł zalogować się w <ph name="PRODUCT_NAME"/>.</translation>
<translation id="2892225385726009373">Gdy to ustawienie jest włączone, <ph name="PRODUCT_NAME"/> zawsze będzie sprawdzać odwołania do certyfikatów serwerów, które są pomyślnie zatwierdzane i są podpisane za pomocą lokalnie zainstalowanych certyfikatów CA.

      Jeśli <ph name="PRODUCT_NAME"/> nie może odczytać informacji o stanie odwołania, takie certyfikaty są traktowane jako odrzucone.

      Jeśli ta zasada nie jest ustawiona lub jej wartość to Fałsz, wtedy Chrome używa istniejących ustawień sprawdzania odwołań online.</translation>
<translation id="1438955478865681012">Pozwala skonfigurować zasady dotyczące rozszerzeń. Użytkownikowi nie wolno instalować rozszerzeń dodanych do czarnej listy, jeśli nie wymieniono ich na białej liście. Możesz ponadto wymusić automatyczne instalowanie rozszerzeń w przeglądarce <ph name="PRODUCT_NAME"/>, wskazując je za pomocą zasady <ph name="EXTENSIONINSTALLFORCELIST_POLICY_NAME"/>. Czarna lista ma priorytet nad listą wymuszonych rozszerzeń.</translation>
<translation id="3516856976222674451">Ogranicz maksymalną długość sesji użytkownika

      Jeśli ta opcja jest ustawiona, określa czas, po upływie którego użytkownik jest automatycznie wylogowywany, a jego sesja przerywana. Użytkownik jest informowany o pozostałym czasie przez licznik czasu pokazywany na pasku zadań.

      W przypadku nieustawienia tej opcji długość sesji jest nieograniczona.

      Jeśli ta opcja zostanie ustawiona, użytkownicy nie będą mogli jej zmienić ani nadpisać.

      Wartość opcji należy podać w milisekundach. Wartości są dopasowywane do przedziału od 30 sekund od 24 godzin.</translation>
<translation id="9200828125069750521">Parametry dla adresów URL obrazów używających POST</translation>
<translation id="2769952903507981510">Konfiguracja wymaganej nazwy domeny dla hostów zdalnego dostępu</translation>
<translation id="8294750666104911727">Normalnie strony, które w tagu X-UA-Compatible mają wartość chrome=1, będą renderowane w <ph name="PRODUCT_FRAME_NAME"/> niezależnie od ustawienia zasady „ChromeFrameRendererSettings”.

          Jeśli włączysz to ustawienie, strony nie będą skanowane w poszukiwaniu metatagów.

          Jeśli wyłączysz to ustawienie, strony będą skanowane w poszukiwaniu metatagów.

          Jeśli nie ustawisz tej zasady, strony będą skanowane w poszukiwaniu metatagów.</translation>
<translation id="3478024346823118645">Wyczyść dane użytkownika przy wylogowaniu</translation>
<translation id="8668394701842594241">Określa listę wtyczek włączonych w <ph name="PRODUCT_NAME"/> i uniemożliwia użytkownikom zmianę tego ustawienia. Możesz użyć symboli wieloznacznych „*” i „?”, które zastąpią sekwencje dowolnych znaków. Symbol „*” odpowiada dowolnej liczbie znaków, natomiast „?” oznacza jeden opcjonalny znak (czyli jeden lub zero znaków). Znakiem zmiany znaczenia jest „\”, dlatego aby wprowadzić faktyczny znak „*”, „?” lub „\”, musisz umieścić przed nim znak „\”. Wtyczki wymienione na liście są zawsze używane w <ph name="PRODUCT_NAME"/>, jeśli zostały zainstalowane. Wtyczki są oznaczone jako włączone na stronie „about:plugins”, a użytkownicy nie mogą ich wyłączyć. Pamiętaj, że ta zasada zastępuje zasady DisabledPlugins i DisabledPluginsExceptions. Jeśli zasada nie zostanie skonfigurowana, użytkownik będzie mógł wyłączyć każdą wtyczkę zainstalowaną w systemie.</translation>
<translation id="653608967792832033">Określa, po jakim czasie nieaktywności użytkownika blokowany jest ekran przy zasilaniu z baterii.

          Jeśli ta zasada ma wartość większą niż zero, określa czas, przez który użytkownik musi pozostać bezczynny, zanim <ph name="PRODUCT_OS_NAME"/> zablokuje ekran.

          Jeśli ta zasada ma wartość równą zero, <ph name="PRODUCT_OS_NAME"/> nie blokuje ekranu, gdy użytkownik jest bezczynny.

          Jeśli ta zasada nie jest ustawiona, używana jest domyślna wartość długości czasu.

          Zalecanym sposobem blokowania ekranu przy bezczynności jest włączenie blokowania ekranu przy wstrzymaniu i skonfigurowanie systemu <ph name="PRODUCT_OS_NAME"/> tak, by był wstrzymywany po opóźnieniu bezczynności. Ta zasada powinna być używana tylko wtedy, gdy zablokowanie ekranu powinno nastąpić znacznie wcześniej niż wstrzymanie lub gdy wstrzymanie po bezczynności nie jest pożądane.

          Wartość zasady powinna być określona w milisekundach. Wartości muszą być mniejsze niż opóźnienie bezczynności.</translation>
<translation id="4157003184375321727">Zgłoś wersje systemu operacyjnego i oprogramowania układowego</translation>
<translation id="4752214355598028025">Usługa Bezpieczne przeglądanie wyświetla ostrzeżenie, gdy użytkownik chce wejść na stronę oznaczoną jako potencjalnie szkodliwa. Włączenie tego ustawienia uniemożliwia użytkownikom przejście ze strony ostrzeżenia na szkodliwą stronę.

      W przypadku wyłączenia lub nieskonfigurowania tego ustawienia użytkownik będzie mógł przejść ze strony ostrzeżenia na stronę oznaczoną jako szkodliwa.</translation>
<translation id="5255162913209987122">Może być zalecana</translation>
<translation id="1861037019115362154">Pozwala określić listę wtyczek wyłączonych w <ph name="PRODUCT_NAME"/> i uniemożliwia użytkownikom zmianę tego ustawienia. Możesz użyć symboli wieloznacznych „*” i „?”, by dopasować sekwencje dowolnych znaków. Symbol „*” odpowiada dowolnej liczbie znaków, natomiast „?” oznacza jeden opcjonalny znak (czyli jeden lub zero znaków). Znakiem zmiany znaczenia jest „\”, dlatego by wprowadzić faktyczny znak „*”, „?” lub „\”, musisz umieścić przed nim znak „\”. Jeśli włączysz to ustawienie, wtyczki wymienione na liście nigdy nie będą używane w <ph name="PRODUCT_NAME"/>. Wtyczki są oznaczone jako wyłączone na stronie „about:plugins”, a użytkownicy nie mogą ich włączyć. Pamiętaj, że ta zasada jest zastępowana przez zasady EnabledPlugins i DisabledPluginsExceptions. Jeśli zasada nie zostanie ustawiona, użytkownik będzie mógł korzystać ze wszystkich wtyczek zainstalowanych w systemie oprócz przestarzałych, niebezpiecznych i niezgodnych wbudowanych wtyczek.</translation>
<translation id="9197740283131855199">Wartość procentowa skalowania opóźnienia przyciemnienia ekranu, jeśli użytkownik stanie się aktywny po przyciemnieniu</translation>
<translation id="1492145937778428165">Pozwala określić w milisekundach okres wysyłania do usługi zarządzania urządzeniem zapytań o zasady dotyczące urządzeń.

      Skonfigurowanie tej zasady powoduje zastąpienie wartości domyślnej, wynoszącej 3 godziny.

      Akceptowane są wartości z zakresu od 1 800 000 (30 minut) do 86 400 000 (1 dzień). Wartości spoza tego zakresu są zamieniane na odpowiednie wartości graniczne.

      W przypadku nieskonfigurowania tej zasady <ph name="PRODUCT_OS_NAME"/> będzie używać wartości domyślnej wynoszącej 3 godziny.</translation>
<translation id="3765260570442823273">Czas wyświetlania ostrzeżenia o wylogowaniu z powodu bezczynności</translation>
<translation id="7302043767260300182">Opóźnienie blokady ekranu przy zasilaniu sieciowym</translation>
<translation id="7331962793961469250">Kiedy zostanie ustawiona wartość Prawda, na stronie Nowa karta nie będą wyświetlane promowane aplikacje z Chrome Web Store. Przypisanie tej opcji wartości Fałsz lub jej nieustawienie spowoduje, że promowane aplikacje z Chrome Web Store będą widoczne na stronie Nowa karta.</translation>
<translation id="7271085005502526897">Importuj stronę startową z przeglądarki domyślnej przy pierwszym uruchomieniu</translation>
<translation id="6036523166753287175">Włącz omijanie zapory sieciowej przez host dostępu zdalnego</translation>
<translation id="1096105751829466145">Domyślny dostawca wyszukiwania</translation>
<translation id="7567380065339179813">Zezwalaj na wtyczki w tych witrynach</translation>
<translation id="4555850956567117258">Włącz zaświadczanie zdalne dla użytkownika</translation>
<translation id="5966615072639944554">Rozszerzenia mają pozwolenie na używanie interfejsu API zaświadczania zdalnego</translation>
<translation id="1617235075406854669">Włącz usuwanie historii przeglądarki i pobierania</translation>
<translation id="5290940294294002042">Określ listę wtyczek, które użytkownik może włączyć lub wyłączyć</translation>
<translation id="3153348162326497318">Pozwala określić rozszerzenia, których użytkownicy NIE mogą instalować. Zainstalowane rozszerzenia zostaną usunięte w przypadku umieszczenia ich na tej liście. Wartość „*” na liście blokad oznacza, że zablokowane są wszystkie rozszerzenia, które nie znajdują się na liście dozwolonych rozszerzeń. Jeśli zasada ta nie zostanie skonfigurowana, użytkownicy mogą instalować dowolne rozszerzenia w <ph name="PRODUCT_NAME"/>.</translation>
<translation id="3067188277482006117">Jeśli ustawiono wartość Prawda, użytkownik może używać modułu sprzętowego w urządzeniach z Chrome do zdalnego poświadczania tożsamości przez wywołanie funkcji chrome.enterprise.platformKeysPrivate.challengeUserKey() interfejsu API Enterprise Platform Keys.

          Jeśli wartość ustawiono na Fałsz lub nie jest ona określona, wywołania kierowane do interfejsu API zakończą się błędem.</translation>
<translation id="5809728392451418079">Ustaw nazwę wyświetlaną dla lokalnych kont na urządzeniu</translation>
<translation id="1427655258943162134">Adres URL serwera proxy</translation>
<translation id="1827523283178827583">Używaj stałych serwerów proxy</translation>
<translation id="3021409116652377124">Wyłącz znajdowanie wtyczek</translation>
<translation id="7236775576470542603">Ustawia domyślny typ lupy włączony na ekranie logowania.

          Jeśli ta zasada jest ustawiona, określa typ lupy, który jest włączony po wyświetleniu ekranu logowania. Ustawienie zasady jako „Brak” wyłącza lupę.

          Gdy ją ustawisz, użytkownicy mogą ją chwilowo zastąpić, włączając lub wyłączając lupę. Wybór użytkownika nie jest jednak trwały i wartość domyślna jest przywracana po ponownym wyświetleniu ekranu logowania lub wtedy, gdy użytkownik przez minutę będzie nieaktywny na tym ekranie.

          Jeśli zasada pozostanie nieustawiona, po pierwszym wyświetleniu ekranu logowania lupa jest wyłączona. Użytkownicy mogą ją w każdej chwili włączyć lub wyłączyć i jej stan na ekranie logowania jest trwały dla wszystkich użytkowników.</translation>
<translation id="5423001109873148185">Po włączeniu tej zasady wymuszany jest import wyszukiwarek z bieżącej przeglądarki domyślnej. Włączenie zasady ma również wpływ na opcje w oknie dialogowym importowania. W przypadku jej wyłączenia wyszukiwarka domyślna nie jest importowana. Jeśli zasada nie zostanie skonfigurowana, użytkownik może zobaczyć pytanie o zaimportowanie wyszukiwarki lub importowanie odbędzie się automatycznie.</translation>
<translation id="3288595667065905535">Kanał wersji</translation>
<translation id="2785954641789149745">Włącza funkcję Bezpieczne przeglądanie w <ph name="PRODUCT_NAME"/> i zapobiega zmianie tego ustawienia przez użytkowników.

      Jeśli włączysz ustawienie, Bezpieczne przeglądanie jest zawsze aktywne.

      W przeciwnym razie ta funkcja nigdy nie jest aktywna.

      Gdy włączysz lub wyłączysz ustawienie, użytkownicy nie mogą zmienić ani zastąpić ustawienia „Włącz ochronę przed wyłudzaniem danych (phishingiem) i złośliwym oprogramowaniem” w <ph name="PRODUCT_NAME"/>.

      Jeśli zasada pozostanie nieustawiona, funkcja jest włączona, ale użytkownik może to zmienić.</translation>
<translation id="268577405881275241">Włącz serwer proxy kompresowania danych</translation>
<translation id="8369602308428138533">Opóźnienie wyłączenia ekranu przy zasilaniu sieciowym</translation>
<translation id="6513756852541213407">Pozwala określić serwer proxy używany w <ph name="PRODUCT_NAME"/> i uniemożliwia użytkownikom zmianę jego ustawień. Jeśli zdecydujesz się nie korzystać z serwera proxy i zawsze bezpośrednio nawiązywać połączenia, wszystkie pozostałe opcje będą ignorowane. Są one ignorowane również w przypadku użycia systemowych ustawień serwera proxy lub automatycznego wykrywania serwera proxy. Jeśli wybierzesz tryb stałego serwera proxy, możesz określić dodatkowe opcje w polach „Adres URL serwera proxy” i „Lista rozdzielonych przecinkami reguł omijania serwera proxy”. W przypadku użycia skryptu PAC serwera proxy musisz w polu „Adres URL pliku PAC serwera proxy” określić adres URL skryptu. Szczegółowe przykłady można znaleźć na stronie <ph name="PROXY_HELP_URL"/>. Jeśli ustawienie jest włączone, <ph name="PRODUCT_NAME"/> ignoruje wszystkie opcje dotyczące serwera proxy określone w wierszu polecenia. W przypadku nieskonfigurowania tej zasady użytkownicy będą mogli samodzielnie wybrać ustawienia proxy.</translation>
<translation id="7763311235717725977">Pozwala określić, czy witryny mogą wyświetlać obrazy. Pokazywanie obrazów może być włączone lub wyłączone dla wszystkich witryn. Jeśli ta zasada nie będzie skonfigurowana, zostanie użyta zasada „AllowImages” i użytkownik będzie mógł zmienić to ustawienie.</translation>
<translation id="5630352020869108293">Przywróć ostatnią sesję</translation>
<translation id="2067011586099792101">Blokuj dostęp do witryn spoza pakietów treści</translation>
<translation id="4980635395568992380">Typ danych:</translation>
<translation id="3096595567015595053">Lista włączonych wtyczek</translation>
<translation id="3048744057455266684">Jeśli ta zasada jest ustawiona, a URL wyszukiwania zaproponowany przez omnibox zawiera ten parametr w ciągu zapytania lub identyfikatorze fragmentu, wtedy sugestia zamiast nieprzetworzonego adresu URL wyszukiwania pokaże wyszukiwane hasła i dostawcę wyszukiwania.

          Ta zasada jest opcjonalna. Jeśli nie jest ustawiona, nie zachodzi zamiana wyszukiwanego hasła.

          Ta zasada jest uwzględniania tylko wtedy, gdy włączona jest zasada „DefaultSearchProviderEnabled”.</translation>
<translation id="5912364507361265851">Zezwalaj użytkownikom na pokazywanie haseł w menedżerze haseł</translation>
<translation id="510186355068252378">Wyłącza synchronizację danych w <ph name="PRODUCT_NAME"/> korzystającą z usług synchronizacji udostępnianych przez Google i uniemożliwia użytkownikom zmianę tego ustawienia. W przypadku włączenia tego ustawienia użytkownicy nie mogą go zmieniać ani zastępować w <ph name="PRODUCT_NAME"/>. Jeśli ta zasada nie zostanie skonfigurowana, użytkownik będzie mógł wybrać, czy chce korzystać z Google Sync.</translation>
<translation id="7953256619080733119">Zarządzane hosty umieszczone przez użytkownika na liście wyjątków</translation>
<translation id="7412982067535265896">Pozwala utworzyć listę wzorców URL-i określających witryny, które mogą ustawiać pliki ważne tylko na czas sesji.

          Jeśli ta zasada nie zostanie skonfigurowana, będzie używana wartość domyślna pobrana z zasady „DefaultCookiesSetting” (jeśli jest określona) lub z osobistej konfiguracji użytkownika.

          Jeśli zasada „RestoreOnStartup” jest skonfigurowana do przywracania URL-i z poprzednich sesji, ta zasada nie będzie przestrzegana i w przypadku tych witryn pliki cookie będą przechowywane trwale.</translation>
<translation id="4807950475297505572">Użytkownicy, którzy najdłużej byli nieaktywni, są usuwani aż do uzyskania odpowiedniej ilości wolnego miejsca</translation>
<translation id="8828766846428537606">Pozwala skonfigurować domyślną stronę startową w przeglądarce <ph name="PRODUCT_NAME"/> i uniemożliwia użytkownikom jej zmianę. Jeśli jako stronę startową ustawisz stronę Nowa karta albo adres URL (wpisany ręcznie), ustawienia strony startowej użytkownika zostaną całkowicie zablokowane. Jeśli adres URL strony startowej nie zostanie określony, użytkownik jako stronę startową będzie mógł ustawić stronę Nowa karta, podając adres „chrome://newtab”.</translation>
<translation id="2231817271680715693">Importuj historię przeglądania z przeglądarki domyślnej przy pierwszym uruchomieniu</translation>
<translation id="1353966721814789986">Strony otwierane po uruchomieniu</translation>
<translation id="7173856672248996428">Profil tymczasowy</translation>
<translation id="1841130111523795147">Pozwala użytkownikowi na zalogowanie się do <ph name="PRODUCT_NAME"/> i zapobiega modyfikowaniu tego ustawienia przez użytkowników.

      W przypadku ustawienia tej zasady możesz określić, czy zezwalasz użytkownikowi na logowanie się do <ph name="PRODUCT_NAME"/>.</translation>
<translation id="5564962323737505851">Pozwala skonfigurować menedżera haseł. Po włączeniu menedżera haseł możesz włączyć lub wyłączyć opcję umożliwiającą użytkownikowi wyświetlenie tekstu zapisanych haseł.</translation>
<translation id="4668325077104657568">Domyślne ustawienie grafik</translation>
<translation id="4492287494009043413">Wyłącza tworzenie zrzutów ekranu</translation>
<translation id="6368403635025849609">Zezwalaj na wykonywanie kodu JavaScript w tych witrynach</translation>
<translation id="6074963268421707432">Nie zezwalaj żadnej witrynie na pokazywanie powiadomień na pulpicie</translation>
<translation id="8614804915612153606">Wyłącza automatyczne aktualizacje</translation>
<translation id="4834526953114077364">Najdłużej nieaktywni użytkownicy, którzy nie logowali się w ciągu ostatnich 3 miesięcy, są usuwani aż do uzyskania odpowiedniej ilości wolnego miejsca</translation>
<translation id="382476126209906314">Skonfiguruj przedrostek gadżetu TalkGadget dla hostów zdalnego dostępu</translation>
<translation id="6561396069801924653">Pokaż opcje ułatwień dostępu w menu na pasku zadań</translation>
<translation id="8104962233214241919">Automatycznie wybierz certyfikaty klienta dla tych witryn</translation>
<translation id="2906874737073861391">Lista rozszerzeń z pakietu aplikacji</translation>
<translation id="3758249152301468420">Wyłącz narzędzia dla programistów</translation>
<translation id="8665076741187546529">Konfiguruj listę rozszerzeń, których instalacja jest wymuszana</translation>
<translation id="410478022164847452">Określa, po jakim czasie nieaktywności użytkownika podejmowane jest działanie po bezczynności przy zasilaniu z sieci.

          Jeśli ta zasada jest ustawiona, określa czas, przez który użytkownik musi pozostać nieaktywny, zanim <ph name="PRODUCT_OS_NAME"/> wykona działanie związane z bezczynnością (można skonfigurować je osobno).

          Jeśli ta zasada nie jest ustawiona, używana jest domyślna wartość długości czasu.

          Wartość tej zasady powinna być określona w milisekundach.</translation>
<translation id="1675391920437889033">Określa typy aplikacji/rozszerzeń, które można instalować.

          To ustawienie tworzy białą listę typów rozszerzeń/aplikacji, których instalacja jest dozwolona w <ph name="PRODUCT_NAME"/>. Wartość jest listą łańcuchów spośród: „extension”, „theme”, „user_script”, „hosted_app”, „legacy_packaged_app”, „platform_app”. Więcej informacji o tych typach można znaleźć w dokumentacji rozszerzeń Chrome.

          Ta zasada wpływa też na rozszerzenia i aplikacje, których instalacja jest wymuszana przez ExtensionInstallForcelist.

          W przypadku skonfigurowania tej opcji rozszerzenia/aplikacje o typie innym niż wymienione na liście nie będą instalowane.

          Jeśli to ustawienie nie zostanie skonfigurowane, nie będą obowiązywać żadne ograniczenia dotyczące dozwolonych typów rozszerzeń/aplikacji.</translation>
<translation id="6378076389057087301">Określ, czy aktywność związana z dźwiękiem wpływa na zarządzanie energią</translation>
<translation id="8818173863808665831">Zgłoś lokalizację geograficzną urządzenia.

      Jeśli ta zasada nie jest ustawiona lub jest ustawiona na wartość nieprawdziwą, lokalizacja nie będzie zgłaszana.</translation>
<translation id="4899708173828500852">Włącz Bezpieczne przeglądanie</translation>
<translation id="4442582539341804154">Włącz blokadę w przypadku bezczynności lub zawieszenia działania urządzenia</translation>
<translation id="7719251660743813569">Określa, czy statystyki użytkowania są przesyłane do Google. W przypadku włączenia tej opcji <ph name="PRODUCT_OS_NAME"/> będzie przesyłać statystyki użytkowania. Jeśli opcja będzie wyłączona lub nieskonfigurowana, przesyłanie statystyk zostanie wyłączone.</translation>
<translation id="2372547058085956601">Opóźnienie automatycznego logowania się do sesji publicznej.

      Jeśli zasada |DeviceLocalAccountAutoLoginId| nie jest ustawiona, ta zasada nie daje żadnych rezultatów. W przeciwnym razie:

      Jeśli ta zasada jest ustawiona, określa czas nieaktywności użytkownika, który powinien upłynąć przed automatycznym zalogowaniem do sesji publicznej określonej przez zasadę |DeviceLocalAccountAutoLoginId|.

      Jeśli ta zasada nie jest ustawiona, wartość limitu czasu będzie wynosić 0 milisekund.

      Wartość tej zasady określa się w milisekundach.</translation>
<translation id="7275334191706090484">Zakładki zarządzane</translation>
<translation id="3570008976476035109">Blokuj wtyczki w tych witrynach</translation>
<translation id="8749370016497832113">Włącza usuwanie historii przeglądarki i pobierania w <ph name="PRODUCT_NAME"/> i uniemożliwia użytkownikom zmianę tego ustawienia.

      Nawet gdy ta zasada jest wyłączona, nie można zagwarantować zachowania historii przeglądarki i pobierania. Użytkownicy mogą mieć możliwość bezpośredniego edytowania lub usuwania plików bazy danych historii, a niektóre lub wszystkie elementy mogą w każdej chwili utracić ważność lub zostać zarchiwizowane.

      Jeśli to ustawienie jest włączone lub nieustawione, można usuwać historię przeglądania i pobierania.

      Jeśli to ustawienie jest wyłączone, nie można usuwać historii przeglądania ani pobierania.</translation>
<translation id="2884728160143956392">Zezwalaj na pliki cookie w tych witrynach tylko na czas sesji</translation>
<translation id="3021272743506189340">Wyłącza synchronizację Dysku Google dla aplikacji Pliki w systemie operacyjnym Chrome, gdy używane jest połączenie komórkowe przy ustawieniu Prawda. W takim przypadku dane są synchronizowane z Dyskiem Google tylko przy połączeniu z siecią Wi-Fi lub Ethernet.

          Jeśli ustawienie nie jest skonfigurowane lub ma wartość Fałsz, użytkownicy mogą przesyłać dane na Dysk Google przez sieć komórkową.</translation>
<translation id="4655130238810647237">Włącza lub wyłącza funkcję edytowania zakładek w przeglądarce <ph name="PRODUCT_NAME"/>. Po włączeniu tego ustawienia zakładki można dodawać, usuwać i modyfikować. Jest to wartość domyślna. Jeśli wyłączysz ustawienie, zakładek nie będzie można dodawać, usuwać ani modyfikować. Istniejące zakładki nadal będą dostępne.</translation>
<translation id="3496296378755072552">Menedżer haseł</translation>
<translation id="4372704773119750918">Nie zezwalaj użytkownikom firmowym na korzystanie z trybu wieloprofilowego (jako użytkownik główny ani dodatkowy)</translation>
<translation id="2565967352111237512">Włącza funkcję anonimowego przesyłania do Google raportów o użytkowaniu i danych dotyczących awarii <ph name="PRODUCT_NAME"/> oraz uniemożliwia użytkownikom zmianę tego ustawienia. Jeśli włączysz ustawienie, raporty o użytkowaniu i dane dotyczące awarii będą anonimowo przesyłane do Google. W przypadku jego wyłączenia raporty i dane nigdy nie są przesyłane do Google. Jeśli ustawienie jest włączone lub wyłączone, użytkownicy nie mogą go zmienić ani zastąpić w <ph name="PRODUCT_NAME"/>. W przypadku nieskonfigurowania tej zasady stosowane będzie ustawienie wybrane przez użytkownika podczas instalacji/przy pierwszym uruchomieniu.</translation>
<translation id="4784220343847172494">Steruje zachowaniem automatycznego czyszczenia na urządzeniach z systemem <ph name="PRODUCT_OS_NAME"/>. Gdy ilość wolnego miejsca na dysku osiąga poziom krytyczny, jest wyzwalane automatyczne czyszczenie, co pozwala odzyskać trochę miejsca.

      Jeśli dla tej zasady ustawiono strategię „RemoveLRU”, automatyczne czyszczenie powoduje usuwanie użytkowników z urządzenia (począwszy od najdawniej zalogowanych) aż do uzyskania odpowiedniej ilości wolnego miejsca.

      Jeśli dla tej zasady ustawiono strategię „RemoveLRUIfDormant”, automatyczne czyszczenie powoduje usuwanie użytkowników, którzy nie logowali się co najmniej od 3 miesięcy (począwszy od najdawniej zalogowanych), aż do uzyskania odpowiedniej ilości wolnego miejsca.

      Jeśli ta zasada nie została ustawiona, funkcja automatycznego czyszczenia korzysta z domyślnej wbudowanej strategii. Obecnie jest to „RemoveLRUIfDormant”.</translation>
<translation id="6256787297633808491">Flagi systemowe do stosowania przy uruchamianiu Chrome</translation>
<translation id="2516600974234263142">Włącza drukowanie w <ph name="PRODUCT_NAME"/> i uniemożliwia użytkownikom zmianę tego ustawienia.

      Jeśli ta opcja jest włączona lub nieskonfigurowana, użytkownicy mogą drukować.

      W przypadku wyłączenia tej opcji użytkownicy nie mogą drukować z <ph name="PRODUCT_NAME"/>. Drukowanie jest wyłączone w menu klucza, aplikacjach JavaScript itd. Nadal można drukować z poziomu wtyczek pomijających <ph name="PRODUCT_NAME"/> podczas drukowania. Na przykład menu niektórych aplikacji Flash zawiera opcję drukowania, która nie jest objęta tą zasadą.</translation>
<translation id="9135033364005346124">Włącz serwer proxy usługi <ph name="CLOUD_PRINT_NAME"/></translation>
<translation id="4519046672992331730">Włącza propozycje wyszukiwania w omniboksie w <ph name="PRODUCT_NAME"/> i uniemożliwia użytkownikom zmianę tego ustawienia.

      Jeśli włączysz to ustawienie, funkcja propozycji będzie aktywna.

      W przypadku jego wyłączenia funkcja jest nieaktywna.

      Jeśli to ustawienie jest włączone lub wyłączone, użytkownicy nie mogą go zmienić ani zastąpić w <ph name="PRODUCT_NAME"/>.

      W przypadku nieskonfigurowania tej zasady ustawienie zostanie włączone, ale użytkownik będzie mógł to zmienić.</translation>
<translation id="6943577887654905793">Nazwa ustawienia w systemie Mac OS/Linux:</translation>
<translation id="6925212669267783763">Konfiguruje katalog używany przez  <ph name="PRODUCT_FRAME_NAME"/> do przechowywania danych użytkownika.

      Jeśli ta zasada zostanie ustawiona, <ph name="PRODUCT_FRAME_NAME"/> użyje podanego katalogu.

      Na http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables znajdziesz listę zmiennych, których możesz użyć.

      Jeśli to ustawienie nie zostanie ustawione, zostanie użyty domyślny katalog profilu.</translation>
<translation id="8906768759089290519">Włącz tryb gościa</translation>
<translation id="2168397434410358693">Opóźnienie bezczynności przy zasilaniu sieciowym</translation>
<translation id="838870586332499308">Włącz dane w roamingu</translation>
<translation id="3234167886857176179">Oto lista zasad, które są przestrzegane przez <ph name="PRODUCT_NAME"/>.

      Nie musisz zmieniać tych ustawień ręcznie. Możesz pobrać łatwe w użyciu szablony
      z <ph name="POLICY_TEMPLATE_DOWNLOAD_URL"/>.

      Lista obsługiwanych zasad jest taka sama dla Chromium i Google Chrome.

      Te zasady są przeznaczone do skonfigurowania Chrome na wewnętrzny użytek Twojej organizacji. Użycie ich poza nią (np. w programie rozpowszechnianym publicznie) spowoduje uznanie oprogramowania za złośliwe i najprawdopodobniej tak też zostanie potraktowane przez Google i oprogramowanie antywirusowe.

      Uwaga: od Chrome 28 w Windows zasady są ładowane bezpośrednio z interfejsu API zasad Grup dyskusyjnych Google. Zasady ręcznie zapisane w rejestrze będą ignorowane. Więcej informacji: http://crbug.com/259236.</translation>
<translation id="2292084646366244343"><ph name="PRODUCT_NAME"/> może sprawdzać pisownię, używając usługi internetowej Google. Jeśli to ustawienie zostanie włączone, usługa będzie zawsze używana. W przypadku wyłączenia tego ustawienia, usługa nie będzie nigdy wykorzystywana.

      Pisownię można nadal sprawdzać, korzystając z pobranego słownika. Ta zasada kontroluje tylko używanie usługi internetowej.

      Jeśli to ustawienie nie zostanie skonfigurowane, użytkownicy będą mogli wybrać, czy chcą używać usługi sprawdzania pisowni.</translation>
<translation id="8782750230688364867">Określa wartość procentową skalowania opóźnienia przyciemnienia ekranu, gdy urządzenie działa w trybie prezentacji.

          Ustawienie tej zasady pozwala określić wartość procentową skalowania opóźnienia przyciemnienia ekranu, gdy urządzenie działa w trybie prezentacji. Skalowanie opóźnienia przyciemnienia powoduje, że opóźnienia wyłączenia i zablokowania ekranu oraz opóźnienie bezczynności są tak dostosowywane, by zachować pierwotnie ustawione odstępy od opóźnienia przyciemnienia ekranu.

          Jeśli zasada nie jest ustawiona, obowiązuje domyślny współczynnik skalowania.

          Współczynnik skalowania musi wynosić co najmniej 100%. Wartości, przy których opóźnienie przyciemnienia ekranu w trybie prezentacji byłoby krótsze od standardowego opóźnienia tego rodzaju, są niedozwolone.</translation>
<translation id="254524874071906077">Ustaw Chrome jako przeglądarkę domyślną</translation>
<translation id="8764119899999036911">Pozwala określić, czy generowana nazwa SPN w protokole Kerberos jest tworzona na podstawie kanonicznej nazwy DNS, czy też wpisanej, oryginalnej nazwy. Włączenie tego ustawienia powoduje pominięcie wyszukiwania rekordu CNAME i użycie wprowadzonej nazwy serwera. Jeśli wyłączysz ustawienie lub nie skonfigurujesz go, nazwa kanoniczna serwera będzie określana za pomocą wyszukiwania rekordu CNAME.</translation>
<translation id="5056708224511062314">Lupa wyłączona</translation>
<translation id="4377599627073874279">Zezwalaj na wyświetlanie wszelkich grafik we wszystkich witrynach</translation>
<translation id="7195064223823777550">Określa, jakie działanie ma zostać wykonane po zamknięciu pokrywy przez użytkownika.

          Jeśli ta zasada jest ustawiona, określa działanie wykonywane przez system <ph name="PRODUCT_OS_NAME"/> po zamknięciu pokrywy urządzenia.

          Jeśli ta zasada nie jest ustawiona, wykonywane jest działanie domyślne (czyli wstrzymanie).

          Jeśli działaniem jest wstrzymanie, system <ph name="PRODUCT_OS_NAME"/> można skonfigurować osobno tak, by ekran był lub nie był blokowany przed wstrzymaniem.</translation>
<translation id="3915395663995367577">Adres URL pliku PAC serwera proxy</translation>
<translation id="2144674628322086778">Zezwalaj użytkownikom firmowym na pełnienie funkcji zarówno użytkownika głównego, jak i dodatkowego (ustawienie domyślne)</translation>
<translation id="1022361784792428773">Identyfikatory rozszerzeń, których nie może instalować użytkownik (wartość * oznacza wszystkie)</translation>
<translation id="5499375345075963939">Ta zasada jest aktywna tylko w trybie sklepu.

      Gdy ta zasada zostanie ustawiona na wartość różną od 0, aktualnie zalogowany użytkownik demonstracyjny zostanie automatycznie wylogowany po upływie podanego okresu bezczynności.

      Wartość zasady należy określić w milisekundach.</translation>
<translation id="7683777542468165012">Dynamiczne odświeżanie zasad</translation>
<translation id="1160939557934457296">Wyłącz możliwość kontynuacji na stronie ostrzeżenia Bezpiecznego przeglądania</translation>
<translation id="8987262643142408725">Wyłącz dzielenie rekordów SSL</translation>
<translation id="4529945827292143461">Dostosuj listę wzorcowych URL-i, które powinny zawsze być renderowane przez przeglądarkę hosta. Jeśli ta zasada nie zostanie skonfigurowana, dla wszystkich witryn będzie używany domyślny mechanizm renderowania określony przez zasadę „ChromeFrameRendererSettings”. Przykładowe wzorce są dostępne na http://www.chromium.org/developers/how-tos/chrome-frame-getting-started</translation>
<translation id="8044493735196713914">Zgłoś tryb uruchomienia urządzenia</translation>
<translation id="2746016768603629042">Ta zasada została wycofana. Zamiast niej użyj DefaultJavaScriptSetting.

      Umożliwia wyłączenie JavaScriptu w <ph name="PRODUCT_NAME"/>.

      Jeśli to ustawienie zostanie wyłączone, strony nie będą mogły używać JavaScriptu, a użytkownik nie będzie mógł zmienić tego ustawienia.

      Jeśli to ustawienie będzie włączone lub nieustawione, strony będą mogły używać JavaScriptu, ale użytkownik będzie mógł zmienić to ustawienie.</translation>
<translation id="1942957375738056236">W tym miejscu możesz podać URL serwera proxy. Ta zasada obowiązuje tylko wówczas, gdy zdecydujesz się ręcznie wprowadzić ustawienia serwera proxy za pomocą opcji „Wybierz sposób określenia ustawień serwera proxy”. Nie ustawiaj tej zasady w przypadku wybrania innego trybu ustawiania zasad proxy. Więcej opcji i szczegółowych przykładów znajdziesz na <ph name="PROXY_HELP_URL"/></translation>
<translation id="6076008833763548615">Wyłącz podłączanie pamięci zewnętrznych.

      Po włączeniu tej zasady pamięci zewnętrzne będą niedostępne w przeglądarce plików.

      Ta zasada dotyczy wszystkich typów nośników pamięci, takich jak na przykład napędy flash USB, zewnętrzne dyski twarde, karty pamięci SD i inne, pamięci optyczne itd. Pamięć wewnętrzna nie podlega tej zasadzie, więc nadal będzie można otwierać pliki z folderu Pobrane. Ta zasada nie dotyczy również Dysku Google.

      W przypadku wyłączenia lub nieskonfigurowania tego ustawienia użytkownicy będą mogli korzystać na urządzeniu ze wszystkich obsługiwanych typów pamięci zewnętrznych.</translation>
<translation id="6936894225179401731">Określa maksymalną liczbę jednoczesnych połączeń z serwerem proxy. Niektóre serwery proxy nie są w stanie obsłużyć dużej liczby jednoczesnych połączeń z tym samym klientem. W takiej sytuacji można rozwiązać problem, ustawiając dla tej zasady mniejszą wartość. Jej wartość powinna być mniejsza niż 100 i większa niż 6. Wartość domyślna wynosi 32. Niektóre aplikacje sieciowe używają wielu połączeń z oczekującymi żądaniami GET, dlatego zmniejszenie wartości tej zasady poniżej wartości 32 może powodować przerwy w działaniu sieci, jeśli zbyt wiele takich aplikacji będzie otwartych. Zmniejszasz wartości domyślne na własne ryzyko. W przypadku nieskonfigurowania tej zasady będzie używana wartość domyślna, czyli 32.</translation>
<translation id="5395271912574071439">Włącza separację hostów zdalnego dostępu podczas połączenia.

          W przypadku włączenia tej opcji fizyczne urządzenia wejściowe i wyjściowe hosta będą wyłączane na czas trwania połączenia zdalnego.

          Jeśli to ustawienie będzie wyłączone lub nieustawione, zarówno zdalni, jak i lokalni użytkownicy będą mogli korzystać z udostępnianego hosta.</translation>
<translation id="4894257424747841850">Raportuj listę użytkowników urządzenia, którzy niedawno się zalogowali.

      Jeśli ta zasada będzie wyłączona lub nieustawiona, użytkownicy nie będą raportowani.</translation>
<translation id="1426410128494586442">Tak</translation>
<translation id="4897928009230106190">Określa parametry używane przy sugerowaniu haseł z użyciem POST. Składa się z rozdzielonych przecinkami par nazwy i wartości. Jeśli wartość jest parametrem szablonu, tak jak w przykładzie powyżej {searchTerms}, zostanie ona zastąpiona rzeczywistymi danymi wyszukiwanych słów.

          Ta zasada jest opcjonalna. Jeśli nie jest ustawiona, żądania sugerowanych wyszukiwań są wysyłane przy użyciu metody GET.

          Ta zasada jest uwzględniana tylko wtedy, gdy włączona jest zasada „DefaultSearchProviderEnabled”.</translation>
<translation id="4962195944157514011">Określa URL wyszukiwarki używanej podczas wyszukiwania domyślnego. URL powinien zawierać ciąg „<ph name="SEARCH_TERM_MARKER"/>”, który podczas zapytania zostanie zastąpiony hasłami wyszukiwanymi przez użytkownika. Ta opcja musi być ustawiona w przypadku włączenia zasady „DefaultSearchProviderEnabled” i tylko wtedy będzie uwzględniana.</translation>
<translation id="6009903244351574348">Pozwól <ph name="PRODUCT_FRAME_NAME"/> obsługiwać wymienione typy treści. Jeśli ta zasada nie zostanie skonfigurowana, dla wszystkich witryn będzie używany domyślny mechanizm renderujący określony przez zasadę „ChromeFrameRendererSettings”.</translation>
<translation id="3381968327636295719">Używaj domyślnie przeglądarki hosta</translation>
<translation id="3627678165642179114">Włącz lub wyłącz internetową usługę sprawdzania pisowni</translation>
<translation id="6520802717075138474">Importuj wyszukiwarki z przeglądarki domyślnej przy pierwszym uruchomieniu</translation>
<translation id="4039085364173654945">Określa, czy umieszczona na stronie treść dodatkowa innej firmy może wyświetlać okno dialogowe z podstawowym uwierzytelnianiem HTTP. Zwykle ta zasada jest wyłączona w celu ochrony przed phishingiem. W przypadku nieskonfigurowania zasady ustawienie jest wyłączone i treść dodatkowa innej firmy nie może wyświetlać okna dialogowego z podstawowym uwierzytelnianiem HTTP.</translation>
<translation id="4946368175977216944">Określa flagi, które należy zastosować przy uruchomieniu Chrome. Wskazane flagi są stosowane przed uruchomieniem Chrome nawet dla ekranu logowania.</translation>
<translation id="7447786363267535722">Umożliwia zapisanie haseł i używanie ich w <ph name="PRODUCT_NAME"/>. Jeśli włączysz to ustawienie, <ph name="PRODUCT_NAME"/> może zapamiętywać hasła użytkowników i wprowadzać je za nich automatycznie podczas kolejnego logowania do witryny. Jeśli zaś je wyłączysz, użytkownicy nie będą mogli zapisywać nowych ani używać dotychczas zapisanych haseł. W przypadku ustawienia tej zasady użytkownicy nie będą mogli zmienić ani zastąpić tego ustawienia w <ph name="PRODUCT_NAME"/>. Jeśli ta zasada nie zostanie skonfigurowana, ustawienie będzie włączone, ale użytkownik będzie mógł to zmienić.</translation>
<translation id="1138294736309071213">Ta zasada jest aktywna tylko w trybie sklepu.

      W przypadku urządzeń w trybie sklepu określa czas, po upływie którego na ekranie logowania jest wyświetlany wygaszacz ekranu.

      Wartość tej zasady należy podać w milisekundach.</translation>
<translation id="6368011194414932347">Konfiguruj adres URL strony startowej</translation>
<translation id="2877225735001246144">Wyłącz wyszukiwanie rekordu CNAME podczas negocjowania uwierzytelniania Kerberos</translation>
<translation id="9120299024216374976">Określa strefę czasową używaną na urządzeniu. Użytkownicy mogą zmienić podaną strefę czasową na czas bieżącej sesji. Jednak po wylogowaniu ponownie ustawiana jest podana strefa czasowa. W przypadku podania nieprawidłowej wartości zasada jest aktywowana z ustawieniem „GMT”. W przypadku podania pustego łańcucha zasada jest ignorowana.

      Jeśli ta zasada jest nieużywana, aktualnie aktywna strefa czasowa będzie nadal stosowana, ale użytkownicy będą mogli ją zmienić w sposób trwały. Dlatego zmiana wprowadzona przez jednego użytkownika będzie wpływać na ekran logowania wszystkich innych użytkowników.

      W nowych urządzeniach ustawiona jest strefa czasowa „Stany Zjednoczone/Czas pacyficzny”.

      Format wartości musi być zgodny z nazwami stref czasowych w bazie danych stref czasowych IANA (patrz: „http://en.wikipedia.org/wiki/List_of_tz_database_time_zones” – strona w języku angielskim). To oznacza, że większość stref czasowych można podawać w formacie „kontynent/duże_miasto” lub „ocean/duże_miasto”.</translation>
<translation id="3646859102161347133">Ustaw typ lupy</translation>
<translation id="3528000905991875314">Włącz alternatywne strony błędów</translation>
<translation id="1283072268083088623">Pozwala określić schematy uwierzytelniania HTTP obsługiwane w <ph name="PRODUCT_NAME"/>. Możliwe wartości to „podstawowe”, „podsumowanie”, „NTLM” i „negocjacja”. Poszczególne wartości rozdziel przecinkami. Jeśli ta zasada nie zostanie skonfigurowana, będą używane wszystkie cztery schematy.</translation>
<translation id="4914647484900375533">Włącza funkcję wyszukiwania dynamicznego w <ph name="PRODUCT_NAME"/> i zapobiega zmianie tego ustawienia przez użytkowników.

      Jeśli włączysz ustawienie, wyszukiwanie dynamiczne w <ph name="PRODUCT_NAME"/> jest włączone.

      W przeciwnym razie wyszukiwanie dynamiczne w <ph name="PRODUCT_NAME"/> jest wyłączone.

      Gdy włączysz lub wyłączysz ustawienie, użytkownicy nie mogą go zmienić ani zastąpić.

      Jeśli pozostanie ono nieustawione, użytkownik może zdecydować, czy chce używać tej funkcji.

      Ustawienie zostało usunięte z Chrome 29 i nowszych wersji.</translation>
<translation id="6114416803310251055">przestarzała</translation>
<translation id="8493645415242333585">Wyłącz zapisywanie historii przeglądarki</translation>
<translation id="5319306267766543020">Umożliwia skonfigurowanie zarządzania energią w systemie <ph name="PRODUCT_OS_NAME"/>.

      Te zasady pozwalają skonfigurować zachowanie systemu <ph name="PRODUCT_OS_NAME"/>, gdy użytkownik pozostaje nieaktywny przez pewien czas.</translation>
<translation id="2747783890942882652">Konfiguruje wymaganą nazwę hosta, która będzie stosowana do hostów zdalnego dostępu, i uniemożliwia użytkownikom jej zmianę.

          Jeśli to ustawienie zostanie włączone, hosty będą mogły być udostępniane tylko z użyciem kont zarejestrowanych w określonej domenie.

          W przypadku wyłączenia lub nieskonfigurowania tego ustawienia hosty będą mogły być udostępniane z użyciem dowolnego konta.</translation>
<translation id="6417861582779909667">Umożliwia skonfigurowanie listy wzorcowych URL-i określających witryny, którym nie wolno tworzyć plików cookie. Jeśli ta zasada nie zostanie skonfigurowana, dla wszystkich witryn będzie używana globalna wartość domyślna pobierana z zasady „DefaultCookiesSetting” (jeśli została ustawiona) lub z osobistej konfiguracji użytkownika.</translation>
<translation id="5457296720557564923">Umożliwia stronom dostęp do statystyk użytkowania pamięci JavaScript. To ustawienie udostępnia stronie internetowej statystyki pamięci z panelu profili Narzędzi dla programistów.</translation>
<translation id="5776485039795852974">Pytaj za każdym razem, gdy witryna chce pokazywać powiadomienia na pulpicie</translation>
<translation id="5047604665028708335">Zezwalaj na dostęp do witryn spoza pakietów treści</translation>
<translation id="5052081091120171147">Po włączeniu tej zasady wymuszany jest import historii przeglądania z bieżącej przeglądarki domyślnej. Włączenie zasady ma również wpływ na opcje w oknie dialogowym importowania. W przypadku jej wyłączenia historia przeglądania nie jest importowana. Jeśli zasada nie jest skonfigurowana, użytkownik może zostać zapytany, czy zaimportować historię lub operacja ta zostanie wykonana automatycznie.</translation>
<translation id="6786747875388722282">Rozszerzenia</translation>
<translation id="7132877481099023201">Adresy URL, które bez pytania otrzymają dostęp do urządzeń do nagrywania filmów</translation>
<translation id="8947415621777543415">Zgłoś lokalizację urządzenia</translation>
<translation id="1655229863189977773">Ustaw rozmiar dyskowej pamięci podręcznej w bajtach</translation>
<translation id="6376842084200599664">Umożliwia podanie listy rozszerzeń, które będą instalowane w trybie cichym bez działań użytkownika.

          Każda pozycja listy jest łańcuchem zawierającym identyfikator rozszerzenia oraz URL aktualizacji oddzielone średnikiem (<ph name="SEMICOLON"/>). Identyfikator rozszerzenia to 32-literowy łańcuch, który można znaleźć np. na <ph name="CHROME_EXTENSIONS_LINK"/> podczas pracy w trybie programisty. Adres URL aktualizacji powinien wskazywać na dokument Update Manifest XML, jak to opisano na <ph name="LINK_TO_EXTENSION_DOC1"/>. Pamiętaj, że URL aktualizacji ustawiony w tej zasadzie jest używany tylko przy początkowej instalacji. Kolejne aktualizacje rozszerzenia będą używać adresu URL aktualizacji wskazanego w manifeście rozszerzenia.

          Dla każdej pozycji <ph name="PRODUCT_NAME"/> będzie pobierać z usługi aktualizacji, dostępnej pod podanym URL-em, rozszerzenie określone identyfikatorem rozszerzenia i instalować je w trybie cichym.

          Na przykład <ph name="EXTENSION_POLICY_EXAMPLE"/> instaluje rozszerzenie <ph name="EXTENSION_POLICY_EXAMPLE_EXTENSION_NAME"/> z adresu URL aktualizacji Chrome Web Store. Więcej informacji o hostingu rozszerzeń znajdziesz na <ph name="LINK_TO_EXTENSION_DOC2"/>.

          Użytkownicy nie będą mogli odinstalować rozszerzeń określonych przez tę zasadę. Jeśli usuniesz rozszerzenie z listy, zostanie ono automatycznie odinstalowane przez <ph name="PRODUCT_NAME"/>. Rozszerzenia podane na tej liście są też automatycznie dodawane do białej listy instalacji – nie dotyczy ich zasada  ExtensionsInstallBlacklist.

          W przypadku nieustawienia tej zasady użytkownik będzie mógł odinstalować każde rozszerzenie z <ph name="PRODUCT_NAME"/>.</translation>
<translation id="6899705656741990703">Automatycznie wykrywaj ustawienia serwera proxy</translation>
<translation id="8382184662529825177">Włącz używanie zaświadczania zdalnego do ochrony treści na urządzeniu</translation>
<translation id="7003334574344702284">Po włączeniu tej zasady wymuszany jest import zapisanych haseł z poprzedniej przeglądarki domyślnej. Włączenie zasady ma również wpływ na opcje w oknie dialogowym importowania. W przypadku jej wyłączenia zapisane hasła nie są importowane. Jeśli zasada nie jest skonfigurowana, użytkownik może zostać zapytany, czy zaimportować hasła lub operacja ta zostanie wykonana automatycznie.</translation>
<translation id="6258193603492867656">Pozwala określić, czy generowana nazwa SPN w protokole Kerberos ma zawierać port niestandardowy. Po włączeniu tego ustawienia i wprowadzeniu portu niestandardowego (tzn. innego niż 80 i 443) jest on umieszczany w generowanej nazwie SPN w protokole Kerberos. Jeśli wyłączysz ustawienie, generowana nazwa SPN w protokole Kerberos nie będzie w żadnym przypadku zawierać portu.</translation>
<translation id="3236046242843493070">Wzorce URL-ów, z których dozwolone jest instalowanie rozszerzeń, aplikacji i skryptów użytkownika</translation>
<translation id="2498238926436517902">Zawsze autoukrywaj półkę</translation>
<translation id="253135976343875019">Opóźnienie ostrzeżenia o bezczynności przy zasilaniu sieciowym</translation>
<translation id="480987484799365700">Włączenie tej zasady powoduje wymuszenie przełączenia profilu w tryb tymczasowy. Jeśli zasada jest określona jako zasada systemu operacyjnego (np. obiekt zasad grupy w systemie Windows), zostanie zastosowana do każdego profilu w systemie. Ustawienie jej jako zasady w chmurze powoduje zastosowanie jej tylko do profilu zalogowanego przez konto zarządzane.

      W tym trybie dane profilu są zachowywane na dysku tylko na czas sesji użytkownika. Funkcje takie jak historia przeglądarki, rozszerzenia i ich dane, dane internetowe (na przykład pliki cookie) oraz internetowe bazy danych nie zostają zachowane po zamknięciu przeglądarki. Użytkownik może jednak ręcznie pobrać dane na dysk, zapisać strony lub je wydrukować.

      Jeśli użytkownik włączył synchronizację, te wszystkie dane są zachowywane w jego profilu synchronizacji podobnie jak w zwykłych profilach. Dostępny jest też tryb incognito, o ile nie został wyłączony przez zasadę.

      Jeśli zasada jest wyłączona lub nie ustawiono jej, logowanie prowadzi do zwykłych profili.</translation>
<translation id="6997592395211691850">Określa, czy dla lokalnych kotwic zaufania są wymagane sprawdzenia online OCSP/CRL</translation>
<translation id="152657506688053119">Lista alternatywnych URL-i dla domyślnego dostawcy wyszukiwania</translation>
<translation id="8992176907758534924">Nie zezwalaj na pokazywanie grafik w żadnej witrynie</translation>
<translation id="262740370354162807">Włącz wysyłanie dokumentów do <ph name="CLOUD_PRINT_NAME"/>.</translation>
<translation id="7717938661004793600">Skonfiguruj funkcje ułatwień dostępu w <ph name="PRODUCT_OS_NAME"/>.</translation>
<translation id="5182055907976889880">Skonfiguruj Dysk Google w <ph name="PRODUCT_OS_NAME"/>.</translation>
<translation id="8704831857353097849">Lista wyłączonych wtyczek</translation>
<translation id="8391419598427733574">Zgłasza wersje systemu operacyjnego i oprogramowania układowego zarejestrowanych urządzeń. Po włączeniu zasady zarejestrowane urządzenia okresowo zgłaszają wersje systemu i oprogramowania. Jeśli zasada nie jest ustawiona lub jest wyłączona, informacje o wersji nie są przesyłane.</translation>
<translation id="467449052039111439">Otwórz adresy URL z listy</translation>
<translation id="5883015257301027298">Domyślne ustawienie plików cookie</translation>
<translation id="5017500084427291117">Blokuje dostęp do wymienionych URL-i.

      Zasada uniemożliwia użytkownikowi wczytanie stron internetowych dodanych do czarnej listy.

      URL ma format „schemat://host:port/ścieżka”.
      Opcjonalny schemat to http, https lub ftp. Blokowany jest tylko dany schemat. Jeśli nie zostanie określony, blokowane są wszystkie.
      Parametr host to nazwa hosta lub adres IP. Subdomeny nazwy hosta również są blokowane. Aby zapobiec blokowaniu subdomen, przed nazwą hosta umieść znak „.”. Specjalna nazwa hosta „*” spowoduje zablokowanie wszystkich domen.
      Opcjonalny prawidłowy port to liczba z zakresu od 1 do 65 535. Jeśli nie zostanie określony, blokowane są wszystkie.
      Określenie opcjonalnej ścieżki powoduje blokowanie tylko ścieżek z podanym prefiksem.

      Wyjątki można zdefiniować w zasadzie dotyczącej białej listy adresów URL. Maksymalna liczba wpisów w tych zasadach wynosi 1000. Kolejne wpisy są ignorowane.

      W przypadku nieskonfigurowania tej zasady żadne URL-e nie będą blokowane w przeglądarce.</translation>
<translation id="2762164719979766599">Określa listę kont na urządzeniu, które będą pokazywane na ekranie logowania.

      Każdy wpis określa identyfikator używany wewnętrznie do rozróżniania lokalnych kont na urządzeniu.</translation>
<translation id="8955719471735800169">Powrót do góry</translation>
<translation id="2534584045044686957">Umożliwia skonfigurowanie wielkości pamięci podręcznej używanej przez <ph name="PRODUCT_NAME"/> do przechowywania buforowanych plików multimedialnych na dysku.

      Jeśli ustawisz tę zasadę, <ph name="PRODUCT_NAME"/> będzie używać podanego rozmiaru pamięci podręcznej, niezależnie od tego, czy użytkownik określi flagę „--media-cache-size”.

      Jeśli wartość tej zasady zostanie ustawiona na 0, będzie używany domyślny rozmiar pamięci podręcznej, ale użytkownik nie będzie mógł go zmienić.

      Jeśli ta zasada nie zostanie ustawiona, będzie używany rozmiar domyślny, ale użytkownik będzie mógł go zmienić, używając flagi --media-cache-size.</translation>
<translation id="3723474915949495925">Pozwala określić listę wtyczek, które użytkownik może włączyć lub wyłączyć w <ph name="PRODUCT_NAME"/>.

      Możesz użyć symboli wieloznacznych „*” i „?”, by dopasować sekwencje dowolnych znaków. Symbol „*” odpowiada dowolnej liczbie znaków, natomiast „?” oznacza jeden opcjonalny znak (czyli jeden lub zero znaków). Znakiem zmiany znaczenia jest „\”, dlatego by wprowadzić faktyczny znak „*”, „?” lub „\”, musisz umieścić przed nim znak „\”.

      Jeśli włączysz to ustawienie, w <ph name="PRODUCT_NAME"/> będzie mogła być używana określona lista wtyczek. Użytkownicy będą je mogli włączać i wyłączać na stronie „about:plugins”, nawet jeśli wtyczka będzie zgodna ze wzorcem w zasadzie DisabledPlugins. Użytkownicy będą też mogli włączać i wyłączać wtyczki niezgodne z wzorcami w zasadach DisabledPlugins, DisabledPluginsExceptions i EnabledPlugins.

      Ta zasada ma umożliwić ścisłą kontrolę uruchamiania wtyczek, gdy lista „DisabledPlugins” zawiera pozycje z symbolami wieloznacznymi (na przykład wyłączenie wszystkich wtyczek – „*” lub wyłączenie wszystkich wtyczek Java – „Java*”), a administrator chce włączyć tylko konkretną wersję – na przykład „IcedTea Java 2.3”. Te konkretne wersje można określić w tej zasadzie.

      Jeśli ta zasada nie zostanie ustawiona, każda wtyczka zgodna ze wzorcem na liście „DisabledPlugins” zostanie wyłączona i zablokowana, a użytkownik nie będzie mógł jej włączyć.</translation>
<translation id="4557134566541205630">URL strony nowej karty domyślnego dostawcy wyszukiwania</translation>
<translation id="546726650689747237">Opóźnienie przyciemnienia ekranu przy zasilaniu sieciowym</translation>
<translation id="4988291787868618635">Działanie, jakie ma zostać wykonane po osiągnięciu opóźnienia bezczynności</translation>
<translation id="7260277299188117560">Sieć P2P aktualizacji automatycznych włączona</translation>
<translation id="5316405756476735914">Pozwala określić, czy witryny mogą tworzyć dane lokalne. Tworzenie danych lokalnych może być dozwolone lub zabronione w przypadku wszystkich witryn. Jeśli ta zasada nie zostanie skonfigurowana, zostanie zastosowane ustawienie „AllowCookies”, a użytkownik będzie mógł je zmienić.</translation>
<translation id="4250680216510889253">Nie</translation>
<translation id="1522425503138261032">Zezwalaj witrynom na śledzenie fizycznej lokalizacji użytkownika</translation>
<translation id="6467433935902485842">Umożliwia skonfigurowanie listy wzorcowych URL-i określających witryny, w których nie mogą być uruchamiane wtyczki. Jeśli ta zasada nie zostanie skonfigurowana, dla wszystkich witryn będzie używana globalna wartość domyślna pochodząca z zasady „DefaultPluginsSetting” (jeśli została skonfigurowana) lub z osobistej konfiguracji użytkownika.</translation>
<translation id="4423597592074154136">Ręcznie określ ustawienia serwera proxy</translation>
<translation id="209586405398070749">Wersja stabilna</translation>
<translation id="8170878842291747619">Włącza zintegrowaną usługę Tłumacz Google w <ph name="PRODUCT_NAME"/>. Jeśli włączysz tę opcję, w <ph name="PRODUCT_NAME"/> w razie potrzeby pojawi się zintegrowany pasek narzędzi oferujący możliwość przetłumaczenia strony. Jeśli wyłączysz tę opcję, użytkownicy nie zobaczą paska tłumaczeń. Ustawienie tej opcji zablokuje możliwość jej zmiany przez użytkowników w <ph name="PRODUCT_NAME"/>. W przypadku nieokreślenia tego ustawienia użytkownicy mogą zdecydować, czy chcą używać tej funkcji czy nie.</translation>
<translation id="9035964157729712237">Identyfikatory rozszerzeń nieobjętych czarną listą</translation>
<translation id="8244525275280476362">Maksymalne opóźnienie pobrania po unieważnieniu zasady</translation>
<translation id="8587229956764455752">Pozwól na tworzenie nowych kont użytkowników</translation>
<translation id="7417972229667085380">Wartość procentowa skalowania opóźnienia bezczynności w trybie prezentacji (wycofana)</translation>
<translation id="3964909636571393861">Zezwalaj na dostęp do listy adresów URL</translation>
<translation id="3450318623141983471">Zgłasza stan przełącznika trybu programisty podczas uruchomienia urządzenia. Jeśli zasada nie jest ustawiona lub jest wyłączona, stan przełącznika trybu programisty nie jest zgłaszany.</translation>
<translation id="1811270320106005269">Powoduje włączenie blokady w przypadku bezczynności lub zawieszenia działania urządzenia z systemem operacyjnym <ph name="PRODUCT_OS_NAME"/>.

      Jeśli włączysz to ustawienie, użytkownik w celu odblokowania uśpionego urządzenia będzie musiał podać hasło.

      Po wyłączeniu ustawienia wybudzenie nie wymaga podawania hasła.

      Jeśli ustawienie jest włączone lub wyłączone, użytkownicy nie mogą go zmienić ani zastąpić.

      Jeśli zasada nie zostanie skonfigurowana, użytkownik może wybrać, czy chce odblokowywać urządzenie przy użyciu hasła.</translation>
<translation id="6022948604095165524">Działanie po uruchomieniu</translation>
<translation id="9042911395677044526">Pozwala na przesyłanie konfiguracji sieciowej w trybie push do urządzeń z <ph name="PRODUCT_OS_NAME"/> dla poszczególnych użytkowników. Konfiguracja sieci to łańcuch w formacie JSON zgodny z formatem Open Network Configuration opisanym na <ph name="ONC_SPEC_URL"/></translation>
<translation id="7128918109610518786">Lista identyfikatorów aplikacji pokazywanych przez <ph name="PRODUCT_OS_NAME"/> jako aplikacje przypięte na pasku programu uruchamiającego.

      Jeśli ta zasada jest skonfigurowana, zestaw aplikacji jest ustalony i nie może być zmieniany przez użytkownika.

      Jeśli zasada nie jest ustawiona, użytkownik może zmieniać listę aplikacji przypiętych w programie uruchamiającym.</translation>
<translation id="1679420586049708690">Sesja publiczna dla automatycznego logowania</translation>
<translation id="7625444193696794922">Określa kanał wersji, z którym to urządzenie powinno być powiązane na stałe.</translation>
<translation id="2552966063069741410">Strefa czasowa</translation>
<translation id="2240879329269430151">Umożliwia określenie, czy w witrynach mogą być pokazywane wyskakujące okienka. Pokazywanie wyskakujących okienek może być dozwolone lub zabronione we wszystkich witrynach. W przypadku nieskonfigurowania tej zasady będzie używane ustawienie „BlockPopups”, a użytkownik będzie mógł je zmienić.</translation>
<translation id="2529700525201305165">Określ użytkowników, którzy mogą logować się do <ph name="PRODUCT_NAME"/></translation>
<translation id="8971221018777092728">Zegar automatycznego logowania do sesji publicznej</translation>
<translation id="8285435910062771358">Pełnoekranowa lupa włączona</translation>
<translation id="5141670636904227950">Ustaw domyślny typ lupy włączony na ekranie logowania</translation>
<translation id="3864818549971490907">Domyślne ustawienie wtyczek</translation>
<translation id="7151201297958662315">Określa, czy proces <ph name="PRODUCT_NAME"/> został uruchomiony przy logowaniu do systemu operacyjnego i podtrzymuje jego działanie po zamknięciu ostatniego okna przeglądarki, co pozwala utrzymać aktywność aplikacji działających w tle. Proces tła zawsze wyświetla w zasobniku systemowym ikonę umożliwiającą zamknięcie procesu.

      Po włączeniu tej zasady tryb pracy w tle jest włączony i użytkownik nie może nim sterować w ustawieniach przeglądarki.

      Po wyłączeniu tej zasady tryb pracy w tle jest wyłączony i użytkownik nie może nim sterować w ustawieniach przeglądarki.

      Jeśli ta zasada nie zostanie ustawiona, tryb pracy w tle początkowo jest wyłączony, ale użytkownik może nim sterować w ustawieniach przeglądarki.</translation>
<translation id="4320376026953250541">Microsoft Windows XP z dodatkiem SP2 lub nowszy</translation>
<translation id="5148753489738115745">Pozwala określić dodatkowe parametry używane, gdy <ph name="PRODUCT_FRAME_NAME"/> uruchamia <ph name="PRODUCT_NAME"/>.

          Jeśli ta zasada nie jest ustawiona, używany jest domyślny wiersz polecenia.</translation>
<translation id="2646290749315461919">Umożliwia określenie, czy witryny mogą śledzić fizyczną lokalizację użytkownika. Śledzenie fizycznej lokalizacji użytkownika może być domyślnie dozwolone lub zabronione bądź użytkownik może być o to pytany za każdym razem, gdy witryna żąda informacji o lokalizacji. W przypadku nieskonfigurowania tej zasady używane będzie ustawienie „AskGeolocation”, a użytkownik będzie mógł je zmienić.</translation>
<translation id="6394350458541421998">Ta zasada została wycofana w <ph name="PRODUCT_OS_NAME"/> w wersji 29. Zamiast niej użyj zasady PresentationScreenDimDelayScale.</translation>
<translation id="5770738360657678870">Wersja deweloperska (może być niestabilna)</translation>
<translation id="2959898425599642200">Reguły omijania serwera proxy</translation>
<translation id="228659285074633994">Określa czas bez wprowadzenia danych przez użytkownika, po którym wyświetlane jest okno dialogowe ostrzeżenia przy zasilaniu sieciowym.

          Gdy ta zasada jest ustawiona, określa wymagany czas nieaktywności użytkownika przed wyświetleniem w <ph name="PRODUCT_OS_NAME"/> okna dialogowego z ostrzeżeniem informującym, że zostanie wykonana odpowiednia czynność.

          Gdy ta zasada nie jest ustawiona, ostrzeżenie nie jest wyświetlane.

          Wartość dla zasady należy podać w milisekundach. Wartości są ograniczane, tak aby nie przekraczały wartości opóźnienia nieaktywności.</translation>
<translation id="1098794473340446990">Zgłasza godziny aktywności urządzenia. Po włączeniu zasady zarejestrowane urządzenie zgłasza, kiedy korzysta z niego użytkownik. Jeśli zasada nie jest ustawiona lub jest wyłączona, okresy aktywności urządzenia nie są rejestrowane ani zgłaszane.</translation>
<translation id="7937766917976512374">Zezwól lub nie na przechwytywanie wideo</translation>
<translation id="427632463972968153">Określa parametry używane przy wyszukiwaniu obrazem przy użyciu POST. Składa się z rozdzielonych przecinkami par nazwy i wartości. Jeśli wartość jest parametrem szablonu, tak jak w przykładzie powyżej {imageThumbnail}, zostanie ona zastąpiona rzeczywistymi danymi miniatury obrazu.

          Ta zasada jest opcjonalna. Jeśli nie jest ustawiona, żądania wyszukiwania obrazem są wysyłane przy użyciu metody GET.

          Ta zasada jest uwzględniana tyko wtedy, gdy włączona jest zasada „DefaultSearchProviderEnabled”.</translation>
<translation id="8818646462962777576">Wzorce na tej liście są dopasowywane do źródła
      zabezpieczeń adresu URL, z którego pochodzi żądanie. Po znalezieniu odpowiednika
      dostęp do urządzeń do przechwytywania dźwięku jest udzielany bez pytania.

      UWAGA: obecnie ta zasada działa tylko w trybie kiosku.</translation>
<translation id="489803897780524242">Parametr sterujący zamianą wyszukiwanego hasła dla domyślnego dostawcy wyszukiwania</translation>
<translation id="316778957754360075">To ustawienie zostało wycofane w <ph name="PRODUCT_NAME"/> w wersji 29. Zalecany sposób konfigurowania kolekcji rozszerzeń lub aplikacji udostępnianych przez organizację polega na tym, że witrynę z pakietami CRX umieszcza się w zasadzie ExtensionInstallSources, a na stronie internetowej udostępnia się bezpośrednie linki do pakietów do pobrania. Program uruchamiający tę stronę internetową można utworzyć, korzystając z zasady ExtensionInstallForcelist.</translation>
<translation id="6401669939808766804">Wyloguj użytkownika</translation>
<translation id="4826326557828204741">Czynność, jaka ma zostać podjęta po osiągnięciu opóźnienia bezczynności przy pracy na baterii</translation>
<translation id="7912255076272890813">Skonfiguruj dozwolone typy aplikacji/rozszerzeń</translation>
<translation id="817455428376641507">Zezwala na otwieranie wymienionych URL-i jako wyjątków względem czarnej listy URL-i.

      Format pozycji tej listy znajdziesz w opisie zasady czarnej listy adresów URL.

      Za pomocą tej zasady można utworzyć wyjątki w restrykcyjnych czarnych listach. Na przykład pozycja „*” może znajdować się na czarnej liście, by zablokować wszystkie żądania, a za pomocą tej zasady można zezwolić na dostęp do ograniczonej listy URL-i. Wyjątki można tworzyć dla konkretnych schematów, subdomen innych domen, portów lub konkretnych ścieżek.

      Najbardziej precyzyjny filtr będzie określać, czy URL jest zablokowany czy dozwolony. Biała lista ma pierwszeństwo przed czarną.

      Maksymalna liczba wpisów w tej zasadzie to 1000. Kolejne są ignorowane.

      W przypadku nieskonfigurowania tej zasady nie będzie wyjątków w zasadzie „URLBlacklist”.</translation>
<translation id="4163644371169597382">Administratorzy IT urządzeń firmowych mogą użyć tej flagi do określenia, czy użytkownicy mogą korzystać z ofert w procesie rejestracji systemu operacyjnego Chrome.

      Jeśli wartość tej zasady to Prawda lub nie jest ona ustawiona, użytkownicy mogą wykorzystać oferty przy rejestracji systemu operacyjnego Chrome.

      Jeśli wartość tej zasady to Fałsz, użytkownicy nie mogą wykorzystać ofert.</translation>
<translation id="8148901634826284024">Włącza funkcję ułatwień dostępu w postaci trybu wysokiego kontrastu.

          Jeśli ta zasada ma wartość „prawda”, tryb wysokiego kontrastu jest zawsze włączony.

          Jeśli ma ona wartość „fałsz”, ten tryb jest zawsze wyłączony.

          Gdy ją ustawisz, użytkownicy nie mogą jej zmienić ani zastąpić.

          Jeśli zasada pozostanie nieustawiona, tryb wysokiego kontrastu jest początkowo wyłączony, ale użytkownik może go w każdej chwili włączyć.</translation>
<translation id="6177482277304066047">Ustawia wersję docelową dla autoaktualizacji.

      Określa przedrostek wersji docelowej aktualizacji systemu <ph name="PRODUCT_OS_NAME"/>. Jeśli na urządzeniu działa wersja starsza niż określona przez podany przedrostek, zostanie wykonana aktualizacja do najnowszej wersji z danym przedrostkiem. Jeśli na urządzeniu działa już późniejsza wersja, nie są wprowadzane żadne zmiany (czyli nie jest przywracana starsza wersja), a na urządzeniu jest pozostawiana aktualnie używana wersja. Jak pokazano w poniższym przykładzie, format przedrostka rozróżnia komponenty:

      &quot;&quot; (lub brak konfiguracji): aktualizacja do najnowszej dostępnej wersji.
      &quot;1412.&quot;: aktualizacja do dowolnej wersji podrzędnej 1412 (np. 1412.24.34 lub 1412.60.2)
      &quot;1412.2.&quot;: aktualizacja do dowolnej wersji podrzędnej 1412.2 (np. 1412.2.34 lub 1412.2.2)
      &quot;1412.24.34&quot;: aktualizacja tylko do tej konkretnej wersji</translation>
<translation id="8102913158860568230">Domyślne ustawienia strumienia multimediów</translation>
<translation id="6641981670621198190">Wyłącz obsługę interfejsów API grafiki 3D</translation>
<translation id="7929480864713075819">Włącz raportowanie informacji o pamięci (rozmiar stosu pamięci JS) do strony.</translation>
<translation id="5703863730741917647">Określa czynność podejmowaną po osiągnięciu opóźnienia bezczynności.

          Ta zasada jest przestarzała i w przyszłości zostanie wycofana.

          Ta zasada zawiera wartość zapasową dla bardziej szczegółowych zasad <ph name="IDLEACTIONAC_POLICY_NAME"/> i <ph name="IDLEACTIONBATTERY_POLICY_NAME"/>. Jeśli jest ona ustawiona, jej wartość jest używana, gdy nie jest określona odpowiednia bardziej szczegółowa zasada.

          Gdy ta zasada nie jest ustawiona, nie wpływa na zachowanie bardziej szczegółowych zasad.</translation>
<translation id="5997543603646547632">Domyślnie używaj zegara 24-godzinnego</translation>
<translation id="7003746348783715221">Ustawienia przeglądarki <ph name="PRODUCT_NAME"/></translation>
<translation id="4723829699367336876">Włącz omijanie zapory sieciowej przez klienta dostępu zdalnego</translation>
<translation id="6367755442345892511">Czy użytkownik ma mieć możliwość skonfigurowania kanału wersji</translation>
<translation id="3868347814555911633">Ta zasada jest aktywna tylko w trybie sklepu.

      Zawiera listę rozszerzeń, które są automatycznie instalowane dla użytkownika demonstracyjnego w przypadku urządzeń działających w trybie sklepu. Rozszerzenia są zapisane na urządzeniu i można je zainstalować w trybie offline, po instalacji aplikacji.

       Każda pozycja listy zawiera słownik, w którym obowiązkowe pola „extension-id” i „update-url” muszą zawierać odpowiednio identyfikator rozszerzenia i adres URL aktualizacji.</translation>
<translation id="9096086085182305205">Biała lista serwera uwierzytelniania</translation>
<translation id="4980301635509504364">Zezwala na przechwytywanie wideo lub tego zabrania.

      Jeśli ta zasada jest włączona lub nie jest skonfigurowana (ustawienie domyślne),
      użytkownik jest pytany o pozwolenie na przechwytywanie wideo, chyba że dany URL 
      jest na liście VideoCaptureAllowedUrls – wtedy pozwolenie jest udzielane bez pytania.

      Gdy zasada jest wyłączona, użytkownik nigdy nie jest pytany, a przechwytywanie wideo
      jest dostępne tylko dla stron, których adresy URL są na liście VideoCaptureAllowedUrls.

      Zasada dotyczy wszystkich typów wejść wideo, a nie tylko wbudowanej kamery.</translation>
<translation id="7063895219334505671">Zezwalaj na wyskakujące okienka w tych witrynach</translation>
<translation id="4052765007567912447">Pozwala określić, czy użytkownik może wyświetlać tekst haseł w menedżerze haseł. Jeśli wyłączysz to ustawienie, w oknie menedżera haseł nie będzie można wyświetlać tekstu przechowywanych haseł. W przypadku włączenia lub nieskonfigurowania tej zasady użytkownicy będą mogli wyświetlać tekst haseł w menedżerze haseł.</translation>
<translation id="5936622343001856595">Wymusza realizację zapytań do wyszukiwarki Google z aktywnym filtrem SafeSearch i uniemożliwia użytkownikom zmianę tego ustawienia.

      Jeśli ta opcja zostanie włączona, filtr SafeSearch w wyszukiwarce Google będzie zawsze aktywny.

      W przypadku wyłączenia tego ustawienia lub niepodania wartości nie będzie wymuszane stosowanie filtru SafeSearch w wyszukiwarce Google.</translation>
<translation id="6017568866726630990">Pokaż systemowo okno wydruku zamiast podglądu wydruku.

      W przypadku włączenia tej opcji <ph name="PRODUCT_NAME"/> będzie otwierać systemowe okno drukowania zamiast wbudowanego podglądu wydruku, gdy użytkownik będzie chciał wydrukować stronę.

      Jeśli ta opcja będzie nieustawiona lub wyłączona, polecenia wydruku będą wyświetlać ekran podglądu.</translation>
<translation id="7933141401888114454">Włącz tworzenie użytkowników nadzorowanych</translation>
<translation id="2824715612115726353">Włącz tryb incognito</translation>
<translation id="1057535219415338480">Włącza przewidywanie działań sieciowych w <ph name="PRODUCT_NAME"/> i uniemożliwia użytkownikom zmianę tego ustawienia.

      Ta zasada steruje nie tylko wstępnym pobieraniem DNS, ale też wstępnym łączeniem przez TCP i SSL oraz wstępnym renderowaniem. Nazwa zasady wiąże się ze wstępnym pobieraniem DNS z przyczyn historycznych.

      Jeśli włączysz lub wyłączysz tę zasadę, użytkownicy nie będą mogli zmienić ani nadpisać tego ustawienia w <ph name="PRODUCT_NAME"/>.

      Jeśli ta zasada pozostanie nieustawiona, ustawienie zostanie włączone, ale użytkownicy będą mogli je zmienić.</translation>
<translation id="4541530620466526913">Lokalne konta na urządzeniu</translation>
<translation id="5815129011704381141">Automatyczne ponowne uruchomienie po aktualizacji</translation>
<translation id="1757688868319862958">Zezwala na uruchamianie w przeglądarce <ph name="PRODUCT_NAME"/> wtyczek wymagających autoryzacji. W przypadku włączenia tego ustawienia aktualne wtyczki są zawsze uruchamiane. Jeśli ustawienie jest wyłączone lub nie jest skonfigurowane, użytkownikom są wyświetlane monity o udzielenie pozwolenia na uruchomienie wtyczek wymagających autoryzacji. Wtyczki te mogą naruszyć bezpieczeństwo danych.</translation>
<translation id="6392973646875039351">Włącza funkcję autouzupełniania w <ph name="PRODUCT_NAME"/> i umożliwia użytkownikom automatyczne wypełnianie formularzy internetowych za pomocą zapisanych wcześniej informacji, takich jak np. adres czy dane karty kredytowej. Jeśli wyłączysz to ustawienie, autouzupełnianie będzie niedostępne dla użytkowników. Jeśli ustawienie jest włączone lub nieskonfigurowane, użytkownik zachowuje kontrolę nad autouzupełnianiem. Może wówczas konfigurować profile autouzupełniania oraz włączać i wyłączać tę funkcję według własnego uznania.</translation>
<translation id="6157537876488211233">Lista rozdzielonych przecinkami reguł omijania serwera proxy</translation>
<translation id="7788511847830146438">Według profilu</translation>
<translation id="2516525961735516234">Określa, czy aktywność związana z filmami wpływa na zarządzanie energią.

          Jeśli wartość tej zasady to Prawda lub nie jest ona ustawiona, podczas odtwarzania filmu nieaktywność użytkownika nie jest brana pod uwagę. Uniemożliwia to osiągnięcie opóźnienia bezczynności, przyciemnienie, wyłączenie i zablokowanie ekranu oraz wykonanie odpowiednich działań.

          Jeśli wartość tej zasady to Fałsz, aktywność związana z filmem nie wyklucza postrzegania użytkownika jako bezczynnego.</translation>
<translation id="3965339130942650562">Limit czasu bezczynności, po którym następuje wylogowanie</translation>
<translation id="5814301096961727113">Ustaw domyślny stan potwierdzeń głosowych na ekranie logowania</translation>
<translation id="9084985621503260744">Określ, czy aktywność związana z filmami wpływa na zarządzanie energią</translation>
<translation id="7091198954851103976">Zawsze uruchamiaj wtyczki wymagające autoryzacji</translation>
<translation id="1708496595873025510">Ustaw ograniczenie pobierania odmian</translation>
<translation id="8870318296973696995">Strona startowa</translation>
<translation id="1240643596769627465">Pozwala określić URL wyszukiwarki, z której pobierane są wyniki wyszukiwania dynamicznego. URL musi zawierać ciąg <ph name="SEARCH_TERM_MARKER"/>, który podczas wyszukiwania jest zastępowany tekstem wprowadzonym przez użytkownika. Ta zasada jest opcjonalna. Jeśli nie zostanie skonfigurowana, wyniki wyszukiwania dynamicznego nie będą dostarczane. Ta zasada jest egzekwowana tylko wówczas, gdy włączona jest zasada „DefaultSearchProviderEnabled”.</translation>
<translation id="6693751878507293182">Jeśli włączysz to ustawienie, automatyczne wyszukiwanie i instalowanie brakujących wtyczek zostanie wyłączone w <ph name="PRODUCT_NAME"/>. W przypadku wyłączenia lub nieskonfigurowania tej opcji mechanizm wyszukujący wtyczki będzie aktywny.</translation>
<translation id="2650049181907741121">Działanie, jakie ma zostać wykonane po zamknięciu pokrywy przez użytkownika</translation>
<translation id="7880891067740158163">Umożliwia określenie listy wzorcowych URL-i definiujących witryny, dla których <ph name="PRODUCT_NAME"/> automatycznie wybiera certyfikaty klienta, jeśli dana witryna żąda certyfikatu. Jeśli ta zasada nie zostanie skonfigurowana, certyfikat nie będzie wybierany automatycznie w przypadku żadnej witryny.</translation>
<translation id="3866249974567520381">Opis</translation>
<translation id="5192837635164433517">Włącza alternatywne strony błędów wbudowane w przeglądarkę <ph name="PRODUCT_NAME"/> (np. dotyczące nieznalezienia strony) i uniemożliwia użytkownikom zmianę tego ustawienia. Jeśli włączysz ustawienie, alternatywne strony błędów będą używane. W przypadku wyłączenia ustawienia alternatywne strony błędów nigdy nie są używane. Jeśli ustawienie jest włączone lub wyłączone, użytkownicy nie mogą go zmienić ani zastąpić w przeglądarce <ph name="PRODUCT_NAME"/>. W przypadku nieskonfigurowania zasady ustawienie zostanie włączone, ale użytkownik będzie mógł je zmienić.</translation>
<translation id="2236488539271255289">Nie zezwalaj żadnej witrynie na tworzenie danych lokalnych</translation>
<translation id="4467952432486360968">Blokuj pliki cookie innych firm</translation>
<translation id="1305864769064309495">URL-e mapujące słowniki do flagi wartości logicznej, określającej pozwolenie na dostęp do hosta (prawda lub fałsz).

          Ta zasada przeznaczona jest do użytku wewnętrznego przez Chrome.</translation>
<translation id="5586942249556966598">Nic nie rób</translation>
<translation id="131353325527891113">Pokaż nazwy użytkowników na ekranie logowania</translation>
<translation id="5317965872570843334">Umożliwia stosowanie protokołu STUN i serwerów przekazywania, gdy klienci zdalni próbują nawiązać połączenie z tym komputerem. Jeśli ustawienie jest włączone, klienci zdalni mogą wykrywać komputer i łączyć się z nim nawet wówczas, gdy są oddzieleni zaporą sieciową. Jeśli ustawienie jest wyłączone, a wychodzące połączenia UDP są filtrowane przez zaporę sieciową, z komputerem mogą łączyć się tylko klienci w sieci lokalnej. W przypadku nieskonfigurowania zasady ustawienie zostanie włączone.</translation>
<translation id="4057110413331612451">Zezwalaj użytkownikom firmowym na pełnienie funkcji tylko użytkownika głównego w trybie wieloprofilowym</translation>
<translation id="5365946944967967336">Pokaż przycisk strony startowej na pasku narzędzi</translation>
<translation id="3709266154059827597">Konfiguruj czarną listę instalacji rozszerzeń</translation>
<translation id="8451988835943702790">Używaj strony Nowa karta jako strony początkowej</translation>
<translation id="4617338332148204752">Pomiń sprawdzanie metatagów w <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="8469342921412620373">Powoduje korzystanie z usług domyślnego dostawcy wyszukiwania. Jeśli włączysz to ustawienie, wpisanie w omniboksie tekstu, który nie jest URL-em, będzie powodować użycie wyszukiwarki domyślnej. Możesz określić domyślnego dostawcę wyszukiwania, konfigurując pozostałe zasady dotyczące wyszukiwarki domyślnej. Jeśli te pola pozostaną puste, użytkownik będzie mógł wybrać dostawcę domyślnego. W przypadku wyłączenia ustawienia wpisanie w omniboksie tekstu, który nie jest URL-em, nie powoduje wykonania wyszukiwania. Jeśli ustawienie jest włączone lub wyłączone, użytkownicy nie mogą go zmienić ani zastąpić w przeglądarce <ph name="PRODUCT_NAME"/>. W przypadku nieskonfigurowania tej zasady używany jest domyślny dostawca wyszukiwania, a użytkownik może określić listę dostawców wyszukiwania.</translation>
<translation id="4791031774429044540">Włącza funkcję ułatwień dostępu w postaci dużego kursora.

          Jeśli ta zasada ma wartość „prawda”, duży kursor jest zawsze włączony.

          Jeśli ma ona wartość „fałsz”, taki kursor jest zawsze wyłączony.

          Gdy ją ustawisz, użytkownicy nie mogą jej zmienić ani zastąpić.

          Jeśli zasada pozostanie nieustawiona, duży kursor jest początkowo wyłączony, ale użytkownik może go w każdej chwili włączyć.</translation>
<translation id="2633084400146331575">Włącz potwierdzenia głosowe</translation>
<translation id="8731693562790917685">Ustawienia treści umożliwiają określenie sposobu obsługi treści danego typu (na przykład plików cookie, grafik czy kodu JavaScript).</translation>
<translation id="2411919772666155530">Blokuj powiadomienia w tych witrynach.</translation>
<translation id="6923366716660828830">Określa nazwę domyślnego dostawcy wyszukiwania. Jeśli ta zasada pozostanie pusta lub nieskonfigurowana, będzie używana nazwa hosta określona w URL-u wyszukiwarki. Ta zasada jest uwzględniana tylko przy włączonej zasadzie „DefaultSearchProviderEnabled”.</translation>
<translation id="4869787217450099946">Określa, czy jest dozwolona blokada wybudzania ekranu. Blokady takie mogą być żądane przez rozszerzenia poprzez interfejs API zarządzania energią.

          Jeśli ta zasada ma ustawienie Prawda lub nie jest ustawiona, blokada wybudzania ekranu będzie respektowana w celu zarządzania energią.

          Jeśli ma ona ustawienie Fałsz, blokada wybudzania ekranu będzie ignorowana.</translation>
<translation id="467236746355332046">Obsługiwane funkcje:</translation>
<translation id="7632724434767231364">Nazwa biblioteki GSSAPI</translation>
<translation id="3038323923255997294">Kontynuuj działanie aplikacji w tle po zamknięciu <ph name="PRODUCT_NAME"/></translation>
<translation id="8909280293285028130">Określa, po jakim czasie nieaktywności użytkownika blokowany jest ekran przy zasilaniu z sieci.

          Jeśli ta zasada ma wartość większą niż zero, określa czas, przez który użytkownik musi pozostać bezczynny, zanim <ph name="PRODUCT_OS_NAME"/> zablokuje ekran.

          Jeśli ta zasada ma wartość równą zero, <ph name="PRODUCT_OS_NAME"/> nie blokuje ekranu, gdy użytkownik jest bezczynny.

          Jeśli ta zasada nie jest ustawiona, używana jest domyślna wartość długości czasu.

          Zalecanym sposobem blokowania ekranu przy bezczynności jest włączenie blokowania ekranu przy wstrzymaniu i skonfigurowanie systemu <ph name="PRODUCT_OS_NAME"/> do przejścia do stanu wstrzymywania po opóźnieniu bezczynności. Ta zasada powinna być używana tylko wtedy, gdy blokowanie ekranu powinno nastąpić na długo przed wstrzymaniem lub gdy wstrzymanie po bezczynności nie jest pożądane.

          Wartość zasady powinna być określona w milisekundach. Wartości muszą być mniejsze niż opóźnienie bezczynności.</translation>
<translation id="7651739109954974365">Określa, czy na urządzeniu powinno być włączone przesyłanie danych w roamingu. W przypadku włączenia tej zasady przesyłanie danych w roamingu będzie dozwolone. Jeśli zasada będzie wyłączona lub nieskonfigurowana, przesyłanie danych w roamingu będzie niedostępne.</translation>
<translation id="6244210204546589761">Adresy URL otwierane po uruchomieniu</translation>
<translation id="7468416082528382842">Lokalizacja w rejestrze systemu Windows:</translation>
<translation id="1808715480127969042">Blokuj pliki cookie w tych witrynach</translation>
<translation id="1908884158811109790">Wyłącza Dysk Google przy połączeniu komórkowym w aplikacji Pliki systemu operacyjnego Chrome</translation>
<translation id="7340034977315324840">Zgłoś godziny aktywności urządzenia</translation>
<translation id="4928632305180102854">Określa, czy <ph name="PRODUCT_OS_NAME"/> pozwala na tworzenie nowych kont użytkowników. Jeśli będzie mieć wartość false, użytkownicy, którzy nie mają jeszcze konta, nie będą mogli się zalogować.

      Jeśli ta zasada będzie mieć wartość true lub nie zostanie skonfigurowana, tworzenie nowych kont użytkowników będzie dozwolone pod warunkiem, że zasada <ph name="DEVICEUSERWHITELISTPROTO_POLICY_NAME"/> nie będzie zakazywać użytkownikom logowania się.</translation>
<translation id="4389091865841123886">Konfiguruje zdalne poświadczanie przy użyciu mechanizmu TPM</translation>
<translation id="3518214502751233558">Określa, czy odliczanie opóźnień związanych z zarządzaniem energią oraz czasu związanego z limitem długości sesji powinno być rozpoczynane dopiero po pierwszej aktywności użytkownika w sesji</translation>
<translation id="8256688113167012935">Określa nazwę konta, którą <ph name="PRODUCT_OS_NAME"/> pokazuje na ekranie logowania dla danego lokalnego konta na urządzeniu.

      W przypadku ustawienia tej opcji na ekranie logowania w graficznym module wybierania loginu dla odpowiedniego lokalnego konta na urządzeniu będzie używany podany łańcuch.

      Jeśli ta opcja nie zostanie ustawiona, <ph name="PRODUCT_OS_NAME"/> użyje identyfikatora konta e-mail lokalnego konta na urządzeniu jako nazwy wyświetlanej na ekranie logowania.

      Ta zasada jest ignorowana w przypadku zwykłych kont użytkownika.</translation>
<translation id="267596348720209223">Pozwala określić kodowania znaków obsługiwane przez dostawcę wyszukiwania. Kodowania są określane za pomocą nazw stron kodowych, np. UTF-8, GB2312 czy ISO-8859-1. Są stosowane w podanej kolejności. Ta zasada jest opcjonalna. Jeśli nie zostanie skonfigurowana, będzie używana wartość domyślna, czyli UTF-8. Zasada ta jest stosowana tylko przy włączonej zasadzie „DefaultSearchProviderEnabled”.</translation>
<translation id="1349276916170108723">Wyłącza synchronizowanie Dysku Google dla aplikacji Pliki w systemie operacyjnym Chrome, gdy wartość zasady to Prawda. W takim przypadku na Dysk Google nie są przesyłane żadne dane.

          Jeśli wartość jest ustawiona na Fałsz, użytkownicy mogą przesyłać pliki na Dysk Google.</translation>
<translation id="1964634611280150550">Tryb incognito wyłączony</translation>
<translation id="5971128524642832825">Wyłącza Dysk w aplikacji Pliki systemu operacyjnego Chrome</translation>
<translation id="1847960418907100918">Określa parametry używane przy wyszukiwaniu dynamicznym z użyciem POST. Składa się z rozdzielonych przecinkami par nazwy i wartości. Jeśli wartość jest parametrem szablonu, tak jak w przykładzie powyżej {searchTerms}, zostanie ona zastąpiona rzeczywistymi danymi wyszukiwanych słów.

          Ta zasada jest opcjonalna. Jeśli nie jest ustawiona, żądania wyszukiwania dynamicznego są wysyłane przy użyciu metody GET.

          Ta zasada jest uwzględniana tylko wtedy, gdy włączona jest zasada „DefaultSearchProviderEnabled”.</translation>
<translation id="1454846751303307294">Umożliwia skonfigurowanie listy wzorcowych URL-i określających witryny, w których nie może być wykonywany kod JavaScript. W przypadku nieskonfigurowania tej zasady dla wszystkich witryn będzie używana globalna wartość domyślna pobierana z zasady „DefaultJavaScriptSetting” (jeśli została skonfigurowana) lub z osobistej konfiguracji użytkownika.</translation>
<translation id="538108065117008131">Zezwalaj wtyczce <ph name="PRODUCT_FRAME_NAME"/> na obsługę następujących typów treści</translation>
<translation id="2312134445771258233">Umożliwia skonfigurowanie stron wczytywanych po uruchomieniu. Zawartość listy „Adresy URL otwierane po uruchomieniu” jest ignorowana, chyba że wybierzesz opcję „Otwórz adresy URL z listy” w ustawieniu „Działanie po uruchomieniu”.</translation>
<translation id="243972079416668391">Określa, jakie działanie ma zostać podjęte po osiągnięciu opóźnienia bezczynności przy zasilaniu prądem zmiennym.

          Gdy ta zasada jest ustawiona, określa czynność podejmowaną przez <ph name="PRODUCT_OS_NAME"/>, gdy użytkownik pozostaje nieaktywny przez długość czasu wyznaczoną przez opóźnienie bezczynności (czas ten można skonfigurować osobno).

          Jeśli ta zasada nie jest ustawiona, podejmowana jest domyślna czynność, czyli wstrzymanie.

          Jeśli czynnością jest wstrzymanie, <ph name="PRODUCT_OS_NAME"/> można skonfigurować osobno tak, by ekran przedtem był lub nie był blokowany.</translation>
<translation id="7750991880413385988">Otwórz stronę nowej karty</translation>
<translation id="741903087521737762">Pozwala określić działanie przy uruchomieniu.

          Jeśli wybierzesz „Otwórz stronę nowej karty”, przy każdym uruchomieniu <ph name="PRODUCT_NAME"/> będzie otwierana strona nowej karty.

          Jeśli wybierzesz „Przywróć ostatnią sesję”, zostanie wznowiona sesja przeglądania i ponownie wczytane URL-e, które były otwarte przy zamknięciu <ph name="PRODUCT_NAME"/>.
          Wybranie tej opcji wyłącza niektóre ustawienia zależne od sesji lub powodujące wykonywanie działań przy zamykaniu (np. czyszczenie danych przeglądarki przy zamykaniu lub zapisywanie plików cookie tylko na czas sesji).

          Jeśli wybierzesz „Otwórz adresy URL z listy”, po uruchomieniu <ph name="PRODUCT_NAME"/> przez użytkownika będą otwierane strony z listy „Adresy URL otwierane po uruchomieniu”.

          Jeśli włączysz to ustawienie, użytkownicy nie będą mogli go zmienić ani zastąpić w <ph name="PRODUCT_NAME"/>.

          Wyłączenie tego ustawienia jest równoznaczne z pozostawieniem go nieskonfigurowanego. Użytkownik nadal może je zmienić w <ph name="PRODUCT_NAME"/>.</translation>
<translation id="8161570238552664224">Zezwalaj na odtwarzanie dźwięku.

      W przypadku wyłączenia tej opcji wyjście audio urządzenia nie będzie dostępne, gdy użytkownik będzie zalogowany.

      Ta zasada wpływa na wszystkie typy wyjść audio, a nie tylko na wbudowane głośniki. Ta zasada wyłącza też dźwiękowe funkcje ułatwień dostępu. Nie należy jej włączać, jeśli użytkownik potrzebuje czytnika ekranu.

      Jeśli to ustawienie będzie włączone lub nieskonfigurowane, użytkownicy będą mogli używać wszystkich obsługiwanych wyjść audio urządzenia.</translation>
<translation id="5761030451068906335">Konfiguruje ustawienia serwera proxy w <ph name="PRODUCT_NAME"/>. Zasada nie jest jeszcze gotowa, więc nie należy jej używać.</translation>
<translation id="3006443857675504368">Pokazuj opcje ułatwień dostępu <ph name="PRODUCT_OS_NAME"/> w menu systemowym.

          Jeśli ta zasada jest ustawiona na wartość Prawda, opcje ułatwień dostępu są zawsze wyświetlane w menu na pasku zadań.

          Jeśli ta zasada jest ustawiona na wartość Fałsz, opcje ułatwień dostępu nie są wyświetlane w menu na pasku zadań.

          Jeśli ta zasada jest ustawiona, użytkownicy nie mogą jej zmienić ani zastąpić.

          Jeśli ta zasada jest nieustawiona, opcje ułatwień dostępu nie będą wyświetlane w menu na pasku zadań, ale użytkownik będzie mógł włączyć wyświetlanie opcji ułatwień dostępu na stronie Ustawienia.</translation>
<translation id="8344454543174932833">Importuj zakładki z przeglądarki domyślnej przy pierwszym uruchomieniu</translation>
<translation id="1019101089073227242">Ustaw katalog danych użytkownika</translation>
<translation id="5826047473100157858">Określa, czy użytkownik może otwierać strony w trybie incognito w <ph name="PRODUCT_NAME"/>. W przypadku opcji „Włączone” lub nieskonfigurowania zasady strony mogą być otwierane w tym trybie. Opcja „Wyłączone” uniemożliwia otwieranie stron w tym trybie. Po wybraniu opcji „Wymuszone” strony można otwierać TYLKO w trybie incognito.</translation>
<translation id="2988031052053447965">Ukryj aplikację Chrome Web Store i link w stopce na stronie Nowa karta i w programie uruchamiającym aplikacje systemu operacyjnego Chrome.

      Jeśli wartość tej zasady to Prawda, ikony są ukryte.

      Gdy zasada ma wartość Fałsz lub nie została skonfigurowana, ikony są widoczne.</translation>
<translation id="5085647276663819155">Wyłącz podgląd wydruku</translation>
<translation id="8672321184841719703">Wersja docelowa automatycznych aktualizacji</translation>
<translation id="1689963000958717134">Pozwala na przesyłanie konfiguracji sieciowej w trybie push do urządzeń z <ph name="PRODUCT_OS_NAME"/> dla wszystkich użytkowników. Konfiguracja sieci to łańcuch w formacie JSON zgodny z formatem Open Network Configuration opisanym na <ph name="ONC_SPEC_URL"/></translation>
<translation id="6699880231565102694">Włącz uwierzytelnianie dwuskładnikowe dla hostów zdalnego dostępu</translation>
<translation id="2030905906517501646">Słowo kluczowe domyślnego dostawcy wyszukiwania</translation>
<translation id="3072045631333522102">Wygaszacz ekranu używany na ekranie logowania w trybie sklepu</translation>
<translation id="4550478922814283243">Włącz lub wyłącz uwierzytelnianie bez kodu PIN</translation>
<translation id="7712109699186360774">Zawsze mnie pytaj, gdy strona chce użyć kamery i/lub mikrofonu</translation>
<translation id="350797926066071931">Włącz Tłumacza</translation>
<translation id="3711895659073496551">Wstrzymaj</translation>
<translation id="4010738624545340900">Zezwolenie na wywoływanie okien dialogowych wyboru plików</translation>
<translation id="4518251772179446575">Pytaj, gdy witryna chce śledzić fizyczną lokalizację użytkownika</translation>
<translation id="402759845255257575">Nie zezwalaj na wykonywanie kodu JavaScript w żadnej witrynie</translation>
<translation id="5457924070961220141">Umożliwia skonfigurowanie domyślnego mechanizmu renderowania HTML po zainstalowaniu wtyczki <ph name="PRODUCT_FRAME_NAME"/>. Ustawieniem domyślnym, stosowanym w przypadku nieskonfigurowania tej zasady, jest zezwolenie przeglądarce hosta na wykonywanie renderowania, jednak możesz opcjonalnie zastąpić to ustawienie, tak aby strony HTML były domyślnie renderowane przez wtyczkę <ph name="PRODUCT_FRAME_NAME"/>.</translation>
<translation id="706669471845501145">Zezwalaj witrynom na pokazywanie powiadomień na pulpicie</translation>
<translation id="7529144158022474049">Współczynnik rozkładania automatycznych aktualizacji w czasie</translation>
<translation id="2188979373208322108">Włącza pasek zakładek w przeglądarce <ph name="PRODUCT_NAME"/>. Jeśli włączysz to ustawienie, w <ph name="PRODUCT_NAME"/> będzie pokazywany pasek zakładek. W przypadku wyłączenia ustawienia pasek nie będzie wyświetlany. Jeśli ustawienie jest włączone lub wyłączone, użytkownicy nie mogą go zmienić ani zastąpić w <ph name="PRODUCT_NAME"/>. W przypadku nieskonfigurowania tego ustawienia użytkownik może zdecydować, czy chce używać tej funkcji.</translation>
<translation id="5475361623548884387">Włącz drukowanie</translation>
<translation id="7287359148642300270">Określa, które serwery mają być uwzględniane na białej liście wbudowanego uwierzytelniania. Funkcja ta jest włączana tylko w przypadku otrzymania w <ph name="PRODUCT_NAME"/> żądania uwierzytelnienia od serwera proxy lub serwera znajdującego się na tej liście dozwolonych.

          Nazwy serwerów należy rozdzielić przecinkami. Symbole wieloznaczne (*) są dozwolone.

          Jeśli ta zasada jest nieustawiona, Chrome próbuje wykryć, czy serwer działa w intranecie, i dopiero wtedy odpowiada na żądania IWA. W przypadku wykrycia serwera internetowego przesyłane przez niego żądania IWA będą ignorowane przez Chrome.</translation>
<translation id="3653237928288822292">Ikona domyślnego dostawcy wyszukiwania</translation>
<translation id="2872961005593481000">Wyłącz</translation>
<translation id="4445684791305970001">Wyłącza narzędzia dla programistów i konsolę JavaScript. Jeśli włączysz to ustawienie, niemożliwe będzie uzyskanie dostępu do narzędzi dla programistów i dokonanie przeglądu elementów witryny. Wszelkie skróty klawiszowe oraz pozycje w menu aplikacji i menu kontekstowym umożliwiające otwarcie narzędzi dla programistów lub konsoli JavaScript będą nieaktywne. Wyłączenie lub nieskonfigurowanie tej opcji umożliwi korzystanie z narzędzi dla programistów i konsoli JavaScript.</translation>
<translation id="9203071022800375458">Wyłącz tworzenie zrzutów ekranu.

W przypadku włączenia tej zasady nie będzie można tworzyć zrzutów ekranu, używając skrótów klawiszowych lub interfejsów API rozszerzeń.

W przypadku wyłączenia lub nieskonfigurowania tej zasady tworzenie zrzutów ekranu będzie dozwolone.</translation>
<translation id="5697306356229823047">Raportuj użytkowników urządzenia</translation>
<translation id="8649763579836720255">Urządzenia z Chrome OS mogą używać zaświadczeń zdalnych (zweryfikowanego dostępu), by uzyskać certyfikat Chrome OS CA, który zaświadcza, że urządzenie jest uprawnione do odtwarzania materiałów chronionych. Ten proces obejmuje wysłanie do Chrome OS CA informacji polecających sprzęt, które jednoznacznie identyfikują urządzenie.

          Jeśli w tym ustawieniu wybierzesz wartość Fałsz, urządzenie nie będzie korzystać z zaświadczeń zdalnych do ochrony treści i może nie móc odtwarzać materiałów chronionych.

          Jeśli w tym ustawieniu wybierzesz wartość Prawda lub w ogóle go nie skonfigurujesz, zaświadczenia zdalne będą mogły być używane do ochrony treści.</translation>
<translation id="4632343302005518762">Zezwalaj <ph name="PRODUCT_FRAME_NAME"/> na obsługę poniższych typów treści</translation>
<translation id="13356285923490863">Nazwa zasady</translation>
<translation id="557658534286111200">Włącz lub wyłącz edytowanie zakładek</translation>
<translation id="5378985487213287085">Umożliwia określenie, czy witryny mogą wyświetlać powiadomienia na pulpicie. Wyświetlanie powiadomień na pulpicie może być domyślnie dozwolone lub zabronione bądź użytkownikowi może być wyświetlany monit za każdym razem, gdy witryna chce wyświetlić takie powiadomienie. W przypadku nieskonfigurowania tej zasady będzie używana zasada „AskNotifications”, a użytkownik będzie mógł zmienić to ustawienie.</translation>
<translation id="2386362615870139244">Zezwalaj na blokowanie wybudzania ekranu</translation>
<translation id="6908640907898649429">Pozwala skonfigurować domyślnego dostawcę wyszukiwania. Możesz określić domyślnego dostawcę wyszukiwania, z którego usług będzie korzystał ​​użytkownik, lub wyłączyć funkcję wyszukiwarki domyślnej.</translation>
<translation id="6544897973797372144">Jeśli ta zasada zostanie włączona, a zasada ChromeOsReleaseChannel nie będzie określona, użytkownicy domeny rejestrującej będą mogli zmienić kanał wersji urządzenia. Jeśli ta zasada będzie wyłączona, na urządzeniu zostanie zablokowany ostatnio ustawiony kanał.

      Kanał wybrany przez użytkownika zostanie zmieniony przez zasadę ChromeOsReleaseChannel, ale jeśli zasada określa kanał stabilniejszy niż zainstalowany na urządzeniu, kanał zostanie zmieniony, gdy wersja z kanału stabilniejszego będzie miała numer wyższy od wersji zainstalowanej na urządzeniu.</translation>
<translation id="389421284571827139">Pozwala określić serwer proxy używany w <ph name="PRODUCT_NAME"/> i uniemożliwia użytkownikom zmianę jego ustawień. Jeśli zdecydujesz się nie korzystać z serwera proxy i zawsze bezpośrednio nawiązywać połączenia, wszystkie pozostałe opcje będą ignorowane. Są one ignorowane również w przypadku automatycznego wykrywania serwera proxy. Szczegółowe przykłady można znaleźć na <ph name="PROXY_HELP_URL"/>. Jeśli ustawienie jest włączone, <ph name="PRODUCT_NAME"/> ignoruje wszystkie opcje dotyczące serwera proxy określone w wierszu polecenia. W przypadku nieustawienia tych zasad użytkownicy będą mogli samodzielnie określić ustawienie serwera proxy.</translation>
<translation id="681446116407619279">Obsługiwane schematy uwierzytelniania</translation>
<translation id="4027608872760987929">Włącz usługi domyślnego dostawcy wyszukiwania</translation>
<translation id="2223598546285729819">Domyślne ustawienie powiadomień</translation>
<translation id="6158324314836466367">Nazwa firmowego sklepu internetowego (wycofana)</translation>
<translation id="3984028218719007910">Określa, czy <ph name="PRODUCT_OS_NAME"/> przechowuje po wylogowaniu dane konta lokalnego. W przypadku włączenia trwałe konta nie są przechowywane przez <ph name="PRODUCT_OS_NAME"/> i po wylogowaniu wszystkie dane z sesji użytkownika są usuwane. Jeśli ta zasada będzie wyłączona lub nieskonfigurowana, urządzenie może przechowywać zaszyfrowane lokalne dane użytkownika.</translation>
<translation id="3793095274466276777">Pozwala skonfigurować w przeglądarce <ph name="PRODUCT_NAME"/> sprawdzanie przeglądarki domyślnej i uniemożliwia użytkownikom jej zmianę. Jeśli włączysz to ustawienie, <ph name="PRODUCT_NAME"/> zawsze po uruchomieniu będzie sprawdzać, czy jest przeglądarką domyślną, oraz w miarę możliwości automatycznie przypisywać sobie tę rolę. W przypadku wyłączenia ustawienia <ph name="PRODUCT_NAME"/> nigdy nie sprawdza, czy jest przeglądarką domyślną, a opcje umożliwiające użytkownikowi zmianę ustawienia są nieaktywne. Jeśli ustawienie jest nieskonfigurowane, użytkownik może kontrolować funkcję sprawdzania, czy <ph name="PRODUCT_NAME"/> jest przeglądarką domyślną, oraz wyświetlanie odpowiednich powiadomień.</translation>
<translation id="3504791027627803580">Określa adres URL wyszukiwarki używanej do wyszukiwania obrazem. Żądania wyszukiwania będą wysyłane przy użyciu metody GET. Jeśli zasada DefaultSearchProviderImageURLPostParams jest ustawiona, wtedy takie żądania będą używać metody POST.

          Ta zasada jest opcjonalna. Jeśli nie jest ustawiona, nie będzie używane wyszukiwanie obrazem.

          Ta zasada jest uwzględniana tylko wtedy, gdy włączona jest zasada „DefaultSearchProviderEnabled”.</translation>
<translation id="7529100000224450960">Umożliwia skonfigurowanie listy wzorcowych URL-i określających witryny, w których mogą być otwierane wyskakujące okienka. Jeśli ta zasada nie zostanie skonfigurowana, dla wszystkich witryn będzie używana globalna wartość domyślna pochodząca z zasady „DefaultPopupsSetting” (jeśli została skonfigurowana) lub z osobistej konfiguracji użytkownika.</translation>
<translation id="6155936611791017817">Ustaw domyślny stan dużego kursora na ekranie logowania</translation>
<translation id="1530812829012954197">Zawsze renderuj strony w przeglądarce hosta według następujących wzorców adresów URL</translation>
<translation id="9026000212339701596">Nazwy hostów mapujące słowniki do flagi wartości logicznej, określającej pozwolenie na dostęp do hosta (prawda lub fałsz).

          Ta zasada jest przeznaczona do użytku wewnętrznego w Chrome.</translation>
<translation id="913195841488580904">Blokuj dostęp do listy adresów URL</translation>
<translation id="3292147213643666827">Umożliwia działanie <ph name="PRODUCT_NAME"/> jako serwera proxy między <ph name="CLOUD_PRINT_NAME"/> a starszymi drukarkami podłączonymi do komputera.

      Jeśli to ustawienie jest włączone lub nieskonfigurowane, użytkownicy mogą włączyć serwer proxy drukowania w chmurze, uwierzytelniając się na swoim koncie Google.

      W przypadku wyłączenia ustawienia użytkownicy nie mogą włączyć serwera proxy ani udostępnić w <ph name="CLOUD_PRINT_NAME"/> drukarek podłączonych do komputera.</translation>
<translation id="6373222873250380826">Włączone ustawienie wyłącza automatyczne aktualizacje.

      Jeśli to ustawienie jest nieskonfigurowane lub wyłączone, urządzenia z <ph name="PRODUCT_OS_NAME"/> automatycznie sprawdzają dostępność aktualizacji.</translation>
<translation id="6190022522129724693">Domyślne ustawienie wyskakujących okienek</translation>
<translation id="847472800012384958">Nie zezwalaj na pokazywanie wyskakujących okienek w żadnej witrynie</translation>
<translation id="4733471537137819387">Zasady dotyczące zintegrowanego uwierzytelniania HTTP.</translation>
<translation id="8951350807133946005">Ustaw katalog podręcznej pamięci dyskowej</translation>
<translation id="603410445099326293">Parametry dla sugerowania URL-i używających POST</translation>
<translation id="2592091433672667839">Czas bezczynności, po upływie którego w trybie sklepu na ekranie logowania jest wyświetlany wygaszacz ekranu</translation>
<translation id="166427968280387991">Serwer proxy</translation>
<translation id="2805707493867224476">Zezwalaj na pokazywanie wyskakujących okienek we wszystkich witrynach</translation>
<translation id="1727394138581151779">Blokuj wszystkie wtyczki</translation>
<translation id="8118665053362250806">Ustaw rozmiar dyskowej pamięci podręcznej</translation>
<translation id="7079519252486108041">Blokuj wyskakujące okienka w tych witrynach</translation>
<translation id="1859633270756049523">Ogranicz długość sesji</translation>
<translation id="7433714841194914373">Włącz wyszukiwanie dynamiczne</translation>
<translation id="4983201894483989687">Zezwalaj na uruchamianie nieaktualnych wtyczek</translation>
<translation id="443665821428652897">Wyczyść dane witryn w momencie zamknięcia przeglądarki (wycofana)</translation>
<translation id="3823029528410252878">Wyłącza zapisywanie historii przeglądarki <ph name="PRODUCT_NAME"/> i uniemożliwia użytkownikom zmianę tego ustawienia. Po włączeniu ustawienia historia przeglądania nie jest zapisywana. Jeśli ustawienie jest wyłączone lub nieskonfigurowane, historia przeglądania jest zapisywana.</translation>
<translation id="7295019613773647480">Włącz obsługę użytkowników nadzorowanych</translation>
<translation id="2759224876420453487">Kontrolowanie zachowania użytkownika w sesji wieloprofilowej</translation>
<translation id="3844092002200215574">Określa katalog, w którym <ph name="PRODUCT_NAME"/> będzie przechowywać pliki buforowane na dysku.

     Jeśli ustawisz tę zasadę, <ph name="PRODUCT_NAME"/> będzie używać tego katalogu, niezależnie od tego, czy użytkownik określi flagę „--disk-cache-dir”.

      Na http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables znajdziesz listę zmiennych, których możesz użyć.

      W przypadku nieustawienia tej zasady zostanie użyty domyślny katalog pamięci podręcznej, a użytkownik będzie mógł go zmienić, używając flagi „--disk-cache-dir” w wierszu poleceń.</translation>
<translation id="3034580675120919256">Umożliwia określenie, czy w witrynach może być wykonywany kod JavaScript. Wykonanie kodu JavaScript może być dozwolone lub zabronione we wszystkich witrynach. W przypadku nieskonfigurowania tej zasady będzie używane ustawienie „AllowJavaScript”, a użytkownik będzie mógł je zmienić.</translation>
<translation id="193900697589383153">Dodaje przycisk wylogowania do paska zadań.

      Po włączeniu tej opcji, gdy sesja jest aktywna a ekran niezablokowany, na pasku zadań jest wyświetlany duży czerwony przycisk wylogowania.

      Jeśli ta opcja jest wyłączona, na pasku zadań nie jest wyświetlany duży czerwony przycisk wylogowania.</translation>
<translation id="5111573778467334951">Określa, jakie działanie ma zostać podjęte po osiągnięciu opóźnienia bezczynności przy zasilaniu z baterii.

          Gdy ta zasada jest ustawiona, określa czynność podejmowaną przez <ph name="PRODUCT_OS_NAME"/>, gdy użytkownik pozostaje nieaktywny w czasie wyznaczonym przez opóźnienie bezczynności (czas ten można skonfigurować osobno).

          Jeśli ta zasada nie jest ustawiona, podejmowana jest domyślna czynność, czyli wstrzymanie.

          Jeśli czynnością jest wstrzymanie, <ph name="PRODUCT_OS_NAME"/> można skonfigurować osobno tak, by ekran przedtem był lub nie był blokowany.</translation>
<translation id="3195451902035818945">Wyłącza dzielenie rekordów SSL. Pozwala on uniknąć luki w zabezpieczeniach protokołów SSL 3.0 i TLS 1.0, ale może powodować problemy ze zgodnością z niektórymi serwerami HTTPS i proxy. Jeśli zasada nie jest ustawiona lub jest wyłączona, dzielenie rekordów obowiązuje przy połączeniach SSL/TLS z szyfrowaniem CBC.</translation>
<translation id="6903814433019432303">Ta zasada jest aktywna tylko w trybie sklepu.

      Określa zestaw URL-i do załadowania po uruchomieniu sesji demonstracyjnej. Ta zasada zastępuje pozostałe mechanizmy ustawiania początkowego URL-a i dlatego można ją zastosować tylko do sesji niepowiązanej z konkretnym użytkownikiem.</translation>
<translation id="5868414965372171132">Konfiguracja sieci na poziomie użytkownika</translation>
<translation id="8519264904050090490">Zarządzane adresy URL dodane przez użytkownika na listę wyjątków</translation>
<translation id="4480694116501920047">Wymuś stosowanie filtru SafeSearch</translation>
<translation id="465099050592230505">URL firmowego sklepu internetowego (wycofana)</translation>
<translation id="1221359380862872747">Załaduj podane URL-e przy logowaniu demonstracyjnym</translation>
<translation id="2431811512983100641">Określa, czy ma być włączone rozszerzenie certyfikatów TLS powiązanych z domeną.

      To ustawienie umożliwia testowanie rozszerzenia certyfikatów TLS powiązanych z domeną. Jest ono eksperymentalne i zostanie usunięte w przyszłości.</translation>
<translation id="8711086062295757690">Pozwala określić słowo kluczowe będące skrótem umożliwiającym wywołanie w omniboksie usługi wyszukiwania od tego dostawcy. Ta zasada jest opcjonalna. Jeśli nie zostanie ustawiona, żadne słowo kluczowe nie będzie aktywować dostawcy wyszukiwania. Ta zasada jest uwzględniana tylko po włączeniu zasady „DefaultSearchProviderEnabled”.</translation>
<translation id="5774856474228476867">Adres URL wyszukiwarki od domyślnego dostawcy wyszukiwania</translation>
<translation id="4650759511838826572">Wyłącz schematy protokołów adresów URL</translation>
<translation id="7831595031698917016">Określa maksymalne opóźnienie w milisekundach między otrzymaniem unieważnienia zasady a pobraniem nowej z usługi zarządzania urządzeniem.

      Ustawienie tej zasady zmienia domyślną wartość 5000 milisekund. Prawidłowe wartości zawierają się w zakresie od 1000 (1 sekunda) do 300 000 (5 minut). Wartości spoza zakresu zostaną zmienione na zgodne z nim.

      Nieskonfigurowanie tej zasady spowoduje, że <ph name="PRODUCT_NAME"/> będzie używać domyślnej wartości 5000 milisekund.</translation>
<translation id="8099880303030573137">Opóźnienie bezczynności przy zasilaniu z baterii</translation>
<translation id="2761483219396643566">Opóźnienie ostrzeżenia o bezczynności przy zasilaniu z baterii</translation>
<translation id="5058056679422616660">Pakiety aktualizacji automatycznych w <ph name="PRODUCT_OS_NAME"/> można pobierać przez HTTP zamiast HTTPS. Umożliwia to przejrzyste buforowanie plików pobieranych przez HTTP.

      Jeśli w tej zasadzie wybierzesz wartość Prawda, <ph name="PRODUCT_OS_NAME"/> będzie próbować pobierać aktualizacje automatyczne przez HTTP. Jeśli wybierzesz tu wartość Fałsz lub w ogóle nie skonfigurujesz tej zasady, do pobierania pakietów aktualizacji automatycznych będzie używany protokół HTTPS.</translation>
<translation id="1468307069016535757">Ustawia domyślny stan funkcji ułatwień dostępu w postaci trybu wysokiego kontrastu na ekranie logowania.

          Jeśli ta zasada ma wartość „prawda”, po wyświetleniu ekranu logowania tryb wysokiego kontrastu jest włączony.

          Jeśli ma ona wartość „fałsz”, po wyświetleniu ekranu logowania ten tryb jest wyłączony.

          Gdy ją ustawisz, użytkownicy mogą ją chwilowo zastąpić, włączając lub wyłączając tryb wysokiego kontrastu. Wybór użytkownika nie jest jednak trwały i wartość domyślna jest przywracana po ponownym wyświetleniu ekranu logowania lub wtedy, gdy użytkownik przez minutę będzie nieaktywny na tym ekranie.

          Jeśli zasada pozostanie nieustawiona, po pierwszym wyświetleniu ekranu logowania tryb wysokiego kontrastu jest wyłączony. Użytkownicy mogą go w każdej chwili włączyć lub wyłączyć i jego stan na ekranie logowania jest trwały dla wszystkich użytkowników.</translation>
<translation id="602728333950205286">Adres URL wyszukiwania dynamicznego od domyślnego dostawcy wyszukiwania</translation>
<translation id="3030000825273123558">Włącz raportowanie statystyk</translation>
<translation id="8465065632133292531">Parametry dla URL-i dynamicznych używających POST</translation>
<translation id="6659688282368245087">Określa format zegara do stosowania w urządzeniu.

      Ta zasada pozwala skonfigurować format zegara do stosowania na ekranie logowania i dla zegara domyślnego używanego podczas sesji użytkowników. Użytkownicy mogą zmienić ten format na swoich kontach.

      Jeśli w tej zasadzie wybierzesz wartość Prawda, na urządzeniu będzie używany zegar 24-godzinny. Jeśli wybierzesz tu wartość Fałsz, na urządzeniu będzie używany zegar 12-godzinny.

      Jeśli w ogóle nie skonfigurujesz tej zasady, na urządzeniu będzie używany domyślny zegar 24-godzinny.</translation>
<translation id="6559057113164934677">Nie pozwalaj żadnym stronom na dostęp do kamery i mikrofonu</translation>
<translation id="7273823081800296768">Jeśli to ustawienie jest włączone lub nie jest skonfigurowane, użytkownicy mogą parować klienty i hosty w czasie połączenia, co wyklucza potrzebę wpisywania kodu PIN za każdym razem.

          Jeśli to ustawienie jest wyłączone, ta funkcja nie będzie dostępna.</translation>
<translation id="1675002386741412210">Obsługiwana przez:</translation>
<translation id="1608755754295374538">Adresy URL, które bez pytania otrzymają dostęp do urządzeń do nagrywania dźwięku</translation>
<translation id="3547954654003013442">Ustawienia serwera proxy</translation>
<translation id="5921713479449475707">Zezwalaj na pobieranie aktualizacji automatycznych przez HTTP</translation>
<translation id="4482640907922304445">Powoduje pokazanie przycisku strony startowej na pasku narzędzi <ph name="PRODUCT_NAME"/>. Jeśli włączysz to ustawienie, przycisk strony startowej będzie zawsze widoczny. W przypadku wyłączenia ustawienia przycisk nigdy nie jest widoczny. Jeśli ustawienie jest włączone lub wyłączone, użytkownicy nie mogą go zmienić ani zastąpić w <ph name="PRODUCT_NAME"/>. W przypadku nieskonfigurowania tej zasady użytkownik będzie mógł wybrać, czy chce, aby przycisk strony startowej był pokazywany.</translation>
<translation id="2518231489509538392">Zezwalaj na odtwarzanie dźwięku</translation>
<translation id="8146727383888924340">Zezwalaj użytkownikom na wykorzystanie ofert w procesie rejestracji systemu operacyjnego Chrome</translation>
<translation id="7301543427086558500">Określa listę alternatywnych URL-i, które umożliwiają uzyskanie wyników haseł z wyszukiwarki. Adresy URL powinny zawierać łańcuch <ph name="SEARCH_TERM_MARKER"/> używany do wskazania haseł do wyszukania.

          Ta zasada jest opcjonalna. Jeśli nie zostanie ustawiona, do wydobywania haseł do wyszukania nie będą używane alternatywne URL-e.

          Ta zasada jest stosowana tylko wtedy, gdy włączono zasadę „DefaultSearchProviderEnabled”.</translation>
<translation id="436581050240847513">Raportuj interfejsy sieciowe urządzeń</translation>
<translation id="6282799760374509080">Zezwól lub nie na przechwytywanie dźwięku</translation>
<translation id="8864975621965365890">Pomija monit o odinstalowanie wyświetlany wtedy, gdy witryna jest renderowana przez <ph name="PRODUCT_FRAME_NAME"/>.</translation>
<translation id="3264793472749429012">Kodowania obsługiwane przez domyślnego dostawcę wyszukiwania</translation>
<translation id="285480231336205327">Włącz tryb wysokiego kontrastu</translation>
<translation id="5366977351895725771">Jeśli ta zasada ma wartość „fałsz”, ten użytkownik nie może tworzyć użytkowników nadzorowanych. Dotychczasowi użytkownicy nadzorowani będą nadal dostępni.

          Jeśli ma ona wartość „prawda” lub nie jest skonfigurowana, ten użytkownik może tworzyć użytkowników nadzorowanych i zarządzać nimi.</translation>
<translation id="8101760444435022591">Ponieważ sprawdzanie online, czy certyfikat nie został unieważniony (ignorowany z powodu błędu sieci) nie poprawia bezpieczeństwa, w <ph name="PRODUCT_NAME"/> 19 i nowszych wersjach jest domyślnie wyłączone. W przypadku włączenia tej zasady przywrócone zostanie wcześniejsze zachowanie i będzie wykonywane sprawdzanie OCSP/CRL online.

      Jeśli ta zasada nie zostanie ustawiona lub będzie wyłączona, Chrome w wersji 19 lub nowszej nie będzie sprawdzał unieważnień online.</translation>
<translation id="5469484020713359236">Umożliwia skonfigurowanie listy wzorcowych URL-i określających witryny, którym wolno tworzyć pliki cookie. Jeśli ta zasada nie zostanie skonfigurowana, dla wszystkich witryn będzie używana globalna wartość domyślna pochodząca z zasady „DefaultCookiesSetting” (jeśli została skonfigurowana) lub z osobistej konfiguracji użytkownika.</translation>
<translation id="1504431521196476721">Zdalne poświadczanie</translation>
<translation id="1881299719020653447">Ukryj sklep Chrome Web Store na nowych kartach i w programie uruchamiającym aplikacje.</translation>
<translation id="930930237275114205">Ustaw katalog danych użytkownika <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="244317009688098048">Włącz automatyczne logowanie skrótem klawiszowym.

      Jeśli ta zasada nie jest skonfigurowana lub ma wartość Prawda, a lokalne konto na urządzeniu jest ustawione do logowania z zerowym opóźnieniem, <ph name="PRODUCT_OS_NAME"/> będzie uznawać skrót klawiszowy Ctrl+Alt+S.

      Jeśli wartość to Fałsz, nie można ominąć zerowego opóźnienia logowania (o ile jest skonfigurowane).</translation>
<translation id="5208240613060747912">Umożliwia skonfigurowanie listy wzorcowych URL-i określających witryny, w których nie mogą być wyświetlane powiadomienia. Jeśli ta zasada nie zostanie skonfigurowana, dla wszystkich witryn będzie używana globalna wartość domyślna pochodząca z zasady „DefaultNotificationsSetting” (jeśli została skonfigurowana) lub z osobistej konfiguracji użytkownika.</translation>
<translation id="346731943813722404">Określa, czy odliczanie opóźnień związanych z zarządzaniem energią oraz czasu związanego z limitem długości sesji powinno być rozpoczynane dopiero po zarejestrowaniu pierwszej aktywności użytkownika w sesji.

          W przypadku włączenia tej zasady odliczanie opóźnień związanych z zarządzaniem energią oraz czasu związanego z limitem długości sesji nie będzie rozpoczynane do momentu zarejestrowania pierwszej aktywności użytkownika w sesji.

         Jeśli ta zasada będzie wyłączona lub nieustawiona, odliczanie opóźnień związanych z zarządzaniem energią oraz czasu związanego z limitem długości sesji będzie rozpoczynane od razu po rozpoczęciu sesji.</translation>
<translation id="4600786265870346112">Włącz duży kursor</translation>
<translation id="8592105098257899882">Konfiguruje rozmiar pamięci podręcznej używanej przez <ph name="PRODUCT_NAME"/> do przechowywania plików buforowanych na dysku. W przypadku ustawienia tej zasady <ph name="PRODUCT_NAME"/> będzie używać określonego rozmiaru pamięci podręcznej, niezależnie od tego, czy użytkownik poda parametr „--disk-cache-size”. Jeśli dla tej zasady zostanie ustawiona wartość 0, będzie używany domyślny rozmiar pamięci podręcznej, ale użytkownik nie będzie mógł go zmienić. W przypadku nieskonfigurowania zasady będzie używany rozmiar domyślny, ale użytkownik będzie mógł go zmienić za pomocą parametru --disk-cache-size.</translation>
<translation id="5887414688706570295">Konfiguruje przedrostek gadżetu TalkGadget, który będzie używany przez hosty zdalnego dostępu, i uniemożliwia użytkownikom jego zmianę.

          W przypadku określenia tego przedrostka jest on dołączany na początku podstawowej nazwy gadżetu TalkGadget, by utworzyć pełną nazwę domeny dla gadżetu TalkGadget. Podstawowa nazwa domeny gadżetu TalkGadget to „.talkgadget.google.com”.

          Jeśli to ustawienie zostanie włączone, podczas uzyskiwania dostępu do gadżetu TalkGadget hosty będą używać niestandardowej, a nie domyślnej nazwy domeny.

          W przypadku wyłączenia lub nieskonfigurowania tego ustawienia wszystkie hosty będą używać domyślnej nazwy domeny gadżetu TalkGadget („chromoting-host.talkgadget.google.com”).

          Ta zasada nie ma wpływu na klienty zdalnego dostępu. Do uzyskania dostępu do gadżetu TalkGadget wykorzystują one zawsze domenę „chromoting-client.talkgadget.google.com”.</translation>
<translation id="5765780083710877561">Opis:</translation>
<translation id="6915442654606973733">Włącza funkcję ułatwień dostępu w postaci potwierdzeń głosowych.

          Jeśli ta zasada ma wartość „prawda”, potwierdzenia głosowe są zawsze włączone.

          Jeśli ma ona wartość „fałsz”, takie potwierdzenia są zawsze wyłączone.

          Gdy ją ustawisz, użytkownicy nie mogą jej zmienić ani zastąpić.

          Jeśli zasada pozostanie nieustawiona, potwierdzenia głosowe są początkowo wyłączone, ale użytkownik może je w każdej chwili włączyć.</translation>
<translation id="7796141075993499320">Umożliwia skonfigurowanie listy wzorcowych URL-i określających witryny, w których mogą być uruchamiane wtyczki. Jeśli ta zasada nie zostanie skonfigurowana, dla wszystkich witryn będzie używana globalna wartość domyślna pochodząca z zasady „DefaultPluginsSetting” (jeśli została skonfigurowana) lub z osobistej konfiguracji użytkownika.</translation>
<translation id="3809527282695568696">Umożliwia określenie listy otwieranych URL-i, jeśli jako działanie po uruchomieniu wybrano opcję „Otwórz adresy URL z listy”. W przypadku nieskonfigurowania zasady po uruchomieniu nie będzie otwierany żaden URL. Ta zasada jest stosowana tylko wówczas, gdy zasada „RestoreOnStartup” jest skonfigurowana jako „RestoreOnStartupIsURLs”.</translation>
<translation id="649418342108050703">Wyłącza obsługę interfejsów API grafiki 3D. Włączenie tego ustawienia uniemożliwia stronom internetowym korzystanie z procesora graficznego (GPU). W szczególności strony internetowe nie mają dostępu do interfejsu API WebGL, natomiast wtyczki nie mogą korzystać z interfejsu API Pepper 3D. Wyłączenie ustawienia lub nieskonfigurowanie go pozwala stronom internetowym korzystać z interfejsu API WebGL, a wtyczkom – z interfejsu API Pepper 3D. Domyślne ustawienia przeglądarki mogą powodować konieczność podania argumentów w wierszu polecenia w celu użycia tych interfejsów API.</translation>
<translation id="2077273864382355561">Opóźnienie wyłączenia ekranu przy zasilaniu z baterii</translation>
<translation id="909184783177222836">Zarządzanie energią</translation>
<translation id="3417418267404583991">Jeśli ta zasada zostanie włączona lub nie będzie skonfigurowana, <ph name="PRODUCT_OS_NAME"/> będzie umożliwiał logowanie się w trybie gościa. Logowania w trybie gościa to anonimowe sesje użytkownika, które nie wymagają hasła.

      W przypadku wyłączenia tej zasady <ph name="PRODUCT_OS_NAME"/> nie będzie zezwalać na uruchamianie sesji gościa.</translation>
<translation id="8329984337216493753">Ta zasada jest aktywna tylko w trybie sklepu.

      W przypadku określenia zasady DeviceIdleLogoutTimeout ta zasada określa czas wyświetlania okna ostrzegawczego z licznikiem czasu, które jest wyświetlane przed wylogowaniem użytkownika.

      Wartość zasady należy podać w milisekundach.</translation>
<translation id="237494535617297575">Umożliwia skonfigurowanie listy wzorców URL-i określających witryny, w których mogą być wyświetlane powiadomienia. Jeśli ta zasada nie zostanie skonfigurowana, dla wszystkich witryn będzie używana globalna wartość domyślna pochodząca z zasady „DefaultNotificationsSetting” (jeśli została skonfigurowana) lub z osobistej konfiguracji użytkownika.</translation>
<translation id="7258823566580374486">Włącz separację hostów zdalnego dostępu</translation>
<translation id="5560039246134246593">Dodaj parametr do pobierania odmian w <ph name="PRODUCT_NAME"/>.

      Ustawienie tej zasady powoduje dodanie parametru „restrict” do URL-a używanego do pobierania odmiany. Wartość parametru będzie taka sama jak wartość określona w tej zasadzie.

      Jeśli zasada nie zostanie określona, nie będzie modyfikować URL-a odmian.</translation>
<translation id="944817693306670849">Ustaw rozmiar dyskowej pamięci podręcznej.</translation>
<translation id="8544375438507658205">Domyślny mechanizm renderowania HTML wtyczki <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="2371309782685318247">Pozwala określić w milisekundach okres wysyłania zapytań dotyczących zasad użytkownika do usługi zarządzania urządzeniem. 

      Ustawienie tej zasady powoduje zastąpienie wartości domyślnej wynoszącej 3 godziny. Akceptowane są wartości z zakresu od 1 800 000 (30 minut) do 86 400 000 (1 dzień). Wszelkie wartości spoza tego zakresu są zmieniane na odpowiednie wartości graniczne.

     W przypadku nieskonfigurowania tej zasady <ph name="PRODUCT_NAME"/> użyje wartości domyślnej wynoszącej 3 godziny.</translation>
<translation id="2571066091915960923">Włącza i wyłącza serwer proxy kompresowania danych i uniemożliwia użytkownikom zmienianie tego ustawienia.

      Jeśli włączysz lub wyłączysz to ustawienie, użytkownicy nie będą mogli go zmienić ani zastąpić.

      Jeśli nie skonfigurujesz tej zasady, użytkownicy będą mogli sami wybrać, czy chcą używać serwera proxy kompresowania danych czy nie.</translation>
<translation id="7424751532654212117">Lista wyjątków od listy wyłączonych wtyczek</translation>
<translation id="6233173491898450179">Ustaw katalog pobierania</translation>
<translation id="78524144210416006">Konfigurowanie zarządzania energią na ekranie logowania w <ph name="PRODUCT_OS_NAME"/>.

      Ta zasada pozwala na skonfigurowanie zachowania <ph name="PRODUCT_OS_NAME"/>, gdy użytkownik nie jest aktywny podczas wyświetlania ekranu logowania. Zarządza ona wieloma ustawieniami. Jej składnię i zakresy wartości znajdziesz w odpowiednich zasadach, które sterują zarządzaniem energią podczas sesji. Oto jedyne odstępstwa od tych zasad:
      * Czynnością podejmowaną przy bezczynności lub zamknięciu pokrywy nie może być zakończenie sesji.
      * Domyślną czynnością podczas bezczynności przy zasilaniu prądem zmiennym jest wyłączenie.

      Zasada ta powinna być sformułowana w formie ciągu, który zawiera poszczególne ustawienia w formacie JSON, i przyjmować ten schemat:
      {
        &quot;type&quot;: &quot;object&quot;,
        &quot;properties&quot;: {
          &quot;AC&quot;: {
            &quot;description&quot;: &quot;Ustawienia zarządzania energią są stosowane tylko przy zasilaniu prądem zmiennym&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;Czas bezczynności użytkownika, po którym ekran jest przyciemniany (w milisekundach)&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;ScreenOff&quot; {
                    &quot;description&quot;: &quot;Czas bezczynności użytkownika, po którym ekran jest wyłączany (w milisekundach)&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;Idle&quot;: {
                    &quot;description&quot;: &quot;Czas bez działania użytkownika, po którym podejmowane jest działanie bezczynności (w milisekundach)&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  }
                }
              },
              &quot;IdleAction&quot;: {
                &quot;description&quot;: &quot;Działanie do podjęcia po osiągnięciu opóźnienia bezczynności&quot;,
                &quot;enum&quot;: [ &quot;Suspend&quot;, &quot;Shutdown&quot;, &quot;DoNothing&quot; ]
              }
            }
          },
          &quot;Battery&quot;: {
            &quot;description&quot;: &quot;Ustawienia zarządzania energią podejmowane tylko przy zasilaniu z baterii&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;Czas bezczynności użytkownika, po którym ekran jest przyciemniany (w milisekundach)&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;ScreenOff&quot;: {
                    &quot;description&quot;: &quot;Czas bezczynności użytkownika, po którym ekran jest wyłączany (w milisekundach)&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;Idle&quot;: {
                    &quot;description&quot;: &quot;Czas bezczynności użytkownika, po którym podejmowane jest działanie bezczynności&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  }
                }
              },
              &quot;IdleAction&quot;: {
                &quot;description&quot;: &quot;Działanie do podjęcia po osiągnięciu opóźnienia bezczynności&quot;,
                &quot;enum&quot;: [ &quot;Suspend&quot;, &quot;Shutdown&quot;, &quot;DoNothing&quot; ]
              }
            }
          },
          &quot;LidCloseAction&quot;: {
            &quot;description&quot;: &quot;Działanie do podjęcia po zamknięciu pokrywy&quot;,
            &quot;enum&quot;: [ &quot;Suspend&quot;, &quot;Shutdown&quot;, &quot;DoNothing&quot; ]
          },
          &quot;UserActivityScreenDimDelayScale&quot;: {
            &quot;description&quot;: &quot;Procent skalowania opóźnienia przyciemnienia ekranu przy wykryciu aktywności użytkownika, gdy ekran jest przyciemniony lub wkrótce po wyłączeniu ekranu&quot;,
            &quot;type&quot;: &quot;integer&quot;,
            &quot;minimum&quot;: 100
          }
        }
      }

      Jeśli ustawienie nie jest określone, używana jest wartość domyślna.

      Jeśli ta zasada nie jest ustawiona, dla wszystkich ustawień stosowane są wartości domyślne.</translation>
<translation id="8908294717014659003">Pozwala określić, czy strony mogą korzystać z urządzeń do rejestrowania multimediów. Dostęp do tych urządzeń może być dozwolony domyślnie lub użytkownik może być pytany za każdym razem, gdy strona chce użyć urządzenia do rejestrowania multimediów.

          Jeśli ta zasada nie zostanie ustawiona, będzie stosowane ustawienie „PromptOnAccess” i użytkownik nie będzie mógł go zmienić.</translation>
<translation id="2299220924812062390">Określ listę włączonych wtyczek</translation>
<translation id="328908658998820373">Zezwalaj na tryb pełnoekranowy.

      Ta zasada steruje dostępnością trybu pełnoekranowego, w którym cały interfejs <ph name="PRODUCT_NAME"/> jest ukryty i widać tylko treść internetową.

      Jeśli w tej zasadzie wybierzesz wartość Prawda lub w ogóle jej nie skonfigurujesz, użytkownik, aplikacje i rozszerzenia o odpowiednich uprawnieniach będą mogli przechodzić w tryb pełnoekranowy.

      Jeśli wybierzesz tu wartość Fałsz, ani użytkownik, ani żadne aplikacje czy rozszerzenia nie będą mogli przechodzić w tryb pełnoekranowy.

      Na wszystkich platformach poza <ph name="PRODUCT_OS_NAME"/> tryb kiosku jest niedostępny, gdy tryb ekranowy jest wyłączony.</translation>
<translation id="4325690621216251241">Dodaj przycisk wylogowania do paska zadań</translation>
<translation id="924557436754151212">Importuj zapisane hasła z przeglądarki domyślnej przy pierwszym uruchomieniu</translation>
<translation id="1465619815762735808">Kliknij, by uruchomić</translation>
<translation id="7227967227357489766">Określa listę użytkowników, którzy mogą logować się do urządzenia. Pozycje mają postać <ph name="USER_WHITELIST_ENTRY_FORMAT"/>, np. <ph name="USER_WHITELIST_ENTRY_EXAMPLE"/>. Aby zezwolić na logowanie dowolnym użytkownikom z domeny, użyj wpisów w postaci <ph name="USER_WHITELIST_ENTRY_WILDCARD"/>.

      Jeśli ta zasada nie zostanie skonfigurowana, nie będą obowiązywały żadne ograniczenia dotyczące użytkowników, którzy mogą się logować. Pamiętaj, że tworzenie użytkowników nadal wymaga właściwego skonfigurowania zasady <ph name="DEVICEALLOWNEWUSERS_POLICY_NAME"/>.</translation>
<translation id="8135937294926049787">Określa, po jakim czasie nieaktywności użytkownika wyłączany jest ekran przy zasilaniu z sieci.

          Jeśli ta zasada ma wartość większą niż zero, określa czas, przez który użytkownik musi pozostać bezczynny, zanim <ph name="PRODUCT_OS_NAME"/> wyłączy ekran.

          Jeśli ta zasada ma wartość równą zero, <ph name="PRODUCT_OS_NAME"/> nie wyłącza ekranu, gdy użytkownik jest bezczynny.

          Jeśli ta zasada nie jest ustawiona, używana jest domyślna wartość długości czasu.

          Wartość tej zasady powinna być określona w milisekundach. Wartości nie mogą być wyższe od opóźnienia bezczynności.</translation>
<translation id="1897365952389968758">Zezwalaj na wykonywanie kodu JavaScript we wszystkich witrynach</translation>
<translation id="5244714491205147861">Zarządzanie energią na ekranie logowania</translation>
<translation id="922540222991413931">Konfiguruj źródła instalacji rozszerzeń, aplikacji i skryptów użytkownika</translation>
<translation id="7323896582714668701">Dodatkowe parametry wiersza poleceń dla <ph name="PRODUCT_NAME"/></translation>
<translation id="6931242315485576290">Wyłącz synchronizację danych z Google</translation>
<translation id="7006788746334555276">Ustawienia treści</translation>
<translation id="63659515616919367">Steruje zachowaniem użytkowników w sesji wieloprofilowej na urządzeniach <ph name="PRODUCT_OS_NAME"/>.

      Jeśli w tej zasadzie wybierzesz wartość „MultiProfileUserBehaviorUnrestricted”, użytkownik będzie mógł pełnić funkcję użytkownika głównego lub dodatkowego w sesjach wieloprofilowych.

      Jeśli w tej zasadzie wybierzesz wartość „MultiProfileUserBehaviorMustBePrimary”, w sesjach wieloprofilowych użytkownik będzie mógł pełnić tylko funkcję użytkownika głównego.

      Jeśli w tej zasadzie wybierzesz wartość „MultiProfileUserBehaviorNotAllowed”, użytkownik nie będzie mógł brać udziału w sesjach wieloprofilowych.

      Jeśli skonfigurujesz to ustawienie, użytkownicy nie będą mogli go zmienić ani zastąpić.

      Jeśli zmienisz to ustawienie, gdy użytkownik będzie zalogowany w sesji wieloprofilowej, wszyscy użytkownicy biorący udział w tej sesji zostaną sprawdzeni pod kątem zgodności z ich odpowiednimi ustawieniami. Jeśli okaże się, że któryś z nich nie może już brać udziału w sesjach wieloprofilowych, sesja zostanie zamknięta.

      Jeśli w ogóle nie skonfigurujesz tej zasady, zostanie użyta wartość domyślna „MultiProfileUserBehaviorUnrestricted”.</translation>
<translation id="5142301680741828703">Zawsze renderuj strony we wtyczce <ph name="PRODUCT_FRAME_NAME"/> według następujących wzorców adresów URL</translation>
<translation id="4625915093043961294">Konfiguruj białą listę instalacji rozszerzeń</translation>
<translation id="187819629719252111">Umożliwia dostęp do plików lokalnych na komputerze, zezwalając <ph name="PRODUCT_NAME"/> na wyświetlanie okien dialogowych wyboru pliku. Po włączeniu tego ustawienia użytkownicy mogą w normalny sposób otwierać okna dialogowe wyboru pliku. Jeśli wyłączysz ustawienie, w momencie wykonania przez użytkownika czynności powodującej wywołanie okna dialogowego wyboru pliku (np. zaimportowanie zakładek, przesłanie plików, zapisanie linków itp.) zostanie wyświetlony komunikat, a działanie przeglądarki będzie kontynuowane, tak jakby użytkownik kliknął przycisk Anuluj w oknie dialogowym wyboru pliku. Jeśli ustawienie jest nieskonfigurowane, użytkownicy mogą w normalny sposób otwierać okna dialogowe wyboru pliku.</translation>
<translation id="4507081891926866240">Pozwala dostosować listę wzorcowych URL-i stron, które zawsze mają być renderowane przez wtyczkę <ph name="PRODUCT_FRAME_NAME"/>. W przypadku nieskonfigurowania tej zasady dla wszystkich stron będzie używany domyślny mechanizm renderujący określony przez zasadę „ChromeFrameRendererSettings”. Przykładowe wzorce można znaleźć na http://www.chromium.org/developers/how-tos/chrome-frame-getting-started</translation>
<translation id="3101501961102569744">Wybierz sposób określenia ustawień serwera proxy</translation>
<translation id="1803646570632580723">Lista przypiętych aplikacji pokazywanych w programie uruchamiającym</translation>
<translation id="1062011392452772310">Włącz zaświadczanie zdalne dla urządzenia</translation>
<translation id="7774768074957326919">Używaj systemowych ustawień serwera proxy</translation>
<translation id="3891357445869647828">Włącz obsługę języka JavaScript</translation>
<translation id="868187325500643455">Zezwalaj na automatyczne uruchamianie wtyczek we wszystkich witrynach</translation>
<translation id="7421483919690710988">Ustaw rozmiar dyskowej pamięci podręcznej multimediów w bajtach</translation>
<translation id="5226033722357981948">Określ, czy funkcja znajdowania wtyczek ma być wyłączona</translation>
<translation id="4890209226533226410">Ustawia włączony typ lupy.

          Jeśli ta zasada jest ustawiona, określa typ lupy, który jest włączony. Ustawienie zasady jako „Brak” wyłącza lupę.

          Gdy ją ustawisz, użytkownicy nie mogą jej zmienić ani zastąpić.

          Jeśli zasada pozostanie nieustawiona, lupa jest początkowo wyłączona, ale użytkownik może ją w każdej chwili włączyć.</translation>
<translation id="3428247105888806363">Włącz przewidywanie działań sieciowych</translation>
<translation id="3460784402832014830">Określa adres URL, którego wyszukiwarka ma używać do otwierania strony nowej karty.

          Ta zasada jest opcjonalna. Jeśli jej nie skonfigurujesz, na stronie nowej karty nie będzie otwierana żadna strona.

          Ta zasada jest stosowana tylko wtedy, gdy jest włączona zasada „DefaultSearchProviderEnabled”.</translation>
<translation id="6145799962557135888">Umożliwia skonfigurowanie listy wzorcowych URL-i określających witryny, w których może być wykonywany kod JavaScript. Jeśli ta zasada nie zostanie skonfigurowana, dla wszystkich witryn będzie używana globalna wartość domyślna pochodząca z zasady „DefaultJavaScriptSetting” (jeśli została skonfigurowana) lub z osobistej konfiguracji użytkownika.</translation>
<translation id="2757054304033424106">Typy rozszerzeń/aplikacji, które można instalować</translation>
<translation id="7053678646221257043">Po włączeniu tej zasady wymuszany jest import zakładek z bieżącej przeglądarki domyślnej. Włączenie zasady ma również wpływ na opcje w oknie dialogowym importowania. W przypadku jej wyłączenia zakładki nie są importowane. Jeśli zasada nie jest skonfigurowana, użytkownik może zostać zapytany, czy zakładki mają zostać zaimportowane lub operacja ta zostanie wykonana automatycznie.</translation>
<translation id="5757829681942414015">Określa katalog, w którym <ph name="PRODUCT_NAME"/> będzie przechowywać dane użytkownika.

      Jeśli ustawisz tę zasadę, <ph name="PRODUCT_NAME"/> użyje podanego katalogu, niezależnie od tego, czy użytkownik określi flagę „--user-data-dir”.

      Na http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables znajdziesz listę zmiennych, których możesz użyć.

      W przypadku nieustawienia tej zasady zostanie użyta domyślna ścieżka profilu, a użytkownik będzie mógł ją zmienić, używając flagi „--user-data-dir” w wierszu poleceń.</translation>
<translation id="5067143124345820993">Biała lista loginów użytkowników</translation>
<translation id="2514328368635166290">Pozwala określić URL wybranej ikony domyślnego dostawcy wyszukiwania. Ta zasada jest opcjonalna. Jeśli nie zostanie skonfigurowana, ikona dostawcy wyszukiwania nie będzie wyświetlana. Ta zasada jest stosowana tylko przy włączonej zasadzie „DefaultSearchProviderEnabled”.</translation>
<translation id="7194407337890404814">Nazwa domyślnego dostawcy wyszukiwania</translation>
<translation id="1843117931376765605">Częstotliwość odświeżania zasad użytkownika</translation>
<translation id="5535973522252703021">Biała lista serwerów przekazywania poświadczeń w protokole Kerberos</translation>
<translation id="9187743794267626640">Wyłącz podłączanie pamięci zewnętrznych</translation>
<translation id="6353901068939575220">Określa parametry używane przy wyszukiwaniu URL-a z użyciem POST. Składa się z rozdzielonych przecinkami par nazwy i wartości. Jeśli wartość jest parametrem szablonu, tak jak w przykładzie powyżej {searchTerms}, zostanie ona zastąpiona rzeczywistymi danymi wyszukiwanych słów.

          Ta zasada jest opcjonalna. Jeśli nie jest ustawiona, żądania wyszukiwań są wysyłane przy użyciu metody GET.

          Ta zasada jest uwzględniana tylko wtedy, gdy włączona jest zasada „DefaultSearchProviderEnabled”.</translation>
<translation id="5307432759655324440">Dostępność trybu incognito</translation>
<translation id="4056910949759281379">Wyłącz protokół SPDY</translation>
<translation id="3808945828600697669">Określ listę wyłączonych wtyczek</translation>
<translation id="4525521128313814366">Pozwala na ustawienie listy wzorcowych URL-i, które określają witryny mogące wyświetlać obrazy. Jeśli ta zasada nie zostanie skonfigurowana, dla wszystkich witryn będzie używana globalna wartość domyślna pochodząca z zasady „DefaultImagesSettings” (jeśli została skonfigurowana) lub z osobistej konfiguracji użytkownika.</translation>
<translation id="8499172469244085141">Ustawienia domyślne (użytkownicy mogą zmienić)</translation>
<translation id="8693243869659262736">Użyj wbudowanego klienta DNS</translation>
<translation id="3072847235228302527">Określ Warunki korzystania z usługi dla lokalnego konta na urządzeniu</translation>
<translation id="5523812257194833591">Sesja publiczna, do której następuje automatyczne zalogowanie po opóźnieniu.

      Jeśli ta zasada jest ustawiona, użytkownik zostanie automatycznie zalogowany do określonej sesji po upływie określonego czasu nieaktywności na ekranie logowania. Sesja publiczna musi zostać wcześniej skonfigurowana (zobacz zasadę |DeviceLocalAccounts|).

      Jeśli ta zasada jest nieustawiona, automatyczne logowanie nie działa.</translation>
<translation id="5983708779415553259">Domyślne zachowanie dla witryn nie jest zawarte w żadnym pakiecie treści</translation>
<translation id="3866530186104388232">Jeśli ta zasada jest włączona lub nieskonfigurowana, <ph name="PRODUCT_OS_NAME"/> będzie umożliwiał wybranie nazwy użytkownika spośród zarejestrowanych nazw wyświetlanych na ekranie logowania. W przypadku wyłączenia tej zasady <ph name="PRODUCT_OS_NAME"/> będzie prosił o podanie nazwy użytkownika i hasła.</translation>
<translation id="2098658257603918882">Włącz przesyłanie raportów o użytkowaniu i danych dotyczących awarii</translation>
<translation id="2324547593752594014">Zezwalaj na logowanie się w Chrome</translation>
<translation id="172374442286684480">Zezwalaj wszystkim witrynom na tworzenie danych lokalnych</translation>
<translation id="1151353063931113432">Zezwalaj na grafiki w tych witrynach</translation>
<translation id="1297182715641689552">Używaj skryptu PAC serwera proxy</translation>
<translation id="2976002782221275500">Określa, po jakim czasie nieaktywności użytkownika przyciemniany jest ekran przy zasilaniu z baterii.

          Jeśli ta zasada ma wartość większą niż zero, określa czas, przez który użytkownik musi pozostać bezczynny, zanim <ph name="PRODUCT_OS_NAME"/> przyciemni ekran.

          Jeśli ta zasada ma wartość równą zero, <ph name="PRODUCT_OS_NAME"/> nie przyciemnia ekranu, gdy użytkownik jest bezczynny.

          Jeśli ta zasada nie jest ustawiona, używana jest domyślna wartość długości czasu.

          Wartość tej zasady powinna być określona w milisekundach. Wartości nie mogą być większe niż opóźnienie wyłączenia ekranu (jeśli jest ustawione) i opóźnienie bezczynności.</translation>
<translation id="8631434304112909927">do wersji <ph name="UNTIL_VERSION"/></translation>
<translation id="7469554574977894907">Włącz propozycje wyszukiwania</translation>
<translation id="4906194810004762807">Częstotliwość odświeżania zasad dotyczących urządzeń</translation>
<translation id="8922668182412426494">Serwery, dla których <ph name="PRODUCT_NAME"/> ma uprawnienia do delegowania.

          Nazwy serwerów należy rozdzielić przecinkami. Symbole wieloznaczne (*) są dozwolone.

          Jeśli ta zasada jest nieustawiona, Chrome nie będzie delegować poświadczeń użytkowników, nawet gdy serwer działa w intranecie.</translation>
<translation id="1398889361882383850">Pozwala określić, czy strony będą mogły automatycznie uruchamiać wtyczki. Automatyczne uruchamianie wtyczek może być dozwolone dla wszystkich witryn lub zabronione dla wszystkich witryn.

          Ustawienie Kliknij, by uruchomić zezwala na uruchamianie wtyczek, ale użytkownik musi kliknąć wtyczkę, by rozpoczęło się jej wykonywanie.

          W przypadku nieustawienia tej zasady zostanie użyta opcja „AllowPlugins”, a użytkownik będzie mógł ją zmienić.</translation>
<translation id="7974114691960514888">Ta zasada nie jest już obsługiwana. Umożliwia stosowanie protokołu STUN i serwerów przekazywania podczas łączenia się z klientem zdalnym. Jeśli ustawienie jest włączone, ten komputer może wykrywać hosty zdalne i łączyć się z nimi nawet wówczas, gdy są oddzielone zaporą sieciową. Jeśli ustawienie jest wyłączone, a wychodzące połączenia UDP są filtrowane przez zaporę sieciową, komputer może łączyć się tylko z hostami w sieci lokalnej.</translation>
<translation id="7694807474048279351">Planuje automatyczne ponowne uruchomienie po zastosowaniu aktualizacji <ph name="PRODUCT_OS_NAME"/>.

      Jeśli ta zasada ma wartość „prawda”, po zastosowaniu aktualizacji <ph name="PRODUCT_OS_NAME"/> następuje zaplanowane automatyczne ponowne uruchomienie, które jest wymagane do zakończenia procesu aktualizacji. Ponowne uruchomienie jest zaplanowane do wykonania od razu, ale może zostać opóźnione nawet o 24 godziny, gdy użytkownik akurat korzysta z urządzenia.

      Jeśli zasada ma wartość „fałsz”, po zastosowaniu aktualizacji <ph name="PRODUCT_OS_NAME"/> nie jest zaplanowane automatyczne ponowne uruchomienie. Proces aktualizacji kończy się, gdy użytkownik samodzielnie ponownie uruchomi urządzenie.

      Gdy ustawisz zasadę, użytkownicy nie mogą jej zmienić ani zastąpić.

      Uwaga: automatyczne ponowne uruchomienia obecnie działają tylko wtedy, gdy jest pokazywany ekran logowania lub trwa sesja aplikacji kiosku. W przyszłości to się zmieni i zasada będzie obowiązywała zawsze, niezależnie od tego, czy trwa sesja określonego typu.</translation>
<translation id="5511702823008968136">Włącz pasek zakładek</translation>
<translation id="5105313908130842249">Opóźnienie blokady ekranu przy zasilaniu z baterii</translation>
<translation id="7882585827992171421">Ta zasada jest aktywna tylko w trybie sklepu.

      Określa identyfikator rozszerzenia używanego jako wygaszacz ekranu na ekranie logowania. Rozszerzenie musi być częścią pakietu aplikacji skonfigurowanego dla tej domeny przez zasadę DeviceAppPack.</translation>
<translation id="7736666549200541892">Włącz rozszerzenie certyfikatów TLS powiązanych z domeną (TLS-OBC)</translation>
<translation id="1796466452925192872">Pozwala określić, z jakich adresów URL można instalować rozszerzenia, aplikacje i motywy.

          Począwszy od Chrome 21, trudniej jest instalować rozszerzenia, aplikacje i skrypty użytkownika spoza Chrome Web Store. Wcześniej użytkownik mógł kliknąć link do pliku *.crx, a Chrome po wyświetleniu kilku ostrzeżeń zaoferowałby jego zainstalowanie. Po udostępnieniu Chrome 21 takie pliki trzeba pobrać i przeciągnąć na stronę ustawień Chrome. To ustawienie pozwala określonym adresom URL na używanie starszej, prostszej metody instalacji.

          Każda pozycja tej listy jest wzorcem dopasowania rozszerzeń (zobacz http://code.google.com/chrome/extensions/match_patterns.html). Użytkownicy będą mogli łatwo instalować elementy z każdego adresu URL pasującego do pozycji na liście. Wzorce te muszą pozwalać na dostęp zarówno do lokalizacji pliku *.crx, jak i strony, na której rozpoczyna się pobieranie (strony odsyłającej).

          Pierwszeństwo zachowuje jednak zasada ExtensionInstallBlacklist. Oznacza to, że rozszerzenie znajdujące się na czarnej liście nie zostanie zainstalowane, nawet jeśli pochodzi z witryny odpowiadającej pozycji na tej liście.</translation>
<translation id="2113068765175018713">Ogranicz czas działania urządzenia przez automatyczne ponowne uruchamianie</translation>
<translation id="7848840259379156480">Umożliwia skonfigurowanie domyślnego mechanizmu renderowania HTML po zainstalowaniu wtyczki <ph name="PRODUCT_FRAME_NAME"/>. Ustawieniem domyślnym jest zezwolenie przeglądarce hosta na wykonywanie renderowania, jednak możesz opcjonalnie zastąpić to ustawienie, tak aby strony HTML były domyślnie renderowane przez wtyczkę <ph name="PRODUCT_FRAME_NAME"/>.</translation>
<translation id="186719019195685253">Działanie, jakie ma zostać podjęte po osiągnięciu opóźnienia bezczynności przy zasilaniu prądem zmiennym</translation>
<translation id="7890264460280019664">Raportowanie listy interfejsów sieciowych wraz z ich typami i adresami sprzętu do serwera.

      Jeśli ta zasada nie jest ustawiona lub jej wartość to Fałsz, lista interfejsów nie zostanie zgłoszona.</translation>
<translation id="4121350739760194865">Zablokuj wyświetlanie promocji aplikacji na stronie Nowa karta</translation>
<translation id="2127599828444728326">Zezwalaj na powiadomienia w tych witrynach.</translation>
<translation id="3973371701361892765">Nigdy nie autoukrywaj półki</translation>
<translation id="7635471475589566552">Pozwala skonfigurować język w przeglądarce <ph name="PRODUCT_NAME"/> i uniemożliwia użytkownikom jego zmianę. Jeśli włączysz to ustawienie, w <ph name="PRODUCT_NAME"/> będzie używany określony język. W przypadku, gdy skonfigurowany język nie jest obsługiwany, wybierana jest opcja „en-US”. Jeśli ustawienie jest wyłączone lub nieskonfigurowane, w <ph name="PRODUCT_NAME"/> używany jest preferowany język określony przez użytkownika (jeśli został skonfigurowany), język ustawiony w systemie lub zastępcza opcja „en-US”.</translation>
<translation id="2948087343485265211">Określa, czy aktywność związana z dźwiękiem wpływa na zarządzanie energią.

          Jeśli wartość tej zasady to Prawda lub nie jest ona ustawiona, podczas odtwarzania dźwięku nieaktywność użytkownika nie jest brana pod uwagę. Uniemożliwia to przekroczenie limitu bezczynności oraz wykonanie związanego z tym działania. Jednak niezależnie od aktywności związanej z dźwiękiem przyciemnienie, wyłączenie i zablokowanie ekranu zostanie wykonane po osiągnięciu skonfigurowanych opóźnień.

          Jeśli wartość tej zasady to Fałsz, aktywność związana z dźwiękiem nie wyklucza postrzegania użytkownika jako bezczynnego.</translation>
<translation id="7842869978353666042">Skonfiguruj opcje Dysku Google</translation>
<translation id="718956142899066210">Typy połączeń dozwolone dla aktualizacji</translation>
<translation id="1734716591049455502">Skonfiguruj opcje dostępu zdalnego</translation>
<translation id="7336878834592315572">Zachowaj pliki cookie na czas trwania sesji</translation>
<translation id="7715711044277116530">Wartość procentowa skalowania opóźnienia przyciemnienia ekranu w trybie prezentacji</translation>
<translation id="8777120694819070607">Zezwala na uruchamianie nieaktualnych wtyczek w przeglądarce <ph name="PRODUCT_NAME"/>. Jeśli włączysz to ustawienie, nieaktualne wtyczki będą używane w normalny sposób. W przypadku jego wyłączenia nieaktualne wtyczki nie są używane, a użytkownikom nie są wyświetlane monity o udzielenie pozwolenia na ich uruchomienie. Jeśli ustawienie jest nieskonfigurowane, użytkownikom są wyświetlane monity o udzielenie pozwolenia na uruchomienie nieaktualnych wtyczek.</translation>
<translation id="2629448496147630947">Skonfiguruj opcje dostępu zdalnego w <ph name="PRODUCT_NAME"/>. Funkcje te są uwzględniane dopiero po zainstalowaniu aplikacji internetowej dostępu zdalnego.</translation>
<translation id="1310699457130669094">W tym miejscu możesz podać URL pliku PAC serwera proxy. Ta zasada obowiązuje tylko po wybraniu ręcznego konfigurowania ustawień proxy za pomocą opcji „Wybierz sposób określenia ustawień serwera proxy”. Szczegółowe przykłady można znaleźć na  <ph name="PROXY_HELP_URL"/></translation>
<translation id="1509692106376861764">Ta zasada została wycofana w <ph name="PRODUCT_NAME"/> w wersji 29.</translation>
<translation id="5464816904705580310">Konfiguruj ustawienia dla zarządzanych użytkowników.</translation>
<translation id="3219421230122020860">Tryb incognito dostępny</translation>
<translation id="7690740696284155549">Określa katalog, w którym <ph name="PRODUCT_NAME"/> będzie zapisywać pobrane pliki.

      Jeśli ustawisz tę zasadę, <ph name="PRODUCT_NAME"/> będzie używać tego katalogu niezależnie od tego, czy użytkownik podał własny katalog lub włączył opcję pytania o lokalizację przy każdym pobieraniu.

      Na http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables znajdziesz listę zmiennych, których możesz użyć.

      W przypadku nieustawienia tej zasady zostanie użyty domyślny katalog pobierania, a użytkownik będzie mógł go zmienić.</translation>
<translation id="7381326101471547614">Wyłącza protokół SPDY w <ph name="PRODUCT_NAME"/>. Po włączeniu tej zasady protokół SPDY jest niedostępny w <ph name="PRODUCT_NAME"/>. W przeciwnym razie protokołu można używać. Jeśli zasada nie zostanie ustawiona, protokół SPDY będzie dostępny.</translation>
<translation id="2208976000652006649">Parametry dla adresów URL wyszukiwania używających POST</translation>
<translation id="1583248206450240930">Używaj domyślnie wtyczki <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="1047128214168693844">Nie zezwalaj żadnej witrynie na śledzenie fizycznej lokalizacji użytkownika</translation>
<translation id="4101778963403261403">Pozwala skonfigurować typ domyślnej strony startowej w <ph name="PRODUCT_NAME"/> i uniemożliwia użytkownikom zmianę tego ustawienia. Jako stronę startową możesz wybrać podany przez siebie URL albo stronę Nowa karta. Jeśli włączysz ustawienie, stroną startową zawsze będzie strona Nowa karta, a URL strony startowej będzie ignorowany. W przypadku wyłączenia ustawienia strona Nowa karta nie będzie stroną startową użytkownika, chyba że jako URL strony startowej podano ciąg „chrome://newtab”. Jeśli ustawienie jest włączone lub wyłączone, użytkownicy nie mogą zmienić typu strony startowej w <ph name="PRODUCT_NAME"/>. W przypadku nieskonfigurowania tej zasady użytkownik może wybrać, czy strona Nowa karta ma być stroną startową.</translation>
<translation id="8970205333161758602">Pomiń monit o odinstalowanie <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="3273221114520206906">Domyślne ustawienie języka JavaScript</translation>
<translation id="4025586928523884733">Blokuje pliki cookie innych firm. Włączenie tego ustawienia uniemożliwia tworzenie plików cookie przez elementy stron internetowych niepochodzące z domeny widocznej w pasku adresu przeglądarki. Wyłączenie ustawienia pozwala na tworzenie plików cookie przez te elementy i uniemożliwia użytkownikom jego zmianę. W przypadku nieskonfigurowania tej zasady tworzenie plików cookie przez te elementy będzie dozwolone, ale użytkownik będzie mógł to zmienić.</translation>
<translation id="6810445994095397827">Blokuj kod JavaScript w tych witrynach</translation>
<translation id="6672934768721876104">Ta zasada jest przestarzała, zamiast niej użyj zasady ProxyMode. Pozwala ona określić serwer proxy używany w <ph name="PRODUCT_NAME"/> i uniemożliwia użytkownikom zmianę jego ustawień. Jeśli zdecydujesz się nie korzystać z serwera proxy i zawsze bezpośrednio nawiązywać połączenia, wszystkie pozostałe opcje będą ignorowane. Są one ignorowane również w przypadku użycia systemowych ustawień serwera proxy lub automatycznego wykrywania serwera proxy. Jeśli chcesz ręcznie wprowadzić ustawienia serwera proxy, możesz określić dodatkowe opcje w polach „Adres URL serwera proxy”, „Adres URL pliku PAC serwera proxy” i „Lista rozdzielonych przecinkami reguł omijania serwera proxy”. Szczegółowe przykłady można znaleźć na <ph name="PROXY_HELP_URL"/>. Jeśli ustawienie jest włączone, przeglądarka <ph name="PRODUCT_NAME"/> ignoruje wszystkie opcje dotyczące serwera proxy określone w wierszu polecenia. W przypadku nieskonfigurowania tej zasady użytkownicy mogą samodzielnie wybrać ustawienia proxy.</translation>
<translation id="3780152581321609624">Umieść port niestandardowy w nazwie SPN w protokole Kerberos</translation>
<translation id="1749815929501097806">Określa Warunki korzystania z usługi, które użytkownik musi zaakceptować przed rozpoczęciem sesji używania lokalnego konta na urządzeniu.

      Jeśli ta zasada jest ustawiona, <ph name="PRODUCT_OS_NAME"/> będzie pobierać Warunki korzystania z usługi i wyświetlać je użytkownikowi przy każdym rozpoczęciu sesji. Użytkownik będzie mógł kontynuować tylko po ich zaakceptowaniu.

      Jeśli ta zasada nie jest ustawiona, Warunki korzystania z usługi nie są pokazywane.

      Zasada powinna określać URL, z którego <ph name="PRODUCT_OS_NAME"/> może pobrać Warunki korzystania z usługi. Dokument ten musi mieć postać zwykłego tekstu (MIME) bez żadnych znaczników.</translation>
<translation id="2660846099862559570">Nigdy nie używaj serwera proxy</translation>
<translation id="1435659902881071157">Konfiguracja sieci na poziomie urządzenia</translation>
<translation id="2131902621292742709">Opóźnienie przyciemnienia ekranu przy zasilaniu z baterii</translation>
<translation id="5781806558783210276">Określa, po jakim czasie nieaktywności użytkownika wykonywane jest działanie związane z bezczynnością przy zasilaniu z baterii.

          Jeśli ta zasada jest ustawiona, określa czas, przez który użytkownik musi pozostać nieaktywny, zanim <ph name="PRODUCT_OS_NAME"/> wykona działanie związane z bezczynnością (można skonfigurować je osobno).

          Jeśli ta zasada nie jest ustawiona, używana jest domyślna wartość długości czasu.

          Wartość tej zasady powinna być określona w milisekundach.</translation>
<translation id="5512418063782665071">Adres URL strony startowej</translation>
<translation id="2948381198510798695">W przypadku hostów wymienionych na tej liście przeglądarka <ph name="PRODUCT_NAME"/> omija serwer proxy. Ta zasada obowiązuje tylko wówczas, gdy ręcznie wprowadzisz ustawienia serwera proxy za pomocą opcji „Wybierz sposób określenia ustawień serwera proxy”. Szczegółowe przykłady można znaleźć na <ph name="PROXY_HELP_URL"/></translation>
<translation id="6658245400435704251">Określa, o ile sekund urządzenie może losowo opóźnić pobranie aktualizacji w stosunku do czasu jej opublikowania na serwerze. Urządzenie może odczekać część tego okresu, licząc w sekundach zegara, a pozostałą część, licząc w testach dostępności aktualizacji. Tak czy inaczej okres opóźnienia jest ograniczony z góry, by urządzenie nigdy nie utknęło w stanie oczekiwania na pobranie aktualizacji.</translation>
<translation id="523505283826916779">Ustawienia ułatwień dostępu</translation>
<translation id="1948757837129151165">Zasady uwierzytelniania HTTP</translation>
<translation id="5946082169633555022">Wersja beta</translation>
<translation id="7187256234726597551">Jeśli zasada ma wartość „prawda”, zdalne poświadczanie na potrzeby urządzenia jest dozwolone, a certyfikat jest automatycznie generowany i przesyłany na serwer zarządzania urządzeniami.

          Jeśli ma ona wartość „fałsz” lub nie jest ustawiona, certyfikat nie jest generowany, a wywołania interfejsu API rozszerzenia enterprise.platformKeysPrivate extension kończą się niepowodzeniem.</translation>
<translation id="5242696907817524533">Konfiguruje listę zakładek zarządzanych.

      Zasada jest listą zakładek. Każda z nich to słownik zawierający nazwę („name”) i docelowy adres („url”).

      Zasady te są umieszczone w folderze Zakładki zarządzane wewnątrz Zakładek na komórce. Nie można ich modyfikować.

      Jeśli ta zasada jest ustawiona, Zakładki zarządzane to domyślnie otwierany folder, gdy otwierany jest widok zakładek w Chrome.

      Zakładki zarządzane nie są synchronizowane z kontem użytkownika.</translation>
<translation id="8303314579975657113">Pozwala określić bibliotekę GSSAPI, która ma być używana do uwierzytelniania HTTP. Możesz określić samą nazwę biblioteki lub pełną ścieżkę. Jeśli ustawienie jest nieskonfigurowane, w przeglądarce <ph name="PRODUCT_NAME"/> w zastępstwie używana jest domyślna nazwa biblioteki.</translation>
<translation id="8549772397068118889">Ostrzegaj przy odwiedzaniu witryn spoza pakietów treści</translation>
<translation id="7749402620209366169">Pozwala włączyć uwierzytelnianie dwuskładnikowe dla hostów zdalnego dostępu zamiast stosowania PIN-u określanego przez użytkownika.

          Jeśli to ustawienie jest włączone, podczas uzyskiwania dostępu do hosta użytkownicy muszą podać prawidłowy kod dwuskładnikowy.

          Jeśli to ustawienie jest wyłączone lub nieskonfigurowane, uwierzytelnianie dwuskładnikowe nie będzie włączone i stosowane będzie działanie domyślne – korzystanie z PIN-u zdefiniowanego przez użytkownika.</translation>
<translation id="7329842439428490522">Określa, po jakim czasie nieaktywności użytkownika wyłączany jest ekran przy zasilaniu z baterii.

          Jeśli ta zasada ma wartość większą niż zero, określa czas, przez który użytkownik musi pozostać bezczynny, zanim <ph name="PRODUCT_OS_NAME"/> wyłączy ekran.

          Jeśli ta zasada ma wartość równą zero, <ph name="PRODUCT_OS_NAME"/> nie wyłącza ekranu, gdy użytkownik jest bezczynny.

          Jeśli ta zasada nie jest ustawiona, używana jest domyślna wartość długości czasu.

          Wartość tej zasady powinna być określona w milisekundach. Wartości nie mogą być wyższe od opóźnienia bezczynności.</translation>
<translation id="384743459174066962">Umożliwia skonfigurowanie listy wzorcowych URL-i określających witryny, w których mogą być otwierane wyskakujące okienka. Jeśli ta zasada nie zostanie skonfigurowana, dla wszystkich witryn będzie używana globalna wartość domyślna pochodząca z zasady „DefaultPopupsSetting” (jeśli została skonfigurowana) lub z osobistej konfiguracji użytkownika.</translation>
<translation id="5645779841392247734">Zezwalaj na pliki cookie w tych witrynach</translation>
<translation id="4043912146394966243"> Typy połączeń, które mogą być używane do aktualizowania systemu operacyjnego. Z powodu swojego rozmiaru aktualizacje te silnie wykorzystują połączenie, co może skutkować dodatkowymi kosztami. Dlatego domyślnie są wyłączone w przypadku połączeń uznanych za „kosztowne”, czyli aktualnie dla WiMax, Bluetooth i komórek.

      Rozpoznawane identyfikatory typów połączeń to  „ethernet”, „wifi”, „wimax”, „bluetooth” i „cellular”.</translation>
<translation id="6652197835259177259">Ustawienia użytkowników zarządzanych lokalnie</translation>
<translation id="3243309373265599239">Określa, po jakim czasie nieaktywności użytkownika przyciemniany jest ekran przy zasilaniu z sieci.

          Jeśli ta zasada ma wartość większą niż zero, określa czas, przez który użytkownik musi pozostać bezczynny, zanim <ph name="PRODUCT_OS_NAME"/> przyciemni ekran.

          Jeśli ta zasada ma wartość równą zero, <ph name="PRODUCT_OS_NAME"/> nie przyciemnia ekranu, gdy użytkownik jest bezczynny.

          Jeśli ta zasada nie jest ustawiona, używana jest domyślna wartość długości czasu.

          Wartość tej zasady powinna być określona w milisekundach. Wartości nie mogą być większe niż opóźnienie wyłączenia ekranu (jeśli jest ustawione) i opóźnienie bezczynności.</translation>
<translation id="3859780406608282662">Dodaj parametr do pobierania odmian referencyjnych w <ph name="PRODUCT_OS_NAME"/>.

      Jeśli ta zasada jest ustalona, zostanie dodany parametr zapytania „z ograniczeniem” do adresu URL używanego do pobierania odmian referencyjnych. Wartością parametru będzie wartość tej zasady.

      Jeśli zasada nie jest określona, adres URL nie zostanie zmieniony.</translation>
<translation id="7049373494483449255">Pozwala <ph name="PRODUCT_NAME"/> przesyłać dokumenty do <ph name="CLOUD_PRINT_NAME"/> w celu wydrukowania. UWAGA: to ustawienie wpływa tylko na obsługę <ph name="CLOUD_PRINT_NAME"/> w <ph name="PRODUCT_NAME"/>. Nie uniemożliwia użytkownikom drukowania za pośrednictwem innych witryn. W przypadku włączenia lub nieskonfigurowania tego ustawienia, użytkownicy będą mogli drukować w <ph name="CLOUD_PRINT_NAME"/> z okna drukowania w <ph name="PRODUCT_NAME"/>. Jeśli to ustawienie zostanie wyłączone, użytkownicy nie będą mogli drukować za pomocą <ph name="CLOUD_PRINT_NAME"/> w oknie drukowania przeglądarki <ph name="PRODUCT_NAME"/>.</translation>
<translation id="4088589230932595924">Tryb incognito wymuszany</translation>
<translation id="5862253018042179045">Ustawia domyślny stan funkcji ułatwień dostępu w postaci potwierdzeń głosowych na ekranie logowania.

          Jeśli ta zasada ma wartość „prawda”, po wyświetleniu ekranu logowania potwierdzenia głosowe są włączone.

          Jeśli ma ona wartość „fałsz”, po wyświetleniu ekranu logowania takie potwierdzenia są wyłączone.

          Gdy ją ustawisz, użytkownicy mogą ją chwilowo zastąpić, włączając lub wyłączając potwierdzenia głosowe. Wybór użytkownika nie jest jednak trwały i wartość domyślna jest przywracana po ponownym wyświetleniu ekranu logowania lub wtedy, gdy użytkownik przez minutę będzie nieaktywny na tym ekranie.

          Jeśli zasada pozostanie nieustawiona, po pierwszym wyświetleniu ekranu logowania potwierdzenia głosowe są wyłączone. Użytkownicy mogą je w każdej chwili włączyć lub wyłączyć i ich stan na ekranie logowania jest trwały dla wszystkich użytkowników.</translation>
<translation id="8197918588508433925">Ta zasada określa dozwolone rozszerzenia do użycia z funkcją  chrome.enterprise.platformKeysPrivate.challengeUserKey() interfejsu API Enterprise Platform Keys do zdalnego poświadczania. Rozszerzenia muszą zostać dodane do tej listy, by były używane z interfejsem API.

          Jeśli rozszerzenie nie znajduje się na liście, lub lista nie jest ustawiona, wywołanie interfejsu API zakończy się błędem.</translation>
<translation id="7649638372654023172">Pozwala skonfigurować URL domyślnej strony startowej w urządzeniu <ph name="PRODUCT_NAME"/> i uniemożliwia użytkownikom jego zmianę.

          Strona startowa jest otwierana przyciskiem strony startowej. Strony otwierane przy uruchomieniu są kontrolowane przez zasady RestoreOnStartup.

          Typ strony startowej można ustawić na URL określony tutaj lub na stronę nowej karty. W tym drugim przypadku ta zasada jest ignorowana.

          Jeśli włączysz to ustawienie, użytkownicy nie będą mogli zmienić adresu URL swojej strony startowej na urządzeniu <ph name="PRODUCT_NAME"/>, ale jako tę stronę będą mogli wybrać stronę nowej karty.

          W przypadku nieustawienia tej zasady użytkownicy będą mogli wybrać własną stronę startową, jeśli zasada HomepageIsNewTabPage również nie będzie ustawiona.</translation>
<translation id="4858735034935305895">Zezwalaj na tryb pełnoekranowy</translation>
</translationbundle>