<?xml version="1.0" ?>
<!DOCTYPE translationbundle>
<translationbundle lang="de">
<translation id="1503959756075098984">Ohne Nutzereingriff zu installierende Erweiterungs-IDs und Aktualisierungs-URLs</translation>
<translation id="793134539373873765">Gibt an, ob P2P für die Nutzdaten von Betriebssystem-Updates verwendet werden soll. Falls auf &quot;True&quot; gesetzt, teilen die Geräte Update-Nutzdaten im LAN und versuchen, die Daten von dort zu laden. Dadurch wird potenziell weniger Internetbandbreite verbraucht und es kommt seltener zu Datenstaus. Wenn die Update-Nutzdaten nicht im LAN verfügbar sind, lädt das Gerät sie ersatzweise von einem Updateserver herunter. Ist diese Option auf &quot;False&quot; gesetzt oder nicht konfiguriert, wird P2P nicht verwendet.</translation>
<translation id="2463365186486772703">Gebietsschema der App</translation>
<translation id="1397855852561539316">Vorschlags-URL für die Standardsuchmaschine</translation>
<translation id="3347897589415241400">Standardverhalten für Websites, die nicht in einem Inhaltspaket enthalten sind.

Diese Richtlinien dienen ausschließlich zur internen Verwendung in Chrome.</translation>
<translation id="7040229947030068419">Beispielwert</translation>
<translation id="1213523811751486361">Gibt die URL der Suchmaschine an, die zur Ausgabe der Suchvorschläge verwendet wird. Die URL sollte den String &quot;<ph name="SEARCH_TERM_MARKER"/>&quot; enthalten. Dieser wird bei der Suchanfrage mit dem Text ersetzt, den der Nutzer bis dahin eingegeben hat. Diese Richtlinie ist optional. Wenn keine Festlegung erfolgt, so kommt keine Vorschlags-URL zum Einsatz. Diese Richtlinie wird nur dann umgesetzt, wenn die Richtlinie &quot;DefaultSearchProviderEnabled&quot; aktiviert ist.</translation>
<translation id="6106630674659980926">Passwortmanager aktivieren</translation>
<translation id="7109916642577279530">Hiermit können Audioaufnahmen zugelassen oder abgelehnt werden.

      Wenn diese Richtlinie aktiviert oder nicht konfiguriert ist (Standard), wird beim Zugriff für
      Audioaufnahmen beim Nutzer nachgefragt. Ausgenommen sind URLs auf der Liste
      &quot;AudioCaptureAllowedUrls&quot;. Diese URLs erhalten ohne Nachfrage Zugriff.

      Wenn diese Richtlinie deaktiviert ist, wird nie beim Nutzer nachgefragt und
      Audioaufnahmen sind nur für URLs auf der AudioCaptureAllowedUrls-Liste verfügbar.

      Diese Richtlinie betrifft alle Arten von Audioeingaben, nicht nur das eingebaute Mikrofon.</translation>
<translation id="7267809745244694722">Medientasten standardmäßig als Funktionstasten verwenden</translation>
<translation id="9150416707757015439">Diese Richtlinie ist veraltet. Bitte verwenden Sie stattdessen &quot;IncognitoModeAvailability&quot;. Aktiviert den Inkognito-Modus in <ph name="PRODUCT_NAME"/>. Wenn diese Einstellung aktiviert oder nicht konfiguriert ist, können Nutzer Webseiten im Inkognito-Modus öffnen. Sollte die Einstellung deaktiviert sein, können Nutzer Webseiten nicht im Inkognito-Modus öffnen. Ist die Richtlinie nicht konfiguriert, so ist die Funktion aktiviert, sodass Nutzer den Inkognito-Modus verwenden können.</translation>
<translation id="4203389617541558220">Hiermit kann die Betriebszeit des Geräts durch die Planung automatischer Neustarts begrenzt werden.

      Wenn diese Richtlinie konfiguriert ist, wird damit die Dauer der Gerätebetriebszeit angegeben, nach der ein automatischer Neustart geplant ist.

      Wird die Richtlinie nicht konfiguriert, ist die Betriebszeit des Geräts nicht begrenzt.

      Wenn Sie diese Richtlinie konfigurieren, können die Nutzer sie nicht ändern oder außer Kraft setzen.

      Automatische Neustarts werden zu bestimmten Zeiten geplant, können aber bis zu 24 Stunden auf dem Gerät verzögert werden, wenn das Gerät gerade von einem Nutzer verwendet wird.

      Hinweis: Automatische Neustarts sind derzeit nur aktiviert, wenn die Anmeldeseite angezeigt wird oder eine Kiosk-App-Sitzung läuft. Dies wird zukünftig geändert, sodass die Richtlinie immer gilt, unabhängig davon, ob und welche Sitzung aktiv ist.

      Der Wert für die Richtlinie muss in Sekunden angegeben werden. Der Mindestwert beträgt 3.600 Sekunden (1 Stunde).</translation>
<translation id="5304269353650269372">Diese Richtlinie gibt an, nach welcher Inaktivitätsspanne des Nutzers im Akkubetrieb eine Warnmeldung angezeigt wird.

          Wird diese Richtlinie festgelegt, gibt sie an, wie lange der Nutzer inaktiv sein kann, bevor <ph name="PRODUCT_OS_NAME"/> in einer Warnung auf die bevorstehende Maßnahme hinweist.

          Wird diese Richtlinie nicht festgelegt, erscheint keine Warnung.

          Geben Sie den Richtlinienwert in Millisekunden an. Solange die Inaktivitätsspanne kleiner oder gleich diesem festgelegten Wert ist, erscheint keine Warnung.</translation>
<translation id="7818131573217430250">Standardstatus für den Modus mit hohem Kontrast auf der Anmeldeseite festlegen</translation>
<translation id="7614663184588396421">Liste der deaktivierten Protokollschemas</translation>
<translation id="2309390639296060546">Standardeinstellung für &quot;geolocation&quot;</translation>
<translation id="1313457536529613143">Hiermit wird der Prozentsatz angegeben, um den die Spanne für die Bildschirmabdunkelung skaliert wird, wenn während der Bildschirmabdunkelung oder kurz nach der Bildschirmabschaltung Nutzeraktivität festgestellt wird.

          Wenn diese Richtlinie konfiguriert ist, wird damit der Prozentsatz für die Skalierung der Spanne für die Bildschirmabdunkelung angegeben, wenn während der Bildschirmabdunkelung oder kurz nach der Bildschirmabschaltung Nutzeraktivität festgestellt wird. Sollte die Abdunkelungsspanne skaliert werden, wird die Spanne für die Abschaltung und Sperre des Bildschirms sowie die Inaktivität so angepasst, dass die Abstände der ursprünglichen Konfiguration proportional beibehalten werden.

          Ist diese Richtlinie nicht konfiguriert, wird ein Standardfaktor für die Skalierung verwendet.

          Der Skalierungsfaktor muss mindestens 100 % betragen.</translation>
<translation id="7443616896860707393">Ursprungsübergreifende HTTP-Basic-Authentifizierungsabfragen</translation>
<translation id="2337466621458842053">Ermöglicht Ihnen die Zusammenstellung einer Liste mit URL-Mustern, die Websites angeben, denen das Anzeigen von Bildern gestattet ist. Wenn diese Richtlinie nicht konfiguriert wird, so kommt für alle Websites entweder der globale Standardwert der Richtlinie &quot;DefaultImagesSetting&quot;, falls konfiguriert, oder der persönlichen Konfiguration des Nutzers zum Einsatz.</translation>
<translation id="4680961954980851756">AutoFill aktivieren</translation>
<translation id="5183383917553127163">Mit dieser Richtlinie können Sie festlegen, welche Erweiterungen nicht auf die schwarze Liste gesetzt werden. Der Wert &quot;*&quot; in der schwarzen Liste gibt an, dass alle Erweiterungen ausgeschlossen sind und dass Nutzer nur Erweiterungen installieren können, die in der weißen Liste enthalten sind. Standardmäßig können alle Erweiterungen installiert werden. Wurden jedoch alle Erweiterungen durch eine Richtlinie auf die schwarze Liste gesetzt, kann diese Richtlinie mithilfe der weißen Liste außer Kraft gesetzt werden.</translation>
<translation id="5921888683953999946">Hiermit wird der Standardstatus der Bedienungshilfefunktion für den großen Cursor auf der Anmeldeseite festgelegt.

          Ist diese Richtlinie auf &quot;true&quot; gesetzt, ist der große Cursor aktiviert, wenn die Anmeldeseite angezeigt wird.

          Ist diese Richtlinie auf &quot;false&quot; gesetzt, ist der große Cursor deaktiviert, wenn die Anmeldeseite angezeigt wird.

          Wenn Sie diese Richtlinie konfigurieren, können die Nutzer sie vorübergehend außer Kraft setzen, indem sie den großen Cursor aktivieren bzw. deaktivieren. Die Nutzerauswahl ist jedoch nicht dauerhaft und die Standardeinstellung wird wiederhergestellt, sobald die Anmeldeseite erneut angezeigt wird oder der Nutzer auf der Anmeldeseite eine Minute lang inaktiv ist.

          Falls diese Richtlinie nicht konfiguriert wird, ist der große Cursor deaktiviert, wenn die Anmeldeseite das erste Mal angezeigt wird. Die Nutzer können den großen Cursor jederzeit aktivieren oder deaktivieren und dieser Status bleibt auf der Anmeldeseite erhalten.</translation>
<translation id="3185009703220253572">Ab Version <ph name="SINCE_VERSION"/></translation>
<translation id="5298412045697677971">Avatarbild des Nutzers konfigurieren

      Über diese Richtlinie können Sie das Avatarbild für den Nutzer auf dem Anmeldebildschirm konfigurieren. Zum Festlegen der Richtlinie muss die URL, über die <ph name="PRODUCT_OS_NAME"/> das Avatarbild herunterladen kann, sowie ein kryptografischer Hash angegeben werden, der zum Verifizieren der Integrität des Downloads dient. Das Bild muss im JPEG-Format vorliegen und darf nicht größer als 512 KB sein. Der Zugriff auf die URL muss ohne Authentifizierung möglich sein.

      Das Avatarbild wird heruntergeladen und zwischengespeichert. Sollte sich die URL oder der Hash ändern, wird das Bild erneut heruntergeladen.

      Die Richtlinie sollte als String mit der URL und dem Hash im JSON-Format angegeben werden. Folgendes Schema sollte dabei eingehalten werden:
      {
        &quot;type&quot;: &quot;object&quot;,
        &quot;properties&quot;: {
          &quot;url&quot;: {
            &quot;description&quot;: &quot;URL, über die das Avatarbild heruntergeladen werden kann&quot;,
            &quot;type&quot;: &quot;string&quot;
          },
          &quot;hash&quot;: {
            &quot;description&quot;: &quot;SHA-256-Hash des Avatarbilds&quot;,
            &quot;type&quot;: &quot;string&quot;
          }
        }
      }

      Wenn die Richtlinie festgelegt wird, lädt <ph name="PRODUCT_OS_NAME"/> das Avatarbild herunter und verwendet es.

      Nachdem Sie diese Richtlinie festgelegt haben, kann sie von Nutzern nicht geändert oder überschrieben werden.

      Wenn Sie keine Einstellung für diese Richtlinie festlegen, können Nutzer ihr Avatarbild auf dem Anmeldebildschirm auswählen.</translation>
<translation id="2204753382813641270">Automatisches Ausblenden der Ablage verwalten</translation>
<translation id="3816312845600780067">Tastenkombination zur Umgehung der automatischen Anmeldung aktivieren</translation>
<translation id="3214164532079860003">Bei Aktivierung erzwingt diese Richtlinie, dass die Startseite vom aktuellen Standardbrowser importiert wird. Wenn sie deaktiviert ist, wird die Startseite nicht importiert. Sollte sie nicht konfiguriert sein, so wird der Nutzer gefragt, ob ein Import erfolgen soll, oder der Import findet automatisch statt.</translation>
<translation id="5330684698007383292">Verarbeitung der folgenden Inhaltstypen durch <ph name="PRODUCT_FRAME_NAME"/> zulassen</translation>
<translation id="6647965994887675196">Wurde &quot;true&quot; festgelegt, können betreute Nutzer erstellt und verwendet werden.

          Wurde &quot;false&quot; oder &quot;not configured&quot; festgelegt, wird die Erstellung und Anmeldung betreuter Nutzer deaktiviert. Alle vorhandenen betreuten Nutzer werden ausgeblendet.

          Hinweis: Das Standardverhalten bei Geräten für Kunden und bei Geräten für Unternehmen ist unterschiedlich: Bei Geräten für Kunden sind betreute Nutzer standardmäßig aktiviert, bei Geräten für Unternehmen hingegen sind sie standardmäßig deaktiviert.</translation>
<translation id="69525503251220566">Parameter für Funktion zur bildgesteuerten Suche für Standardsuchanbieter</translation>
<translation id="5469825884154817306">Bilder auf diesen Websites blockieren</translation>
<translation id="8412312801707973447">Ob online OCSP-/CRL-Prüfungen durchgeführt werden</translation>
<translation id="2482676533225429905">Natives Messaging</translation>
<translation id="6649397154027560979">Diese Richtlinie wird nicht mehr verwendet, nutzen Sie stattdessen die Richtlinie &quot;URLBlacklist&quot;.

      Hiermit werden die aufgelisteten Protokollschemata in <ph name="PRODUCT_NAME"/> deaktiviert.

      URLs mit einem Schema von dieser Liste werden nicht geladen und können nicht aufgerufen werden.

      Wenn diese Richtlinie nicht konfiguriert wird oder die Liste leer ist, sind alle Schemata in <ph name="PRODUCT_NAME"/> zugänglich.</translation>
<translation id="3213821784736959823">Legt fest, ob der integrierte DNS-Client von <ph name="PRODUCT_NAME"/> verwendet werden soll.

      Wenn diese Richtlinie auf &quot;true&quot; gesetzt wurde, wird, falls verfügbar, der integrierte DNS-Client verwendet.

      Wenn diese Richtlinie auf &quot;false&quot; gesetzt wurde, wird der integrierte DNS-Client nie verwendet.

      Wenn diese Richtlinie nicht eingerichtet ist, kann der Nutzer über eine Bearbeitung von chrome://flags oder die Festlegung einer Befehlzeilenmarkierung entscheiden, ob der integrierte DNS-Client verwendet wird oder nicht.</translation>
<translation id="2908277604670530363">Maximale Anzahl gleichzeitiger Verbindungen zum Proxyserver</translation>
<translation id="556941986578702361">Automatisches Ausblenden der <ph name="PRODUCT_OS_NAME"/>-Ablage verwalten

      Wenn diese Richtlinie auf &quot;AlwaysAutoHideShelf&quot; gesetzt ist, wird die Ablage immer automatisch ausgeblendet.

      Wenn diese Richtlinie auf &quot;NeverAutoHideShelf&quot; gesetzt ist, wird die Ablage nie automatisch ausgeblendet.

      Wenn Sie die Richtlinie einrichten, können Nutzer diese nicht ändern oder übergehen.

      Wenn die Richtlinie nicht eingerichtet ist, können Nutzer wählen, ob sie die Ablage automatisch ausblenden möchten oder nicht.</translation>
<translation id="4838572175671839397">Enthält einen regulären Ausdruck, der festlegt, welche Nutzer sich in <ph name="PRODUCT_NAME"/> anmelden können.

      Wenn sich ein Nutzer mit einem Nutzernamen anmelden möchte, der nicht diesem Muster entspricht, wird ein entsprechender Fehler ausgegeben.

      Werden diese Richtlinien weder festgelegt noch ausgefüllt, kann sich jeder Nutzer in <ph name="PRODUCT_NAME"/> anmelden.</translation>
<translation id="2892225385726009373">Bei Aktivierung dieser Einstellung führt <ph name="PRODUCT_NAME"/> immer eine Widerrufprüfung für Serverzertifikate durch, die erfolgreich bestätigt und von lokal installierten CA-Zertifikaten signiert wurden.

      Wenn <ph name="PRODUCT_NAME"/> keine Informationen zum Widerrufstatus abrufen kann, werden solche Zertifikate als widerrufen behandelt (&quot;hard-fail&quot;).

      Wenn diese Richtlinie nicht festgelegt oder auf &quot;false&quot; gesetzt ist, verwendet Chrome die vorhandenen Online-Einstellungen zur Widerrufprüfung.</translation>
<translation id="3516856976222674451">Maximale Dauer einer Nutzersitzung festlegen

      Wenn diese Richtlinie festgelegt ist, wird so die maximale Zeitdauer festgelegt, nach der ein Nutzer automatisch abgemeldet und die Sitzung beendet wird. Der Nutzer erfährt über einen Countdown-Zähler in der Taskleiste, wie viel Zeit er noch hat.

      Wenn diese Richtlinie nicht festgelegt wurde, ist die Sitzungsdauer unbegrenzt.

      Wenn Sie diese Richtlinie festlegen, können Nutzer sie nicht ändern oder übergehen.

      Der Richtlinienwert sollte in Millisekunden angegeben werden. Der Wert kann zwischen 30 Sekunden und 24 Stunden liegen.</translation>
<translation id="9200828125069750521">Parameter für URL der Bildsuche, die POST verwendet</translation>
<translation id="2769952903507981510">Erforderlichen Domain-Namen für Remote-Zugriff-Hosts konfigurieren</translation>
<translation id="8294750666104911727">Normalerweise werden Seiten, bei denen das Metatag &quot;X-UA-Compatible&quot; auf &quot;chrome=1&quot; gesetzt ist, unabhängig von der Richtlinie &quot;ChromeFrameRendererSettings&quot; in <ph name="PRODUCT_FRAME_NAME"/> gerendert.

          Bei aktivierter Einstellung werden die Seiten nicht nach Metatags durchsucht.

          Bei deaktivierter Einstellung werden die Seiten nach Metatags durchsucht.

          Ist die Richtlinie nicht festgelegt, werden die Seiten nach Metatags durchsucht.</translation>
<translation id="3478024346823118645">Nutzerdaten bei Abmeldung löschen</translation>
<translation id="8668394701842594241">Gibt eine Liste von Plug-ins an, die in <ph name="PRODUCT_NAME"/> aktiviert sind, und verhindert, dass Nutzer diese Einstellung ändern. Die Platzhalterzeichen &quot;*&quot; und &quot;?&quot; können verwendet werden, um Übereinstimmungen mit beliebigen Zeichenfolgen herbeizuführen. &quot;*&quot; ergibt Übereinstimmungen mit einer beliebigen Anzahl von Zeichen, während &quot;?&quot; für ein einziges optionales Zeichen steht, also keinem oder einem Zeichen entspricht. Das Escape-Zeichen ist &quot;\&quot;, um also wirkliche Übereinstimmungen mit den Zeichen &quot;*&quot;, &quot;?&quot; und &quot;\&quot; zu finden, können Sie das &quot;\&quot;-Zeichen davor platzieren. Die angegebene Liste der Plug-ins wird in <ph name="PRODUCT_NAME"/> immer verwendet, wenn sie installiert sind. Die Plug-ins sind in &quot;about:plugins&quot; als aktiv markiert und können von Nutzern nicht deaktiviert werden. Beachten Sie, dass diese Richtlinie sowohl &quot;DisabledPlugins&quot; als auch &quot;DisabledPluginsExceptions&quot; außer Kraft setzt. Wenn die Richtlinie nicht konfiguriert ist, können Nutzer beliebige auf dem System installierte Plug-ins deaktivieren.</translation>
<translation id="653608967792832033">Hiermit wird angegeben, nach welchem Zeitraum ohne Nutzereingabe der Bildschirm im Akkubetrieb gesperrt wird.

          Wenn für diese Richtlinie ein höherer Wert als null festgelegt wird, gibt dieser an, wie lange ein Nutzer inaktiv sein muss, bevor <ph name="PRODUCT_OS_NAME"/> den Bildschirm sperrt.

          Ist die Richtlinie auf null eingestellt, wird der Bildschirm von <ph name="PRODUCT_OS_NAME"/> nicht gesperrt, wenn der Nutzer inaktiv wird.

          Wenn die Richtlinie nicht konfiguriert ist, wird ein Standardwert verwendet.

          Die empfohlene Vorgehensweise ist, die Bildschirmsperre im Suspend-Modus zu aktivieren und <ph name="PRODUCT_OS_NAME"/> anzuweisen, nach der Inaktivitätsverzögerung in den Suspend-Modus zu wechseln. Diese Richtlinie sollte nur verwendet werden, wenn die Bildschirmsperre erheblich früher als der Suspend-Modus eintreten oder der Suspend-Modus bei Inaktivität gar nicht erfolgen soll.

          Der Wert für die Richtlinie muss in Millisekunden angegeben werden. Werte müssen kleiner als der Wert für die Inaktivitätsverzögerung sein.</translation>
<translation id="979541737284082440">Dieses Dokument kann Richtlinien enthalten, die für den Einsatz in zukünftigen
      <ph name="PRODUCT_NAME"/>-Versionen gedacht sind und die
      ohne vorherige Ankündigung geändert werden können. Die Liste der unterstützten Richtlinien gilt
      sowohl für Chromium als auch für Google Chrome.

      Sie brauchen diese Einstellungen nicht manuell zu konfigurieren. Sie können unter
      <ph name="POLICY_TEMPLATE_DOWNLOAD_URL"/> nutzerfreundliche Vorlagen herunterladen.

      Diese Richtlinien dürfen ausschließlich für die Konfiguration von Chrome-Instanzen verwendet werden, die intern in Ihrem Unternehmen zum Einsatz kommen. Richtlinien, die außerhalb Ihres Unternehmens verwendet werden, z. B. in einem allgemein zugänglichen Programm, werden als Malware eingestuft und höchstwahrscheinlich auch von Google und Anbietern von Antivirenprogrammen als Malware kategorisiert.

      Hinweis: Ab <ph name="PRODUCT_NAME"/> 28
      werden Richtlinien direkt aus der Group Policy API unter
      Windows geladen. Manuell zur Registrierung hinzugefügte Richtlinien werden ignoriert.
      Weitere Informationen finden Sie unter http://crbug.com/259236.

      Ab <ph name="PRODUCT_NAME"/> 35 werden Richtlinien direkt aus der Registrierung gelesen, wenn die Workstation mit einer Active Directory-Domain verknüpft ist. Andernfalls werden die Richtlinien aus dem Gruppenrichtlinienobjekt gelesen.</translation>
<translation id="4157003184375321727">Betriebssystem- und Firmware-Version melden</translation>
<translation id="5255162913209987122">Empfehlenswert</translation>
<translation id="1861037019115362154">Gibt eine Liste von Plug-ins an, die in <ph name="PRODUCT_NAME"/> deaktiviert sind, und verhindert, dass Nutzer diese Einstellung ändern können.

      Die Platzhalterzeichen &quot;*&quot; und &quot;?&quot; können verwendet werden, um Übereinstimmungen mit beliebigen Zeichenfolgen herbeizuführen. &quot;*&quot; ergibt Übereinstimmungen mit einer beliebigen Anzahl von Zeichen, während &quot;?&quot; für ein einziges optionales Zeichen steht, also keinem oder einem Zeichen entspricht. Das Escape-Zeichen ist &quot;\&quot;, um also wirkliche Übereinstimmungen mit den Zeichen &quot;*&quot;, &quot;?&quot; und &quot;\&quot; zu finden, können Sie das &quot;\&quot;-Zeichen davor platzieren.

      Wenn Sie diese Einstellung aktivieren, werden die Plug-ins der angegebenen Liste in <ph name="PRODUCT_NAME"/> nicht verwendet. Die Plug-ins sind in &quot;about:plugins&quot; als deaktiviert markiert und können von Nutzern nicht aktiviert werden.

      Beachten Sie, dass diese Richtlinie sowohl von &quot;EnabledPlugins&quot; als auch &quot;DisabledPluginsExceptions&quot; außer Kraft gesetzt werden kann.

      Ist die Richtlinie nicht konfiguriert, können Nutzer beliebige auf dem System installierte Plug-ins verwenden. Ausnahmen sind hartcodierte, inkompatible, veraltete und gefährliche Plug-ins.</translation>
<translation id="9197740283131855199">Prozentsatz für die Skalierung der Spanne für die Bildschirmabdunkelung, wenn der Nutzer nach der Abdunkelung aktiv wird</translation>
<translation id="1492145937778428165">Gibt das Intervall in Millisekunden an, in dem Informationen zu Geräterichtlinien vom Geräteverwaltungsdienst abgerufen werden.

      Durch das Festlegen dieser Richtlinie wird der Standardwert von 3 Stunden außer Kraft gesetzt. Gültige Werte für diese Richtlinie liegen im Bereich zwischen 1800000 (30 Minuten) und 86400000 (1 Tag). Alle Werte, die nicht in diesem Bereich liegen, werden auf den jeweiligen Grenzwert gesetzt.

      Wenn diese Richtlinie nicht konfiguriert ist, gilt in <ph name="PRODUCT_OS_NAME"/> der Standardwert von 3 Stunden.</translation>
<translation id="3765260570442823273">Dauer der Warnmeldung zur Abmeldung bei Inaktivität</translation>
<translation id="7302043767260300182">Verzögerung für die Bildschirmsperre im Netzbetrieb</translation>
<translation id="7331962793961469250">Wenn die Option auf &quot;True&quot; gesetzt ist, erscheint Werbung für Chrome Web Store-Apps nicht auf der &quot;Neuer Tab&quot;-Seite. Wenn sie auf &quot;False&quot; eingestellt oder nicht konfiguriert ist, so erscheint Chrome Web Store-Werbung auf der &quot;Neuer Tab&quot;-Seite.</translation>
<translation id="7271085005502526897">Startseite bei erster Ausführung aus Standardbrowser importieren</translation>
<translation id="6036523166753287175">Firewallausnahme über Host für Remote-Zugriff aktivieren</translation>
<translation id="1096105751829466145">Standardsuchmaschine</translation>
<translation id="7567380065339179813">Plug-ins auf diesen Websites zulassen</translation>
<translation id="4555850956567117258">Remote-Bescheinigung (Remote Attestation) für den Nutzer aktivieren</translation>
<translation id="5966615072639944554">Erweiterungen, die die Remote Attestation API zur Bestätigung der Nutzeridentität verwenden dürfen</translation>
<translation id="1617235075406854669">Löschen des Browserverlaufs und des Downloadverlaufs aktivieren</translation>
<translation id="5290940294294002042">Liste von Plug-ins angeben, die der Nutzer aktivieren oder deaktivieren kann</translation>
<translation id="3153348162326497318">Ermöglicht Ihnen zu bestimmen, welche Erweiterungen Nutzer nicht installieren dürfen. Bereits installierte Erweiterungen werden entfernt, wenn sie auf die schwarze Liste gesetzt werden. Der Wert &quot;*&quot; in einer schwarzen Liste bedeutet, dass alle Erweiterungen auf die schwarze Liste gesetzt sind. Ausnahmen bilden lediglich solche, die ausdrücklich in der weißen Liste geführt sind. Wenn die Richtlinie nicht konfiguriert ist, so ist es dem Nutzer gestattet, beliebige Erweiterungen in <ph name="PRODUCT_NAME"/> zu installieren.</translation>
<translation id="3067188277482006117">Falls auf &quot;true&quot; gesetzt, ist die Remote-Bestätigung der Nutzeridentität gegenüber der Datenschutz-Zertifizierungsstelle anhand der Hardware des Chrome-Geräts möglich. Dies geschieht über die Enterprise Platform Keys API chrome.enterprise.platformKeysPrivate.challengeUserKey().

Falls die Richtlinie auf &quot;false&quot; gesetzt oder nicht festgelegt wird, treten bei API-Aufrufen Fehler auf und ein Fehlercode wird angezeigt.</translation>
<translation id="5809728392451418079">Anzeigename für lokale Gerätekonten festlegen</translation>
<translation id="1427655258943162134">Adresse oder URL des Proxyservers</translation>
<translation id="1827523283178827583">Feste Proxyserver verwenden</translation>
<translation id="3021409116652377124">Plug-in-Suchfunktion deaktivieren</translation>
<translation id="7236775576470542603">Hiermit wird der Standardtyp für die Lupe festgelegt, die auf der Anmeldeseite aktiviert ist.

          Ist diese Richtlinie konfiguriert, wird damit der Lupentyp bestimmt, der bei der Anzeige der Anmeldeseite aktiviert ist. Wenn Sie die Richtlinie auf &quot;None&quot; setzen, ist die Lupe deaktiviert.

          Wenn Sie diese Richtlinie konfigurieren, können die Nutzer sie vorübergehend außer Kraft setzen, indem sie die Lupe aktivieren bzw. deaktivieren. Die Nutzerauswahl ist jedoch nicht dauerhaft und die Standardeinstellung wird wiederhergestellt, sobald die Anmeldeseite erneut angezeigt wird oder der Nutzer auf der Anmeldeseite eine Minute lang inaktiv ist.

          Falls diese Richtlinie nicht konfiguriert wird, ist die Lupe deaktiviert, wenn die Anmeldeseite das erste Mal angezeigt wird. Die Nutzer können die Lupe jederzeit aktivieren oder deaktivieren und dieser Status bleibt auf der Anmeldeseite erhalten.</translation>
<translation id="5423001109873148185">Bei Aktivierung erzwingt diese Richtlinie den Import von Suchmaschinen aus dem aktuellen Standardbrowser. Wenn die Richtlinie aktiviert ist, wirkt sich das darüber hinaus auf den Importdialog aus. Wenn sie deaktiviert ist, wird die Standardsuchmaschine nicht importiert. Sollte Sie nicht konfiguriert sein, so wird der Nutzer möglicherweise gefragt, ob ein Import stattfinden soll, oder der Import erfolgt automatisch.</translation>
<translation id="3288595667065905535">Release-Kanal</translation>
<translation id="2785954641789149745">Hiermit wird die Safe Browsing-Funktion von <ph name="PRODUCT_NAME"/> aktiviert und verhindert, dass Nutzer diese Einstellung ändern können.

      Wenn Sie diese Einstellung aktivieren, ist Safe Browsing immer aktiv.

      Wenn Sie diese Einstellung deaktivieren, ist Safe Browsing nie aktiv.

      Falls Sie diese Einstellung aktivieren oder deaktivieren, können die Nutzer die Einstellung &quot;Phishing- und Malware-Schutz aktivieren&quot; in <ph name="PRODUCT_NAME"/> nicht ändern oder außer Kraft setzen.

      Ist die Richtlinie nicht konfiguriert, wird Safe Browsing aktiviert, aber die Einstellung kann von den Nutzern geändert werden.</translation>
<translation id="268577405881275241">Funktion für Datenkomprimierungs-Proxy aktivieren</translation>
<translation id="3820526221169548563">Aktiviert die Bedienungshilfefunktion für die Bildschirmtastatur.

          Ist diese Richtlinie auf &quot;true&quot; gesetzt, ist die Bildschirmtastatur immer aktiviert.

          Ist diese Richtlinie auf &quot;false&quot; gesetzt, ist die Bildschirmtastatur immer deaktiviert.

          Wenn Sie diese Richtlinie konfigurieren, können die Nutzer sie nicht ändern oder außer Kraft setzen.

          Wird diese Richtlinie nicht konfiguriert, ist die Bildschirmtastatur zunächst deaktiviert, kann vom Nutzer aber jederzeit aktiviert werden.</translation>
<translation id="8369602308428138533">Verzögerung für die Bildschirmabschaltung im Netzbetrieb</translation>
<translation id="6513756852541213407">Ermöglicht Ihnen festzulegen, welchen Proxy <ph name="PRODUCT_NAME"/> verwendet, und verhindert, dass Nutzer Proxy-Einstellungen ändern. Wenn Sie festlegen, dass kein Proxyserver verwendet, sondern immer eine direkte Verbindung hergestellt werden soll, werden alle anderen Optionen ignoriert. Sollten Sie festlegen, dass die Proxy-Einstellungen des Systems verwendet werden sollen oder der Proxyserver automatisch erkannt werden soll, werden alle anderen Optionen ebenfalls ignoriert. Bei Auswahl der Methode mit festem Proxyserver können Sie in &quot;Adresse oder URL des Proxyservers&quot; und &quot;Durch Komma getrennte Liste der Proxy-Umgehungsregeln&quot; weitere Optionen angeben. Zur Verwendung eines PAC-Proxy-Skripts müssen Sie die URL des Skripts im Feld &quot;URL einer PAC-Proxy-Datei&quot; angeben. Ausführliche Beispiele finden Sie unter <ph name="PROXY_HELP_URL"/>. Wenn Sie diese Einstellung aktivieren, ignoriert <ph name="PRODUCT_NAME"/> alle Proxy-Optionen, die in der Eingabeaufforderung angegeben werden. Wenn die Richtlinie nicht konfiguriert ist, so können Nutzer die Proxy-Einstellungen selbst konfigurieren.</translation>
<translation id="7763311235717725977">Ermöglicht Ihnen festzulegen, ob Websites Bilder anzeigen dürfen. Das Anzeigen von Bildern kann entweder allen Websites gestattet oder für alle unterbunden werden. Wenn diese Richtlinie nicht konfiguriert ist, so kommt &quot;AllowImages&quot; zum Einsatz, wobei der Nutzer dies ändern kann.</translation>
<translation id="5630352020869108293">Letzte Sitzung wiederherstellen</translation>
<translation id="2067011586099792101">Zugriff auf Websites außerhalb von Inhaltspaketen blockieren</translation>
<translation id="4980635395568992380">Datentyp:</translation>
<translation id="3096595567015595053">Liste der aktivierten Plug-ins</translation>
<translation id="3048744057455266684">Falls diese Richtlinie festgelegt ist und eine Such-URL-Vervollständigung aus der Omnibox diesen Parameter im Suchanfragen-String oder der Fragment-ID enthält, werden die Suchbegriffe und Suchanbieter anstelle der Such-URL angezeigt.

          Diese Richtlinie ist optional. Wenn sie nicht konfiguriert wird, erfolgt keine Ersetzung der Suchbegriffe.

          Diese Richtlinie wird nur angewendet, wenn die Richtlinie &quot;DefaultSearchProviderEnabled&quot; aktiviert ist.</translation>
<translation id="5912364507361265851">Anzeige von Passwörtern im Passwortmanager durch Nutzer zulassen</translation>
<translation id="5318185076587284965">Verwendung von Relayservern durch den Host für den Remote-Zugriff gestatten</translation>
<translation id="510186355068252378">Deaktiviert die Datensynchronisierung in <ph name="PRODUCT_NAME"/> über von Google gehostete Synchronisierungsdienste und verhindert, dass Nutzer diese Einstellung ändern. Wenn Sie diese Einstellung aktivieren, so können Nutzer diese Einstellung in <ph name="PRODUCT_NAME"/> nicht ändern oder außer Kraft setzen. Sollte die Richtlinie nicht konfiguriert sein, so können die Nutzer entscheiden, ob Sie Google Sync in Anspruch nehmen möchten.</translation>
<translation id="7953256619080733119">Manuell festgelegte Ausnahme-Hosts für verwalteten Nutzer</translation>
<translation id="4807950475297505572">Die am längsten nicht verwendeten Nutzer werden entfernt, bis genügend freier Speicherplatz vorhanden ist.</translation>
<translation id="8789506358653607371">Vollbildmodus zulassen

      Mit dieser Richtlinie wird festgelegt, ob der Vollbildmodus verfügbar ist. In diesem Modus wird die gesamte Benutzeroberfläche von <ph name="PRODUCT_NAME"/> ausgeblendet, sodass nur die Webseiten sichtbar sind.

      Ist diese Richtlinie auf &quot;true&quot; gesetzt oder nicht konfiguriert, können Nutzer, Apps und Erweiterungen in den Vollbildmodus wechseln, sofern sie die erforderlichen Berechtigungen besitzen.

      Ist die Richtlinie auf &quot;false&quot; gesetzt, können weder der Nutzer, noch Apps oder Erweiterungen in den Vollbildmodus wechseln.

      Auf allen Plattformen außer <ph name="PRODUCT_OS_NAME"/> ist bei deaktiviertem Vollbildmodus auch der Kioskmodus nicht verfügbar.</translation>
<translation id="8828766846428537606">Mit dieser Richtlinie wird die Standard-Startseite in <ph name="PRODUCT_NAME"/> konfiguriert und verhindert, dass Nutzer diese ändern. Wenn Sie vollständig verhindern möchten, dass der Nutzer seine Startseiteneinstellungen ändern kann, müssen Sie entweder die &quot;Neuer Tab&quot;-Seite als Startseite festlegen oder angeben, dass Sie eine URL als Startseite festlegen möchten, und dann eine Startseiten-URL angeben. Falls Sie die Startseiten-URL nicht angeben, kann der Nutzer die &quot;Neuer Tab&quot;-Seite zur Startseite machen, indem er &quot;chrome://newtab&quot; eingibt.</translation>
<translation id="2231817271680715693">Browserverlauf bei erster Ausführung aus Standardbrowser importieren</translation>
<translation id="1353966721814789986">Startseiten</translation>
<translation id="7173856672248996428">Sitzungsspezifisches Profil</translation>
<translation id="1841130111523795147">Erlaubt dem Nutzer die Anmeldung in <ph name="PRODUCT_NAME"/> und verhindert, dass der Nutzer diese Einstellung ändert.

      Durch das Festlegen dieser Richtlinie steuern Sie, ob ein Nutzer sich in <ph name="PRODUCT_NAME"/> anmelden darf oder nicht.</translation>
<translation id="5564962323737505851">Mit dieser Richtlinie wird der Passwortmanager konfiguriert. Ist der Passwortmanager aktiviert, können Sie festlegen, ob der Nutzer gespeicherte Passwörter als Klartext anzeigen kann.</translation>
<translation id="4668325077104657568">Standardeinstellung für Bilder</translation>
<translation id="4492287494009043413">Aufnahme von Screenshots deaktivieren</translation>
<translation id="6368403635025849609">JavaScript auf diesen Websites zulassen</translation>
<translation id="6074963268421707432">Anzeige von Desktop-Benachrichtigungen für keine Website zulassen</translation>
<translation id="8614804915612153606">Automatische Updates deaktivieren</translation>
<translation id="4834526953114077364">Die am längsten nicht verwendeten Nutzer, dich sich in den letzten 3 Monaten nicht angemeldet haben, werden entfernt, bis genügend freier Speicherplatz vorhanden ist.</translation>
<translation id="382476126209906314">TalkGadget-Präfix für Remote-Zugriff-Hosts konfigurieren</translation>
<translation id="6561396069801924653">Optionen für Bedienungshilfen im Taskleistenmenü anzeigen</translation>
<translation id="8104962233214241919">Client-Zertifikate für diese Websites automatisch auswählen</translation>
<translation id="2906874737073861391">Liste der AppPack-Erweiterungen</translation>
<translation id="4386578721025870401">Zeit beschränken, für die sich ein über SAML authentifizierter Nutzer offline anmelden kann

      Bei der Anmeldung kann Chrome OS die Authentifizierung über einen Server (online) oder über ein Passwort im Cache (offline) ausführen.

      Wenn für diese Richtlinie der Wert -1 festgelegt ist, kann sich der Nutzer ohne Zeitlimit offline anmelden. Wird ein anderer Wert festgelegt, gibt dieser den Zeitraum ab der letzten Online-Authentifizierung an, nach dem der Nutzer sich erneut online authentifizieren muss.

      Wird für diese Richtlinie kein Wert festgelegt, verwendet <ph name="PRODUCT_OS_NAME"/> ein Standardzeitlimit von 14 Tagen. Anschließend muss sich der Nutzer erneut online authentifizieren.

      Diese Richtlinie betrifft nur Nutzer, die sich über SAML authentifizieren.

      Der Wert sollte in Sekunden angegeben werden.</translation>
<translation id="3758249152301468420">Entwickler-Tools deaktivieren</translation>
<translation id="8665076741187546529">Liste der Erweiterungen konfigurieren, deren Installation erzwungen wurde</translation>
<translation id="2386768843390156671">Ermöglicht die Installation von Hosts für natives Messaging auf Nutzerebene

          Wenn die Einstellung aktiviert ist, können in <ph name="PRODUCT_NAME"/>
          auf Nutzerebene installierte Hosts für natives Messaging verwendet werden.

          Wenn die Einstellung deaktiviert ist, werden in <ph name="PRODUCT_NAME"/>
          nur auf Systemebene installierte Hosts für natives Messaging verwendet.

          Wenn die Einstellung nicht festgelegt wird, können in <ph name="PRODUCT_NAME"/>
          Hosts für natives Messaging auf Nutzerebene verwendet werden.</translation>
<translation id="410478022164847452">Hiermit wird angegeben, nach welchem Zeitraum ohne Nutzereingabe die Inaktivität im Netzbetrieb erfolgt.

          Wenn diese Richtlinie festgelegt ist, wird damit angegeben, wie lange ein Nutzer inaktiv sein muss, bevor <ph name="PRODUCT_OS_NAME"/> in den Inaktivitätsmodus wechselt. Dieser kann gesondert konfiguriert werden.

          Ist diese Richtlinie nicht konfiguriert, wird ein Standardwert verwendet.

          Der Wert für die Richtlinie muss in Millisekunden angegeben werden.</translation>
<translation id="6598235178374410284">Nutzer-Avatarbild</translation>
<translation id="1675391920437889033">Legt fest, welche Typen von Apps bzw. Erweiterungen installiert werden können.

          Diese Einstellung erstellt eine Whitelist der Typen von Erweiterungen bzw. Apps, die in <ph name="PRODUCT_NAME"/> installiert werden können. Der Wert besteht aus einer Liste von Zeichenfolgen, die jeweils einer der folgenden Zeichenfolgen entsprechen: &quot;extension&quot;, &quot;theme&quot;, &quot;user_script&quot;, &quot;hosted_app&quot;, &quot;legacy_packaged_app&quot;, &quot;platform_app&quot;. Weitere Informationen zu diesen Typen finden Sie in der Dokumentation zu Chrome-Erweiterungen.

          Diese Richtlinie betrifft auch Erweiterungen und Apps, deren Installation mit ExtensionInstallForcelist erzwungen wurde.

          Wenn diese Einstellung konfiguriert wurde, werden Erweiterungen oder Apps, die keinem der Typen auf der Liste entsprechen, nicht installiert.

          Wenn diese Einstellung nicht konfiguriert wurde, bestehen keine Einschränkungen für zulässige Erweiterungs- bzw. App-Typen.</translation>
<translation id="6378076389057087301">Angaben zum Einfluss von Audioaktivitäten auf den Energiesparmodus</translation>
<translation id="8818173863808665831">Meldet den geografischen Standort des Geräts.

      Wenn die Richtlinie nicht oder auf &quot;False&quot; festgelegt wird, wird der Standort nicht gemeldet.</translation>
<translation id="4899708173828500852">Safe Browsing aktivieren</translation>
<translation id="4442582539341804154">Sperre aktivieren, wenn das Gerät inaktiv ist oder angehalten wird</translation>
<translation id="7719251660743813569">Legt fest, ob Nutzungsdaten an Google gesendet werden. Bei Einstellung auf &quot;true&quot; werden Nutzungsdatenberichte von <ph name="PRODUCT_OS_NAME"/> gesendet. Ist die Richtlinie nicht konfiguriert oder auf &quot;false&quot; gesetzt, ist das Senden von Datenberichten deaktiviert.</translation>
<translation id="2372547058085956601">Diese Richtlinie gibt das Intervall bis zur automatischen Anmeldung in einer öffentlichen Sitzung an.

      Falls die Richtlinie |DeviceLocalAccountAutoLoginId| nicht festgelegt wurde, hat diese Richtlinie keine Auswirkungen. Anderenfalls gilt:

      Wird diese Richtlinie festgelegt, gibt sie an, wie lange der Nutzer inaktiv sein kann, bevor er automatisch in einer öffentlichen Sitzung angemeldet wird, die in der Richtlinie |DeviceLocalAccountAutoLoginId| angegeben ist.

      Wird diese Richtlinie nicht festgelegt, werden 0 Millisekunden als Zeitlimit verwendet.

      Geben Sie den Richtlinienwert in Millisekunden an.</translation>
<translation id="7275334191706090484">Verwaltete Lesezeichen</translation>
<translation id="3570008976476035109">Plug-ins auf diesen Websites blockieren</translation>
<translation id="8749370016497832113">Diese Richtlinie ermöglicht das Löschen des Browserverlaufs und des Downloadverlaufs in <ph name="PRODUCT_NAME"/> und verhindert, dass Nutzer diese Einstellung ändern.

      Hinweis: Die Deaktivierung dieser Richtlinie bedeutet nicht unbedingt, dass der Browser- und Downloadverlauf erhalten bleiben, denn möglicherweise sind die Nutzer berechtigt, die Verlaufsdatenbankdateien direkt zu bearbeiten oder zu löschen. Außerdem kann der Browser jederzeit selbst einige oder alle Verlaufselemente archivieren oder nach deren Ablaufdatum löschen.

      Wenn diese Einstellung aktiviert oder nicht festgelegt ist, können der Browser- und Downloadverlauf gelöscht werden.

      Wenn diese Einstellung deaktiviert ist, können der Browser- und Downloadverlauf nicht gelöscht werden.</translation>
<translation id="2884728160143956392">Auf diesen Websites Cookies für die jeweilige Sitzung zulassen</translation>
<translation id="3021272743506189340">Falls auf &quot;true&quot; gesetzt, wird die Synchronisierung zwischen Google Drive und der App &quot;Dateien&quot; von Chrome OS bei Verwendung einer Mobilfunkverbindung deaktiviert. Eine Synchronisierung von Daten mit Google Drive erfolgt dann nur bei bestehender WLAN- oder Ethernet-Verbindung.

Falls die Richtlinie auf &quot;false&quot; gesetzt oder nicht festgelegt wird, können die Nutzer Dateien per Mobilfunkverbindung an Google Drive übertragen.</translation>
<translation id="4655130238810647237">Aktiviert oder deaktiviert die Bearbeitung von Lesezeichen in <ph name="PRODUCT_NAME"/>. Wenn Sie diese Einstellung aktivieren, können Lesezeichen hinzugefügt, entfernt und geändert werden. Dies ist die Standardeinstellung. Sollten Sie diese Einstellung deaktivieren, können Lesezeichen nicht hinzugefügt, entfernt und geändert werden. Vorhandene Lesezeichen sind jedoch weiterhin verfügbar.</translation>
<translation id="3496296378755072552">Passwortmanager</translation>
<translation id="4372704773119750918">Nutzer in Unternehmen dürfen keine Mehrfachprofile verwenden (weder als primärer, noch als sekundärer Nutzer)</translation>
<translation id="7027785306666625591">Hiermit wird die Energieverwaltung in <ph name="PRODUCT_OS_NAME"/> konfiguriert.

      Mit diesen Richtlinien können Sie festlegen, wie <ph name="PRODUCT_OS_NAME"/> sich verhalten soll, wenn der Nutzer für einen bestimmten Zeitraum inaktiv ist.</translation>
<translation id="2565967352111237512">Aktiviert das anonyme Senden von Nutzungs- und Absturzdaten für <ph name="PRODUCT_NAME"/> an Google und verhindert, dass Nutzer die Einstellung ändern. Wenn Sie diese Einstellung aktivieren, so werden anonyme Nutzungs- und Absturzdaten an Google gesendet. Sollten Sie die Einstellung deaktivieren, so werden keine anonymen Nutzungs- und Absturzdaten an Google gesendet. Ist diese Einstellung aktiviert oder deaktiviert, können Nutzer sie in <ph name="PRODUCT_NAME"/> nicht ändern oder außer Kraft setzen. Sollte die Richtlinie nicht konfiguriert sein, so kommt die Einstellung zum Einsatz, die der Nutzer bei der Installation bzw. der ersten Ausführung des Programms angegeben hat.</translation>
<translation id="6256787297633808491">Systemweite Parameter, die beim Starten von Chrome angewendet werden</translation>
<translation id="2516600974234263142">Aktiviert das Drucken in <ph name="PRODUCT_NAME"/> und verhindert, dass Nutzer diese Einstellung ändern.

      Wenn diese Einstellung aktiviert oder nicht konfiguriert ist, können Nutzer drucken.

      Wenn diese Einstellung deaktiviert ist, können Nutzer nicht von <ph name="PRODUCT_NAME"/> aus drucken. Die Druckfunktion wird im Schraubenschlüssel-Menü, in den Erweiterungen, JavaScript-Anwendungen usw. deaktiviert. Es kann weiterhin über Plug-ins gedruckt werden, die <ph name="PRODUCT_NAME"/> während des Druckvorgangs umgehen. Bestimmte Flash-Anwendungen bieten beispielsweise die Druckoption in ihrem Kontextmenü, das von diesen Richtlinien nicht abgedeckt wird.</translation>
<translation id="9135033364005346124"><ph name="CLOUD_PRINT_NAME"/>-Proxy aktivieren</translation>
<translation id="4519046672992331730">Aktiviert Suchvorschläge in der Omnibox von <ph name="PRODUCT_NAME"/> und verhindert, dass Nutzer diese Einstellung ändern.

      Wenn Sie diese Einstellung aktivieren, werden Suchvorschläge angeboten.

      Sollten Sie die Einstellung deaktivieren, werden keine Suchvorschläge gemacht.

      Ist diese Einstellung aktiviert oder deaktiviert, können Nutzer sie in <ph name="PRODUCT_NAME"/> nicht ändern oder außer Kraft setzen.

      Ist die Richtlinie nicht konfiguriert, so wird die Einstellung aktiviert, wobei der Nutzer dies ändern kann.</translation>
<translation id="6943577887654905793">Bevorzugter Mac-/Linux-Name:</translation>
<translation id="8176035528522326671">Unternehmensnutzer nur als primären Nutzer mehrerer Profile zulassen (Standardverhalten für von Unternehmen verwaltete Nutzer)</translation>
<translation id="6925212669267783763">Konfiguriert das Verzeichnis, in dem <ph name="PRODUCT_FRAME_NAME"/> Nutzerdaten speichert.

      Wenn Sie diese Richtlinie festlegen, verwendet <ph name="PRODUCT_FRAME_NAME"/> das angegebene Verzeichnis.

      Unter &quot;http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables&quot; finden Sie eine Liste der Variablen, die verwendet werden können.

      Bleibt diese Einstellung unkonfiguriert, wird das Standardverzeichnis des Profils verwendet.</translation>
<translation id="8906768759089290519">Gastmodus aktivieren</translation>
<translation id="348495353354674884">Bildschirmtastatur aktivieren</translation>
<translation id="2168397434410358693">Inaktivitätsverzögerung im Netzbetrieb</translation>
<translation id="838870586332499308">Daten-Roaming aktivieren</translation>
<translation id="2292084646366244343">In <ph name="PRODUCT_NAME"/> können mithilfe eines Google-Webdienstes Rechtschreibfehler korrigiert werden. Wenn diese Einstellung aktiviert ist, wird dieser Dienst immer verwendet. Ist die Einstellung deaktiviert, wird dieser Dienst nie verwendet.

      Die Rechtschreibprüfung kann weiterhin mit einem heruntergeladenen Wörterbuch durchgeführt werden. Diese Richtlinie bezieht sich nur auf die Verwendung des Online-Dienstes.

      Ist diese Einstellung nicht konfiguriert, können die Nutzer auswählen, ob die Rechtschreibprüfung verwendet werden soll oder nicht.</translation>
<translation id="8782750230688364867">Hiermit wird der Prozentsatz angegeben, um den die Spanne für die Bildschirmabdunkelung skaliert wird, wenn sich das Gerät im Präsentationsmodus befindet.

          Wenn diese Richtlinie konfiguriert ist, wird damit der Prozentsatz für die Skalierung der Spanne für die Bildschirmabdunkelung angegeben, wenn sich das Gerät im Präsentationsmodus befindet. Sollte die Spanne für die Bildschirmabdunkelung skaliert werden, wird die Spanne für die Abschaltung und Sperre des Bildschirms sowie die Inaktivität so angepasst, dass die Abstände der ursprünglichen Konfiguration proportional beibehalten werden.

          Ist diese Richtlinie nicht konfiguriert, wird ein Standardfaktor für die Skalierung verwendet.

          Der Skalierungsfaktor muss mindestens 100 % betragen. Werte, bei denen die Spanne für die Bildschirmabdunkelung im Präsentationsmodus kürzer wäre als regulär, sind nicht zulässig.</translation>
<translation id="254524874071906077">Google Chrome als Standardbrowser festlegen</translation>
<translation id="8112122435099806139">Legt das Uhrzeitformat fest, das für dieses Gerät verwendet werden soll

      Diese Richtlinie konfiguriert das Uhrzeitformat, das auf dem Anmeldebildschirm sowie als Standard für Nutzersitzungen verwendet wird. Nutzer haben die Möglichkeit, das Uhrzeitformat für ihr Konto zu ändern.

      Falls für die Richtlinie &quot;True&quot; ausgewählt ist, verwendet das Gerät das 24-Stunden-Uhrzeitformat. Ist für die Richtlinie &quot;False&quot; konfiguriert, wird das 12-Stunden-Uhrzeitformat verwendet.

      Ist die Richtlinie nicht konfiguriert, wird standardmäßig das 24-Stunden-Uhrzeitformat verwendet.</translation>
<translation id="8764119899999036911">Gibt an, ob der generierte Kerberos-SPN auf dem kanonischen DNS-Namen oder dem ursprünglich eingegebenen Namen basiert. Wenn Sie diese Einstellung aktivieren, wird die CNAME-Suche übersprungen und der Servername so wie eingegeben verwendet. Sollten Sie die Einstellung deaktivieren oder nicht konfigurieren, wird der kanonische Name des Servers per CNAME-Suche ermittelt.</translation>
<translation id="5056708224511062314">Lupe deaktiviert</translation>
<translation id="4377599627073874279">Anzeige aller Bilder auf allen Websites zulassen</translation>
<translation id="7195064223823777550">Hiermit wird angegeben, welche Aktion erfolgen soll, wenn der Nutzer das Gerät zuklappt.

          Wenn diese Richtlinie festgelegt ist, wird damit die Aktion definiert, die <ph name="PRODUCT_OS_NAME"/> ausführt, wenn der Nutzer das Gerät zuklappt.

          Ist diese Richtlinie nicht konfiguriert, wird die Standardaktion verwendet. Diese ist der Suspend-Modus.

          Falls der Suspend-Modus als Aktion festgelegt wird, kann gesondert konfiguriert werden, ob <ph name="PRODUCT_OS_NAME"/> den Bildschirm vorher sperren soll oder nicht.</translation>
<translation id="3915395663995367577">URL einer PAC-Proxy-Datei</translation>
<translation id="1022361784792428773">Erweiterungs-IDs, die der Nutzer nicht installieren darf (&quot;*&quot; für alle)</translation>
<translation id="6064943054844745819">Gibt eine Liste mit veralteten Webplattformfunktionen an, die wieder aktiviert werden sollen

      Anhand dieser Richtlinie haben Administratoren die Möglichkeit, veraltete Webplattformfunktionen für einen begrenzten Zeitraum wieder zu aktivieren. Die Funktionen sind mit einem aus einer Zeichenfolge bestehenden Tag gekennzeichnet und die Funktionen, die den Tags in der Liste entsprechen, welche durch diese Richtlinie festgelegt wurde, werden wieder aktiviert.

      Zurzeit sind folgende Tags definiert:
      - ShowModalDialog_EffectiveUntil20150430

      Falls diese Richtlinie nicht konfiguriert oder die Liste leer ist, bleiben alle veralteten Webplattformfunktionen deaktiviert.</translation>
<translation id="3805659594028420438">Erweiterung für domaingebundene TLS-Zertifikate aktivieren (veraltet)</translation>
<translation id="5499375345075963939">Diese Richtlinie ist nur im Händlermodus aktiv.

      Wenn für diese Richtlinie ein Wert festgelegt wurde und dieser Wert nicht &quot;0&quot; ist, wird der aktuell angemeldete Demo-Nutzer nach der angegebenen Inaktivitätsdauer automatisch abgemeldet.

      Der Wert sollte in Millisekunden angegeben werden.</translation>
<translation id="7683777542468165012">Dynamische Richtlinienaktualisierung</translation>
<translation id="1160939557934457296">Fortfahren von der Safe Browsing-Hinweisseite deaktivieren</translation>
<translation id="8987262643142408725">SSL Record Splitting deaktivieren</translation>
<translation id="4529945827292143461">Zur Anpassung der Liste mit URL-Mustern, die immer vom Hostbrowser gerendert werden müssen. Wenn diese Richtlinie nicht konfiguriert ist, so kommt der über die Richtlinie &quot;ChromeFrameRendererSettings&quot; festgelegte Standard-Renderer zum Einsatz. Beispielmuster finden Sie unter http://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="8044493735196713914">Startmodus von Geräten melden</translation>
<translation id="2746016768603629042">Diese Richtlinie ist veraltet, verwenden Sie stattdessen &quot;DefaultJavaScriptSetting&quot;.

      Hiermit kann JavaScript in <ph name="PRODUCT_NAME"/> deaktiviert werden.

      Wird diese Einstellung deaktiviert, können Webseiten kein JavaScript verwenden und der Nutzer kann diese Einstellung nicht ändern.

      Ist diese Einstellung aktiviert oder nicht definiert, können Webseiten JavaScript verwenden, wobei der Nutzer diese Einstellung jedoch ändern kann.</translation>
<translation id="1942957375738056236">Hier können Sie die URL des Proxyservers angeben. Die Richtlinie tritt nur dann in Kraft, wenn bei &quot;Auswählen, wie Proxyserver-Einstellungen angegeben werden&quot; manuelle Proxy-Einstellungen festgelegt wurden. Sie sollten diese Richtlinie nicht konfigurieren, wenn Sie eine andere Methode zur Festlegung der Proxy-Richtlinien ausgewählt haben. Weitere Optionen und ausführliche Beispiele finden Sie unter <ph name="PROXY_HELP_URL"/>.</translation>
<translation id="6076008833763548615">Deaktiviert die Bereitstellung von externem Speicher.

      Wenn diese Richtlinie auf &quot;True&quot; gesetzt ist, ist im Datei-Browser kein externer Speicher verfügbar.

      Diese Richtlinie gilt für alle Arten von Speichermedien, wie USB-Speichersticks, externe Festplatten, SD-Karten und andere Speicherkarten sowie optische Speichermedien. Der interne Speicher ist nicht betroffen, im Download-Ordner gespeicherte Dateien können darum weiterhin abgerufen werden. Diese Richtlinie hat ebenfalls keine Auswirkungen auf Google Drive.

      Ist diese Einstellung deaktiviert oder nicht konfiguriert, können die Nutzer alle unterstützten externen Speichermedien auf ihrem Gerät verwenden.</translation>
<translation id="6936894225179401731">Legt die maximale Anzahl gleichzeitiger Verbindungen zum Proxyserver fest.

      Einige Proxyserver können eine hohe Anzahl gleichzeitiger Verbindungen pro Client nicht verarbeiten. Dieses Problem kann umgangen werden, indem für diese Richtlinie ein niedrigerer Wert festgelegt wird.

      Der Wert sollte kleiner als 100 und größer als 6 sein. Der Standardwert beträgt 32.

      Einige Web-Apps nutzen viele Verbindungen mit hängenden GETs. Daher kann ein Wert unter 32 dazu führen, dass der Browser hängt, wenn zu viele solcher Web-Apps geöffnet sind. Wenn Sie einen Wert unter dem Standardwert festlegen, geschieht dies auf eigenes Risiko.

      Ist diese Richtlinie nicht konfiguriert, so kommt der Standardwert von 32 zum Einsatz.</translation>
<translation id="5395271912574071439">Aktiviert die Zugangsbeschränkung für Remote-Zugriff-Hosts bei bestehender Verbindung

          Wenn diese Einstellung aktiviert ist, werden die physischen Ein- und Ausgabegeräte des Hosts bei bestehender Remote-Verbindung deaktiviert.

          Wenn diese Einstellung deaktiviert oder nicht festgelegt ist, können lokale und Remote-Nutzer mit dem Host interagieren, sofern dieser freigegeben ist.</translation>
<translation id="2488010520405124654">Aktivierung der Eingabeaufforderung zur Netzwerkkonfiguration im Offlinemodus

      Wenn diese Richtlinie nicht festgelegt oder auf &quot;True&quot; gesetzt ist und ein lokales Gerätekonto für die automatische Anmeldung ohne Verzögerung konfiguriert ist, aber kein Zugang zum Internet besteht, zeigt <ph name="PRODUCT_OS_NAME"/> eine Eingabeaufforderung zur Netzwerkkonfiguration an.

      Ist diese Richtlinie auf &quot;False&quot; gesetzt, wird anstelle der Eingabeaufforderung zur Netzwerkkonfiguration eine Fehlermeldung angezeigt.</translation>
<translation id="1426410128494586442">Ja</translation>
<translation id="4897928009230106190">Gibt die Parameter für die Vorschlagsuche mit POST an. Sie besteht aus durch Komma getrennten Name/Wert-Paaren. Wenn ein Wert ein Vorlagenparameter wie z. B. {searchTerms} im obigen Beispiel ist, wird er durch echte Suchbegriffsdaten ersetzt.

          Diese Richtlinie ist optional. Wenn sie nicht festlegt ist, wird die Vorschlagsuchanfrage mithilfe der GET-Methode gesendet.

          Diese Richtlinie wird nur berücksichtigt, wenn die Richtlinie &quot;DefaultSearchProviderEnabled&quot; aktiviert ist.</translation>
<translation id="8140204717286305802">Meldet eine Liste der Netzwerkschnittstellen mit deren Typen und Hardwareadressen an den Server

      Wird die Richtlinie auf &quot;False&quot; gesetzt, wird die Liste der Netzwerkschnittstellen nicht gemeldet.</translation>
<translation id="4962195944157514011">Gibt die URL einer Suchmaschine an, die für Standardsuchanfragen zum Einsatz kommt. Die URL sollte den String &quot;<ph name="SEARCH_TERM_MARKER"/>&quot; enthalten. Dieser wird bei der Suchanfrage mit dem Text ersetzt, nach dem der Nutzer sucht. Diese Option muss konfiguriert werden, wenn die Richtlinie &quot;DefaultSearchProviderEnabled&quot; aktiviert ist, und wird nur dann beachtet, wenn das der Fall ist.</translation>
<translation id="6009903244351574348"><ph name="PRODUCT_FRAME_NAME"/> erlauben, die gelisteten Inhaltstypen zu verarbeiten. Wenn diese Richtlinie nicht konfiguriert ist, so kommt der Standard-Renderer für alle Websites gemäß der Richtlinie &quot;ChromeFrameRendererSettings&quot; zum Einsatz.</translation>
<translation id="3381968327636295719">Standardmäßig Host-Browser verwenden</translation>
<translation id="3627678165642179114">Webdienst für die Rechtschreibprüfung aktivieren oder deaktivieren</translation>
<translation id="6520802717075138474">Suchmaschinen bei erster Ausführung aus Standardbrowser importieren</translation>
<translation id="4039085364173654945">Bestimmt, ob untergeordnete Inhalte von Drittanbietern auf einer Seite in einem HTTP-Basic-Authentifizierungs-Pop-up erscheinen dürfen. In der Regel ist dies zur Abwehr gegen Phishing deaktiviert. Wenn die Richtlinie nicht konfiguriert ist, so ist die Einstellung standardmäßig deaktiviert, sodass untergeordnete Inhalte von Drittanbietern nicht in einem HTTP-Basic-Authentifizierungs-Pop-up erscheinen dürfen.</translation>
<translation id="4946368175977216944">Hiermit werden die Parameter angegeben, die beim Starten von Chrome angewendet werden sollen. Sie gelten bereits vor dem eigentlichen Starten von Chrome, also auch für den Anmeldebildschirm.</translation>
<translation id="7447786363267535722">Aktiviert das Speichern von Passwörtern und die Verwendung gespeicherter Passwörter in <ph name="PRODUCT_NAME"/>. Wenn Sie diese Einstellung aktivieren, können Nutzer <ph name="PRODUCT_NAME"/> dazu anweisen, sich Passwörter zu merken und das nächste Mal, wenn sie sich in einer Website anmelden möchten, zur Verfügung zu stellen. Sollten Sie die Einstellung deaktivieren, können Nutzer keine Passwörter speichern und bereits gespeicherte Passwörter nicht verwenden. Ist diese Einstellung aktiviert oder deaktiviert, können Nutzer sie in <ph name="PRODUCT_NAME"/> nicht ändern oder außer Kraft setzen. Sollte die Richtlinie nicht konfiguriert sein, so wird sie aktiviert, kann aber vom Nutzer deaktiviert werden.</translation>
<translation id="1138294736309071213">Diese Richtlinie ist nur im Händlermodus aktiv.

      Legt fest, wie lange es dauert, bis für Geräte im Händlermodus der Bildschirmschoner auf der Anmeldeseite erscheint.

      Der Wert für die Richtlinie sollte in Millisekunden angegeben werden.</translation>
<translation id="6368011194414932347">Startseiten-URL konfigurieren</translation>
<translation id="2877225735001246144">CNAME-Suche bei der Aushandlung der Kerberos-Authentifizierung deaktivieren</translation>
<translation id="9120299024216374976">Mit dieser Richtlinie wird die für das Gerät zu verwendende Zeitzone festgelegt. Die Nutzer können die festgelegte Zeitzone für die aktuelle Sitzung außer Kraft setzen. Sobald sie sich abmelden, wird die Zeitzone jedoch wieder auf die festgelegte Einstellung zurückgesetzt. Bei Angabe eines ungültigen Werts greift die Richtlinie weiterhin und es wird stattdessen &quot;GMT&quot; verwendet.

      Wird die Richtlinie nicht angewendet, wird die derzeit aktive Zeitzone verwendet. Allerdings können die Nutzer die Zeitzone dann ändern und die Änderung wird beibehalten. Die Änderung durch einen Nutzer wirkt sich dann auf die Anmeldeseite und die Einstellungen für alle Nutzer aus.

      Bei neuen Geräten ist die Zeitzone &quot;US/Pacific Time&quot; voreingestellt.

      Das Format des Werts entspricht den Namen der Zeitzonen in der &quot;IANA Time Zone Database&quot; (siehe &quot;http://en.wikipedia.org/wiki/List_of_tz_database_time_zones&quot;). Auf die meisten Zeitzonen kann über &quot;Kontinent/Stadt&quot; oder &quot;Ozean/Stadt&quot; verwiesen werden.</translation>
<translation id="3646859102161347133">Lupentyp festlegen</translation>
<translation id="3528000905991875314">Alternative Fehlerseiten aktivieren</translation>
<translation id="1283072268083088623">Gibt an, welche HTTP-Authentifizierungsschemas von <ph name="PRODUCT_NAME"/> unterstützt werden. Mögliche Werte sind &quot;basic&quot;, &quot;digest&quot;, &quot;ntlm&quot; und &quot;negotiate&quot;. Trennen Sie mehrere Werte durch Kommas. Wenn diese Richtlinie nicht konfiguriert ist, so kommen alle vier Schemas zum Einsatz.</translation>
<translation id="1017967144265860778">Energieverwaltung auf dem Anmeldebildschirm</translation>
<translation id="4914647484900375533">Hiermit wird die Instant-Funktion von <ph name="PRODUCT_NAME"/> aktiviert und verhindert, dass Nutzer diese Einstellung ändern können.

      Wenn Sie diese Einstellung aktivieren, ist <ph name="PRODUCT_NAME"/> Instant aktiviert.

      Wenn Sie diese Einstellung deaktivieren, ist <ph name="PRODUCT_NAME"/> Instant deaktiviert.

      Falls Sie diese Einstellung aktivieren oder deaktivieren, können die Nutzer die Einstellung nicht ändern oder außer Kraft setzen.

      Wird diese Einstellung nicht konfiguriert, können die Nutzer entscheiden, ob sie die Funktion verwenden möchten.

      Diese Einstellung ist ab Chrome-Version 29 nicht mehr vorhanden.</translation>
<translation id="6114416803310251055">Veraltet</translation>
<translation id="8493645415242333585">Speichern des Browserverlaufs deaktivieren</translation>
<translation id="2747783890942882652">Konfiguriert den erforderlichen Domain-Namen der Hosts für den Remote-Zugriff und verhindert, dass dieser von Nutzern geändert werden kann.

          Wenn diese Einstellung aktiviert ist, können Hosts nur über Konten gemeinsam genutzt werden, die unter dem angegebenen Domain-Namen registriert sind.

          Ist diese Einstellung deaktiviert oder nicht festgelegt, können Hosts über alle Konten gemeinsam genutzt werden.</translation>
<translation id="6417861582779909667">Ermöglicht die Zusammenstellung einer Liste mit URL-Mustern, die Websites angeben, die keine Cookies speichern dürfen. Wenn diese Richtlinie nicht konfiguriert ist, so kommt für alle Websites der globale Standardwert der Richtlinie &quot;DefaultCookiesSetting&quot;, sofern konfiguriert, oder der persönlichen Konfiguration des Nutzers zum Einsatz.</translation>
<translation id="5776485039795852974">Nachfragen, wenn eine Website Desktop-Benachrichtigungen anzeigen will</translation>
<translation id="5047604665028708335">Zugriff auf Websites außerhalb von Inhaltspaketen erlauben</translation>
<translation id="5052081091120171147">Diese Richtlinie erzwingt, sofern aktiv, den Import des Browserverlaufs aus dem aktuellen Standardbrowser. Ist die Richtlinie aktiviert, wirkt sie sich auch auf den Importdialog aus. Wenn sie deaktiviert ist, erfolgt kein Import des Browserverlaufs. Sollte sie nicht konfiguriert sein, so wird der Nutzer möglicherweise gefragt, ob ein Import erfolgen soll, oder der Import findet automatisch statt.</translation>
<translation id="6786747875388722282">Erweiterungen</translation>
<translation id="7132877481099023201">URLs, denen ohne Nachfrage Zugriff auf Videoaufnahmegeräte gestattet wird</translation>
<translation id="8947415621777543415">Gerätestandort melden</translation>
<translation id="1655229863189977773">Cache-Größe für Datenträger in Byte festlegen</translation>
<translation id="3358275192586364144">Aktiviert in <ph name="PRODUCT_NAME"/> die WPAD-Optimierung und verhindert, dass Nutzer die Einstellung ändern.

      Bei Aktivierung werden die Intervalle verkürzt, in denen Chrome auf DNS-basierte WPAD-Server wartet.

      Wenn für diese Richtlinie keine Einstellung festgelegt wird, wird sie aktiviert und
      kann vom Nutzer nicht geändert werden.</translation>
<translation id="6376842084200599664">Ermöglicht Ihnen, eine Liste mit Erweiterungen festzulegen, die im Hintergrund, d. h. ohne Nutzerinteraktion, installiert werden.

          Jedes Element der Liste ist ein String, der eine Erweiterungs-ID und eine Update-URL enthält, die durch ein Semikolon (<ph name="SEMICOLON"/>) getrennt sind. Die Erweiterungs-ID ist der 32-stellige String, der z. B. im Entwicklermodus in <ph name="CHROME_EXTENSIONS_LINK"/> vorkommt. Die Update-URL sollte auf ein XML-Dokument mit einem Update-Manifest verweisen, wie in <ph name="LINK_TO_EXTENSION_DOC1"/> beschrieben. Beachten Sie, dass die in dieser Richtlinie festgelegte Update-URL nur für die anfängliche Installation verwendet wird. Bei anschließenden Aktualisierungen der Erweiterung wird die im Manifest der Erweiterung angegebene Update-URL verwendet.

          <ph name="PRODUCT_NAME"/> ruft für jedes Element die in der Erweiterungs-ID angegebene Erweiterung beim Update-Dienst unter der angegebenen Update-URL ab und installiert diese im Hintergrund.

          So installiert <ph name="EXTENSION_POLICY_EXAMPLE"/> beispielsweise die Erweiterung <ph name="EXTENSION_POLICY_EXAMPLE_EXTENSION_NAME"/> über die standardmäßige Update-URL des Chrome Web Stores. Weitere Informationen zum Hosten von Erweiterungen finden Sie unter <ph name="LINK_TO_EXTENSION_DOC2"/>.

          Nutzer können die von dieser Richtlinie festgelegten Erweiterungen nicht deinstallieren. Wenn Sie eine Erweiterung aus dieser Liste entfernen, wird diese automatisch von <ph name="PRODUCT_NAME"/> deinstalliert. Die in dieser Liste aufgeführten Erweiterungen werden zudem automatisch in die Whitelist für die Installation aufgenommen. Die &quot;ExtensionsInstallBlacklist&quot; hat auf sie keinen Einfluss.

          Bleibt diese Richtlinie unkonfiguriert, kann der Nutzer jede Erweiterung in <ph name="PRODUCT_NAME"/> deinstallieren.</translation>
<translation id="6899705656741990703">Proxy-Einstellungen automatisch erkennen</translation>
<translation id="4639407427807680016">Namen der Hosts für natives Messaging, die von der schwarzen Liste ausgenommen werden sollen</translation>
<translation id="8382184662529825177">Verwendung von Remote-Bescheinigung (Remote Attestation) zum Schutz von Inhalten für das Gerät aktivieren</translation>
<translation id="7003334574344702284">Diese Richtlinie erzwingt, sofern aktiv, den Import von gespeicherten Passwörtern aus dem vorherigen Standardbrowser. Bei einer Aktivierung wirkt sich die Richtlinie auch auf den Importdialog aus. Wenn sie deaktiviert ist, erfolgt kein Import der gespeicherten Passwörter. Sollte sie nicht konfiguriert sein, so wird der Nutzer möglicherweise gefragt, ob ein Import erfolgen soll, oder der Import findet automatisch statt.</translation>
<translation id="6258193603492867656">Gibt an, ob der generierte Kerberos-SPN einen Nicht-Standard-Port umfassen soll. Falls Sie diese Einstellung aktivieren und ein Nicht-Standard-Port (ein anderer Port als 80 oder 443) eingegeben wird, wird dieser in den generierten Kerberos-SPN aufgenommen. Wenn Sie diese Einstellung deaktivieren oder nicht konfigurieren, umfasst der generierte Kerberos-SPN in keinem Fall einen Port.</translation>
<translation id="3236046242843493070">URL-Muster für die Installation von Erweiterungen, Apps und Nutzerskripten von</translation>
<translation id="2498238926436517902">Ablage immer automatisch ausblenden</translation>
<translation id="253135976343875019">Inaktivitätsspanne bis zur Warnung im Netzbetrieb</translation>
<translation id="480987484799365700">Bei Aktivierung erzwingt diese Richtlinie die Nutzung von sitzungsspezifischen Profilen. Falls diese Richtlinie als BS-Richtlinie angegeben wird (wie GPO unter Windows), gilt sie für jedes Profil im System. Wird sie hingegen als Cloud-Richtlinie festgelegt, gilt sie nur für ein bei einem verwalteten Konto angemeldetes Profil.

      In diesem Modus werden die Profildaten nur für die Dauer der Nutzersitzung auf der Festplatte behalten. Elemente wie der Browserverlauf, Erweiterungen und ihre Daten, Webdaten wie Cookies und Webdatenbanken werden nach dem Schließen des Browsers nicht beibehalten. Dies hindert den Nutzer jedoch nicht daran, Daten manuell auf die Festplatte herunterzuladen, Seiten zu speichern oder zu drucken.

      Wenn der Nutzer die Synchronisierung aktiviert hat, werden alle diese Daten wie bei regulären Profilen in seinem Synchronisierungsprofil beibehalten. Der Inkognito-Modus ist ebenfalls verfügbar, sofern er nicht durch die Richtlinie explizit deaktiviert wird.

      Falls die Richtlinie deaktiviert oder nicht eingestellt wird, werden bei einer Anmeldung reguläre Profile erstellt.</translation>
<translation id="6997592395211691850">Gibt an, ob für lokale Vertrauensanker Online-OCSP/CRLS-Prüfungen erforderlich sind</translation>
<translation id="152657506688053119">Liste alternativer URLs für den Standardsuchanbieter</translation>
<translation id="8992176907758534924">Anzeige von Bildern für alle Websites blockieren</translation>
<translation id="262740370354162807">Senden von Dokumenten an <ph name="CLOUD_PRINT_NAME"/> aktivieren</translation>
<translation id="7717938661004793600">Hiermit konfigurieren Sie die Zugänglichkeitsfunktionen für <ph name="PRODUCT_OS_NAME"/>.</translation>
<translation id="5182055907976889880">Google Drive in <ph name="PRODUCT_OS_NAME"/> konfigurieren</translation>
<translation id="8704831857353097849">Liste der deaktivierten Plug-ins</translation>
<translation id="467449052039111439">URL-Liste öffnen</translation>
<translation id="1988371335297483117">Die Nutzdaten automatischer Updates von <ph name="PRODUCT_OS_NAME"/> können über HTTP statt über HTTPS heruntergeladen werden. Dadurch wird transparentes HTTP-Caching von HTTP-Downloads zugelassen.

      Ist diese Richtlinie auf &quot;true&quot; gesetzt, versucht <ph name="PRODUCT_OS_NAME"/>, die Nutzdaten automatischer Updates über HTTP herunterzuladen. Ist die Richtlinie auf &quot;false&quot; gesetzt oder nicht festgelegt, wird für solche Downloads HTTPS verwendet.</translation>
<translation id="5883015257301027298">Standardeinstellungen für Cookies</translation>
<translation id="5017500084427291117">Blockiert den Zugriff auf die aufgeführten URLs.

      Diese Richtlinie verhindert, dass Nutzer Webseiten von URLs von der schwarzen Liste laden.

      Eine URL weist das Format &quot;scheme://host:port/path&quot; auf.
      Das optionale Schema kann HTTP, HTTPS und FTP sein. Nur dieses Schema wird blockiert. Wurde kein Schema festgelegt, werden alle blockiert.
      Beim Host kann es sich um einen Hostnamen oder eine IP-Adresse handeln. Die Sub-Domains eines Hostnamens werden ebenfalls blockiert. Fügen Sie vor dem Hostnamen einen Punkt (&quot;.&quot;) ein, damit keine Sub-Domains blockiert werden. Der Hostname &quot;*&quot; blockiert alle Domains.
      Der optionale Port besteht aus einer gültigen Portnummer zwischen 1 und 65535. Wurde kein Port ausgewählt, werden alle blockiert.
      Wenn der optionale Pfad festgelegt wurde, werden nur Pfade mit diesem Präfix blockiert.

      Ausnahmen können in der Richtlinie für die weiße URL-Liste festgelegt werden. Diese Richtlinien sind auf 1000 Einträge begrenzt. Darüber hinausgehende Einträge werden ignoriert.

      Bleibt diese Richtlinie unkonfiguriert, werden im Browser keine URLs zur schwarzen Liste hinzugefügt.</translation>
<translation id="2762164719979766599">Gibt die Liste der lokalen Gerätekonten an, die auf der Anmeldeseite angezeigt werden sollen.

      Jeder Listeneintrag besteht aus einer Kennung, die intern dazu verwendet wird, die verschiedenen lokalen Gerätekonten auseinanderzuhalten.</translation>
<translation id="8955719471735800169">Zurück nach oben</translation>
<translation id="4557134566541205630">Standardsuchanbieter-URL für die &quot;Neuer Tab&quot;-Seite</translation>
<translation id="546726650689747237">Verzögerung für die Bildschirmabdunkelung im Netzbetrieb</translation>
<translation id="4988291787868618635">Auszuführende Aktion bei Erreichen der Inaktivitätsverzögerung</translation>
<translation id="7260277299188117560">P2P für automatische Updates aktivieren</translation>
<translation id="5316405756476735914">Ermöglicht Ihnen festzulegen, ob Websites lokale Daten speichern dürfen. Das Speichern lokaler Daten kann entweder allen Websites gestattet oder für alle unterbunden werden. Wenn diese Richtlinie nicht konfiguriert ist, so wird &quot;AllowCookies&quot; verwendet, wobei der Nutzer dies ändern kann.</translation>
<translation id="4250680216510889253">Nein</translation>
<translation id="1522425503138261032">Ermittlung des physischen Standorts des Nutzers durch Websites zulassen</translation>
<translation id="6467433935902485842">Ermöglicht Ihnen die Zusammenstellung einer Liste mit URL-Mustern, die Websites angeben, denen das Ausführen von Plug-ins nicht gestattet ist. Wenn diese Richtlinie nicht konfiguriert ist, kommt für alle Websites entweder der globale Standardwert der Richtlinie &quot;DefaultPluginsSetting&quot;, sofern konfiguriert, oder der persönlichen Konfiguration des Nutzers zu Einsatz.</translation>
<translation id="4423597592074154136">Proxy-Einstellungen manuell angeben</translation>
<translation id="209586405398070749">Stabiler Kanal</translation>
<translation id="8170878842291747619">Aktiviert den integrierten Google Übersetzer-Dienst in <ph name="PRODUCT_NAME"/>. Wenn Sie diese Einstellung aktivieren, so wird in <ph name="PRODUCT_NAME"/> eine integrierte Symbolleiste angezeigt, über die Nutzer die Seite bei Bedarf übersetzen lassen können. Sollten Sie diese Einstellung deaktivieren, erscheint die Übersetzungsleiste grundsätzlich nicht. Das Aktivieren und Deaktivieren dieser Einstellung führt dazu, dass Nutzer diese Einstellung in <ph name="PRODUCT_NAME"/> nicht ändern oder außer Kraft setzen können. Wenn die Einstellung nicht konfiguriert ist, so kann der Nutzer entscheiden, ob er die Funktion in Anspruch nehmen möchte.</translation>
<translation id="9035964157729712237">Aus der schwarzen Liste auszuschließende Erweiterungs-IDs</translation>
<translation id="8244525275280476362">Maximale Abrufverzögerung nach der Außerkraftsetzung einer Richtlinie</translation>
<translation id="8587229956764455752">Erstellung neuer Nutzerkonten erlauben</translation>
<translation id="7417972229667085380">Prozentsatz für die Skalierung der Inaktivitätsspanne im Präsentationsmodus (veraltet)</translation>
<translation id="6211428344788340116">Meldet die Aktivitätszeiten des Geräts

      Wird diese Einstellung nicht konfiguriert oder auf &quot;True&quot; gesetzt, melden registrierte Geräte die Zeiträume, in denen ein Nutzer auf dem Gerät aktiv ist. Wird für diese Einstellung &quot;False&quot; festgelegt, werden die Geräteaktivitätszeiten weder aufgezeichnet noch gemeldet.</translation>
<translation id="3964909636571393861">Zugriff auf aufgelistete URLs gewähren</translation>
<translation id="1811270320106005269">Ermöglicht das Sperren von Geräten, wenn ein <ph name="PRODUCT_OS_NAME"/>-Gerät inaktiv ist oder angehalten wird.

      Wenn Sie diese Einstellung aktivieren, werden Nutzer nach einem Passwort gefragt, um das Gerät aus dem Ruhemodus zu reaktivieren.

      Bei Deaktivierung dieser Einstellung müssen Nutzer kein Passwort eingeben, um das Gerät aus dem Ruhemodus zu reaktivieren.

      Sobald diese Einstellung aktiviert oder deaktiviert ist, können Nutzer sie nicht ändern oder außer Kraft setzen.

      Ist die Richtlinie nicht konfiguriert, kann der Nutzer bestimmen, ob eine Passwortabfrage zum Reaktivieren des Geräts notwendig sein soll.</translation>
<translation id="383466854578875212">Ermöglicht Ihnen, anzugeben, welche Hosts für natives Messaging nicht in die schwarze Liste aufgenommen werden sollen

          Der Wert &quot;*&quot; für die schwarze Liste bedeutet, dass alle Hosts für natives Messaging in die schwarze Liste aufgenommen werden und dass nur Hosts für natives Messaging geladen werden, die auf der weißen Liste stehen.

          Standardmäßig stehen alle Hosts für natives Messaging auf der weißen Liste. Wenn jedoch alle Hosts für natives Messaging durch eine Richtlinie zur schwarzen Liste hinzugefügt wurden, kann diese Richtlinie mithilfe der weißen Liste außer Kraft gesetzt werden.</translation>
<translation id="6022948604095165524">Aktion beim Start</translation>
<translation id="9042911395677044526">Ermöglicht das Übernehmen einer per Push übertragenen Netzwerkkonfiguration pro Nutzer für ein <ph name="PRODUCT_OS_NAME"/>-Gerät. Die Netzwerkkonfiguration ist ein JSON-formatierter String, der den Open Network Configuration-Vorgaben unter <ph name="ONC_SPEC_URL"/> entspricht.</translation>
<translation id="7128918109610518786">Listet die App-IDs auf, die unter <ph name="PRODUCT_OS_NAME"/> in der Übersichtsleiste als in der Übersicht angezeigte Apps erscheinen.

      Wenn diese Richtlinie konfiguriert wird, werden diese Apps festgelegt und können von Nutzern nicht geändert werden.

      Wird diese Richtlinie nicht konfiguriert, können Nutzer die Liste der in der Übersicht angezeigten Apps ändern.</translation>
<translation id="1679420586049708690">Öffentliche Sitzung für automatische Anmeldung</translation>
<translation id="5836064773277134605">Vom Host für den Remote-Zugriff verwendeten UDP-Portbereich einschränken</translation>
<translation id="7625444193696794922">Gibt den Release-Kanal an, an den dieses Gerät gebunden werden soll.</translation>
<translation id="2552966063069741410">Zeitzone</translation>
<translation id="3788662722837364290">Einstellungen für die Energieverwaltung bei Inaktivität des Nutzers</translation>
<translation id="2240879329269430151">Ermöglicht Ihnen zu bestimmen, ob Websites Pop-ups anzeigen dürfen. Das Anzeigen von Pop-ups kann entweder allen Websites gestattet oder für alle unterbunden werden. Wenn diese Richtlinie nicht konfiguriert ist, so kommt &quot;BlockPopups&quot; zum Einsatz, wobei der Nutzer dies ändern kann.</translation>
<translation id="2529700525201305165">Für die Anmeldung in <ph name="PRODUCT_NAME"/> zugelassene Nutzer einschränken</translation>
<translation id="8971221018777092728">Zeitspanne für automatische Anmeldung in öffentlicher Sitzung</translation>
<translation id="8285435910062771358">Vollbildlupe aktiviert</translation>
<translation id="5141670636904227950">Standardtyp für die Lupe festlegen, die auf der Anmeldeseite aktiviert ist</translation>
<translation id="3864818549971490907">Standardeinstellung für Plug-ins</translation>
<translation id="7151201297958662315">Legt fest, ob ein <ph name="PRODUCT_NAME"/>-Prozess bei der Anmeldung im Betriebssystem gestartet und nach dem Schließen des letzten Browserfensters weiterhin ausgeführt werden soll. Auf diese Weise können Apps im Hintergrund aktiv bleiben. Beim Ausführen eines Hintergrundprozesses erscheint ein Symbol in der Taskleiste, über das er jederzeit beendet werden kann.

      Wenn diese Richtlinie auf &quot;true&quot; gesetzt ist, ist der Hintergrundmodus aktiviert und kann nicht vom Nutzer in den Browsereinstellungen geändert werden.

      Bei Festlegung auf &quot;false&quot; ist der Hintergrundmodus deaktiviert und kann ebenfalls nicht vom Nutzer in den Browsereinstellungen geändert werden.

      Ist die Richtlinie nicht konfiguriert, ist der Hintergrundmodus zunächst deaktiviert, kann aber vom Nutzer in den Browsereinstellungen geändert werden.</translation>
<translation id="4320376026953250541">Microsoft Windows XP SP2 oder höher</translation>
<translation id="5148753489738115745">Ermöglicht die Verwendung zusätzlicher Parameter, die beim Start von <ph name="PRODUCT_NAME"/> durch <ph name="PRODUCT_FRAME_NAME"/> eingesetzt werden.

          Wenn diese Richtlinie nicht festgelegt wird, wird die Standardbefehlszeile verwendet.</translation>
<translation id="2646290749315461919">Ermöglicht Ihnen festzulegen, ob Websites den Standort des Nutzers mitverfolgen dürfen. Die Mitverfolgung des Standorts kann standardmäßig gestattet oder nicht gestattet sein oder auf Anfrage beim Nutzer erfolgen. Wenn diese Richtlinie nicht konfiguriert ist, so kommt &quot;AskGeolocation&quot; zum Einsatz, wobei der Nutzer dies ändern kann.</translation>
<translation id="6394350458541421998">Diese Richtlinie ist ab <ph name="PRODUCT_OS_NAME"/>-Version 29 nicht mehr vorhanden. Verwenden Sie stattdessen die Richtlinie &quot;PresentationScreenDimDelayScale&quot;.</translation>
<translation id="2956777931324644324">Diese Richtlinie wird seit <ph name="PRODUCT_NAME"/> Version 36 nicht mehr verwendet.

      Sie legt fest, ob die Erweiterung für domaingebundene TLS-Zertifikate aktiviert werden soll.

      Anhand dieser Einstellung wird die Erweiterung für domaingebundene TLS-Zertifikate zu Testzwecken aktiviert. Diese experimentelle Einstellung wird in absehbarer Zukunft entfernt.</translation>
<translation id="5770738360657678870">Entwicklerkanal (möglicherweise nicht stabil)</translation>
<translation id="2959898425599642200">Proxy-Umgehungsregeln</translation>
<translation id="228659285074633994">Diese Richtlinie gibt an, nach welcher Inaktivitätsspanne des Nutzers im Netzbetrieb eine Warnmeldung angezeigt wird.

          Wird diese Richtlinie festgelegt, gibt sie an, wie lange der Nutzer inaktiv sein kann, bevor <ph name="PRODUCT_OS_NAME"/> in einer Warnung auf die bevorstehende Maßnahme hinweist.

          Wird diese Richtlinie nicht festgelegt, erscheint keine Warnung.

          Geben Sie den Richtlinienwert in Millisekunden an. Solange die Inaktivitätsspanne kleiner oder gleich diesem festgelegten Wert ist, erscheint keine Warnung.</translation>
<translation id="1327466551276625742">Eingabeaufforderung zur Netzwerkkonfiguration im Offlinemodus aktivieren</translation>
<translation id="7937766917976512374">Videoaufzeichnung gestatten oder ablehnen</translation>
<translation id="427632463972968153">Gibt die Parameter für die Bildsuche mit POST an. Sie besteht aus durch Komma getrennten Name/Wert-Paaren. Wenn ein Wert ein Vorlagenparameter wie z. B. {imageThumbnail} im obigen Beispiel ist, wird er durch echte Miniaturansichtsdaten ersetzt.

          Diese Richtlinie ist optional. Wenn sie nicht festlegt ist, wird die Bildsuchanfrage mithilfe der GET-Methode gesendet.

          Diese Richtlinie wird nur berücksichtigt, wenn die Richtlinie &quot;DefaultSearchProviderEnabled&quot; aktiviert ist.</translation>
<translation id="8818646462962777576">Muster in dieser Liste werden mit der Sicherheitsherkunft
      der anfragenden URL abgeglichen. Bei einer Übereinstimmung wird der Zugriff
      auf Audioaufnahmegeräte ohne Nachfrage gestattet.

      Hinweis: Diese Richtlinie wird derzeit nur im Kioskmodus unterstützt.</translation>
<translation id="489803897780524242">Parameter zur Steuerung der Suchbegriffersetzung für den Standardsuchanbieter</translation>
<translation id="316778957754360075">Diese Einstellung wird ab <ph name="PRODUCT_NAME"/>-Version 29 nicht mehr verwendet. Zur Einrichtung einer Sammlung mit Erweiterungen oder Apps, die von der Organisation gehostet wird, empfehlen wir, die Host-Website der CRX-Pakete in &quot;ExtensionInstallSources&quot; einzufügen und auf einer Webseite direkte Downloadlinks zu den Paketen bereitzustellen. Ein Launcher für diese Webseite kann mithilfe der Richtlinie &quot;ExtensionInstallForcelist&quot; erstellt werden.</translation>
<translation id="6401669939808766804">Nutzer abmelden</translation>
<translation id="4826326557828204741">Auszuführende Aktion beim Erreichen der Leerlaufverzögerung während des Akkubetriebs</translation>
<translation id="7912255076272890813">Zulässige App- bzw. Erweiterungstypen konfigurieren</translation>
<translation id="817455428376641507">Erlaubt den Zugriff auf die aufgeführten URLs als Ausnahmen von der schwarzen URL-Liste.

      Informationen zum Format der Einträge in dieser Liste finden Sie in der Beschreibung der Richtlinie für die schwarze URL-Liste.

      Mithilfe dieser Richtlinie können Ausnahmen von restriktiven schwarzen Listen geöffnet werden. So können beispielsweise mit &quot;*&quot; alle Anfragen blockiert werden, während mit dieser Richtlinie der Zugriff auf eine eingeschränkte Liste von URLs erlaubt werden kann. Hiermit können Ausnahmen von bestimmten Schemata, Sub-Domains anderer Domains, Ports oder bestimmten Pfaden geöffnet werden.

      Der spezifischste Filter bestimmt, ob eine URL blockiert oder erlaubt ist. Die Whitelist hat Vorrang vor der schwarzen Liste.

      Diese Richtlinie ist auf 1000 Einträge beschränkt. Alle weiteren Einträge werden ignoriert.

      Bleibt diese Richtlinie unkonfiguriert, gibt es keine Ausnahmen von der schwarzen Liste aus der Richtlinie &quot;URLBlacklist&quot;.</translation>
<translation id="8148901634826284024">Hiermit wird die Bedienungshilfefunktion für den Modus mit hohem Kontrast aktiviert.

          Ist diese Richtlinie auf &quot;true&quot; gesetzt, ist der Modus mit hohem Kontrast immer aktiviert.

          Ist diese Richtlinie auf &quot;false&quot; gesetzt, ist der Modus mit hohem Kontrast immer deaktiviert.

          Wenn Sie diese Richtlinie konfigurieren, können die Nutzer sie nicht ändern oder außer Kraft setzen.

          Wird die Richtlinie nicht konfiguriert, ist der Modus mit hohem Kontrast zunächst deaktiviert, kann aber von den Nutzern jederzeit aktiviert werden.</translation>
<translation id="2201555246697292490">Weiße Liste für natives Messaging konfigurieren</translation>
<translation id="6177482277304066047">Legt eine Zielversion für automatische Aktualisierungen fest.

      Gibt das Präfix einer Zielversion an, auf die <ph name="PRODUCT_OS_NAME"/> aktualisiert werden soll. Wenn das Gerät eine niedrigere Version als im Präfix festgelegt ausführt, wird eine Aktualisierung auf die neueste Version mit diesem Präfix durchgeführt. Sollte das Gerät bereits die neueste Version ausführen, hat diese Richtlinie keine Auswirkungen, das heißt, es werden keine Downgrades ausgeführt, und das Gerät verwendet weiterhin die momentan installierte Version. Das Format des Präfixes bezieht sich auf die jeweilige Komponente, wie im folgenden Beispiel dargestellt:

      &quot;&quot; oder nicht konfiguriert: Aktualisierung auf die neueste verfügbare Version
      &quot;1412.&quot;: Aktualisierung auf eine Nebenversion von 1412, z. B. 1412.24.34 oder 1412.60.2
      &quot;1412.2.&quot;: Aktualisierung auf eine Nebenversion von 1412.2, z. B. 1412.2.34 oder 1412.2.2
      &quot;1412.24.34&quot;: nur Aktualisierung auf diese Version</translation>
<translation id="8102913158860568230">Standardeinstellung für MediaStream</translation>
<translation id="6641981670621198190">Unterstützung für 3D-Grafik-APIs deaktivieren</translation>
<translation id="5196805177499964601">Entwicklermodus blockieren:

      Wenn für diese Richtlinie &quot;True&quot; festgelegt ist, verhindert <ph name="PRODUCT_OS_NAME"/>, dass das Gerät im Entwicklermodus gestartet wird. Das System verweigert den Start und es wird ein Fehlerbildschirm angezeigt, wenn der Schalter für Entwickler aktiviert wird.

      Wird für diese Richtlinie &quot;False&quot; oder gar nichts festgelegt, bleibt der Entwicklermodus für das Gerät verfügbar.</translation>
<translation id="1265053460044691532">Zeit beschränken, für die sich ein über SAML authentifizierter Nutzer offline anmelden kann</translation>
<translation id="5703863730741917647">Geben Sie die beim Erreichen der Leerlaufverzögerung auszuführende Aktion an.

          Diese Richtlinie ist veraltet und wird in Zukunft entfernt werden.

          Diese Richtlinie bietet einen Ersatzwert für die spezifischeren Richtlinien <ph name="IDLEACTIONAC_POLICY_NAME"/> und <ph name="IDLEACTIONBATTERY_POLICY_NAME"/>. Bei Festlegung dieser Richtlinie wird ihr Wert verwendet, wenn die jeweilige spezifischere Richtlinie nicht festgelegt ist.

          Wenn diese Richtlinie nicht festgelegt ist, bleibt das Verhalten der spezifischeren Richtlinien unbeeinflusst.</translation>
<translation id="5997543603646547632">Standardmäßig 24-Stunden-Uhr verwenden</translation>
<translation id="7003746348783715221">Einstellungen für <ph name="PRODUCT_NAME"/></translation>
<translation id="4723829699367336876">Firewallausnahme über Client für Remote-Zugriff aktivieren</translation>
<translation id="2744751866269053547">Protokoll-Handler registrieren</translation>
<translation id="6367755442345892511">Ob der Release-Kanal vom Nutzer konfiguriert werden kann</translation>
<translation id="3868347814555911633">Diese Richtlinie ist nur im Händlermodus aktiv.

      Führt Erweiterungen auf, die bei Geräten im Händlermodus automatisch für den Demo-Nutzer installiert werden. Diese Erweiterungen werden auf dem Gerät gespeichert und können anschließend offline installiert werden.

       Jeder Eintrag enthält ein Verzeichnis, in dem im Feld &quot;extension-id&quot; die Erweiterungs-ID und im Feld &quot;update-url&quot; die Aktualisierungs-URL angegeben werden müssen.</translation>
<translation id="9096086085182305205">Weiße Liste für Authentifizierungsserver</translation>
<translation id="4980301635509504364">Hiermit können Videoaufnahmen zugelassen oder abgelehnt werden.

      Wenn diese Richtlinie aktiviert oder nicht konfiguriert ist (Standard), wird beim Zugriff für
      Videoaufnahmen beim Nutzer nachgefragt. Ausgenommen sind URLs auf der
      Liste &quot;VideoCaptureAllowedUrls&quot;. Diese URLs erhalten ohne Nachfrage Zugriff.

      Wenn diese Richtlinie deaktiviert ist, wird nie beim Nutzer nachgefragt und
      Videoaufnahmen sind nur für URLs auf der VideoCaptureAllowedUrls-Liste verfügbar.

      Diese Richtlinie betrifft alle Arten von Videoeingaben, nicht nur die eingebaute Kamera.</translation>
<translation id="7063895219334505671">Pop-ups auf diesen Websites zulassen</translation>
<translation id="3756011779061588474">Entwicklermodus blockieren</translation>
<translation id="4052765007567912447">Bestimmt, ob Nutzer Passwörter im Passwortmanager in Klartext abrufen können. Wenn Sie diese Einstellung deaktivieren, können sich Nutzer Passwörter im Passwortmanagerfenster nicht in Klartext anzeigen lassen. Sollten Sie sie aktivieren oder nicht konfigurieren, so können Nutzer ihre Passwörter im Passwortmanager in Klartext einsehen.</translation>
<translation id="5936622343001856595">Erzwingt die Ausführung der Google Websuche mit aktivierter SafeSearch-Funktion und verhindert, dass Nutzer diese Einstellung ändern.

      Wenn diese Einstellung aktiviert ist, ist SafeSearch immer in der Google-Suche aktiviert.

      Wenn diese Einstellung deaktiviert ist oder kein Wert festgelegt wurde, wird SafeSearch in der Google-Suche nicht erzwungen.</translation>
<translation id="6017568866726630990">Druckdialogfeld des Systems anstelle der Druckvorschau anzeigen

      Wenn diese Einstellung aktiviert ist, öffnet <ph name="PRODUCT_NAME"/> das Druckdialogfeld des Systems statt der eingerichteten Druckvorschau, sobald ein Nutzer einen Druckauftrag startet.

      Wenn diese Richtlinie nicht festgelegt oder auf &quot;false&quot; gesetzt wurde, wird bei Druckaufträgen die Druckvorschau angezeigt.</translation>
<translation id="7933141401888114454">Erstellung von betreuten Nutzern aktivieren</translation>
<translation id="2824715612115726353">Inkognito-Modus aktivieren</translation>
<translation id="1057535219415338480">Aktiviert die Netzwerkvervollständigung in <ph name="PRODUCT_NAME"/> und verhindert, dass diese Einstellung von Nutzern geändert wird.

      Hiermit wird nicht nur der DNS-Vorabruf gesteuert, sondern auch die TCP- und SSL-Vorverbindung und das Pre-Rendering von Webseiten. Der Richtlinienname bezieht sich aus historischen Gründen auf den DNS-Vorabruf.

      Wenn Sie diese Einstellung aktivieren oder deaktivieren, können Nutzer diese Einstellung in <ph name="PRODUCT_NAME"/> nicht ändern oder überschreiben.

      Bleibt diese Richtlinie unkonfiguriert, wird diese Einstellung aktiviert, kann jedoch vom Nutzer geändert werden.</translation>
<translation id="4541530620466526913">Lokale Gerätekonten</translation>
<translation id="5815129011704381141">Nach Update automatisch neu starten</translation>
<translation id="1757688868319862958">Ermöglicht <ph name="PRODUCT_NAME"/> die Ausführung von Plug-ins, für die eine Autorisierung erforderlich ist. Wenn Sie diese Einstellung aktivieren, werden nicht veraltete Plug-ins immer ausgeführt. Ist diese Einstellung deaktiviert oder nicht eingerichtet, müssen die Nutzer der Ausführung der Plug-ins zustimmen, die eine Autorisierung benötigen. Diese Plug-ins können ein Sicherheitsrisiko darstellen.</translation>
<translation id="6392973646875039351">Aktiviert die AutoFill-Funktion von <ph name="PRODUCT_NAME"/> und ermöglicht es Nutzern, Web-Formulare automatisch mit zuvor gespeicherten Informationen (etwa Adresse oder Kreditkarteninformationen) ausfüllen zu lassen. Wenn Sie diese Einstellung deaktivieren, können Nutzer die AutoFill-Funktion nicht verwenden. Ist diese Einstellung aktiviert oder nicht konfiguriert, kann der Nutzer entscheiden, ob er AutoFill nutzen möchte. Er kann AutoFill-Profile konfigurieren und AutoFill nach eigenem Ermessen aktivieren und deaktivieren.</translation>
<translation id="6157537876488211233">Kommagetrennte Liste der Proxy-Umgehungsregeln</translation>
<translation id="7788511847830146438">Nach Profil</translation>
<translation id="2516525961735516234">Hiermit wird angegeben, ob Videoaktivitäten Einfluss auf den Energiesparmodus haben.

          Wenn diese Richtlinie auf &quot;true&quot; gesetzt oder nicht konfiguriert ist, wird der Nutzer während der Wiedergabe von Videos als aktiv angesehen. Dadurch wird verhindert, dass die Inaktivitätsspanne und die Spanne für die Abdunkelung, Abschaltung oder Sperre des Bildschirms überschritten und entsprechende Aktionen eingeleitet werden.

          Ist diese Richtlinie auf &quot;false&quot; eingestellt, wird der Nutzer trotz Videoaktivität als inaktiv betrachtet.</translation>
<translation id="3965339130942650562">Zeitlimit bis zur Abmeldung eines inaktiven Nutzers</translation>
<translation id="5814301096961727113">Standardstatus für das gesprochene Feedback auf der Anmeldeseite festlegen</translation>
<translation id="1950814444940346204">Veraltete Webplattformfunktionen aktivieren</translation>
<translation id="9084985621503260744">Angaben zum Einfluss von Videoaktivitäten auf den Energiesparmodus</translation>
<translation id="7091198954851103976">Führt Plug-ins, die eine Autorisierung erfordern, immer aus</translation>
<translation id="1708496595873025510">Beschränkung für Abruf des Varianten-Seeds festlegen</translation>
<translation id="8870318296973696995">Startseite</translation>
<translation id="1240643596769627465">Gibt die URL der Suchmaschine an, die zur Ausgabe von Instant-Ergebnissen verwendet wird. Die URL sollte den String <ph name="SEARCH_TERM_MARKER"/> enthalten. Dieser wird bei der Suchanfrage mit dem Text ersetzt, den der Nutzer bis dahin eingegeben hat. Diese Richtlinie ist optional. Wenn keine Festlegung erfolgt, so werden keine Instant-Ergebnisse ausgegeben. Diese Richtlinie wird nur dann umgesetzt, wenn die Richtlinie &quot;DefaultSearchProviderEnabled&quot; aktiviert ist.</translation>
<translation id="6693751878507293182">Wenn Sie diese Einstellung aktivieren, wird die automatische Suche und Installation fehlender Plug-ins in <ph name="PRODUCT_NAME"/> deaktiviert. Ist sie deaktiviert oder nicht konfiguriert, so ist die Plug-in-Suche aktiv.</translation>
<translation id="2650049181907741121">Auszuführende Aktion beim Zuklappen des Geräts</translation>
<translation id="7880891067740158163">Ermöglicht Ihnen die Zusammenstellung einer Liste mit URL-Mustern, die Websites angeben, für die <ph name="PRODUCT_NAME"/> automatisch ein Client-Zertifikat auswählen soll, wenn die Website ein Zertifikat anfordert. Wenn diese Richtlinie nicht konfiguriert ist, erfolgt keine automatische Auswahl für Websites.</translation>
<translation id="3866249974567520381">Beschreibung</translation>
<translation id="5192837635164433517">Aktiviert die Verwendung alternativer Fehlerseiten, die in <ph name="PRODUCT_NAME"/> integriert sind, etwa &quot;Seite nicht gefunden&quot;, und verhindert, dass die Einstellung durch Nutzer geändert wird. Wenn Sie diese Einstellung aktivieren, kommen alternative Fehlerseiten zum Einsatz. Sollten Sie sie deaktivieren, werden alternative Fehlerseiten grundsätzlich nicht verwendet. Ist diese Einstellung aktiviert oder deaktiviert, können Nutzer sie in <ph name="PRODUCT_NAME"/> nicht ändern oder außer Kraft setzen. Wird die Richtlinie nicht konfiguriert, so ist die Funktion aktiv, aber der Nutzer kann dies ändern.</translation>
<translation id="2236488539271255289">Speichern von lokalen Daten für keine Website zulassen</translation>
<translation id="4467952432486360968">Drittanbieter-Cookies blockieren</translation>
<translation id="1305864769064309495">Eine Art Wörterbuch, das URLs einem booleschen Parameter zuordnet und dadurch angibt, ob der Zugriff auf den Host erlaubt (&quot;true&quot;) oder blockiert (&quot;false&quot;) werden soll.

Diese Richtlinien dienen ausschließlich zur internen Verwendung in Chrome.</translation>
<translation id="5586942249556966598">Nichts tun</translation>
<translation id="131353325527891113">Nutzernamen auf Anmeldeseite zeigen</translation>
<translation id="5365946944967967336">Startseiten-Schaltfläche auf Symbolleiste anzeigen</translation>
<translation id="3709266154059827597">Schwarze Liste für Installation von Erweiterungen konfigurieren</translation>
<translation id="1933378685401357864">Hintergrundbild</translation>
<translation id="8451988835943702790">&quot;Neuer Tab&quot;-Seite als Startseite verwenden</translation>
<translation id="4617338332148204752">Metatag-Überprüfung in <ph name="PRODUCT_FRAME_NAME"/> überspringen</translation>
<translation id="8469342921412620373">Ermöglicht die Verwendung einer Standardsuchmaschine. Ist diese Einstellung aktiviert, wird eine Standardsuche durchgeführt, wenn der Nutzer Text in die Omnibox eingibt, der keine URL ist. Sie können die zu verwendende Standardsuchmaschine angeben, indem Sie die restlichen Richtlinien zur Standardsuche festlegen. Werden diese nicht festgelegt, kann der Nutzer die Standardsuchmaschine auswählen. Ist diese Einstellung deaktiviert, wird keine Suche durchgeführt, wenn der Nutzer einen anderen Text als eine URL in die Omnibox eingibt. Falls Sie diese Einstellung aktivieren oder deaktivieren, können Nutzer die Einstellung in <ph name="PRODUCT_NAME"/> nicht ändern oder außer Kraft setzen. Sollte die Richtlinie nicht konfiguriert sein, so wird der Standardsuchanbieter aktiviert und der Nutzer kann die Suchanbieterliste selbst zusammenstellen.</translation>
<translation id="4791031774429044540">Hiermit wird die Bedienungshilfefunktion für den großen Cursor aktiviert.

          Ist diese Richtlinie auf &quot;true&quot; gesetzt, ist der große Cursor immer aktiviert.

          Ist diese Richtlinie auf &quot;false&quot; gesetzt, ist der große Cursor immer deaktiviert.

          Wenn Sie diese Richtlinie konfigurieren, können die Nutzer sie nicht ändern oder außer Kraft setzen.

          Falls die Richtlinie nicht konfiguriert wird, ist der große Cursor zunächst deaktiviert, kann aber von den Nutzern jederzeit aktiviert werden.</translation>
<translation id="2633084400146331575">Gesprochenes Feedback aktivieren</translation>
<translation id="687046793986382807">Diese Richtlinie gilt ab <ph name="PRODUCT_NAME"/> Version 35 nicht mehr.

Speicherinformationen werden unabhängig von der gewählten Option an die Seite weitergegeben, allerdings werden die gemeldeten Größen quantisiert und die Aktualisierungshäufigkeit wird aus Sicherheitsgründen begrenzt. Um genaue Daten in Echtzeit zu erhalten, können Sie Tools wie Telemetry verwenden.</translation>
<translation id="8731693562790917685">Unter &quot;Inhaltseinstellungen&quot; können Sie angeben, wie Inhalte bestimmter Typen (z. B. Cookies, Bilder oder JavaScript) verarbeitet werden.</translation>
<translation id="2411919772666155530">Benachrichtigungen auf diesen Websites blockieren</translation>
<translation id="7332963785317884918">Diese Richtlinie ist veraltet. <ph name="PRODUCT_OS_NAME"/> verwendet immer die &quot;RemoveLRU&quot;-Bereinigungsstrategie.

      Damit wird das automatische Bereinigungsverhalten auf Geräten mit <ph name="PRODUCT_OS_NAME"/> gesteuert. Die automatische Bereinigungsfunktion wird aktiviert, wenn nur noch wenig freier Speicher zur Verfügung steht, um so Speicherplatz freizugeben.

      Wenn für diese Richtlinie &quot;RemoveLRU&quot; festgelegt wird, entfernt die automatische Bereinigungsfunktion so lange Nutzer in der chronologischen Reihenfolge ihrer letzten Anmeldung vom Gerät, bis wieder genügend freier Speicher vorhanden ist.

      Wenn für diese Richtlinie &quot;RemoveLRUIfDormant&quot; festgelegt ist, entfernt die automatische Bereinigungsfunktion nur diejenigen Nutzer vom Gerät, die seit mindestens drei Monaten nicht mehr angemeldet waren. Diese Nutzer werden in der chronologischen Reihenfolge ihrer letzten Anmeldung vom Gerät gelöscht, bis wieder genügend freier Speicher vorhanden ist.

      Ist die Richtlinie nicht konfiguriert, erfolgt die automatische Bereinigung auf Grundlage der integrierten Standardstrategie. Zurzeit handelt es sich dabei um die &quot;RemoveLRUIfDormant&quot;-Strategie.</translation>
<translation id="6923366716660828830">Gibt den Namen des Standardsuchanbieters an. Wenn die Richtlinie leer oder nicht konfiguriert ist, so wird der durch die Such-URL angegebene Hostname verwendet. Diese Richtlinie wird nur dann umgesetzt, wenn &quot;DefaultSearchProviderEnabled&quot; aktiviert ist.</translation>
<translation id="4869787217450099946">Gibt an, ob Bildschirm-Wakelocks zulässig sind. Bildschirm-Wakelocks können von Erweiterungen über die Power Management Extension API angefordert werden.

Falls diese Richtlinie auf &quot;true&quot; gesetzt oder nicht festgelegt wird, werden Bildschirm-Wakelocks bei der Energieverwaltung zugelassen.

Falls die Richtlinie auf &quot;false&quot; gesetzt wird, werden Anfragen für Bildschirm-Wakelocks ignoriert.</translation>
<translation id="467236746355332046">Unterstützte Funktionen:</translation>
<translation id="5447306928176905178">Weitergabe von Speicherinformationen (JS-Heap-Größe) an Seite aktivieren (veraltet)</translation>
<translation id="7632724434767231364">Name der GSSAPI-Bibliothek</translation>
<translation id="3038323923255997294">Apps weiter im Hintergrund ausführen, wenn <ph name="PRODUCT_NAME"/> geschlossen ist</translation>
<translation id="8909280293285028130">Hiermit wird angegeben, nach welchem Zeitraum ohne Nutzereingabe der Bildschirm im Netzbetrieb gesperrt wird.

          Wenn für diese Richtlinie ein höherer Wert als null festgelegt wird, gibt dieser an, wie lange ein Nutzer inaktiv sein muss, bevor <ph name="PRODUCT_OS_NAME"/> den Bildschirm sperrt.

          Ist die Richtlinie auf null eingestellt, wird der Bildschirm von <ph name="PRODUCT_OS_NAME"/> nicht gesperrt, wenn der Nutzer inaktiv wird.

          Wenn die Richtlinie nicht konfiguriert ist, wird ein Standardwert verwendet.

          Die empfohlene Vorgehensweise ist, die Bildschirmsperre im Suspend-Modus zu aktivieren und <ph name="PRODUCT_OS_NAME"/> anzuweisen, nach der Inaktivitätsverzögerung in den Suspend-Modus zu wechseln. Diese Richtlinie sollte nur verwendet werden, wenn die Bildschirmsperre erheblich früher als der Suspend-Modus eintreten oder der Suspend-Modus bei Inaktivität gar nicht erfolgen soll.

          Der Wert für die Richtlinie muss in Millisekunden angegeben werden. Werte müssen kleiner als der Wert für die Inaktivitätsverzögerung sein.</translation>
<translation id="7651739109954974365">Legt fest, ob Daten-Roaming für das Gerät aktiviert werden soll. Bei Einstellung auf &quot;true&quot; ist das Roaming erlaubt. Ist die Richtlinie nicht konfiguriert oder auf &quot;false&quot; gesetzt, ist kein Roaming verfügbar.</translation>
<translation id="6244210204546589761">Beim Start zu öffnende URLs</translation>
<translation id="7468416082528382842">Windows-Registrierungspfad:</translation>
<translation id="1808715480127969042">Cookies auf diesen Websites blockieren</translation>
<translation id="1908884158811109790">Synchronisierung zwischen Google Drive und der App &quot;Dateien&quot; von Chrome OS per Mobilfunkverbindung deaktivieren</translation>
<translation id="7340034977315324840">Aktivitätszeit von Geräten melden</translation>
<translation id="4928632305180102854">Legt fest, ob in <ph name="PRODUCT_OS_NAME"/> das Erstellen neuer Nutzerkonten erlaubt ist. Wenn diese Richtlinie auf &quot;false&quot; eingestellt ist, können sich nur Nutzer mit bereits bestehenden Konten anmelden.

      Ist die Richtlinie auf &quot;true&quot; gesetzt oder nicht konfiguriert, dürfen neue Nutzerkonten erstellt werden, falls die Nutzer nicht durch die Richtlinie &quot;<ph name="DEVICEUSERWHITELISTPROTO_POLICY_NAME"/>&quot; an einer Anmeldung gehindert werden.</translation>
<translation id="4389091865841123886">Konfiguriert die Remote-Bestätigung mit TPM-Mechanismus</translation>
<translation id="9175109938712007705">Da Online-Überprüfungen zu SoftFail-Zertifikatssperren keinen wirkungsvollen Sicherheitseffekt bieten, werden sie ab <ph name="PRODUCT_NAME"/>-Version 19 standardmäßig deaktiviert. Wenn Sie diese Richtlinie auf &quot;true&quot; setzen, wird das vorherige Verhalten wiederhergestellt und es werden online OCSP-/CRL-Prüfungen durchgeführt.

      Falls die Richtlinie nicht konfiguriert oder auf &quot;false&quot; eingestellt ist, führt Chrome ab Version 19 keine Online-Überprüfungen auf Zertifikatssperren mehr durch.</translation>
<translation id="8256688113167012935">Gibt an, welchen Kontonamen <ph name="PRODUCT_OS_NAME"/> für das entsprechende lokale Gerätekonto auf der Anmeldeseite anzeigt.

      Wenn diese Richtlinie eingerichtet ist, wird auf der Anmeldeseite des entsprechenden lokalen Gerätekontos der angegebene String für die bildbasierte Auswahl bei der Anmeldung verwendet.

      Wenn diese Richtlinie nicht eingerichtet wurde, verwendet <ph name="PRODUCT_OS_NAME"/> die E-Mail-Konto-ID des entsprechenden lokalen Gerätekontos als Anzeigename auf der Anmeldeseite.

      Diese Richtlinie ist für reguläre Nutzerkonten nicht relevant.</translation>
<translation id="267596348720209223">Gibt die vom Suchanbieter unterstützten Zeichencodierungen an. Codierungen sind Codepage-Namen wie UTF-8, GB2312 und ISO-8859-1. Sie werden in der Reihenfolge durchprobiert, in der sie angegeben werden. Diese Richtlinie ist optional. Ist sie nicht konfiguriert, so kommt der Standardwert UTF-8 zum Einsatz. Diese Richtlinie wird nur umgesetzt, wenn die Richtlinie &quot;DefaultSearchProviderEnabled&quot; aktiviert ist.</translation>
<translation id="1349276916170108723">Falls auf &quot;true&quot; gesetzt, wird die Synchronisierung zwischen Google Drive und der App &quot;Dateien&quot; von Chrome OS deaktiviert. Es werden dann keine Daten in Google Drive hochgeladen.

Falls die Richtlinie auf &quot;false&quot; gesetzt oder nicht festgelegt wird, können die Nutzer Dateien an Google Drive übertragen.</translation>
<translation id="1964634611280150550">Inkognito-Modus deaktiviert</translation>
<translation id="5971128524642832825">Synchronisierung zwischen Google Drive und der App &quot;Dateien&quot; von Chrome OS deaktivieren</translation>
<translation id="1847960418907100918">Gibt die Parameter für die Suche im Voraus mit POST an. Sie besteht aus durch Komma getrennten Name/Wert-Paaren. Wenn ein Wert ein Vorlagenparameter wie z. B. {searchTerms} im obigen Beispiel ist, wird er durch echte Suchbegriffsdaten ersetzt.

          Diese Richtlinie ist optional. Wenn sie nicht festlegt ist, wird die Anfrage für die Suche im Voraus mithilfe der GET-Methode gesendet.

          Diese Richtlinie wird nur berücksichtigt, wenn die Richtlinie &quot;DefaultSearchProviderEnabled&quot; aktiviert ist.</translation>
<translation id="6095999036251797924">Gibt die Zeitdauer ohne Nutzeraktivität an, nach der der Bildschirm im Netz- oder Akkubetrieb gesperrt wird.

          Wenn ein Wert über null angegeben wird, steht dieser Wert für die Zeitdauer, für die ein Nutzer inaktiv sein muss, bevor der Bildschirm durch <ph name="PRODUCT_OS_NAME"/> gesperrt wird.

          Wenn der Wert null angegeben wird, wird der Bildschirm bei Inaktivität des Nutzers nicht durch <ph name="PRODUCT_OS_NAME"/> gesperrt.

          Wenn kein Wert angegeben wird, wird ein Standardwert verwendet.

          Wenn der Bildschirm bei Inaktivität gesperrt werden soll, empfehlen wir, die Bildschirmsperre für den Wechsel in den Suspend-Modus zu aktivieren und <ph name="PRODUCT_OS_NAME"/> anzuweisen, nach der Inaktivitätsverzögerung in den Suspend-Modus zu wechseln. Diese Richtlinie sollte nur verwendet werden, wenn die Bildschirmsperre deutlich früher aktiviert werden soll als der Suspend-Modus oder wenn der Suspend-Modus bei Inaktivität nicht erwünscht ist.

          Der Richtlinienwert muss in Millisekunden angegeben werden und wird automatisch auf einen Wert unter der Inaktivitätsverzögerung reduziert.</translation>
<translation id="1454846751303307294">Ermöglicht Ihnen die Zusammenstellung einer Liste mit URL-Mustern, die Websites angeben, denen die Ausführung von JavaScript untersagt ist. Wenn diese Richtlinie nicht konfiguriert ist, kommt für alle Websites entweder der globale Standardwert der Richtlinie &quot;DefaultJavaScriptSetting&quot;, falls konfiguriert, oder der persönlichen Konfiguration des Nutzers zum Einsatz.</translation>
<translation id="538108065117008131">Verarbeitung der folgenden Inhaltstypen durch <ph name="PRODUCT_FRAME_NAME"/> zulassen</translation>
<translation id="2312134445771258233">Mit dieser Richtlinie können Sie konfigurieren, welche Seiten beim Start geladen werden. Der Inhalt der Liste &quot;Beim Start zu öffnende URLs&quot; wird ignoriert, sofern die Option &quot;URL-Liste öffnen&quot; unter &quot;Aktion beim Start&quot; nicht ausgewählt ist.</translation>
<translation id="1464848559468748897">Steuert das Nutzerverhalten in einer Sitzung mit mehreren Profilen auf Geräten mit <ph name="PRODUCT_OS_NAME"/>

      Wenn für diese Richtlinie &quot;MultiProfileUserBehaviorUnrestricted&quot; festgelegt ist, kann der Nutzer entweder primärer oder sekundärer Nutzer in einer Sitzung mit mehreren Profilen sein.

      Wenn für diese Richtlinie &quot;MultiProfileUserBehaviorMustBePrimary&quot; festgelegt ist, kann der Nutzer ausschließlich primärer Nutzer in einer Sitzung mit mehreren Profilen sein.

      Ist die Richtlinie auf &quot;MultiProfileUserBehaviorNotAllowed&quot; festgelegt, kann der Nutzer nicht an einer Sitzung mit mehreren Profilen teilnehmen.

      Wenn Sie diese Einstellung konfigurieren, kann sie von Nutzern nicht geändert oder überschrieben werden.

      Wird die Einstellung geändert, während der Nutzer in einer Sitzung mit mehreren Profilen angemeldet ist, werden alle Nutzer mit ihren jeweiligen Einstellungen abgeglichen. Die Sitzung wird beendet, falls einer der Nutzer nicht mehr länger dazu berechtigt ist, an der Sitzung teilzunehmen.

      Falls die Richtlinie nicht konfiguriert ist, gilt der Standardwert &quot;MultiProfileUserBehaviorMustBePrimary&quot; für alle vom Unternehmen verwalteten Nutzer und &quot;MultiProfileUserBehaviorUnrestricted&quot; für nicht verwaltete Nutzer.</translation>
<translation id="243972079416668391">Geben Sie die Aktion an, die während des Wechselstrombetriebs beim Erreichen der Leerlaufverzögerung ausgeführt werden soll.

          Wenn diese Richtlinie festgelegt ist, gibt sie die Aktion an, die <ph name="PRODUCT_OS_NAME"/> ausführt, wenn der Nutzer für die von der Leerlaufverzögerung angegebene Zeitdauer inaktiv ist. Diese Zeitdauer kann separat konfiguriert werden.

          Wenn diese Richtlinie nicht festgelegt ist, wird die Standardaktion ausgeführt: Es wird in den Suspend-Modus gewechselt.

          Wenn als Aktion der Wechsel in den Suspend-Modus festgelegt ist, kann <ph name="PRODUCT_OS_NAME"/> separat dafür konfiguriert werden, den Bildschirm zu sperren oder nicht zu sperren.</translation>
<translation id="7750991880413385988">&quot;Neuer Tab&quot;-Seite öffnen</translation>
<translation id="5761030451068906335">Hiermit werden die Proxy-Einstellungen für <ph name="PRODUCT_NAME"/> konfiguriert. Diese Richtlinie ist noch nicht einsatzbereit und sollte daher nicht verwendet werden.</translation>
<translation id="8344454543174932833">Lesezeichen bei erster Ausführung aus Standardbrowser importieren</translation>
<translation id="1019101089073227242">Verzeichnis für Nutzerdaten festlegen</translation>
<translation id="5826047473100157858">Gibt an, ob der Nutzer Seiten in <ph name="PRODUCT_NAME"/> im Inkognito-Modus öffnen kann. Ist diese Richtlinie aktiviert oder nicht konfiguriert, so können Seiten im Inkognito-Modus geöffnet werden. Wenn sie deaktiviert ist, so können Seiten nicht im Inkognito-Modus geöffnet werden. Mit dem Wert &quot;Forced&quot; können Seiten ausschließlich im Inkognito-Modus geöffnet werden.</translation>
<translation id="2988031052053447965">Diese Richtlinie dient dazu, die Chrome Web Store App und den zugehörigen Fußzeilenlink auf der Seite &quot;Neuer Tab&quot; und im App Launcher von Chrome OS auszublenden.

      Ist diese Richtlinie auf &quot;true&quot; gesetzt, werden die Symbole ausgeblendet.

      Ist diese Richtlinie auf &quot;false&quot; gesetzt oder nicht konfiguriert, sind die Symbole sichtbar.</translation>
<translation id="5085647276663819155">Druckvorschau deaktivieren</translation>
<translation id="8672321184841719703">Automatische Aktualisierung auf Zielversion</translation>
<translation id="553658564206262718">Einstellungen der Energieverwaltung bei Inaktivität des Nutzers konfigurieren

          Mit dieser Richtlinie können Sie mehrere Einstellungen zur Energieverwaltungsstrategie bei Inaktivität des Nutzers festlegen.

          Es gibt vier Aktionen:
          * Der Bildschirm wird gedimmt, wenn der Nutzer für die unter |ScreenDim| angegebene Zeitdauer inaktiv ist.
          * Der Bildschirm wird ausgeschaltet, wenn der Nutzer für die unter |ScreenOff| angegebene Zeitdauer inaktiv ist.
          * Ein Warndialog erscheint, wenn der Nutzer für die unter |IdleWarning| angegebene Zeitdauer inaktiv ist. Mit dem Dialog wird der Nutzer darauf hingewiesen, dass als Nächstes die für die Inaktivität festgelegte Aktion ausgeführt wird.
          * Die unter |IdleAction| angegebene Aktion wird ausgeführt, wenn der Nutzer für die unter |Idle| angegebene Zeitdauer inaktiv ist.

          Die Verzögerungen müssen in Millisekunden angegeben werden und größer als null sein, um die oben jeweils angegebenen Aktionen auszulösen. Falls die Verzögerung auf null gesetzt wird, wird die entsprechende Aktion durch <ph name="PRODUCT_OS_NAME"/> nicht ausgeführt.

          Wenn kein Wert für die Verzögerungen angegeben ist, wird ein Standardwert festgelegt.

          Hinweis: Der Wert für |ScreenDim| muss mit dem Wert für |ScreenOff| identisch oder niedriger sein. Die Werte für |ScreenOff| und |IdleWarning| müssen mit dem Wert für |Idle| identisch oder niedriger sein. Falls Ihre Angaben darüber liegen, werden die Werte automatisch angepasst.

          Für |IdleAction| sind folgende Aktionen möglich:
          * |Suspend|
          * |Logout|
          * |Shutdown|
          * |DoNothing|

          Wenn |IdleAction| nicht festgelegt wird, wird die Standardaktion |Suspend| ausgeführt.

          Es können außerdem spezifische Einstellungen für den Netz- und Akkubetrieb vorgenommen werden.
          </translation>
<translation id="1689963000958717134">Ermöglicht das Übernehmen einer per Push übertragenen Netzwerkkonfiguration für alle Nutzer eines <ph name="PRODUCT_OS_NAME"/>-Geräts. Die Netzwerkkonfiguration ist ein JSON-formatierter String, der den Open Network Configuration-Vorgaben unter <ph name="ONC_SPEC_URL"/> entspricht.</translation>
<translation id="6699880231565102694">Zwei-Faktor-Authentifizierung für Remote-Zugriff-Hosts aktivieren</translation>
<translation id="2030905906517501646">Suchbegriff der Standardsuchmaschine</translation>
<translation id="3072045631333522102">Bildschirmschoner für die Anmeldeseite im Händlermodus</translation>
<translation id="4550478922814283243">Authentifizierung ohne PIN aktivieren oder deaktivieren</translation>
<translation id="7712109699186360774">Nachfragen, wenn eine Website auf meine Kamera bzw. mein Mikrofon zugreifen möchte</translation>
<translation id="350797926066071931">Übersetzung aktivieren</translation>
<translation id="3711895659073496551">Suspend-Modus</translation>
<translation id="4010738624545340900">Aufrufen von Dialogfeldern zur Dateiauswahl zulassen</translation>
<translation id="4518251772179446575">Nachfragen, wenn eine Website den physischen Standort der Nutzer verfolgen möchte</translation>
<translation id="402759845255257575">Ausführung von JavaScript für keine Website zulassen</translation>
<translation id="5457924070961220141">Ermöglicht Ihnen die Konfiguration des Standard-HTML-Renderers, wenn <ph name="PRODUCT_FRAME_NAME"/> installiert ist. Wenn diese Richtlinie nicht konfiguriert ist, so kommt die Standardeinstellung zum Einsatz, wobei der Hostbrowser das Rendering übernimmt. Sie haben aber die Möglichkeit, dies zu ändern und <ph name="PRODUCT_FRAME_NAME"/> das Rendering der HTML-Seite übernehmen zu lassen.</translation>
<translation id="706669471845501145">Anzeige von Desktop-Benachrichtigungen durch Websites zulassen</translation>
<translation id="7529144158022474049">Streufaktor automatisch aktualisieren</translation>
<translation id="2188979373208322108">Aktiviert die Lesezeichenleiste in <ph name="PRODUCT_NAME"/>. Wenn Sie diese Einstellung aktivieren, so erscheint in <ph name="PRODUCT_NAME"/> eine Lesezeichenleiste. Sollten Sie sie deaktivieren, sehen Nutzer die Leiste nicht. Ist diese Einstellung aktiviert oder deaktiviert, können Nutzer sie in <ph name="PRODUCT_NAME"/> nicht ändern oder außer Kraft setzen. Wenn diese Einstellung nicht konfiguriert ist, kann der Nutzer entscheiden, ob er die Funktion in Anspruch nehmen möchte.</translation>
<translation id="7593523670408385997">Konfiguriert die Cache-Größe, die <ph name="PRODUCT_NAME"/> zum Speichern von Dateien im Cache auf dem Datenträger verwendet.

      Wenn Sie diese Richtlinie festlegen, verwendet <ph name="PRODUCT_NAME"/> die angegebene Cache-Größe unabhängig davon, ob der Nutzer den Parameter &quot;--disk-cache-size&quot; angegeben hat oder nicht. Der in dieser Richtlinie angegebene Wert ist keine feste Grenze, sondern mehr ein Richtwert für das Caching-System. Werte, die unter wenigen Megabytes liegen, sind zu klein und werden auf einen sinnvollen Minimalwert aufgerundet.

      Wenn der Wert dieser Richtlinie 0 beträgt, wird die Standard-Cache-Größe verwendet. Der Nutzer kann diese jedoch nicht ändern.

      Wird diese Richtlinie nicht festgelegt, wird die Standardgröße verwendet und der Nutzer kann diese mit dem Parameter &quot;--disk-cache-size&quot; überschreiben.</translation>
<translation id="5475361623548884387">Drucken aktivieren</translation>
<translation id="7287359148642300270">Hiermit legen Sie fest, welche Server auf die Whitelist für integrierte Authentifizierung gesetzt werden. Integrierte Authentifizierung ist nur möglich, wenn <ph name="PRODUCT_NAME"/> eine Authentifizierungsanfrage von einem Proxy oder einem anderen Server erhält, der in dieser Liste erlaubter Server enthalten ist.

          Fügen Sie zwischen den verschiedenen Servernamen ein Komma als Trennzeichen ein. Platzhalter (*) sind zulässig.

          Wenn Sie diese Richtlinie nicht konfigurieren, versucht Chrome zu ermitteln, ob der fragliche Server sich im Intranet befindet, und reagiert nur dann auf IWA-Anfragen. Wenn der Server sich dagegen im Internet befindet, werden dessen IWA-Anfragen von Chrome ignoriert.</translation>
<translation id="3653237928288822292">Symbol der Standardsuchmaschine</translation>
<translation id="4721232045439708965">Hier können Sie das Startverhalten festlegen.

          Wenn Sie &quot;'Neuer Tab'-Seite öffnen&quot; wählen, wird die &quot;Neuer Tab&quot;-Seite bei jedem Start von <ph name="PRODUCT_NAME"/> geöffnet.

          Wenn Sie &quot;Letzte Sitzung wiederherstellen&quot; wählen, werden die URLs, die beim letzten Schließen von <ph name="PRODUCT_NAME"/> geöffnet waren, erneut geöffnet und die Browsersitzung wird wiederhergestellt.
          Mit dieser Option werden einige Einstellungen deaktiviert, die während oder beim Beenden einer Sitzung ausgeführt werden, wie das Löschen von Browserdaten beim Schließen oder Sitzungs-Cookies für bestimmte Sitzungen.

          Wenn Sie &quot;Liste der URLs öffnen&quot; wählen, wird die Liste &quot;Beim Start zu öffnende URLs&quot; geöffnet, sobald ein Nutzer <ph name="PRODUCT_NAME"/> startet.

          Wenn Sie diese Einstellung aktivieren, kann sie nicht von Nutzern in <ph name="PRODUCT_NAME"/> geändert oder außer Kraft gesetzt werden.

          Die Deaktivierung dieser Einstellung entspricht einer nicht konfigurierten Option. Ein Nutzer kann sie dann in <ph name="PRODUCT_NAME"/> ändern.</translation>
<translation id="2872961005593481000">Herunterfahren</translation>
<translation id="4445684791305970001">Deaktiviert die Entwickler-Tools und die JavaScript-Konsole. Wenn Sie diese Einstellung aktivieren, besteht kein Zugriff mehr auf die Entwickler-Tools, sodass Website-Elemente nicht mehr überprüft werden können. Jegliche Tastenkombinationen und Menü- und Kontextmenüeinträge zum Öffnen der Entwickler-Tools oder der JavaScript-Konsole werden deaktiviert. Ist diese Option deaktiviert oder nicht konfiguriert, so können die Entwickler-Tools und die JavaScript-Konsole verwendet werden.</translation>
<translation id="9203071022800375458">Deaktiviert die Aufnahme von Screenshots.

      Wenn die Richtlinie aktiviert ist, können keine Screenshots über Tastenkombinationen oder Erweiterungs-APIs aufgenommen werden.

      Ist die Richtlinie deaktiviert oder nicht konfiguriert, ist die Aufnahme von Screenshots möglich.</translation>
<translation id="5697306356229823047">Gerätenutzer aufzeichnen</translation>
<translation id="8649763579836720255">Chrome OS-Geräte können mithilfe einer Remote-Bescheinigung für überprüften Zugriff ein von der Chrome OS-Zertifizierungsstelle herausgegebenes Zertifikat erhalten, das die Berechtigung des Geräts für die Wiedergabe geschützter Medien nachweist. Bei diesem Vorgang werden Informationen zur Bestätigung der Hardware an die Chrome OS-Zertifizierungsstelle gesendet, anhand derer das Gerät eindeutig identifiziert werden kann.

          Ist die Einstellung auf &quot;false&quot; gesetzt, verwendet das Gerät keine Remote-Bescheinigung für geschützte Medien und kann möglicherweise keine geschützten Medien wiedergeben.

          Ist die Einstellung auf &quot;true&quot; gesetzt oder nicht festgelegt, kann das Gerät die Remote-Bescheinigung für geschützte Medien verwenden.</translation>
<translation id="4632343302005518762">Verarbeitung der gelisteten Inhaltstypen durch <ph name="PRODUCT_FRAME_NAME"/> zulassen</translation>
<translation id="13356285923490863">Richtlinienname</translation>
<translation id="557658534286111200">Bearbeitung von Lesezeichen aktivieren oder deaktivieren</translation>
<translation id="5378985487213287085">Ermöglicht Ihnen festzulegen, ob Websites Desktop-Benachrichtigungen anzeigen dürfen. Das Anzeigen von Desktop-Benachrichtigungen kann entweder standardmäßig gestattet oder nicht gestattet werden oder auf Anfrage beim Nutzer geschehen. Wenn diese Richtlinie nicht konfiguriert ist, so kommt &quot;AskNotifications&quot; zum Einsatz, wobei dies vom Nutzer geändert werden kann.</translation>
<translation id="2386362615870139244">Bildschirm-Wakelocks zulassen</translation>
<translation id="6908640907898649429">Konfiguriert die Standardsuchmaschine. Sie können die Standardsuchmaschine für die Nutzer auswählen oder die Standardsuche deaktivieren.</translation>
<translation id="6544897973797372144">Wenn diese Richtlinie auf &quot;True&quot; gesetzt ist und die Richtlinie &quot;ChromeOsReleaseChannel&quot; nicht angegeben ist, können Nutzer der Anmelde-Domain den Release-Kanal des Geräts ändern. Ist diese Richtlinie auf &quot;False&quot; gesetzt, wird auf dem Gerät der zuletzt eingestellte Kanal verwendet und dieser kann nicht geändert werden.

      Der vom Nutzer ausgewählte Kanal wird durch die Richtlinie &quot;ChromeOsReleaseChannel&quot; außer Kraft gesetzt. Falls der Kanal der Richtlinie jedoch stabiler ist als der auf dem Gerät installierte Kanal, wird der Kanal erst gewechselt, nachdem der stabilere Kanal eine höhere Versionsnummer als der auf dem Gerät installierte Kanal erreicht hat.</translation>
<translation id="389421284571827139">Ermöglicht Ihnen, den von <ph name="PRODUCT_NAME"/> verwendeten Proxyserver anzugeben, und verhindert, dass Nutzer die Proxy-Einstellungen ändern. Wenn Sie sich dafür entscheiden, nie einen Proxyserver, sondern immer eine direkte Verbindung zu nutzen, so werden alle anderen Optionen ignoriert. Sollten Sie die automatische Erkennung des Proxyservers wählen, werden ebenfalls alle anderen Optionen ignoriert. Ausführliche Beispiele erhalten Sie unter <ph name="PROXY_HELP_URL"/>. Wenn Sie diese Einstellung aktivieren, so ignoriert <ph name="PRODUCT_NAME"/> alle Proxy-bezogenen Optionen, die über die Befehlszeile angegeben werden. Sind diese Richtlinien nicht konfiguriert, so können Nutzer ihre eigenen Proxy-Einstellungen wählen.</translation>
<translation id="681446116407619279">Unterstützte Authentifizierungsschemas</translation>
<translation id="4027608872760987929">Standardsuchmaschine aktivieren</translation>
<translation id="2223598546285729819">Standardeinstellung für Benachrichtigungen</translation>
<translation id="6158324314836466367">Unternehmens-Web-Store-Name (veraltet)</translation>
<translation id="3984028218719007910">Legt fest, ob lokale Kontodaten nach der Abmeldung in <ph name="PRODUCT_OS_NAME"/> gespeichert werden. Bei Einstellung auf &quot;true&quot; werden Konten nicht dauerhaft in <ph name="PRODUCT_OS_NAME"/> gespeichert und alle Daten der Nutzersitzung werden nach der Abmeldung verworfen. Ist die Richtlinie auf &quot;false&quot; gesetzt oder nicht konfiguriert, können (verschlüsselte) lokale Nutzerdaten auf dem Gerät verbleiben.</translation>
<translation id="3793095274466276777">Konfiguriert den Standardbrowser, führt in <ph name="PRODUCT_NAME"/> eine Überprüfung durch und verhindert, dass Nutzer die Einstellung ändern. Falls Sie diese Einstellung aktivieren, überprüft <ph name="PRODUCT_NAME"/> bei jedem Start, ob es der Standardbrowser ist. Nach Möglichkeit registriert sich die Anwendung dann automatisch. Ist diese Einstellung deaktiviert, überprüft <ph name="PRODUCT_NAME"/> nie, ob es der Standardbrowser ist. Außerdem werden alle Nutzersteuerelemente zum Einstellen dieser Option deaktiviert. Falls diese Einstellung nicht festgelegt ist, kann der Nutzer selbst steuern, ob <ph name="PRODUCT_NAME"/> der Standardbrowser ist und ob Nutzerbenachrichtigungen angezeigt werden sollen, wenn dies nicht der Fall ist.</translation>
<translation id="3504791027627803580">Gibt die URL der Suchmaschine für die Bildsuche an. Suchanfragen werden mithilfe der GET-Methode gesendet. Wenn die Richtlinie &quot;DefaultSearchProviderBildURLPostParams&quot; festgelegt ist, wird bei Bildsuchanfragen stattdessen die POST-Methode verwendet.

          Diese Richtlinie ist optional. Wenn sie nicht festlegt ist, wird keine Bildsuche verwendet.

          Diese Richtlinie wird nur berücksichtigt, wenn die Richtlinie &quot;DefaultSearchProviderEnabled&quot; aktiviert ist.</translation>
<translation id="7529100000224450960">Ermöglicht Ihnen die Zusammenstellung einer Liste mit URL-Mustern, die Websites angeben, denen das Öffnen von Pop-ups gestattet ist. Wenn diese Richtlinie nicht konfiguriert ist, so kommt für alle Websites entweder der globale Standardwert der Richtlinie &quot;DefaultPopupsSetting&quot;, sofern konfiguriert, oder der persönlichen Konfiguration des Nutzers zum Einsatz.</translation>
<translation id="6155936611791017817">Standardstatus für den großen Cursor auf der Anmeldeseite festlegen</translation>
<translation id="1530812829012954197">Immer die folgenden URL-Muster im Host-Browser darstellen</translation>
<translation id="9026000212339701596">Eine Art Wörterbuch, das Hostnamen einem booleschen Parameter zuordnet und dadurch angibt, ob der Zugriff auf den Host erlaubt (&quot;true&quot;) oder blockiert (&quot;false&quot;) werden soll.

Diese Richtlinien dienen ausschließlich zur internen Verwendung in Chrome.</translation>
<translation id="913195841488580904">Zugriff auf aufgelistete URLs blockieren</translation>
<translation id="5461308170340925511">Konfiguriert erweiterungsbezogene Richtlinien. Der Nutzer kann auf der schwarzen Liste befindliche Erweiterungen nur dann installieren, wenn diese sich auf der weißen Liste befinden. Sie können auch erzwingen, dass <ph name="PRODUCT_NAME"/> Erweiterungen automatisch installiert werden, indem Sie die Erweiterungen in <ph name="EXTENSIONINSTALLFORCELIST_POLICY_NAME"/> angeben. Erweiterungen, deren Installation erzwungen wurde, werden immer installiert, unabhängig davon, ob sie sich auf der schwarzen Liste befinden.</translation>
<translation id="3292147213643666827">Mithilfe dieser Richtlinie kann <ph name="PRODUCT_NAME"/> als Proxy zwischen <ph name="CLOUD_PRINT_NAME"/> und älteren Druckern fungieren, die an den Computer angeschlossen sind.

     Wenn diese Einstellung aktiviert ist oder nicht konfiguriert wurde, können Nutzer den Google Cloud Print-Proxy durch die Authentifizierung mit ihrem Google-Konto aktivieren.

       Ist diese Einstellung deaktiviert, können Nutzer den Proxy nicht aktivieren und der Computer darf seine Drucker nicht für <ph name="CLOUD_PRINT_NAME"/> freigeben.</translation>
<translation id="6373222873250380826">Bei Festlegung auf &quot;true&quot; werden automatische Updates deaktiviert.

      Ist die Richtlinie nicht konfiguriert oder auf &quot;false&quot; gesetzt, suchen <ph name="PRODUCT_OS_NAME"/>-Geräte automatisch nach Updates.</translation>
<translation id="6190022522129724693">Standardeinstellung für Pop-ups</translation>
<translation id="847472800012384958">Anzeige von Pop-ups für keine Website zulassen</translation>
<translation id="4733471537137819387">Strategien im Hinblick auf die integrierte HTTP-Authentifizierung</translation>
<translation id="8501011084242226370">Gibt eine Liste von Plug-ins an, die der Nutzer in <ph name="PRODUCT_NAME"/> aktivieren oder deaktivieren kann.

      Die Platzhalterzeichen &quot;*&quot; und &quot;?&quot; können verwendet werden, um beliebige Zeichenfolgen zuzuordnen. &quot;*&quot; entspricht einer beliebigen Anzahl von Zeichen, während &quot;?&quot; ein optionales einzelnes Zeichen darstellt (kein oder ein Zeichen). Als Escape-Zeichen wird &quot;\&quot; verwendet. Dieses können Sie vor &quot;*&quot; oder &quot;?&quot; setzen, um nach diesen Zeichen (Sternchen bzw. Fragezeichen) zu suchen.

      Wenn Sie diese Einstellung aktivieren, kann die angegebene Liste von Plug-ins in <ph name="PRODUCT_NAME"/> verwendet werden. Nutzer können diese in &quot;about:plugins&quot; aktivieren oder deaktivieren, selbst wenn das Plug-in auch mit einem Muster in DisabledPlugins übereinstimmt. Zudem können Nutzer Plug-ins aktivieren oder deaktivieren, die mit keinen Mustern in DisabledPlugins, DisabledPluginsExceptions und EnabledPlugins übereinstimmen.

      Diese Richtlinie soll einen strengen Ausschluss von Plug-ins ermöglichen. Dabei enthält die Liste &quot;DisabledPlugins&quot; Platzhaltereinträge wie &quot;*&quot; zur Deaktivierung aller Plug-ins oder &quot;*Java*&quot; zur Deaktivierung aller Java-Plug-ins. Der Administrator kann jedoch bestimmte Versionen wie &quot;IcedTea Java 2.3&quot; aktivieren. Diese spezifischen Versionen können in dieser Richtlinie festgelegt werden.

      Beachten Sie, dass sowohl der Plug-in-Name als auch der Plug-in-Gruppenname ausgenommen werden müssen. Jede Plug-in-Gruppe wird in einem separaten Abschnitt unter &quot;about:plugins&quot; angezeigt. Jeder Abschnitt kann ein oder mehrere Plug-ins enthalten. So gehört beispielsweise das Plug-in &quot;Shockwave Flash&quot; der Gruppe &quot;Adobe Flash Player&quot; an. Wenn dieses Plug-in von der schwarzen Liste ausgenommen werden soll, muss in der Ausnahmeliste für beide Namen eine Übereinstimmung vorhanden sein.

      Wird diese Richtlinie nicht konfiguriert, werden alle Plug-ins, die mit den Mustern in &quot;DisabledPlugins&quot; übereinstimmen, als deaktiviert gesperrt. Sie können dann nicht vom Nutzer aktiviert werden.</translation>
<translation id="8951350807133946005">Datenträger-Cache-Verzeichnis festlegen</translation>
<translation id="603410445099326293">Parameter für URL der Vorschlagsuche, die POST verwendet</translation>
<translation id="2592091433672667839">Dauer der Inaktivität, bevor im Händlermodus der Bildschirmschoner auf der Anmeldeseite erscheint</translation>
<translation id="166427968280387991">Proxyserver</translation>
<translation id="2805707493867224476">Anzeige von Pop-ups für alle Websites zulassen</translation>
<translation id="1727394138581151779">Alle Plug-ins blockieren</translation>
<translation id="8118665053362250806">Cache-Größe für Mediendatenträger festlegen</translation>
<translation id="6565312346072273043">Standardstatus für die Bildschirmtastatur auf der Anmeldeseite festlegen

          Wenn diese Richtlinie auf &quot;true&quot; gesetzt ist, ist die Bildschirmtastatur aktiviert, wenn die Anmeldeseite angezeigt wird.

          Wenn diese Richtlinie auf &quot;falsch&quot; gesetzt ist, ist die Bildschirmtastatur deaktiviert, wenn die Anmeldeseite angezeigt wird.

          Wenn Sie diese Richtlinie konfigurieren, kann diese von Nutzern vorübergehend außer Kraft gesetzt werden, indem sie die Bildschirmtastatur aktivieren oder deaktivieren. Die Wahl des Nutzers ist jedoch nicht dauerhaft. Deshalb wird die Standardeinstellung wiederhergestellt, wenn die Anmeldeseite erneut aufgerufen wird oder der Nutzer innerhalb von einer Minute keine Eingabe auf der Anmeldeseite macht.

          Wird diese Richtlinie nicht konfiguriert, ist die Bildschirmtastatur beim erstmaligen Aufrufen der Anmeldeseite deaktiviert. Nutzer können die Bildschirmtastatur jederzeit aktivieren oder deaktivieren, wobei ihr Status auf der Anmeldeseite bei einem Nutzerwechsel erhalten bleibt.</translation>
<translation id="7079519252486108041">Pop-ups auf diesen Websites blockieren</translation>
<translation id="1859633270756049523">Sitzungsdauer begrenzen</translation>
<translation id="7433714841194914373">Google Instant aktivieren</translation>
<translation id="4983201894483989687">Ausführung veralteter Plug-ins zulassen</translation>
<translation id="443665821428652897">Websitedaten beim Schließen des Browsers löschen (veraltet)</translation>
<translation id="3823029528410252878">Deaktiviert das Speichern des Browserverlaufs in <ph name="PRODUCT_NAME"/> und verhindert, dass Nutzer diese Einstellung ändern. Wenn diese Einstellung aktiviert ist, wird der Browserverlauf nicht gespeichert. Ist diese Einstellung deaktiviert oder nicht konfiguriert, so wird der Browserverlauf gespeichert.</translation>
<translation id="7295019613773647480">Betreute Nutzer aktivieren</translation>
<translation id="2759224876420453487">Nutzerverhalten in Mehrfachprofil-Sitzung steuern</translation>
<translation id="3844092002200215574">Konfiguriert das Verzeichnis, in dem <ph name="PRODUCT_NAME"/> Dateien aus dem Cache auf der Festplatte speichert.

      Wenn Sie diese Richtlinie festlegen, verwendet <ph name="PRODUCT_NAME"/> das angegebene Verzeichnis unabhängig davon, ob der Nutzer die Markierung &quot;--disk-cache-dir&quot; festgelegt hat.

      Unter &quot;http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables&quot; finden Sie eine Liste der Variablen, die verwendet werden können.

      Bleibt diese Richtlinie unkonfiguriert, wird das Cache-Standardverzeichnis verwendet. Dieses kann dann vom Nutzer mit der Befehlszeilenmarkierung &quot;--disk-cache-dir&quot; überschrieben werden.</translation>
<translation id="3034580675120919256">Ermöglicht Ihnen festzulegen, ob Websites JavaScript ausführen dürfen. Das Ausführen von JavaScript kann entweder allen Websites gestattet oder für alle unterbunden werden. Wenn diese Richtlinie nicht konfiguriert ist, so kommt &quot;AllowJavaScript&quot; zum Einsatz, wobei der Nutzer dies ändern kann.</translation>
<translation id="193900697589383153">Fügt der Taskleiste eine Schaltfläche &quot;Abmelden&quot; hinzu.

      Wenn diese Option aktiviert wurde, wird während einer aktiven Sitzung und bei nicht gesperrtem Bildschirm eine große, rote Schaltfläche &quot;Abmelden&quot; in der Taskleiste angezeigt.

      Wenn diese Option deaktiviert oder nicht spezifiziert wurde, befindet sich in der Taskleiste keine große, rote Schaltfläche &quot;Abmelden&quot;.</translation>
<translation id="5111573778467334951">Geben Sie die Aktion an, die während des Akkubetriebs beim Erreichen der Leerlaufverzögerung ausgeführt werden soll.

          Wenn diese Richtlinie festgelegt ist, gibt sie die Aktion an, die <ph name="PRODUCT_OS_NAME"/> ausführt, wenn der Nutzer für die von der Leerlaufverzögerung angegebene Zeitdauer inaktiv ist. Diese Zeitdauer kann separat konfiguriert werden.

          Wenn diese Richtlinie nicht festgelegt ist, wird die Standardaktion ausgeführt: Es wird in den Suspend-Modus gewechselt.

          Wenn als Aktion der Wechsel in den Suspend-Modus festgelegt ist, kann <ph name="PRODUCT_OS_NAME"/> separat dafür konfiguriert werden, den Bildschirm zu sperren oder nicht zu sperren.</translation>
<translation id="3195451902035818945">Gibt an, ob SSL Record Splitting deaktiviert werden soll. Record Splitting ist eine Problemumgehung für eine Schwachstelle in SSL 3.0 und TLS 1.0, kann jedoch Kompatibilitätsprobleme mit einigen HTTPS-Servern und Proxys verursachen. Wenn die Richtlinie nicht konfiguriert oder &quot;False&quot; festgelegt ist, wird Record Splitting bei SSL/TLS-Verbindungen mit CBC-Cipher-Suites eingesetzt.</translation>
<translation id="6903814433019432303">Diese Richtlinie ist nur im Händlermodus aktiv.

      Bestimmt, welche URLs beim Start der Demo-Sitzung geladen werden. Mit dieser Richtlinie werden alle anderen Mechanismen zum Festlegen der Start-URL außer Kraft gesetzt. Die Richtlinie kann darum nur auf eine Sitzung angewandt werden, die keinem bestimmten Nutzer zugeordnet ist.</translation>
<translation id="5868414965372171132">Netzwerkkonfiguration auf Nutzerebene</translation>
<translation id="8519264904050090490">Manuell festgelegte Ausnahme-URLs für verwalteten Nutzer</translation>
<translation id="4480694116501920047">SafeSearch erzwingen</translation>
<translation id="465099050592230505">Unternehmens-Web-Store-URL (veraltet)</translation>
<translation id="2006530844219044261">Energieverwaltung</translation>
<translation id="1221359380862872747">Bei Demo-Anmeldung angegebene URLs laden</translation>
<translation id="8711086062295757690">Gibt das Suchkürzel an, das als die Verknüpfung fungiert, die in der Omnibox als Auslöser der Suche für diesen Anbieter verwendet wird. Diese Richtlinie ist optional. Wenn sie nicht konfiguriert ist, so wird der Suchanbieter von keinem Suchkürzel aktiviert. Diese Richtlinie wird nur umgesetzt, wenn die Richtlinie &quot;DefaultSearchProviderEnabled&quot; aktiviert ist.</translation>
<translation id="1152117524387175066">Meldet den Status des Entwicklerschalters des Geräts beim Start

      Wird die Richtlinie auf &quot;False&quot; gesetzt, wird der Status des Entwicklerschalters nicht gemeldet.</translation>
<translation id="5774856474228476867">Such-URL der Standardsuchmaschine</translation>
<translation id="4650759511838826572">URL-Protokollschemas deaktivieren</translation>
<translation id="7831595031698917016">Gibt die maximale Verzögerung in Millisekunden zwischen dem Empfang der Außerkraftsetzung einer Richtlinie und dem Abrufen der neuen Richtlinie vom Geräteverwaltungsdienst an.

      Durch das Festlegen dieser Richtlinie wird der Standardwert von 5.000 Millisekunden außer Kraft gesetzt. Für diese Richtlinie können Werte von 1.000 (1 Sekunde) bis 300.000 (5 Minuten) festgelegt werden. Werte außerhalb dieses Bereichs werden auf den nächstgelegenen Grenzwert gerundet.

      Bei Festlegung dieser Richtlinie verwendet <ph name="PRODUCT_NAME"/> den Standardwert von 5.000 Millisekunden.</translation>
<translation id="8099880303030573137">Inaktivitätsverzögerung im Akkubetrieb</translation>
<translation id="1709037111685927635">Hintergrundbild konfigurieren

      Mit dieser Richtlinie können Sie das Hintergrundbild konfigurieren, das auf dem Desktop und dem Anmeldebildschirm des Nutzers erscheint. Um die Richtlinie festzulegen, geben Sie die URL an, unter der <ph name="PRODUCT_OS_NAME"/> das Hintergrundbild herunterladen kann, und geben Sie einen kryptografischen Hashwert zur Überprüfung der Integrität des Downloads an. Das Bild muss im JPEG-Format vorliegen und darf maximal 16 MB groß sein. Der Zugriff auf die URL muss ohne Authentifizierung möglich sein.

      Das Hintergrundbild wird heruntergeladen und im Cache gespeichert. Ändert sich die URL oder der Hashwert, wird das Bild erneut heruntergeladen.

      Die Richtlinie wird in Form einer Zeichenfolge festgelegt, die die URL und den Hashwert im JSON-Format gemäß folgendem Schema enthält:
      {
        &quot;type&quot;: &quot;object&quot;,
        &quot;properties&quot;: {
          &quot;url&quot;: {
            &quot;description&quot;: &quot;URL, von der das Hintergrundbild heruntergeladen werden kann&quot;,
            &quot;type&quot;: &quot;string&quot;
          },
          &quot;hash&quot;: {
            &quot;description&quot;: &quot;SHA-256-Hashwert des Hintergrundbildes&quot;,
            &quot;type&quot;: &quot;string&quot;
          }
        }
      }

      Wenn die Richtlinie festgelegt wird, lädt <ph name="PRODUCT_OS_NAME"/> das Hintergrundbild herunter und verwendet es.

      In diesem Fall kann die Richtlinie nicht durch Nutzer geändert oder überschrieben werden.

      Wenn die Richtlinie nicht festgelegt wird, kann der Nutzer ein Bild auswählen, das auf dem Desktop und dem Anmeldebildschirm erscheint.</translation>
<translation id="2761483219396643566">Inaktivitätsspanne bis zur Warnung im Akkubetrieb</translation>
<translation id="6281043242780654992">Konfiguriert Richtlinien für das native Messaging. Hosts für natives Messaging auf der schwarzen Liste können nur geladen werden, wenn sie auch auf der weißen Liste stehen.</translation>
<translation id="1468307069016535757">Hiermit wird der Standardstatus der Bedienungshilfefunktion für den Modus mit hohem Kontrast auf der Anmeldeseite festgelegt.

          Ist diese Richtlinie auf &quot;true&quot; gesetzt, ist der Modus mit hohem Kontrast aktiviert, wenn die Anmeldeseite angezeigt wird.

          Ist diese Richtlinie auf &quot;false&quot; gesetzt, ist der Modus mit hohem Kontrast deaktiviert, wenn die Anmeldeseite angezeigt wird.

          Wenn Sie diese Richtlinie konfigurieren, können die Nutzer sie vorübergehend außer Kraft setzen, indem sie den Modus mit hohem Kontrast aktivieren bzw. deaktivieren. Die Nutzerauswahl ist jedoch nicht dauerhaft und die Standardeinstellung wird wiederhergestellt, sobald die Anmeldeseite erneut angezeigt wird oder der Nutzer auf der Anmeldeseite eine Minute lang inaktiv ist.

          Falls diese Richtlinie nicht konfiguriert wird, ist der Modus mit hohem Kontrast deaktiviert, wenn die Anmeldeseite das erste Mal angezeigt wird. Die Nutzer können den Modus mit hohem Kontrast jederzeit aktivieren oder deaktivieren und dieser Status bleibt auf der Anmeldeseite erhalten.</translation>
<translation id="602728333950205286">Google Instant-URL der Standardsuchmaschine</translation>
<translation id="3030000825273123558">Messdatenberichte aktivieren</translation>
<translation id="8465065632133292531">Parameter für URL der Suche im Voraus, die POST verwendet</translation>
<translation id="6559057113164934677">Keine Website darf auf meine Kamera oder mein Mikrofon zugreifen</translation>
<translation id="7273823081800296768">Wenn diese Einstellung aktiviert oder nicht konfiguriert ist, kann der Nutzer beim Herstellen der Verbindung ein Pairing von Clients und Hosts durchführen. Dadurch braucht nicht jedes Mal eine PIN eingegeben zu werden.

          Bei Deaktivierung dieser Einstellung ist diese Funktion nicht verfügbar.</translation>
<translation id="1675002386741412210">Unterstützt von:</translation>
<translation id="1608755754295374538">URLs, denen ohne Nachfrage Zugriff auf Audioaufnahmegeräte gestattet wird</translation>
<translation id="3547954654003013442">Proxy-Einstellungen</translation>
<translation id="5921713479449475707">Downloads automatischer Updates über HTTP zulassen</translation>
<translation id="4482640907922304445">Zeigt die Schaltfläche &quot;Startseite&quot; in der Symbolleiste von <ph name="PRODUCT_NAME"/> an. Wenn Sie diese Einstellung aktivieren, so wird die Schaltfläche &quot;Startseite&quot; immer angezeigt. Sollten Sie sie deaktivieren, erscheint die Schaltfläche nicht. Ist diese Einstellung aktiviert oder deaktiviert, können Nutzer sie in <ph name="PRODUCT_NAME"/> nicht ändern oder außer Kraft setzen. Ist die Richtlinie nicht konfiguriert, so kann der Nutzer selbst bestimmen, ob die Schaltfläche &quot;Startseite&quot; zur Verfügung stehen soll.</translation>
<translation id="2518231489509538392">Wiedergabe von Audioinhalten zulassen</translation>
<translation id="8146727383888924340">Nutzern das Einlösen von Angeboten über die Chrome OS-Registrierung gestatten</translation>
<translation id="7301543427086558500">Definiert eine Liste alternativer URLs, mit denen Suchbegriffe aus der Suchmaschine extrahiert werden können. Die URLs sollten den String <ph name="SEARCH_TERM_MARKER"/> enthalten, der zum Extrahieren der Suchbegriffe verwendet wird.

          Diese Richtlinie ist optional. Wird sie nicht festgelegt, werden keine alternativen URLs zum Extrahieren von Suchbegriffen verwendet.

          Diese Richtlinie wird nur befolgt, wenn die Richtlinie &quot;DefaultSearchProviderEnabled&quot; aktiviert ist.</translation>
<translation id="436581050240847513">Gerätenetzwerk-Schnittstellen melden</translation>
<translation id="6282799760374509080">Audioaufzeichnung gestatten oder ablehnen</translation>
<translation id="8864975621965365890">Unterdrückung des Hinweises auf Einstellung des Frames, der beim Rendern einer Website durch <ph name="PRODUCT_FRAME_NAME"/> erscheint</translation>
<translation id="3264793472749429012">Standardsuchmaschinen-Codierungen</translation>
<translation id="285480231336205327">Modus mit hohem Kontrast aktivieren</translation>
<translation id="5366977351895725771">Wurde &quot;false&quot; festgelegt, kann dieser Nutzer keine betreuten Nutzer erstellen. Alle vorhandenen betreuten Nutzer sind weiterhin verfügbar.

          Wurde &quot;true&quot; oder &quot;not configured&quot; festgelegt, kann dieser Nutzer betreute Nutzer erstellen und verwalten.</translation>
<translation id="5469484020713359236">Ermöglicht Ihnen die Zusammenstellung einer Liste mit URL-Mustern, die Websites angeben, denen das Speichern von Cookies gestattet ist. Wenn diese Richtlinie nicht konfiguriert ist, kommt für alle Websites entweder der globale Standardwert der Richtlinie &quot;DefaultCookiesSetting&quot;, sofern konfiguriert, oder der persönlichen Konfiguration des Nutzers zum Einsatz.</translation>
<translation id="1504431521196476721">Remote-Bestätigung</translation>
<translation id="1881299719020653447">Web Store auf der Seite &quot;Neuer Tab&quot; und im App Launcher ausblenden</translation>
<translation id="930930237275114205">Verzeichnis für <ph name="PRODUCT_FRAME_NAME"/>-Nutzerdaten festlegen</translation>
<translation id="244317009688098048">Aktiviert Tastenkombination zur Umgehung der automatischen Anmeldung.

Falls diese Richtlinie auf &quot;true&quot; gesetzt oder nicht festgelegt wird und bei einem gerätespezifischen lokalen Konto eine verzögerungsfreie automatische Anmeldung konfiguriert ist, dann erlaubt es <ph name="PRODUCT_OS_NAME"/>, mit dem Tastaturkürzel Strg+Alt+S die automatische Anmeldung zu umgehen und stattdessen den Anmeldebildschirm aufzurufen.

Falls die Richtlinie auf &quot;false&quot; gesetzt wird, kann eine verzögerungsfreie automatische Anmeldung, sofern konfiguriert, nicht umgangen werden.</translation>
<translation id="5208240613060747912">Ermöglicht Ihnen die Zusammenstellung einer Liste mit URL-Mustern, die Websites angeben, denen es nicht gestattet ist, Benachrichtigungen anzuzeigen. Wenn diese Richtlinie nicht konfiguriert ist, kommt für alle Websites entweder der globale Standardwert der Richtlinie &quot;DefaultNotificationsSetting&quot;, sofern konfiguriert, oder der persönlichen Konfiguration des Nutzers zum Einsatz.</translation>
<translation id="346731943813722404">Damit legen Sie fest, ob die erste Aktivität des Nutzers in einer Sitzung als Ausgangspunkt für Verzögerungen beim Energiesparmodus und Begrenzungen der Sitzungslänge verwendet werden soll.
          Wenn diese Richtlinie auf &quot;true&quot; gesetzt ist, wie die erste Aktivität des Nutzers in einer Sitzung als Ausgangspunkt für Verzögerungen beim Energiesparmodus und Begrenzungen der Sitzungslänge verwendet.

          Ist die Richtlinie auf &quot;false&quot; gesetzt oder nicht definiert, wird der Start der Sitzung als Ausgangspunkt für Verzögerungen beim Energiesparmodus und Begrenzungen der Sitzungslänge verwendet.</translation>
<translation id="4600786265870346112">Großen Cursor aktivieren</translation>
<translation id="5887414688706570295">Konfiguriert das TalkGadget-Präfix, das von Remote-Zugriff-Hosts verwendet wird, und verhindert, dass dieses von Nutzern geändert werden kann.

          Wenn dieses Präfix angegeben wird, wird es dem TalkGadget-Basisnamen vorangestellt, um einen vollständigen Domain-Namen für das TalkGadget zu erstellen. Der Basisname der TalkGadget-Domain lautet &quot;.talkgadget.google.com&quot;.

          Wenn diese Einstellung aktiviert ist, verwenden die Hosts beim Zugriff auf das TalkGadget den benutzerdefinierten Domain-Namen anstelle des Standard-Domain-Namens.

          Ist die Einstellung deaktiviert oder nicht festgelegt, wird der Standard-Domain-Name für das TalkGadget (&quot;chromoting-host.talkgadget.google.com&quot;) für alle Hosts verwendet.

          Clients für den Remote-Zugriff sind von dieser Richtlinieneinstellung nicht betroffen. Diese verwenden immer &quot;chromoting-client.talkgadget.google.com&quot; für den Zugriff auf das TalkGadget.</translation>
<translation id="1103860406762205913">Aktiviert die alte webbasierte Anmeldung</translation>
<translation id="5765780083710877561">Beschreibung:</translation>
<translation id="6915442654606973733">Hiermit wird die Bedienungshilfefunktion für das gesprochene Feedback aktiviert.

          Ist diese Richtlinie auf &quot;true&quot; gesetzt, ist das gesprochene Feedback immer aktiviert.

          Ist diese Richtlinie auf &quot;false&quot; gesetzt, ist das gesprochene Feedback immer deaktiviert.

          Wenn Sie diese Richtlinie konfigurieren, können die Nutzer sie nicht ändern oder außer Kraft setzen.

          Wird diese Richtlinie nicht konfiguriert, ist das gesprochene Feedback zunächst deaktiviert, kann aber von den Nutzern jederzeit aktiviert werden.</translation>
<translation id="7796141075993499320">Ermöglicht die Zusammenstellung einer Liste mit URL-Mustern, die Websites angeben, denen die Ausführung von Plug-ins gestattet ist. Wenn diese Richtlinie nicht konfiguriert ist, kommt für alle Websites entweder der globale Standardwert der Richtlinie &quot;DefaultPluginsSetting&quot;, sofern konfiguriert, oder der persönlichen Konfiguration des Nutzers zu Einsatz.</translation>
<translation id="3809527282695568696">Wenn &quot;URL-Liste öffnen&quot; als Startaktion ausgewählt wird, können Sie hier die Liste der zu öffnenden URLs zusammenstellen. Sollte die Richtlinie nicht konfiguriert sein, so wird keine URL beim Start geöffnet. Sie wird nur umgesetzt, wenn die Richtlinie &quot;RestoreOnStartup&quot; auf &quot;RestoreOnStartupIsURLs&quot; eingestellt ist.</translation>
<translation id="649418342108050703">Diese Richtlinie deaktiviert die Unterstützung für 3D-Grafik-APIs. Ist diese Einstellung aktiviert, können Webseiten nicht auf die GPU (Graphics Processing Unit) zugreifen. Insbesondere können Webseiten nicht auf das WebGL-API zugreifen und Plug-ins können das Pepper-3D-API nicht verwenden. Ist diese Einstellung deaktiviert oder nicht konfiguriert, können Webseiten möglicherweise auf das WebGL-API zugreifen und Plug-ins auf das Pepper-3D-API. Bei der Standardeinstellung des Browsers kann es weiterhin erforderlich sein, dass zur Verwendung dieser APIs Argumente über die Eingabeaufforderung übergeben werden.</translation>
<translation id="2077273864382355561">Verzögerung für die Bildschirmabschaltung im Akkubetrieb</translation>
<translation id="9112897538922695510">Damit können Sie eine Liste mit Protokoll-Handlern registrieren, wobei dies lediglich eine empfohlene Richtlinie sein kann. Für die Eigenschaft |protocol| sollte ein Schema wie &quot;mailto&quot; und für die Eigenschaft |url| das URL-Muster der Anwendung festgelegt werden, die das Schema verwaltet. Das Muster kann &quot;%s&quot; enthalten, was später durch die jeweilige URL ersetzt wird.

          Die von der Richtlinie registrierten Protokoll-Handler werden mit den Protokoll-Handlern zusammengeführt, die vom Nutzer registriert wurden, und können gemeinsam verwendet werden. Der Nutzer kann die durch die Richtlinie installierten Protokoll-Handler durch Installieren eines neuen standardmäßigen Handlers überschreiben. Ein von der Richtlinie registrierter Protokoll-Handler kann jedoch nicht entfernt werden.</translation>
<translation id="3417418267404583991">Wenn diese Richtlinie auf &quot;true&quot; gesetzt oder nicht konfiguriert ist, sind Gastanmeldungen in <ph name="PRODUCT_OS_NAME"/> möglich. Eine Anmeldung als Gast erfolgt anonym und erfordert keine Passworteingabe.

      Ist die Richtlinie auf &quot;false&quot; eingestellt, können in <ph name="PRODUCT_OS_NAME"/> keine Gastsitzungen gestartet werden.</translation>
<translation id="8329984337216493753">Diese Richtlinie ist nur im Händlermodus aktiv.

      Falls die Richtlinie &quot;DeviceIdleLogoutTimeout&quot; konfiguriert ist, wird mithilfe der vorliegenden Richtlinie festgelegt, wie lange das Warnfenster mit Countdown für Nutzer zu sehen sein soll, bevor sie abgemeldet werden.

      Der Wert für die Richtlinie sollte in Millisekunden angegeben werden.</translation>
<translation id="237494535617297575">Ermöglicht Ihnen die Zusammenstellung einer Liste mit URL-Mustern, die Websites angeben, denen das Anzeigen von Benachrichtigungen gestattet ist. Wenn diese Richtlinie nicht konfiguriert ist, kommt für alle Websites entweder der globale Standardwert der Richtlinie &quot;DefaultNotificationsSetting&quot;, sofern konfiguriert, oder der persönlichen Konfiguration des Nutzers zum Einsatz.</translation>
<translation id="527237119693897329">Ermöglicht Ihnen, festzulegen, welche Hosts für natives Messaging nicht geladen werden sollen

          Der Wert &quot;*&quot; für die schwarze Liste bedeutet, dass alle Hosts für natives Messaging in die schwarze Liste aufgenommen werden, es sei denn, sie stehen explizit auf der weißen Liste.

          Wenn für diese Richtlinie kein Wert angegeben wird, lädt <ph name="PRODUCT_NAME"/> alle installierten Hosts für natives Messaging.</translation>
<translation id="749556411189861380">Meldet die Betriebssystem- und Firmwareversion von registrierten Geräten

      Wird diese Einstellung nicht konfiguriert oder auf &quot;True&quot; gesetzt, melden registrierte Geräte in regelmäßigen Abständen ihre Betriebssystem- und Firmwareversion. Wird für diese Einstellung &quot;False&quot; festgelegt, werden keine Informationen zur Version gemeldet.</translation>
<translation id="7258823566580374486">Zugangsbeschränkung für Remote-Zugriff-Hosts aktivieren</translation>
<translation id="5560039246134246593">Hiermit fügen Sie beim Abrufen des Varianten-Seeds in <ph name="PRODUCT_NAME"/> einen Parameter hinzu.

      Ist die Richtlinie konfiguriert, wird der Abfrageparameter &quot;restrict&quot; zu der URL hinzugefügt, über die der Varianten-Seed abgerufen wird. Den Wert des Parameters legen Sie in dieser Richtlinie fest.

      Ist die Richtlinie nicht konfiguriert, bleibt die URL zum Abrufen des Varianten-Seeds unverändert.</translation>
<translation id="944817693306670849">Datenträger-Cache-Größe festlegen</translation>
<translation id="8544375438507658205">Standardanwendung für HTML-Darstellung in <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="2371309782685318247">Gibt das Intervall in Millisekunden an, in dem Informationen zu Nutzerrichtlinien vom Geräteverwaltungsdienst abgerufen werden.

      Durch das Festlegen dieser Richtlinie wird der Standardwert von 3 Stunden außer Kraft gesetzt. Gültige Werte für diese Richtlinie liegen im Bereich zwischen 1800000 (30 Minuten) und 86400000 (1 Tag). Alle Werte, die nicht in diesem Bereich liegen, werden auf den jeweiligen Grenzwert gesetzt.

      Wenn diese Richtlinie nicht konfiguriert ist, gilt in <ph name="PRODUCT_NAME"/> der Standardwert von 3 Stunden.</translation>
<translation id="2571066091915960923">Aktiviert oder deaktiviert den Proxy für die Datenkomprimierung und verhindert, dass die Nutzer diese Einstellung ändern können.

      Wenn Sie diese Einstellung aktivieren oder deaktivieren, können die Nutzer sie nicht ändern oder überschreiben.

      Ist die Richtlinie nicht festgelegt, kann der Nutzer festlegen, ob die Funktion für den Datenkomprimierungs-Proxy verwendet werden soll oder nicht.</translation>
<translation id="2170233653554726857">WPAD-Optimierung aktivieren</translation>
<translation id="7424751532654212117">Liste der Ausnahmen von der Liste der deaktivierten Plug-ins</translation>
<translation id="6233173491898450179">Downloadverzeichnis festlegen</translation>
<translation id="8908294717014659003">Hier können Sie festlegen, ob Websites der Zugriff auf Medienaufnahmegeräte erlaubt werden soll. Der Zugriff auf Medienaufnahmegeräte kann standardmäßig zugelassen werden oder Sie können einstellen, dass der Nutzer jedes Mal gefragt wird, wenn eine Website auf Medienaufnahmegeräte zugreifen möchte.

          Ist diese Richtlinie nicht konfiguriert, wird &quot;PromptOnAccess&quot; verwendet und der Nutzer kann diese Einstellung ändern.</translation>
<translation id="4429220551923452215">Aktiviert oder deaktiviert die App-Verknüpfung in der Lesezeichenleiste

      Wenn diese Richtlinie nicht konfiguriert wird, kann der Nutzer im Kontextmenü der Lesezeichenleiste wählen, ob die App-Verknüpfung ein- oder ausgeblendet wird.

      Wird diese Richtlinie konfiguriert, kann der Nutzer sie nicht ändern und die App-Verknüpfung wird entweder immer oder nie angezeigt.</translation>
<translation id="2299220924812062390">Liste der aktivierten Plug-ins angeben</translation>
<translation id="4325690621216251241">Schaltfläche &quot;Abmelden&quot; zur Taskleiste hinzufügen</translation>
<translation id="924557436754151212">Gespeicherte Passwörter bei erster Ausführung aus Standardbrowser importieren</translation>
<translation id="1465619815762735808">Click-to-Play</translation>
<translation id="7227967227357489766">Definiert eine Liste mit Nutzern, die sich auf dem Gerät anmelden dürfen. Die Einträge haben das Format <ph name="USER_WHITELIST_ENTRY_FORMAT"/>, zum Beispiel <ph name="USER_WHITELIST_ENTRY_EXAMPLE"/>. Um allen Nutzern in einer Domain die Anmeldung zu erlauben, verwenden Sie Einträge im Format <ph name="USER_WHITELIST_ENTRY_WILDCARD"/>.

       Falls diese Richtlinie nicht konfiguriert ist, gibt es keine Beschränkungen, welche Nutzer sich anmelden dürfen. Zum Erstellen neuer Nutzer muss aber weiterhin die Richtlinie &quot;<ph name="DEVICEALLOWNEWUSERS_POLICY_NAME"/>&quot; entsprechend konfiguriert werden.</translation>
<translation id="2521581787935130926">App-Verknüpfung in der Lesezeichenleiste anzeigen</translation>
<translation id="8135937294926049787">Hiermit wird angegeben, nach welchem Zeitraum ohne Nutzereingabe der Bildschirm im Netzbetrieb abgeschaltet wird.

          Wenn für diese Richtlinie ein höherer Wert als null festgelegt wird, gibt dieser an, wie lange ein Nutzer inaktiv sein muss, bevor <ph name="PRODUCT_OS_NAME"/> den Bildschirm abschaltet.

          Ist die Richtlinie auf null eingestellt, wird der Bildschirm von <ph name="PRODUCT_OS_NAME"/> nicht abgeschaltet, wenn der Nutzer inaktiv wird.

           Wenn die Richtlinie nicht konfiguriert ist, wird ein Standardwert verwendet.

          Der Wert für die Richtlinie muss in Millisekunden angegeben werden. Werte müssen kleiner oder gleich dem Wert für die Inaktivitätsverzögerung sein.</translation>
<translation id="1897365952389968758">Ausführung von JavaScript für alle Websites zulassen</translation>
<translation id="922540222991413931">Installationsquellen für Erweiterungen, Apps und Nutzerskripte konfigurieren</translation>
<translation id="7323896582714668701">Zusätzliche Befehlszeilenparameter für <ph name="PRODUCT_NAME"/></translation>
<translation id="6931242315485576290">Synchronisierung der Daten mit Google deaktivieren</translation>
<translation id="1330145147221172764">Bildschirmtastatur aktivieren</translation>
<translation id="7006788746334555276">Inhaltseinstellungen</translation>
<translation id="450537894712826981">Konfiguriert die Cache-Größe, die <ph name="PRODUCT_NAME"/> zum Speichern von Mediendateien im Cache auf dem Datenträger verwendet.

      Wenn Sie diese Richtlinie festlegen, verwendet <ph name="PRODUCT_NAME"/> die angegebene Cache-Größe unabhängig davon, ob der Nutzer den Parameter &quot;--media-cache-size&quot; angegeben hat oder nicht. Der in dieser Richtlinie angegebene Wert ist keine festgelegte Grenze, sondern mehr ein Richtwert für das Caching-System. Werte, die unter wenigen Megabytes liegen, sind zu klein und werden auf einen sinnvollen Minimalwert aufgerundet.

      Wenn der Wert dieser Richtlinie 0 beträgt, wird die Standard-Cache-Größe verwendet. Der Nutzer kann diese jedoch nicht ändern.

      Wird diese Richtlinie nicht festgelegt, wird die Standardgröße verwendet und der Nutzer kann diese mit dem Parameter &quot;--media-cache-size&quot; überschreiben.</translation>
<translation id="5142301680741828703">Folgende URL-Muster immer in <ph name="PRODUCT_FRAME_NAME"/> darstellen</translation>
<translation id="4625915093043961294">Weiße Liste für Installation von Erweiterungen konfigurieren</translation>
<translation id="5893553533827140852">Wenn diese Einstellung aktiviert ist, wird für Anfragen zur Gnubby-Authentifizierung ein Proxy über eine Remotehostverbindung verwendet.

Wenn diese Einstellung deaktiviert oder nicht konfiguriert ist, wird kein Proxy für Anfragen zur Gnubby-Authentifizierung verwendet.</translation>
<translation id="187819629719252111">Ermöglicht den Zugriff auf lokale Dateien auf dem Computer, indem <ph name="PRODUCT_NAME"/> gestattet wird, Dialogfelder zur Dateiauswahl anzuzeigen. Wenn Sie diese Einstellung aktivieren, können Nutzer Dateiauswahl-Dialogfelder wie gewohnt öffnen. Ist diese Einstellung deaktiviert, wird bei jeder Nutzeraktion, bei der ein Dialogfeld zur Dateiauswahl angezeigt werden würde, etwa beim Importieren von Lesezeichen, beim Hochladen von Dateien oder beim Speichern von Links, stattdessen eine Meldung angezeigt. Außerdem wird davon ausgegangen, dass der Nutzer im Dialogfeld zur Dateiauswahl auf &quot;Abbrechen&quot; geklickt hat. Wenn diese Einstellung nicht konfiguriert ist, so können Nutzer Dateiauswahl-Dialogfelder wie gewohnt öffnen.</translation>
<translation id="4507081891926866240">Passt die Liste mit URL-Mustern an, die immer von <ph name="PRODUCT_FRAME_NAME"/> gerendert werden müssen. Wenn diese Richtlinie nicht konfiguriert ist, kommt der über die Richtlinie &quot;ChromeFrameRendererSettings&quot; festgelegte Standard-Renderer zum Einsatz. Beispielmuster finden Sie unter http://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="3101501961102569744">Auswählen, wie Proxyserver-Einstellungen angegeben werden</translation>
<translation id="1803646570632580723">Liste der in der Übersicht angezeigten Apps ansehen</translation>
<translation id="1062011392452772310">Remote-Bescheinigung (Remote Attestation) für das Gerät aktivieren</translation>
<translation id="7774768074957326919">System-Proxy-Einstellungen verwenden</translation>
<translation id="3891357445869647828">JavaScript aktivieren</translation>
<translation id="2274864612594831715">Diese Richtlinie konfiguriert die Aktivierung der Bildschirmtastatur als Eingabegerät unter Chrome OS. Diese Richtlinie kann nicht von Nutzern überschrieben werden.

      Falls für die Richtlinie &quot;True&quot; festgelegt ist, ist die Bildschirmtastatur immer aktiviert.

      Bei Auswahl von &quot;False&quot; ist die Bildschirmtastatur immer deaktiviert.

      Falls Sie diese Richtlinie konfigurieren, können Nutzer diese weder ändern noch überschreiben, haben jedoch weiterhin die Möglichkeit, eine Bildschirmtastatur als Eingabehilfe zu aktivieren bzw. zu deaktivieren. Diese hat dann Vorrang vor der Bildschirmtastatur dieser Richtlinie. Die Steuerung der Bildschirmtastatur als Eingabehilfe ist über die Richtlinie |VirtualKeyboardEnabled| möglich.

      Falls diese Richtlinie nicht konfiguriert ist, ist die Bildschirmtastatur zunächst deaktiviert, kann jedoch vom Nutzer jederzeit aktiviert werden. Anhand von heuristischen Regeln kann darüber hinaus festgelegt werden, wann die Tastatur eingeblendet wird.</translation>
<translation id="6774533686631353488">Hosts für natives Messaging, die ohne Berechtigung des Administrators installiert wurden, auf Nutzerebene zulassen</translation>
<translation id="868187325500643455">Automatische Ausführung von Plug-ins für alle Websites zulassen</translation>
<translation id="7421483919690710988">Cache-Größe für Mediendatenträger in Byte festlegen</translation>
<translation id="5226033722357981948">Angeben, ob Plug-in-Suchfunktion deaktiviert werden soll</translation>
<translation id="7234280155140786597">Namen der unzulässigen Hosts für natives Messaging (oder &quot;*&quot; für alle)</translation>
<translation id="4890209226533226410">Hiermit wird der aktivierte Lupentyp festgelegt.

          Wenn diese Richtlinie konfiguriert wird, wird damit festgelegt, welcher Lupentyp aktiviert werden soll. Bei Festlegung auf &quot;None&quot; wird die Lupe deaktiviert.

          Wenn Sie diese Richtlinie konfigurieren, können die Nutzer sie nicht ändern oder außer Kraft setzen.

          Wird diese Richtlinie nicht konfiguriert, ist die Lupe zunächst deaktiviert, kann aber von den Nutzern jederzeit aktiviert werden.</translation>
<translation id="3428247105888806363">Netzwerkvervollständigung aktivieren</translation>
<translation id="3460784402832014830">Gibt die URL an, die eine Suchmaschine zum Bereitstellen der &quot;Neuer Tab&quot;-Seite verwendet.

          Diese Richtlinie ist optional. Ist sie nicht festgelegt, wird keine &quot;Neuer Tab&quot;-Seite bereitgestellt.

          Die Richtlinie wird nur berücksichtigt, wenn die Richtlinie &quot;DefaultSearchProviderEnabled&quot; aktiviert ist.</translation>
<translation id="6145799962557135888">Ermöglicht Ihnen die Zusammenstellung einer Liste mit URL-Mustern, die Websites angeben, denen die Ausführung von JavaScript gestattet ist. Wenn diese Richtlinie nicht konfiguriert ist, kommt für alle Websites entweder der globale Standardwert der Richtlinie &quot;DefaultJavaScriptSetting&quot;, falls konfiguriert, oder der persönlichen Konfiguration des Nutzers zum Einsatz.</translation>
<translation id="2757054304033424106">Typen von Erweiterungen bzw. Apps, die installiert werden können</translation>
<translation id="7053678646221257043">Bei Aktivierung erzwingt diese Richtlinie, dass die Lesezeichen vom aktuellen Standardbrowser importiert werden. Wenn Sie deaktiviert ist, werden keine Lesezeichen importiert. Sollte Sie nicht konfiguriert sein, wird der Nutzer gefragt, ob ein Import erfolgen soll, oder der Import findet automatisch statt.</translation>
<translation id="5757829681942414015">Konfiguriert das Verzeichnis, in dem <ph name="PRODUCT_NAME"/> Nutzerdaten speichert.

      Wenn Sie diese Richtlinie festlegen, verwendet <ph name="PRODUCT_NAME"/> das angegebene Verzeichnis unabhängig davon, ob der Nutzer die Markierung &quot;--user-data-dir&quot; festgelegt hat.

      Unter &quot;http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables&quot; finden Sie eine Liste der Variablen, die verwendet werden können.

      Bleibt diese Richtlinie unkonfiguriert, wird der Standardpfad des Profils verwendet. Dieser kann dann vom Nutzer mit der Befehlszeilenmarkierung &quot;--user-data-dir&quot; überschrieben werden.</translation>
<translation id="5067143124345820993">Weiße Liste für Nutzer bei der Anmeldung</translation>
<translation id="2514328368635166290">Gibt die Favicon-URL für den Standardsuchanbieter an. Diese Richtlinie ist optional. Wenn sie nicht konfiguriert ist, so erscheint kein Symbol für den Suchanbieter. Diese Richtlinie wird nur umgesetzt, wenn die Richtlinie &quot;DefaultSearchProviderEnabled&quot; aktiviert ist.</translation>
<translation id="7194407337890404814">Name der Standardsuchmaschine</translation>
<translation id="1843117931376765605">Aktualisierungsrate für Nutzerrichtlinien</translation>
<translation id="5535973522252703021">Weiße Liste für Kerberos-Bevollmächtigungs-Server</translation>
<translation id="9187743794267626640">Bereitstellen von externem Speicher deaktivieren</translation>
<translation id="6353901068939575220">Gibt die Parameter für die Suche nach einer URL mit POST an. Sie besteht aus durch Komma getrennten Name/Wert-Paaren. Wenn ein Wert ein Vorlagenparameter wie z. B. {searchTerms} im obigen Beispiel ist, wird er durch echte Suchbegriffsdaten ersetzt.

          Diese Richtlinie ist optional. Wenn sie nicht festlegt ist, wird die Suchanfrage mithilfe der GET-Methode gesendet.

          Diese Richtlinie wird nur berücksichtigt, wenn die Richtlinie &quot;DefaultSearchProviderEnabled&quot; aktiviert ist.</translation>
<translation id="5307432759655324440">Inkognito-Modus - Verfügbarkeit</translation>
<translation id="4056910949759281379">SPDY-Protokoll deaktivieren</translation>
<translation id="3808945828600697669">Liste der deaktivierten Plug-ins angeben</translation>
<translation id="4525521128313814366">Ermöglicht Ihnen die Zusammenstellung einer Liste mit URL-Mustern, die Websites angeben, denen das Anzeigen von Bildern nicht gestattet ist. Wenn diese Richtlinie nicht konfiguriert ist, kommt für alle Websites entweder der globale Standardwert der Richtlinie &quot;DefaultImagesSetting&quot;, falls konfiguriert, oder der persönlichen Konfiguration des Nutzers zum Einsatz.</translation>
<translation id="8499172469244085141">Standardeinstellungen (können vom Nutzer überschrieben werden)</translation>
<translation id="4816674326202173458">Unternehmensnutzer sowohl als primären als auch als sekundären Nutzer zulassen (Standardverhalten für nicht verwaltete Nutzer)</translation>
<translation id="8693243869659262736">Integrierten DNS-Client verwenden</translation>
<translation id="3072847235228302527">Nutzungsbedingungen für ein lokales Gerätekonto festlegen</translation>
<translation id="5523812257194833591">Hiermit geben Sie die öffentliche Sitzung an, in der ein Nutzer nach einer bestimmten Zeitspanne automatisch angemeldet wird.

      Ist diese Richtlinie festgelegt, wird der Nutzer nach Ablauf einer bestimmten Zeitspanne der Inaktivität beim Anmeldebildschirm automatisch in der angegebenen Sitzung angemeldet. Die öffentliche Sitzung muss vorher konfiguriert werden, siehe |DeviceLocalAccounts|.

      Ist die Richtlinie nicht festgelegt, wird der Nutzer nicht automatisch angemeldet.</translation>
<translation id="5983708779415553259">Standardverhalten für Websites, die nicht zu einem Inhaltspaket gehören</translation>
<translation id="3866530186104388232">Wenn diese Richtlinie auf &quot;true&quot; gesetzt oder nicht konfiguriert ist, werden in <ph name="PRODUCT_OS_NAME"/> vorhandene Nutzer auf der Anmeldeseite aufgeführt und der Nutzer kann einen Namen auswählen. Ist die Richtlinie auf &quot;false&quot; eingestellt, wird in <ph name="PRODUCT_OS_NAME"/> eine Aufforderung zur Eingabe von Nutzername und Passwort angezeigt.</translation>
<translation id="7384902298286534237">Ermöglicht Ihnen die Erstellung einer Liste mit URL-Mustern, die Websites angeben, denen das Speichern von Sitzungscookies gestattet ist.

          Dies sind Cookies, die jeweils nur für eine Sitzung gültig sind. Ist diese Richtlinie nicht konfiguriert, kommt für alle Websites entweder der globale Standardwert der Richtlinie &quot;DefaultCookiesSetting&quot;, sofern konfiguriert, oder die persönliche Konfiguration des Nutzers zum Einsatz.

          Falls mit der Richtlinie &quot;RestoreOnStartup&quot; das Wiederherstellen von URLs aus vorherigen Sitzungen aktiviert ist, wird die vorliegende Richtlinie nicht berücksichtigt und Cookies für diese Websites werden dauerhaft gespeichert.</translation>
<translation id="2098658257603918882">Berichte mit Nutzungs- und Absturzdaten erstellen</translation>
<translation id="4633786464238689684">Ändert das Standardverhalten der Tasten in der obersten Reihe zu Funktionstastenverhalten

Wenn die Richtlinie auf &quot;TRUE&quot; gesetzt wird, führt die oberste Reihe der Tastatur standardmäßig Funktionstastenbefehle aus. Um die Tasten stattdessen wieder als Medientasten zu verwenden, drückt der Nutzer die Suchtaste.

Wenn die Richtlinie auf &quot;FALSE&quot; gesetzt oder nicht festgelegt wird, führt die Tastatur standardmäßig Medientastenbefehle aus und führt bei gedrückter Suchtaste Funktionstastenbefehle aus.</translation>
<translation id="2324547593752594014">Anmeldung in Chrome zulassen</translation>
<translation id="172374442286684480">Speichern von lokalen Daten für alle Websites zulassen</translation>
<translation id="1151353063931113432">Bilder auf diesen Websites zulassen</translation>
<translation id="1297182715641689552">PAC-Proxy-Skript verwenden</translation>
<translation id="2976002782221275500">Hiermit wird angegeben, nach welchem Zeitraum ohne Nutzereingabe der Bildschirm im Akkubetrieb abgedunkelt wird.

          Wenn für diese Richtlinie ein höherer Wert als null festgelegt wird, gibt dieser an, wie lange ein Nutzer inaktiv sein muss, bevor <ph name="PRODUCT_OS_NAME"/> den Bildschirm abdunkelt.

          Ist die Richtlinie auf null eingestellt, wird der Bildschirm von <ph name="PRODUCT_OS_NAME"/> nicht abgedunkelt, wenn der Nutzer inaktiv wird.

          Wenn die Richtlinie nicht konfiguriert ist, wird ein Standardwert verwendet.

          Der Wert für die Richtlinie muss in Millisekunden angegeben werden. Werte müssen kleiner oder gleich dem Wert der Verzögerung für die Bildschirmabschaltung (falls angegeben) und der Inaktivitätsverzögerung sein.</translation>
<translation id="8631434304112909927">Bis Version <ph name="UNTIL_VERSION"/></translation>
<translation id="7469554574977894907">Suchvorschläge aktivieren</translation>
<translation id="4906194810004762807">Aktualisierungsrate für Geräterichtlinien</translation>
<translation id="8922668182412426494">Server, auf die <ph name="PRODUCT_NAME"/> zur Authentifizierung verweisen darf.

          Fügen Sie zwischen die verschiedenen Servernamen ein Komma als Trennzeichen ein. Platzhalter (*) sind erlaubt.

          Wenn Sie diese Richtlinie nicht konfigurieren, leitet Chrome keine Anmeldedaten von Nutzern weiter, auch nicht an Server innerhalb des Intranets.</translation>
<translation id="1398889361882383850">Mit dieser Richtlinie können Sie festlegen, ob Websites Plug-ins automatisch ausführen dürfen. Das automatische Ausführen von Plug-ins kann entweder allen Websites gestattet oder für alle Websites unterbunden werden.

           Click-to-Play ermöglicht die Ausführung von Plug-ins. Der Nutzer muss jedoch darauf klicken, um die Ausführung zu initiieren.

          Wird diese Richtlinie nicht konfiguriert, wird die Richtlinie &quot;AllowPlugins&quot; genutzt, die der Nutzer ändern kann.</translation>
<translation id="7974114691960514888">Diese Richtlinie wird nicht mehr unterstützt. Sie aktiviert beim Verbinden zu einem Remote-Client den Einsatz von STUN und Relay-Servern. Wenn diese Einstellung aktiviert wird, kann dieser Computer Remote-Hostcomputer finden und eine Verbindung herstellen, selbst wenn sie sich hinter einer Firewall befinden. Sollte die Einstellung deaktiviert sein und ausgehende UDP-Verbindungen von der Firewall gefiltert werden, dann kann dieser Computer nur Verbindungen zu Hostcomputern innerhalb des lokalen Netzwerks aufbauen.</translation>
<translation id="7694807474048279351">Hiermit wird ein automatischer Neustart nach einem Update von <ph name="PRODUCT_OS_NAME"/> geplant.

      Ist diese Richtlinie auf &quot;true&quot; gesetzt, ist ein automatischer Neustart geplant, nachdem <ph name="PRODUCT_OS_NAME"/> aktualisiert wurde und ein Neustart erforderlich ist, um den Updatevorgang abzuschließen. Die Ausführung des Neustarts ist sofort geplant, kann aber bis zu 24 Stunden auf dem Gerät verzögert werden, wenn das Gerät gerade von einem Nutzer verwendet wird.

      Ist diese Richtlinie auf &quot;false&quot; gesetzt, ist nach einem Update von <ph name="PRODUCT_OS_NAME"/> kein automatischer Neustart geplant. Der Updatevorgang wird abgeschlossen, sobald der Nutzer das Gerät das nächste Mal neu startet.

      Wenn Sie diese Richtlinie konfigurieren, können die Nutzer sie nicht ändern oder außer Kraft setzen.

      Hinweis: Automatische Neustarts sind derzeit nur aktiviert, wenn die Anmeldeseite angezeigt wird oder eine Kiosk-App-Sitzung läuft. Dies wird zukünftig geändert, sodass die Richtlinie immer gilt, unabhängig davon, ob und welche Sitzung aktiv ist.</translation>
<translation id="5511702823008968136">Lesezeichenleiste aktivieren</translation>
<translation id="5105313908130842249">Verzögerung für die Bildschirmsperre im Akkubetrieb</translation>
<translation id="7882585827992171421">Diese Richtlinie ist nur im Händlermodus aktiv.

      Bestimmt die ID der Erweiterung, die als Bildschirmschoner auf der Anmeldeseite verwendet werden soll. Die Erweiterung muss Teil des App-Pakets sein, das in der DeviceAppPack-Richtlinie für diese Domain konfiguriert wurde.</translation>
<translation id="1796466452925192872">Hier können Sie festlegen, bei welchen URLs die Installation von Erweiterungen, Apps und Designs zugelassen werden soll.

          Seit Chrome 21 ist die Installation von Erweiterungen, Apps und Nutzerskripten von Quellen außerhalb des Chrome Web Stores schwieriger geworden. In den Vorgängerversionen konnten Nutzer auf den Link zu einer CRX-Datei klicken und die Datei nach einigen Hinweisen in Chrome installieren. In allen Versionen ab Chrome 21 müssen Dateien zuerst heruntergeladen und dann auf die Seite &quot;Einstellungen&quot; in Chrome verschoben werden. Über diese Richtlinie kann bei bestimmten URLs der alte, einfachere Installationsvorgang angewendet werden.

          Bei den Einträgen in dieser Liste handelt es sich um auf die Erweiterung angepasste Übereinstimmungsmuster (siehe http://code.google.com/chrome/extensions/match_patterns.html). Wenn eine URL mit einem Eintrag in dieser Liste übereinstimmt, können Nutzer ihn ganz einfach über diese URL installieren. Sowohl der Speicherort der CRX-Datei als auch die Seite, über die der Download gestartet wird (der Referrer), müssen durch diese Muster zugelassen sein.

          &quot;ExtensionInstallBlacklist&quot; hat Vorrang vor dieser Richtlinie. Eine Erweiterung auf der schwarzen Liste wird folglich nicht installiert, auch wenn sie von einer Website auf dieser Liste stammt.</translation>
<translation id="2113068765175018713">Betriebsdauer der Geräte durch automatische Neustarts begrenzen</translation>
<translation id="4224610387358583899">Verzögerungen für die Bildschirmsperre</translation>
<translation id="5388730678841939057">Legt die Strategie fest, die bei der automatischen Bereinigung zur Freigabe von Festplattenspeicher verwendet wird (veraltet)</translation>
<translation id="7848840259379156480">Mit dieser Richtlinie können Sie die Standardanwendung für die HTML-Darstellung konfigurieren, wenn <ph name="PRODUCT_FRAME_NAME"/> installiert ist. Bei der Standardeinstellung übernimmt der Host-Browser die Darstellung. Sie können dies jedoch wahlweise außer Kraft setzen und festlegen, dass HTML-Seiten standardmäßig mithilfe von <ph name="PRODUCT_FRAME_NAME"/> angezeigt werden sollen.</translation>
<translation id="186719019195685253">Auszuführende Aktion beim Erreichen der Leerlaufverzögerung während des Wechselstrombetriebs</translation>
<translation id="197143349065136573">Aktiviert die alte webbasierte Anmeldung

      Diese Einstellung eignet sich für Unternehmenskunden, die SSO-Lösungen verwenden, die noch nicht mit der neuen Inline-Anmeldung kompatibel sind.
      Bei Aktivierung dieser Einstellung wird die alte webbasierte Anmeldung verwendet.
      Wenn Sie diese Einstellung deaktivieren oder nicht konfigurieren, wird die neue Inline-Anmeldung standardmäßig verwendet. Nutzer können die alte webbasierte Anmeldung weiterhin über die Befehlszeilenmarkierung --enable-web-based-signin aktivieren.

      Die experimentelle Einstellung wird in Zukunft entfernt, sobald die Inline-Anmeldung alle SSO-Anmeldeprozesse vollständig unterstützt.</translation>
<translation id="4121350739760194865">App-Werbung nicht auf der &quot;Neuer Tab&quot;-Seite anzeigen</translation>
<translation id="2127599828444728326">Benachrichtigungen auf diesen Websites zulassen</translation>
<translation id="3973371701361892765">Ablage nie automatisch ausblenden</translation>
<translation id="7635471475589566552">Konfiguriert das App-Gebietsschema in <ph name="PRODUCT_NAME"/> und verhindert, dass Nutzer das Gebietsschema ändern. Wenn Sie diese Einstellung aktivieren, verwendet <ph name="PRODUCT_NAME"/> das angegebene Gebietsschema. Wird das konfigurierte Gebietsschema nicht unterstützt, kommt stattdessen &quot;en-US&quot; zum Einsatz. Ist diese Einstellung deaktiviert oder nicht konfiguriert, verwendet <ph name="PRODUCT_NAME"/> das vom Nutzer angegebene bevorzugte Gebietsschema (sofern konfiguriert), das Gebietsschema des Systems oder das Ersatz-Gebietsschema &quot;en-US&quot;.</translation>
<translation id="2948087343485265211">Hiermit wird angegeben, ob Audioaktivitäten Einfluss auf den Energiesparmodus haben.

          Wenn diese Richtlinie auf &quot;True&quot; gesetzt oder nicht konfiguriert ist, wird der Nutzer nicht als inaktiv angesehen, während Audioinhalte wiedergegeben werden. Dadurch wird verhindert, dass das Inaktivitätstzeitlimit erreicht und die entsprechende Aktion eingeleitet wird. Die Abdunkelung, Abschaltung und Sperre des Bildschirms erfolgen jedoch unabhängig von den Audioaktivitäten gemäß den konfigurierten Zeitlimits.

          Ist diese Richtlinie auf &quot;False&quot; eingestellt, wird der Nutzer trotz Audioaktivitäten als inaktiv angesehen.</translation>
<translation id="7842869978353666042">Optionen von Google Drive konfigurieren</translation>
<translation id="718956142899066210">Für Updates zugelassene Verbindungstypen</translation>
<translation id="1734716591049455502">Optionen für Remote-Zugriff konfigurieren</translation>
<translation id="7336878834592315572">Cookies für die Dauer der Sitzung beibehalten</translation>
<translation id="7715711044277116530">Prozentsatz für die Skalierung der Spanne für die Bildschirmabdunkelung im Präsentationsmodus</translation>
<translation id="8777120694819070607">Aktiviert die Ausführung veralteter Plug-ins in <ph name="PRODUCT_NAME"/>. Falls Sie diese Einstellung aktivieren, werden veraltete Plug-ins wie normale Plug-ins verwendet. Ist diese Einstellung deaktiviert, werden veraltete Plug-ins nicht verwendet und Nutzer werden nicht aufgefordert, ihrer Ausführung zuzustimmen. Falls diese Einstellung nicht festgelegt ist, müssen die Nutzer zustimmen, damit veraltete Plug-ins ausgeführt werden können.</translation>
<translation id="2629448496147630947">Konfigurieren Sie die Optionen für Remote-Zugriff in <ph name="PRODUCT_NAME"/>. Diese Einstellungen sind nur aktiv, wenn die Web-App für Remote-Zugriff installiert ist.</translation>
<translation id="4001275826058808087">IT-Administratoren von Unternehmensgeräten können hiermit festlegen, ob Nutzer Angebote über die Chrome OS-Registrierung einlösen können.

      Wenn diese Richtlinie auf &quot;True&quot; gesetzt oder nicht konfiguriert ist, können Nutzer Angebote über die Chrome OS-Registrierung einlösen.

      Ist die Richtlinie auf &quot;False&quot; eingestellt, können Nutzer keine Angebote einlösen.</translation>
<translation id="1310699457130669094">Hier können Sie eine URL zu einer Proxy-PAC-Datei angeben. Diese Richtlinie tritt nur dann in Kraft, wenn Sie bei &quot;Auswählen, wie Proxyserver-Einstellungen angegeben werden&quot; manuelle Proxy-Einstellungen angegeben haben. Sie sollten diese Richtlinie nicht konfigurieren, wenn Sie sich für eine andere Methode zur Festlegung der Proxy-Richtlinien entschieden haben. Ausführliche Beispiele erhalten Sie unter <ph name="PROXY_HELP_URL"/>.</translation>
<translation id="1509692106376861764">Diese Richtlinie wird ab <ph name="PRODUCT_NAME"/>-Version 29 nicht mehr verwendet.</translation>
<translation id="5464816904705580310">Konfiguriert Einstellungen für verwaltete Nutzer</translation>
<translation id="3219421230122020860">Inkognito-Modus verfügbar</translation>
<translation id="7690740696284155549">Konfiguriert das Verzeichnis, das <ph name="PRODUCT_NAME"/> zum Herunterladen von Dateien verwendet.

      Wenn Sie diese Richtlinie festlegen, verwendet <ph name="PRODUCT_NAME"/> das angegebene Verzeichnis unabhängig davon, ob der Nutzer selbst eines angegeben oder die Markierung zur Einblendung einer Eingabeaufforderung zur Angabe des Downloadpfads aktiviert hat.

      Unter &quot;http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables&quot; finden Sie eine Liste der Variablen, die verwendet werden können.

      Bleibt diese Richtlinie unkonfiguriert, wird der Standard-Downloadpfad verwendet, wobei dieser vom Nutzer geändert werden kann.</translation>
<translation id="7381326101471547614">Hiermit wird die Verwendung des SPDY-Protokolls in <ph name="PRODUCT_NAME"/> verhindert. Wenn diese Richtlinie aktiviert ist, steht das SPDY-Protokoll in <ph name="PRODUCT_NAME"/> nicht zur Verfügung. Sollte sie deaktiviert werden, kann SPDY genutzt werden. Ist die Richtlinie nicht konfiguriert, steht SPDY zur Verfügung.</translation>
<translation id="2208976000652006649">Parameter für URL der Suche, die POST verwendet</translation>
<translation id="1583248206450240930">Standardmäßig <ph name="PRODUCT_FRAME_NAME"/> verwenden</translation>
<translation id="1047128214168693844">Verfolgung des physischen Standorts der Nutzer für keine Website zulassen</translation>
<translation id="4101778963403261403">Konfiguriert die Art der Standardstartseite in <ph name="PRODUCT_NAME"/> und verhindert, dass Nutzer Startseiteneinstellungen ändern. Die Startseite kann entweder auf eine von Ihnen angegebene URL oder auf die &quot;Neuer Tab&quot;-Seite festgelegt werden. Wenn Sie diese Einstellung aktivieren, kommt standardmäßig die &quot;Neuer Tab&quot;-Seite als Startseite zum Einsatz, wobei die Startseiten-URL ignoriert wird. Sollten Sie sie deaktivieren, dient die &quot;Neuer Tab&quot;-Seite nie als Startseite für den Nutzer, es sei denn, die URL wird auf &quot;chrome://newtab&quot; festgelegt. Ist diese Einstellung aktiviert oder deaktiviert, können Nutzer ihren Startseitentyp in <ph name="PRODUCT_NAME"/> nicht ändern. Wenn die Richtlinie nicht konfiguriert ist, kann der Nutzer selbst bestimmen, ob die &quot;Neuer Tab&quot;-Seite als Startseite dienen soll.</translation>
<translation id="8970205333161758602">Hinweis auf Einstellung von <ph name="PRODUCT_FRAME_NAME"/> unterdrücken</translation>
<translation id="3273221114520206906">JavaScript-Standardeinstellung</translation>
<translation id="4025586928523884733">Blockiert Cookies von Drittanbietern. Das Aktivieren dieser Einstellung verhindert, dass Webseitenelemente, die nicht von der Domain stammen, die in der Adressleiste des Browser zu sehen ist, Cookies speichern. Wenn die Einstellung deaktiviert wird, dürfen Cookies von Webseitenelementen, die nicht von der Domain stammen, die in der Adressleiste des Browsers zu sehen ist, gespeichert werden. Zudem können Nutzer diese Einstellung nicht ändern. Sollte diese Richtlinie nicht konfiguriert sein, so werden Drittanbieter-Cookies aktiviert, der Nutzer kann dies jedoch ändern.</translation>
<translation id="4604931264910482931">Schwarze Liste für natives Messaging konfigurieren</translation>
<translation id="6810445994095397827">JavaScript auf diesen Websites blockieren</translation>
<translation id="6672934768721876104">Verwenden Sie statt dieser Richtlinie &quot;ProxyMode&quot;, da die Richtlinie veraltet ist. Mit dieser Richtlinie können Sie angeben, welchen Proxy <ph name="PRODUCT_NAME"/> verwendet, und verhindern, dass Nutzer die Proxy-Einstellungen ändern. Wenn Sie festlegen, dass kein Proxyserver verwendet, sondern immer eine direkte Verbindung hergestellt werden soll, werden alle anderen Optionen ignoriert. Falls Sie bestimmen, dass die Proxy-Einstellungen des Systems verwendet werden sollen oder der Proxyserver automatisch ermittelt werden soll, werden alle anderen Optionen ebenfalls ignoriert. Bei Auswahl manueller Proxy-Einstellungen können Sie in &quot;Adresse oder URL des Proxyservers&quot;, &quot;URL einer PAC-Proxy-Datei&quot; und &quot;Kommagetrennte Liste der Proxy-Umgehungsregeln&quot; weitere Optionen angeben. Ausführliche Beispiele erhalten Sie unter <ph name="PROXY_HELP_URL"/>. Wenn Sie diese Einstellung aktivieren, ignoriert <ph name="PRODUCT_NAME"/> alle Proxy-Optionen, die per Eingabeaufforderung angegeben werden. Ist die Richtlinie nicht konfiguriert, so können Nutzer Ihre eigenen Proxy-Einstellungen vornehmen.</translation>
<translation id="3780152581321609624">Nicht-Standard-Port in Kerberos-SPN einschließen</translation>
<translation id="1749815929501097806">Legt die Nutzungsbedingungen fest, die der Nutzer akzeptieren muss, bevor eine Sitzung mit einem lokalen Gerätekonto gestartet werden kann.

      Wenn die Richtlinie festgelegt ist, lädt <ph name="PRODUCT_OS_NAME"/> die Nutzungsbedingungen herunter und zeigt sie dem Nutzer an, sobald eine Sitzung mit einem lokalen Gerätekonto gestartet wird. Der Nutzer kann die Sitzung erst fortsetzen, nachdem er die Nutzungsbedingungen akzeptiert hat.

      Ist diese Richtlinie nicht konfiguriert, werden keine Nutzungsbedingungen angezeigt.

      In der Richtlinie muss eine URL angegeben werden, von der <ph name="PRODUCT_OS_NAME"/> die Nutzungsbedingungen herunterladen kann. Die Nutzungsbedingungen müssen als unformatierter Text mit dem MIME-Typ &quot;text/plain&quot; vorliegen. Markups sind nicht zulässig.</translation>
<translation id="2623014935069176671">Auf erste Nutzeraktivität warten</translation>
<translation id="2660846099862559570">Nie Proxy verwenden</translation>
<translation id="637934607141010488">Meldet eine Liste der Gerätenutzer, die sich kürzlich angemeldet haben

      Wird die Richtlinie auf &quot;False&quot; gesetzt, werden die Nutzer nicht gemeldet.</translation>
<translation id="1956493342242507974">Konfiguriert die Energieverwaltung auf dem Anmeldebildschirm in <ph name="PRODUCT_OS_NAME"/>.

      Mit dieser Richtlinie konfigurieren Sie, wie <ph name="PRODUCT_OS_NAME"/> sich verhalten soll, wenn auf dem Anmeldebildschirm keine Nutzeraktivität erfolgt. Durch die Richtlinie werden mehrere Einstellungen festgelegt. Deren Semantik und zulässige Wertebereiche finden Sie unter den entsprechenden Richtlinien zur Steuerung der Energieverwaltung innerhalb einer Sitzung. Diese Richtlinie unterscheidet sich nur in folgenden Punkten:
      * Bei Inaktivität oder Schließen des Deckels kann als Aktion nicht die Beendigung der Sitzung ausgeführt werden.
      * Als Standardaktion bei Inaktivität wird das Gerät bei Netzanschluss heruntergefahren.

      Wird für eine Einstellung kein Wert festgelegt, wird ein Standardwert verwendet.

      Wenn die Richtlinie nicht festgelegt wird, gelten für alle Einstellungen Standardwerte.</translation>
<translation id="1435659902881071157">Netzwerkkonfiguration auf Geräteebene</translation>
<translation id="8071636581296916773">Ermöglicht den Einsatz von Relayservern, wenn Remote-Clients versuchen, eine Verbindung zu diesem Computer herzustellen

          Ist diese Einstellung aktiviert, können Remote-Clients eine Verbindung zu diesem Computer über Relayserver herstellen, sofern keine direkte Verbindung verfügbar ist, zum Beispiel aufgrund von Firewallbeschränkungen.

          Diese Richtlinie wird ignoriert, falls die Richtlinie <ph name="REMOTEACCESSHOSTFIREWALLTRAVERSAL_POLICY_NAME"/> deaktiviert ist.

          Falls diese Richtlinie nicht konfiguriert ist, wird die Einstellung aktiviert.</translation>
<translation id="2131902621292742709">Verzögerung für die Bildschirmabdunkelung im Akkubetrieb</translation>
<translation id="5781806558783210276">Hiermit wird angegeben, nach welchem Zeitraum ohne Nutzereingabe die Inaktivität im Akkubetrieb erfolgt.

          Wenn diese Richtlinie festgelegt ist, wird damit angegeben, wie lange ein Nutzer inaktiv sein muss, bevor <ph name="PRODUCT_OS_NAME"/> in den Inaktivitätsmodus wechselt. Dieser kann gesondert konfiguriert werden.

          Ist diese Richtlinie nicht konfiguriert, wird ein Standardwert verwendet.

          Der Wert für diese Richtlinie muss in Millisekunden angegeben werden.</translation>
<translation id="5512418063782665071">Startseiten-URL</translation>
<translation id="2948381198510798695"><ph name="PRODUCT_NAME"/> umgeht für die Liste der hier angegebenen Hosts alle Proxys. Diese Richtlinie tritt nur dann in Kraft, wenn Sie bei &quot;Auswählen, wie Proxyserver-Einstellungen angegeben werden&quot; manuelle Proxy-Einstellungen angegeben haben. Sie sollten diese Richtlinie nicht konfigurieren, wenn Sie sich für eine andere Methode zur Festlegung der Proxy-Richtlinien entschieden haben. Ausführliche Beispiele erhalten Sie unter <ph name="PROXY_HELP_URL"/>.</translation>
<translation id="6658245400435704251">Legt die Anzahl von Sekunden fest, die eine Verzögerung ab dem Übertragungszeitpunkt an den Server maximal betragen darf, wenn ein Gerät ein Update herunterlädt. Die Verzögerungszeit setzt sich aus der Istzeit und der auf die Anzahl der Überprüfungen auf Updates verwendeten Zeit zusammen. Die obere Grenze für den Streufaktor bildet ein konstanter Zeitraum, sodass ein Gerät nur eine begrenzte Zeit lang auf den Download eines Updates wartet.</translation>
<translation id="102492767056134033">Standardstatus für die Bildschirmtastatur auf der Anmeldeseite festlegen</translation>
<translation id="523505283826916779">Zugänglichkeitseinstellungen</translation>
<translation id="1948757837129151165">Richtlinien für HTTP-Authentifizierung</translation>
<translation id="5946082169633555022">Beta-Kanal</translation>
<translation id="7187256234726597551">Bei Festlegung auf &quot;true&quot; ist die Remote-Bestätigung für das Gerät erlaubt. Ein Zertifikat wird automatisch erstellt und auf den Device Management Server hochgeladen.

          Wird die Richtlinie auf &quot;false&quot; gesetzt oder nicht konfiguriert, wird kein Zertifikat erstellt und Aufrufe der Erweiterungs-API &quot;enterprise.platformKeysPrivate&quot; schlagen fehl.</translation>
<translation id="5242696907817524533">Konfiguriert eine Liste verwalteter Lesezeichen

      Bei dieser Richtlinie handelt es sich um eine Liste von Lesezeichen. Jedes Lesezeichen ist ein Wörterbuch, das den Namen des Lesezeichens und die Ziel-URL enthält.

      Diese Lesezeichen werden im Ordner für verwaltete Lesezeichen innerhalb der mobilen Lesezeichen platziert. Sie können nicht vom Nutzer geändert werden.

      Wenn diese Richtlinie festgelegt ist, sind die verwalteten Lesezeichen der Standardordner, der beim Aufrufen der Lesezeichenansicht in Chrome geöffnet wird.

      Verwaltete Lesezeichen werden nicht mit dem Nutzerkonto synchronisiert.</translation>
<translation id="6757375960964186754">Zeigt <ph name="PRODUCT_OS_NAME"/>-Optionen für Bedienungshilfen im Systemmenü an.

          Ist diese Richtlinie auf &quot;true&quot; gesetzt, werden die Optionen für Bedienungshilfen immer im Taskleistenmenü angezeigt.

          Ist diese Richtlinie auf &quot;false&quot; gesetzt, werden die Optionen für Bedienungshilfen nie im Taskleistenmenü angezeigt.

          Wenn Sie diese Richtlinie konfigurieren, können die Nutzer sie nicht ändern oder außer Kraft setzen.

          Wenn diese Richtlinie nicht konfiguriert wird, erscheinen keine Optionen für Bedienungshilfen im Taskleistenmenü, der Nutzer kann deren Anzeige jedoch auf der Seite &quot;Einstellungen&quot; aktivieren.</translation>
<translation id="8303314579975657113">Gibt an, welche GSSAPI-Bibliothek für die HTTP-Authentifizierung verwendet werden soll. Sie können entweder nur den Namen einer Bibliothek oder einen vollständigen Pfad angeben. Wenn diese Einstellung nicht festgelegt ist, verwendet <ph name="PRODUCT_NAME"/> einen Standardnamen für die Bibliothek.</translation>
<translation id="8549772397068118889">Vor dem Besuch von Websites außerhalb von Inhaltspaketen warnen</translation>
<translation id="7749402620209366169">Aktiviert die Zwei-Faktor-Authentifizierung für Remote-Zugriff-Hosts anstelle einer vom Nutzer angegebenen PIN.

          Wenn diese Einstellung aktiviert ist, müssen Nutzer einen gültigen Zwei-Faktor-Code angeben, wenn sie auf einen Host zugreifen möchten.

          Ist diese Einstellung deaktiviert oder nicht festgelegt, wird die Zwei-Faktor-Authentifizierung nicht aktiviert und das Standardverfahren zur Eingabe einer nutzerdefinierten PIN wird verwendet.</translation>
<translation id="6698424063018171973">Schränkt den vom Host für den Remote-Zugriff verwendeten UDP-Portbereich auf diesem Computer ein

          Wenn diese Richtlinie nicht konfiguriert ist oder auf eine leere Zeichenfolge festgelegt wird, kann der Host für den Remote-Zugriff alle verfügbaren Ports nutzen. Falls die Richtlinie <ph name="REMOTEACCESSHOSTFIREWALLTRAVERSAL_POLICY_NAME"/> deaktiviert ist, verwendet der Host für den Remote-Zugriff jedoch nur die UDP-Ports im Bereich 12400–12409.</translation>
<translation id="7329842439428490522">Hiermit wird angegeben, nach welchem Zeitraum ohne Nutzereingabe der Bildschirm im Akkubetrieb abgeschaltet wird.

          Wenn für diese Richtlinie ein höherer Wert als null festgelegt wird, gibt dieser an, wie lange ein Nutzer inaktiv sein muss, bevor <ph name="PRODUCT_OS_NAME"/> den Bildschirm abschaltet.

          Ist die Richtlinie auf null eingestellt, wird der Bildschirm von <ph name="PRODUCT_OS_NAME"/> nicht abgeschaltet, wenn der Nutzer inaktiv wird.

          Wenn die Richtlinie nicht konfiguriert ist, wird ein Standardwert verwendet.

          Der Wert für die Richtlinie muss in Millisekunden angegeben werden. Werte müssen kleiner oder gleich dem Wert für die Inaktivitätsverzögerung sein.</translation>
<translation id="384743459174066962">Ermöglicht Ihnen die Zusammenstellung einer Liste mit URL-Mustern, die Websites angeben, denen das Öffnen von Pop-ups nicht gestattet ist. Wenn diese Richtlinie nicht konfiguriert ist, kommt für alle Websites der globale Standardwert der Richtlinie &quot;DefaultPopupsSetting&quot;, sofern konfiguriert, oder der persönlichen Konfiguration des Nutzers zum Einsatz.</translation>
<translation id="5645779841392247734">Cookies auf diesen Websites zulassen</translation>
<translation id="4043912146394966243">Die Verbindungstypen, die für Betriebssystemaktualisierungen zulässig sind. Betriebssystemaktualisierungen beanspruchen die Verbindung aufgrund ihrer Größe potenziell stark und können zusätzliche Kosten verursachen. Deshalb sind sie für als kostenintensiv geltende Verbindungstypen standardmäßig nicht aktiviert. Dazu gehören derzeit beispielsweise WiMAX, Bluetooth und Mobilfunkverbindungen.

      Die anerkannten Verbindungstypkennungen lauten &quot;ethernet&quot;, &quot;wifi&quot;, &quot;wimax&quot;, &quot;bluetooth&quot; und &quot;cellular&quot;.</translation>
<translation id="6652197835259177259">Einstellungen für lokal verwaltete Nutzer</translation>
<translation id="2808013382476173118">Aktiviert den Einsatz von STUN-Servern, wenn Remote-Clients versuchen, eine Verbindung zu diesem Computer herzustellen

          Wenn diese Einstellung aktiviert wird, können Remote-Clients diesen Computer finden und eine Verbindung herstellen, selbst wenn er sich hinter einer Firewall befindet.

          Falls die Einstellung deaktiviert ist und ausgehende UDP-Verbindungen von der Firewall gefiltert werden, erlaubt dieser Computer nur Verbindungen von Clientcomputern im lokalen Netzwerk.

          Wenn diese Richtlinie nicht konfiguriert ist, wird die Einstellung aktiviert.</translation>
<translation id="3243309373265599239">Hiermit wird angegeben, nach welchem Zeitraum ohne Nutzereingabe der Bildschirm im Netzbetrieb abgedunkelt wird.

          Wenn für diese Richtlinie ein höherer Wert als null festgelegt wird, gibt dieser an, wie lange ein Nutzer inaktiv sein muss, bevor <ph name="PRODUCT_OS_NAME"/> den Bildschirm abdunkelt.

          Ist die Richtlinie auf null eingestellt, wird der Bildschirm von <ph name="PRODUCT_OS_NAME"/> nicht abgedunkelt, wenn der Nutzer inaktiv wird.

          Wenn die Richtlinie nicht konfiguriert ist, wird ein Standardwert verwendet.

          Der Wert für die Richtlinie muss in Millisekunden angegeben werden. Werte müssen kleiner oder gleich dem Wert der Verzögerung für die Bildschirmabschaltung (falls angegeben) und der Inaktivitätsverzögerung sein.</translation>
<translation id="3859780406608282662">Fügt einen Parameter für den Abruf des Varianten-Seeds in <ph name="PRODUCT_OS_NAME"/> hinzu.

Falls die Richtlinie festgelegt wird, wird der Abfrageparameter &quot;restrict&quot; zu der URL hinzugefügt, über die der Varianten-Seed abgerufen wird. Der Wert des Parameters wird in der Richtlinie angegeben.

Falls die Richtlinie nicht festgelegt wird, bleibt die Varianten-Seed-URL unverändert.</translation>
<translation id="7049373494483449255">Ermöglicht es <ph name="PRODUCT_NAME"/>, Dokumente zum Drucken an <ph name="CLOUD_PRINT_NAME"/> zu senden. Hinweis: Dies wirkt sich nur auf die <ph name="CLOUD_PRINT_NAME"/>-Unterstützung in <ph name="PRODUCT_NAME"/> aus. Die Richtlinie verhindert nicht, dass Nutzer Druckaufträge auf Websites geben. Wenn diese Einstellung aktiviert oder nicht konfiguriert ist, können Nutzer im <ph name="PRODUCT_NAME"/>-Druckdialog über <ph name="CLOUD_PRINT_NAME"/> drucken. Sollte die Einstellung deaktiviert sein, können Nutzer im <ph name="PRODUCT_NAME"/>-Druckdialog über <ph name="CLOUD_PRINT_NAME"/> nicht drucken.</translation>
<translation id="4088589230932595924">Inkognito-Modus erzwungen</translation>
<translation id="5862253018042179045">Hiermit wird der Standardstatus der Bedienungshilfefunktion für das gesprochene Feedback auf der Anmeldeseite festgelegt.

          Ist diese Richtlinie auf &quot;true&quot; gesetzt, ist das gesprochene Feedback aktiviert, wenn die Anmeldeseite angezeigt wird.

          Ist diese Richtlinie auf &quot;false&quot; gesetzt, ist das gesprochene Feedback deaktiviert, wenn die Anmeldeseite angezeigt wird.

          Wenn Sie diese Richtlinie konfigurieren, können die Nutzer sie vorübergehend außer Kraft setzen, indem sie das gesprochene Feedback aktivieren bzw. deaktivieren. Die Nutzerauswahl ist jedoch nicht dauerhaft und die Standardeinstellung wird wiederhergestellt, sobald die Anmeldeseite erneut angezeigt wird oder der Nutzer auf der Anmeldeseite eine Minute lang inaktiv ist.

          Falls diese Richtlinie nicht konfiguriert wird, ist das gesprochene Feedback deaktiviert, wenn die Anmeldeseite das erste Mal angezeigt wird. Die Nutzer können das gesprochene Feedback jederzeit aktivieren oder deaktivieren und dieser Status bleibt auf der Anmeldeseite erhalten.</translation>
<translation id="8197918588508433925">Mit dieser Richtlinie wird festgelegt, welche Erweiterungen zum Zweck der Remote-Bestätigung die Enterprise Platform Keys API chrome.enterprise.platformKeysPrivate.challengeUserKey() verwenden dürfen. Damit eine Erweiterung die API verwenden darf, muss sie zu dieser Liste hinzugefügt werden.

Wenn eine Erweiterung nicht in der Liste enthalten ist oder keine Liste festgelegt wurde, treten beim API-Aufruf Fehler auf und ein Fehlercode wird angezeigt.</translation>
<translation id="2811293057593285123">Der Safe Browsing-Dienst zeigt einen Warnhinweis, wenn Nutzer zu Websites navigieren möchten, die als potenziell schädlich eingestuft sind. Bei Aktivierung dieser Einstellung können Nutzer nicht von der Hinweisseite zu der schädlichen Website weiter navigieren.

      Ist die Einstellung deaktiviert oder nicht konfiguriert, können Nutzer zu der gekennzeichneten Website navigieren, nachdem sie den Warnhinweis gesehen haben.</translation>
<translation id="7649638372654023172">Hiermit wird die Standard-URL für die Startseite in <ph name="PRODUCT_NAME"/> konfiguriert und verhindert, dass diese von Nutzern geändert werden kann.

          Die Startseite ist die Seite, die über die Schaltfläche &quot;Startseite&quot; geöffnet wird. Die Seiten, die beim Hochfahren geöffnet werden, werden über die Richtlinien &quot;RestoreOnStartup&quot; kontrolliert.

          Der Startseitentyp kann entweder auf eine URL, die Sie hier angeben, oder auf die &quot;Neuer Tab&quot;-Seite eingestellt werden. Wenn Sie sich für die &quot;Neuer Tab&quot;-Seite entscheiden, wird diese Richtlinie nicht angewendet.

          Wenn Sie diese Einstellung aktivieren, können Nutzer ihre Startseiten-URL in <ph name="PRODUCT_NAME"/> nicht ändern, jedoch weiterhin ihre Startseite auf die &quot;Neuer Tab&quot;-Seite umstellen.

          Ist diese Richtlinie nicht konfiguriert, können die Nutzer selbst eine Startseite wählen, sofern &quot;HomepageIsNewTabPage&quot; ebenfalls nicht konfiguriert ist.</translation>
<translation id="3806576699227917885">Wiedergabe von Audioinhalten zulassen

      Wenn diese Richtlinie auf &quot;False&quot; festgelegt wird, ist die Wiedergabe von Audioinhalten über das Gerät nicht möglich, während der Nutzer angemeldet ist.

      Diese Richtlinie gilt für jegliche Form der Audiowiedergabe, nicht nur für integrierte Lautsprecher. Bedienungshilfen für Audio werden mit dieser Richtlinie ebenfalls gesperrt. Aktivieren Sie diese Richtlinie nicht, wenn der Nutzer einen Screenreader benötigt.

      Wenn diese Einstellung auf &quot;True&quot; festgelegt oder nicht konfiguriert ist, können die Nutzer alle unterstützten Audiowiedergabetypen auf dem Gerät verwenden.</translation>
<translation id="6517678361166251908">Gnubby-Authentifizierung zulassen</translation>
<translation id="4858735034935305895">Vollbildmodus zulassen</translation>
</translationbundle>