<?xml version="1.0" ?><!DOCTYPE translationbundle><translationbundle lang="id">
<translation id="1503959756075098984">ID ekstensi dan URL pembaruan akan dipasang secara diam-diam</translation>
<translation id="793134539373873765">Tentukan apakah p2p akan digunakan untuk payload pembaruan OS. Jika disetel ke True, perangkat akan membagi dan berusaha menggunakan payload pembaruan pada LAN, serta berpotensi mengurangi penggunaan dan kepadatan bandwidth internet. Jika payload pembaruan tidak tersedia di LAN, perangkat tersebut akan kembali mengunduh dari server yang diperbarui. Jika disetel ke False atau tidak dikonfigurasi, p2p tidak akan digunakan.</translation>
<translation id="2463365186486772703">Lokal aplikasi</translation>
<translation id="1397855852561539316">URL saran penyedia penelusuran default</translation>
<translation id="3347897589415241400">Perilaku default untuk situs ini tidak ada pada paket konten mana pun.

          Kebijakan ini untuk penggunaan internal oleh Chrome itu sendiri.</translation>
<translation id="7040229947030068419">Nilai contoh:</translation>
<translation id="1213523811751486361">Tentukan URL mesin telusur yang digunakan untuk menyediakan saran penelusuran. URL sebaiknya berisi string '<ph name="SEARCH_TERM_MARKER"/>', yang pada waktu kueri akan diganti dengan teks yang telah dimasukkan oleh pengguna sejauh ini. Kebijakan ini bersifat opsional. Jika tidak disetel, tidak ada URL yang disarankan yang akan digunakan. Kebijakan ini hanya diterapkan jika kebijakan 'DefaultSearchProviderEnabled' diaktifkan.</translation>
<translation id="6106630674659980926">Aktifkan pengelola sandi</translation>
<translation id="7109916642577279530">Mengizinkan atau menolak penangkapan audio.

      Jika diaktifkan atau tidak dikonfigurasi (default), pengguna akan dimintai
      akses penangkapan audio kecuali untuk URL yang dikonfigurasi di
      daftar AudioCaptureAllowedUrls yang akan diberi akses tanpa meminta.

      Jika kebijakan ini dinonaktifkan, pengguna tidak akan pernah diminta dan
      penangkapan audio hanya tersedia untuk URL yang dikonfigurasi dalam AudioCaptureAllowedUrls.

      Kebijakan ini mempengaruhi semua jenis masukan audio dan tidak hanya mikrofon yang ada di dalam.</translation>
<translation id="7267809745244694722">Default tombol media ke tombol fungsi</translation>
<translation id="9150416707757015439">Kebijakan ini sudah tidak digunakan lagi. Gunakan IncognitoModeAvailability sebagai gantinya. Aktifkan mode Penyamaran di <ph name="PRODUCT_NAME"/>. Jika setelan ini diaktifkan atau tidak dikonfigurasi, pengguna dapat membuka laman web dalam mode penyamaran. Jika setelan ini dinonaktifkan, pengguna tidak dapat membuka laman web dalam mode penyamaran. Jika kebijakan ini dibiarkan tanpa disetel, kebijakan ini akan diaktifkan dan pengguna akan dapat menggunakan mode penyamaran.</translation>
<translation id="4203389617541558220">Membatasi waktu operasi perangkat dengan menjadwalkan mulai ulang otomatis.

      Saat kebijakan ini disetel, kebijakan ini menentukan panjang waktu operasi perangkat setelah mulai ulang otomatis dijadwalkan.

      Saat kebijakan ini tidak disetel, waktu operasi perangkat tidak dibatasi.

      Jika Anda menyetel kebijakan ini, pengguna tidak dapat mengubah atau menimpanya.

      Mulai ulang otomatis dijadwalkan pada waktu yang ditentukan, namun dapat ditunda di perangkat hingga 24 jam jika pengguna sedang menggunakan perangkat.

      Catatan: Saat ini, mulai ulang otomatis hanya diaktifkan saat layar masuk ditampilkan atau sesi aplikasi kios sedang berjalan. Ini akan berubah di masa mendatang dan kebijakan akan terus berlaku, terlepas dari apakah sesi jenis tertentu apa pun sedang berlangsung atau tidak.

      Nilai kebijakan harus ditentukan dalam detik. Nilai dijepit hingga paling tidak 3600 (satu jam).</translation>
<translation id="5304269353650269372">Menentukan panjang waktu tanpa masukan pengguna yang setelahnya dialog peringatan akan ditampilkan saat menggunakan daya baterai.

          Saat kebijakan ini disetel, ini menentukan panjang waktu yang harus dilalui pengguna dalam kondisi menganggur sebelum <ph name="PRODUCT_OS_NAME"/> menampilkan dialog peringatan yang memberi tahu pengguna bahwa tindakan menganggur akan dijalankan.

          Saat kebijakan ini tidak disetel, dialog peringatan tidak akan ditampilkan.

          Nilai kebijakan harus ditentukan dalam milidetik. Nilai dibatasi agar kurang dari atau sama dengan penundaan menganggur.</translation>
<translation id="7818131573217430250">Menyetel status default mode kontras tinggi di layar masuk</translation>
<translation id="7614663184588396421">Daftar skema protokol yang dinonaktifkan</translation>
<translation id="2309390639296060546">Setelan geolokasi default</translation>
<translation id="1313457536529613143">Menentukan persentase yang digunakan untuk menskalakan penundaan layar redup saat mengamati aktivitas pengguna selagi layar diredupkan atau tak lama setelah layar dimatikan.

          Jika kebijakan ini disetel, kebijakan ini menentukan persentase yang digunakan untuk menskalakan penundaan layar redup saat mengamati aktivitas pengguna selagi layar diredupkan atau tak lama setelah layar dimatikan. Saat penundaan redup diskalakan, penundaan status menganggur, layar kunci, layar mati juga disesuaikan agar jarak waktu dari penundaan layar redup sesuai konfigurasi asli.

          Jika kebijakan ini tidak disetel, faktor skala default akan digunakan.

          Faktor skala harus 100% atau lebih.</translation>
<translation id="7443616896860707393">Permintaan Autentikasi Dasar HTTP lintas asal</translation>
<translation id="2337466621458842053">Memungkinkan Anda menyetel daftar pola url yang menentukan situs yang diizinkan untuk menampilkan gambar. Jika kebijakan ini dibiarkan tanpa disetel, nilai global default akan digunakan untuk semua situs, baik dari kebijakan 'DefaultImagesSetting', jika disetel, maupun konfigurasi pribadi pengguna.</translation>
<translation id="4680961954980851756">Aktifkan IsiOtomatis</translation>
<translation id="5183383917553127163">Memungkinkan Anda menentukan ekstensi mana yang tidak masuk daftar hitam. Nilai daftar hitam * berarti semua ekstensi dimasukkan ke daftar hitam dan pengguna hanya dapat memasang ekstensi yang tercantum dalam daftar putih. Jika tidak diubah, semua ekstensi dimasukkan ke daftar putih, tetapi jika semua ekstensi telah dimasukkan ke daftar hitam karena kebijakan, daftar putih dapat digunakan untuk mengesampingkan kebijakan tersebut.</translation>
<translation id="5921888683953999946">Menyetel status default fitur aksesibilitas kursor besar di layar masuk.

          Jika kebijakan ini disetel ke true, kursor besar akan diaktifkan saat layar masuk ditampilkan.

          Jika kebijakan ini disetel ke false, kursor besar akan dinonaktifkan saat layar masuk ditampilkan.

          Jika Anda menyetel kebijakan ini, pengguna dapat menimpanya untuk sementara dengan mengaktifkan atau menonaktifkan kursor besar. Namun, pilihan pengguna tidak bersifat permanen dan setelan default akan dipulihkan kapan pun layar masuk ditampilkan lagi atau pengguna menganggur di layar masuk selama satu menit.

          Jika kebijakan ini tidak disetel, kursor besar dinonaktifkan saat layar masuk ditampilkan untuk pertama kali. Pengguna dapat mengaktifkan atau menonaktifkan kursor besar kapan pun dan statusnya di layar masuk bersifat permanen antar pengguna.</translation>
<translation id="3185009703220253572">sejak versi <ph name="SINCE_VERSION"/></translation>
<translation id="5298412045697677971">Konfigurasi gambar avatar pengguna.

      Kebijakan ini memungkinkan Anda mengonfigurasi gambar avatar yang mewakili pengguna di layar masuk. Kebijakan ini disetel dengan menentukan URL tempat <ph name="PRODUCT_OS_NAME"/> dapat mengunduh gambar avatar dan hash kriptografi yang digunakan untuk memverifikasi integritas unduhan. Gambar harus dalam format JPEG dan ukurannya tidak boleh melebihi 512 KB. URL harus dapat diakses tanpa autentikasi.

      Gambar avatar diunduh dan disimpan dalam cache. Gambar akan diunduh kembali saat URL atau hash berubah.

      Kebijakan ini perlu ditetapkan sebagai string yang mengekspresikan URL dan hash dalam format JSON, sesuai dengan skema berikut:
      {
        &quot;type&quot;: &quot;object&quot;,
        &quot;properties&quot;: {
          &quot;url&quot;: {
            &quot;description&quot;: &quot;URL tempat gambar avatar dapat diunduh.&quot;,
            &quot;type&quot;: &quot;string&quot;
          },
          &quot;hash&quot;: {
            &quot;description&quot;: &quot;Hash SHA-256 gambar avatar.&quot;,
            &quot;type&quot;: &quot;string&quot;
          }
        }
      }

      Jika kebijakan ini disetel, <ph name="PRODUCT_OS_NAME"/> akan mengunduh dan menggunakan gambar avatar.

      Jika Anda menyetel kebijakan ini, pengguna tidak dapat mengubah atau menggantinya.

      Jika kebijakan ini tidak disetel, pengguna dapat memilih gambar avatar yang mewakili dirinya di layar masuk.</translation>
<translation id="2204753382813641270">Kontrol sembunyi otomatis rak</translation>
<translation id="3816312845600780067">Aktifkan pintasan keyboard penyelamatan untuk masuk otomatis</translation>
<translation id="3214164532079860003">Kebijakan ini memaksa beranda diimpor dari browser default yang sedang digunakan, jika diaktifkan. Jika dinonaktifkan, beranda tidak diimpor. Jika tidak disetel, pengguna mungkin akan ditanya apakah ingin mengimpor, atau pengimporan dapat terjadi secara otomatis.</translation>
<translation id="5330684698007383292">Izinkan <ph name="PRODUCT_FRAME_NAME"/> menangani jenis konten berikut</translation>
<translation id="6647965994887675196">Jika disetel ke true, pengguna yang dilindungi dapat dibuat dan digunakan.

          Jika disetel ke false atau tidak dikonfigurasi, pembuatan dan proses masuk pengguna yang dilindungi akan dinonaktifkan. Semua pengguna diawasi yang sudah ada akan tersembunyi.

          CATATAN: Perilaku default untuk perangkat pelanggan dan perusahaan berbeda: pada perangkat pelanggan, pengguna yang dilindungi diaktifkan secara default, namun pada perangkat perusahaan, pengguna yang dilindungi dinonaktifkan secara default.</translation>
<translation id="69525503251220566">Parameter menyediakan fitur telusuri pakai gambar untuk penyedia penelusuran default</translation>
<translation id="5469825884154817306">Cekal gambar pada situs ini</translation>
<translation id="8412312801707973447">Apakah pemeriksaan OCSP/CRL online dilakukan atau tidak</translation>
<translation id="2482676533225429905">Perpesanan Asli</translation>
<translation id="6649397154027560979">Kebijakan ini tidak lagi digunakan, gunakan URLBlacklist sebagai gantinya.

      Menonaktifkan skema protokol yang dicantumkan di <ph name="PRODUCT_NAME"/>.

      URL yang menggunakan skema dari daftar ini tidak akan dimuat dan tidak dapat dinavigasikan.

      Jika kebijakan ini tidak disetel atau daftar kosong, semua skema akan dapat diakses di <ph name="PRODUCT_NAME"/>.</translation>
<translation id="3213821784736959823">Mengontrol apakah klien DNS di dalamnya digunakan di <ph name="PRODUCT_NAME"/>.

      Jika kebijakan ini disetel ke benar, klien DNS yang ada di dalamnya akan digunakan, jika tersedia.

      Jika kebijakan ini disetel ke salah, klien DNS yang ada di dalamnya tidak akan pernah digunakan.

      Jika kebijakan dibiarkan tidak disetel, pengguna akan dapat mengubah apakah klien DNS yang ada di dalamnya digunakan dengan mengedit chrome://flags atau menentukan tanda baris perintah.</translation>
<translation id="2908277604670530363">Jumlah maksimal sambungan serentak ke server proxy</translation>
<translation id="556941986578702361">Mengontrol rak <ph name="PRODUCT_OS_NAME"/> sembunyi otomatis.

      Jika kebijakan ini disetel ke 'AlwaysAutoHideShelf', rak akan selalu bersembunyi secara otomatis.

      Jika kebijakan ini disetel ke 'NeverAutoHideShelf', rak tidak akan bersembunyi otomatis.

      Jika Anda menyetel kebijakan ini, pengguna tidak dapat mengubah atau menggantinya.

      Jika kebijakan ini dibiarkan tidak disetel, pengguna dapat memilih apakah rak akan bersembunyi otomatis atau tidak.</translation>
<translation id="4838572175671839397">Berisi ekspresi reguler yang digunakan untuk menentukan pengguna yang dapat masuk ke <ph name="PRODUCT_NAME"/>.

      Kesalahan yang sesuai akan ditampilkan jika pengguna mencoba untuk masuk dengan nama pengguna yang tidak cocok dengan pola ini.

      Jika kebijakan ini dibiarkan tidak disetel atau kosong, semua pengguna dapat masuk ke <ph name="PRODUCT_NAME"/>.</translation>
<translation id="2892225385726009373">Saat setelan ini diaktifkan, <ph name="PRODUCT_NAME"/> akan selalu melakukan pemeriksaan pembatalan untuk sertifikasi server yang berhasil memvalidasi dan masuk dengan sertifikat CA yang dipasang secara lokal.

      Jika <ph name="PRODUCT_NAME"/> tidak dapat memperoleh informasi status pembatalan, sertifikat tersebut yang akan diperlakukan sebagai dicabut ('kegagalan fatal').

      Jika kebijakan tidak disetel, atau disetel ke false, Chrome akan menggunakan setelan pemeriksaan pembatalan online yang ada.</translation>
<translation id="3516856976222674451">Membatasi lama maksimum sesi pengguna.

      Jika kebijakan ini disetel, durasi waktu ditentukan, setelah itu pengguna akan dikeluarkan secara otomatis, dan sesi tersebut dihentikan. Waktu yang tersisa diberitahukan kepada pengguna melalui penghitung waktu mundur yang ditampilkan di baki sistem.

      Jika kebijakan ini tidak disetel, lamanya sesi tidak dibatasi.

      Jika Anda menyetel kebijakan ini, pengguna tidak dapat mengubah atau menggantinya.

      Nilai kebijakan harus ditentukan dalam milidetik. Nilai ditetapkan dengan rentang antara 30 detik hingga 24 jam.</translation>
<translation id="9200828125069750521">Parameter untuk URL gambar yang menggunakan POST</translation>
<translation id="2769952903507981510">Mengonfigurasi nama domain yang dibutuhkan untuk hosting akses jarak jauh</translation>
<translation id="8294750666104911727">Umumnya laman dengan X-UA-Compatible yang disetel ke chrome=1 akan dirender di <ph name="PRODUCT_FRAME_NAME"/> terlepas dari kebijakan 'ChromeFrameRendererSettings'.

          Jika Anda mengaktifkan setelan ini, meta tag laman tidak akan dipindai.

          Jika Anda menonaktifkan setelan ini, meta tag laman akan dipindai.

          Jika kebijakan ini tidak disetel, meta tag laman akan dipindai.</translation>
<translation id="3478024346823118645">Hapus data pengguna saat keluar</translation>
<translation id="8668394701842594241">Menentukan daftar plugin yang diaktifkan di <ph name="PRODUCT_NAME"/> dan mencegah pengguna mengubah setelan ini. Karakter pengganti '*' dan '?' dapat digunakan untuk mencocokkan rangkaian karakter sembarang. '*' mencocokkan jumlah sembarang dari karakter, sedangkan '?' menentukan karakter tunggal opsional, yaitu mencocokkan dengan nol atau satu karakter. Karakter hindar adalah '\', jadi untuk mencocokkan '*', '?', atau karakter '\' yang sebenarnya, Anda dapat menempatkan sebuah '\' di depannya. Daftar plugin tertentu selalu digunakan di <ph name="PRODUCT_NAME"/> jika dipasang. Plugin ditandai sebagai diaktifkan pada 'about:plugins' dan pengguna tidak dapat menonaktifkannya. Perhatikan bahwa kebijakan ini menimpa DisabledPlugins dan DisabledPluginsExceptions. Jika kebijakan ini dibiarkan tidak disetel, pengguna dapat menonaktifkan plugin apa pun yang dipasang di dalam sistem.</translation>
<translation id="653608967792832033">Menentukan panjang waktu tanpa masukan pengguna sebelum layar terkunci ketika menggunakan daya baterai.

          Saat kebijakan ini disetel ke nilai yang lebih besar dari nol, nilai tersebut akan menentukan panjang waktu pengguna tetap menganggur sebelum <ph name="PRODUCT_OS_NAME"/> mengunci layar.

          Saat kebijakan ini disetel ke nol, <ph name="PRODUCT_OS_NAME"/> tidak mengunci layar saat pengguna menganggur.

          Saat kebijakan ini tidak disetel, panjang waktu default digunakan.

          Cara yang disarankan untuk mengunci layar saat menganggur adalah dengan mengaktifkan penangguhan penguncian layar dan meminta <ph name="PRODUCT_OS_NAME"/> menangguhkan setelah masa menganggur ditunda. Kebijakan ini seharusnya hanya digunakan saat penguncian layar harus berlangsung selama jumlah waktu signifikan yang lebih cepat daripada ditangguhkan atau saat penundaan pada masa menganggur tidak diinginkan sama sekali.

          Nilai kebijakan ini harus ditentukan dalam milidetik. Nilai dijepit menjadi lebih sedikit dari penundaan waktu menganggur.</translation>
<translation id="979541737284082440">(Dokumen ini dapat mencakup kebijakan yang ditargetkan untuk versi
      <ph name="PRODUCT_NAME"/> yang lebih baru, semuanya
      dapat berubah tanpa pemberitahuan. Daftar kebijakan yang didukung
      sama untuk Chromium dan Google Chrome.)

      Anda tidak perlu mengubah setelan ini secara manual!  Unduh template yang mudah digunakan dari
      <ph name="POLICY_TEMPLATE_DOWNLOAD_URL"/>.

      Kebijakan ini dengan ketat digunakan untuk diterapkan guna mengonfigurasi contoh Chrome di dalam organisasi Anda. Penggunaan kebijakan ini di luar organisasi Anda (misalnya, dalam program yang didistribusikan untuk umum) dianggap sebagai perangkat lunak perusak dan kemungkinan besar akan diberi label sebagai perangkat lunak perusak oleh Google dan vendor antivirus.

      Catatan: Mulai <ph name="PRODUCT_NAME"/>
      28, kebijakan dimuat secara langsung dari API Kebijakan Grup di
      Windows. Kebijakan yang ditulis secara manual ke registri akan diabaikan. Lihat
      http://crbug.com/259236 untuk detailnya.

      Mulai <ph name="PRODUCT_NAME"/> 35, kebijakan dibacakan langsung dari registri jika tempat kerja bergabung dengan domain Direktori Aktif; jika tidak, kebijakan akan dibacakan dari GPO.</translation>
<translation id="4157003184375321727">Laporkan versi OS dan firmware</translation>
<translation id="5255162913209987122">Dapat Direkomendasikan</translation>
<translation id="1861037019115362154">Menentukan daftar plugin yang dinonaktifkan di <ph name="PRODUCT_NAME"/> dan mencegah pengguna mengubah setelan ini.

      Karakter pengganti '*' dan '?' dapat digunakan untuk mencocokkan urutan karakter sembarang. '*' cocok dengan sembarang jumlah karakter sedangkan '?' menentukan karakter tunggal opsional, yaitu yang cocok dengan nol atau satu karakter. Karakter hindar adalah '\', jadi untuk mencocokkan dengan karakter '*', '?', atau '\', jadi '\' di depannya.

      Jika Anda mengaktifkan setelan ini, daftar plugin tertentu tidak akan pernah digunakan di <ph name="PRODUCT_NAME"/>. Plugin ditandai sebagai nonaktif di 'about:plugins' dan pengguna tidak dapat mengaktifkannya.

      Perhatikan bahwa kebijakan ini dapat ditimpa oleh EnabledPlugins dan DisabledPluginsExceptions.

      Jika kebijakan ini tidak disetel, pengguna dapat menggunakan plugin apa pun yang dipasang pada sistem kecuali untuk plugin berbahaya, usang, atau tidak kompatibel yang sulit dikodekan.</translation>
<translation id="9197740283131855199">Persentase yang digunakan untuk menskalakan penundaan layar redup jika pengguna aktif setelah peredupan</translation>
<translation id="1492145937778428165">Menentukan periode dalam milidetik saat layanan pengelola perangkat ditanya tentang informasi kebijakan perangkat.

      Menetapkan kebijakan ini akan menimpa nilai default 3 jam. Nilai yang valid untuk kebijakan ini adalah dalam kisaran dari 1800000 (30 menit) sampai 86400000 (1 hari). Nilai apa pun yang tidak berada dalam jangkauan ini akan dikunci ke batas masing-masing.

      Membiarkan kebijakan ini tidak disetel akan membuat <ph name="PRODUCT_OS_NAME"/> menggunakan nilai default 3 jam.</translation>
<translation id="3765260570442823273">Durasi pesan peringatan proses keluar nganggur</translation>
<translation id="7302043767260300182">Penundaan kunci layar saat menggunakan daya AC</translation>
<translation id="7331962793961469250">Bila disetel ke True, promosi untuk apl Toko Web Chrome tidak akan muncul pada laman tab baru. Menyetel opsi ini ke False atau membiarkannya tanpa disetel akan membuat promosi untuk apl Toko Web Chrome muncul di laman tab baru</translation>
<translation id="7271085005502526897">Impor beranda dari browser default saat pertama kali dijalankan</translation>
<translation id="6036523166753287175">Mengaktifkan firewall traversal dari host akses jarak jauh</translation>
<translation id="1096105751829466145">Penyedia penelusuran default</translation>
<translation id="7567380065339179813">Izinkan plugin pada situs ini</translation>
<translation id="4555850956567117258">Mengaktifkan pengesahan jarak jauh bagi pengguna</translation>
<translation id="5966615072639944554">Ekstensi yang diizinkan untuk menggunakan API pengesahan jarak jauh</translation>
<translation id="1617235075406854669">Aktifkan penghapusan riwayat unduhan atau browser</translation>
<translation id="5290940294294002042">Tentukan daftar plugin yang dapat diaktifkan atau dinonaktifkan pengguna</translation>
<translation id="3153348162326497318">Memungkinkan Anda menentukan ekstensi mana yang TIDAK dapat dipasang oleh pengguna. Ekstensi yang sudah terpasang akan dihapus jika masuk dalam daftar hitam. Nilai daftar hitam '*' berarti semua ekstensi tercantum dalam daftar hitam kecuali secara eksplisit tercantum dalam daftar putih. Jika kebijakan ini dibiarkan tanpa disetel, pengguna dapat memasang ekstensi apa pun di <ph name="PRODUCT_NAME"/>.</translation>
<translation id="3067188277482006117">Jika disetel ke true, pengguna dapat menggunakan perangkat keras pada perangkat Chrome untuk membuktikan identitasnya dari jarak jauh ke CA privasi melalui API Kunci Platform Perusahaan chrome.enterprise.platformKeysPrivate.challengeUserKey().

          Jika disetel ke false, atau jika tidak disetel, panggilan ke API akan gagal dengan suatu kode kesalahan.</translation>
<translation id="5809728392451418079">Setel nama tampilan untuk akun lokal perangkat</translation>
<translation id="1427655258943162134">Alamat atau URL server proxy</translation>
<translation id="1827523283178827583">Gunakan server proxy tetap</translation>
<translation id="3021409116652377124">Nonaktifkan pencari plugin</translation>
<translation id="7236775576470542603">Menyetel jenis lup default yang diaktifkan di layar masuk.

          Jika kebijakan ini disetel, kebijakan ini mengontrol jenis lup yang diaktifkan saat layar masuk ditampilkan. Menyetel kebijakan ini ke &quot;None&quot; menonaktifkan lup.

          Jika Anda menyetel kebijakan ini, pengguna dapat menimpanya untuk sementara dengan mengaktifkan atau menonaktifkan lup. Namun, pilihan pengguna tidak bersifat permanen dan setelan default akan dipulihkan kapan pun layar masuk ditampilkan lagi atau pengguna tetap menganggur di layar masuk selama satu menit.

          Jika kebijakan ini tidak disetel, lup dinonaktifkan saat layar masuk ditampilkan untuk pertama kali. Pengguna dapat mengaktifkan atau menonaktifkan lup kapan saja dan statusnya di layar masuk bersifat permanen antar pengguna.</translation>
<translation id="5423001109873148185">Kebijakan ini memaksa mesin telusur untuk diimpor dari browser default yang digunakan, jika diaktifkan. Jika diaktifkan, kebijakan ini juga memengaruhi dialog impor. Jika dinonaktifkan, mesin telusur default tidak diimpor. Jika tidak disetel, pengguna mungkin akan ditanya apakah ingin mengimpor, atau pengimporan dapat terjadi secara otomatis.</translation>
<translation id="3288595667065905535">Saluran rilis</translation>
<translation id="2785954641789149745">Mengaktifkan fitur Penjelajahan Aman <ph name="PRODUCT_NAME"/> dan mencegah pengguna mengubah setelan ini.

      Jika Anda mengaktifkan setelan ini, Penjelajahan Aman akan selalu aktif.

      Jika Anda menonaktifkan setelan ini, Penjelajahan Aman tidak akan pernah aktif.

      Jika Anda mengaktifkan atau menonaktifkan setelan ini, pengguna tidak dapat mengubah atau menimpa setelan &quot;Aktifkan perlindungan phishing dan perangkat lunak perusak&quot; di <ph name="PRODUCT_NAME"/>.

      Jika kebijakan ini tidak disetel, kebijakan akan diaktifkan namun pengguna dapat mengubahnya.</translation>
<translation id="268577405881275241">Aktifkan fitur proxy kompresi data</translation>
<translation id="3820526221169548563">Mengaktifkan fitur aksesibilitas keyboard di layar.

          Jika kebijakan ini disetel ke true, keyboard di layar akan selalu diaktifkan.

          Jika kebijakan ini disetel ke false, keyboard di layar akan selalu dinonaktifkan.

          Jika Anda menyetel kebijakan ini, pengguna tidak dapat mengubah atau menggantinya.

          Jika kebijakan ini tidak disetel, keyboard di layar awalnya dinonaktifkan namun dapat diaktifkan oleh pengguna kapan saja.</translation>
<translation id="8369602308428138533">Penundaan mematikan layar saat menggunakan daya AC</translation>
<translation id="6513756852541213407">Memungkinkan Anda menentukan server proxy yang digunakan oleh <ph name="PRODUCT_NAME"/> dan mencegah pengguna mengubah setelan proxy. Jika Anda memilih untuk tidak pernah menggunakan server proxy dan selalu tersambung secara langsung, semua opsi lain akan diabaikan. Jika Anda memilih menggunakan setelan proxy sistem atau mendeteksi server proxy secara otomatis, semua opsi lain akan diabaikan. Jika Anda memilih mode proxy server tetap, Anda dapat menentukan opsi lebih lanjut di 'Alamat atau URL server proxy' dan 'Daftar peraturan pengabaian proxy yang dipisahkan koma'. Jika Anda memilih untuk menggunakan skrip .pac proxy, Anda harus menentukan URL dalam skrip di 'URL ke file .pac proxy'. Untuk contoh mendetail, kunjungi: <ph name="PROXY_HELP_URL"/> Jika Anda mengaktifkan setelan ini, <ph name="PRODUCT_NAME"/> akan mengabaikan semua opsi yang berhubungan dengan proxy yang ditentukan dalam baris perintah. Membiarkan kebijakan ini tanpa disetel akan memungkinkan pengguna memilih sendiri setelan proxy.</translation>
<translation id="7763311235717725977">Memungkinkan Anda menyetel apakah situs diizinkan untuk menampilkan gambar. Menampilkan gambar dapat diizinkan untuk semua situs web atau ditolak untuk semua situs web. Jika kebijakan ini dibiarkan tidak disetel, 'AllowImages' akan digunakan dan pengguna dapat mengubahnya.</translation>
<translation id="5630352020869108293">Mengembalikan sesi terakhir</translation>
<translation id="2067011586099792101">Memblokir akses ke situs di luar paket konten</translation>
<translation id="4980635395568992380">Jenis data:</translation>
<translation id="3096595567015595053">Daftar plugin yang diaktifkan</translation>
<translation id="3048744057455266684">Jika kebijakan ini disetel dan URL penelusuran yang disarankan dari omnibox berisi parameter ini dalam string kueri atau dalam pengenal fragmen, maka saran akan menampilkan istilah penelusuran dan penyedia penelusuran dan bukan URL penelusuran mentah.

          Kebijakan ini adalah opsional. Jika tidak disetel, penggantian istilah penelusuran tidak akan dilakukan.

          Kebijakan ini hanya akan ditaati jika kebijakan 'DefaultSearchProviderEnabled' diaktifkan.</translation>
<translation id="5912364507361265851">Izinkan pengguna menampilkan sandi pada Pengelola Sandi</translation>
<translation id="5318185076587284965">Aktifkan penggunaan server relay oleh hosting akses jarak jauh</translation>
<translation id="510186355068252378">Menonaktifkan sinkronisasi data di <ph name="PRODUCT_NAME"/> dengan menggunakan layanan sinkronisasi yang dihosting oleh Google dan mencegah pengguna mengubah setelan ini. Jika Anda mengaktifkan setelan ini, pengguna tidak dapat mengubah atau menimpa setelan ini di <ph name="PRODUCT_NAME"/>. Jika kebijakan ini dibiarkan tidak disetel, pengguna dapat memilih apakah akan menggunakan Google Sync yang disediakan atau tidak.</translation>
<translation id="7953256619080733119">Hosting pengecualian manual pengguna yang dikelola</translation>
<translation id="4807950475297505572">Pengguna yang paling jarang digunakan dihapus sampai terdapat cukup ruang kosong</translation>
<translation id="8789506358653607371">Mengizinkan mode layar penuh.

      Kebijakan ini mengontrol ketersediaan mode layar penuh tempat seluruh UI <ph name="PRODUCT_NAME"/> tersembunyi dan hanya konten web yang terlihat.

      Jika kebijakan ini disetel ke true atau tidak dikonfigurasi, penguna, aplikasi, dan ekstensi dengan izin yang sesuai dapat memasuki mode layar penuh.

      Jika kebijakan ini disetel ke false, pengguna dan aplikasi maupun ekstensi tidak dapat memasuki mode layar penuh.

      Mode kios di semua platform kecuali <ph name="PRODUCT_OS_NAME"/> tidak akan tersedia saat mode layar penuh dinonaktifkan.</translation>
<translation id="8828766846428537606">Mengonfigurasi beranda default pada <ph name="PRODUCT_NAME"/> dan mencegah pengguna mengubahnya. Setelan beranda pengguna hanya dikunci sepenuhnya, jika Anda memilih beranda sebagai laman tab baru, atau menyetelnya menjadi URL dan menentukan URL beranda. Jika Anda tidak menentukan URL beranda, pengguna masih dapat menyetel beranda ke laman tab baru dengan menentukan 'chrome://newtab'.</translation>
<translation id="2231817271680715693">Impor riwayat browseran dari browser default saat pertama kali dijalankan</translation>
<translation id="1353966721814789986">Laman permulaan</translation>
<translation id="7173856672248996428">Profil singkat</translation>
<translation id="1841130111523795147">Memungkinkan pengguna masuk ke <ph name="PRODUCT_NAME"/> dan mencegah pengguna mengubah setelan ini.

      Jika Anda menyetel kebijakan ini, Anda dapat mengonfigurasikan apakah pengguna diizinkan untuk masuk ke <ph name="PRODUCT_NAME"/> atau tidak.</translation>
<translation id="5564962323737505851">Mengonfigurasi pengelola sandi. Jika pengelola sandi diaktifkan, Anda dapat memilih mengaktifkan atau menonaktifkan apakah pengguna dapat menampilkan sandi tersimpan dalam teks yang jelas.</translation>
<translation id="4668325077104657568">Setelan gambar default</translation>
<translation id="4492287494009043413">Menonaktifkan pengambilan tangkapan layar</translation>
<translation id="6368403635025849609">Izinkan JavaScript di situs ini</translation>
<translation id="6074963268421707432">Jangan izinkan situs apa pun menampilkan pemberitahuan desktop</translation>
<translation id="8614804915612153606">Nonaktifkan Pembaruan Otomatis</translation>
<translation id="4834526953114077364">Pengguna yang paling jarang digunakan yang belum masuk dalam 3 bulan terakhir dihapus sampai terdapat cukup ruang kosong</translation>
<translation id="382476126209906314">Mengonfigurasi awalan TalkGadget untuk hosting akses jarak jauh</translation>
<translation id="6561396069801924653">Tampilkan opsi aksesibilitas di menu baki sistem</translation>
<translation id="8104962233214241919">Memilih sertifikat klien untuk situs ini secara otomatis</translation>
<translation id="2906874737073861391">Daftar ekstensi AppPack</translation>
<translation id="4386578721025870401">Batasi waktu bagi pengguna yang diautentikasi melalui SAML untuk dapat masuk saat offline.

      Selama proses masuk, Chrome OS dapat mengautentikasi server (online) atau menggunakan sandi yang tersimpan di dalam cache (offline).

      Jika kebijakan ini disetel ke nilai -1, pengguna dapat mengautentikasi tanpa batas saat offline. Jika kebijakan ini disetel ke nilai lainnya, akan menentukan panjang waktu sejak autentikasi online terakhir yang setelah itu pengguna harus menggunakan autentikasi online lagi.

      Membiarkan kebijakan ini tidak disetel membuat <ph name="PRODUCT_OS_NAME"/> menggunakan batas waktu default yakni 14 hari yang setelah itu pengguna harus menggunakan autentikasi online lagi.

      Kebijakan ini hanya berpengaruh terhadap pengguna yang diautentikasi menggunakan SAML.

      Nilai kebijakan tersebut seharusnya dapat ditentukan dalam hitungan detik.</translation>
<translation id="3758249152301468420">Nonaktifkan Alat Pengembang</translation>
<translation id="8665076741187546529">Konfigurasikan daftar ekstensi yang dipasang secara paksa</translation>
<translation id="2386768843390156671">Memungkinkan pemasangan tingkat pengguna pada host Native Messaging.

          Jika setelan ini diaktifkan, <ph name="PRODUCT_NAME"/> memungkinkan
          penggunaan host Native Messaging dipasang pada tingkat pengguna.

          Jika setelan ini dinonaktifkan <ph name="PRODUCT_NAME"/> hanya akan
          menggunakan host Native Messaging yang dipasang pada tingkat sistem.

          Jika setelan ini tidak disetel <ph name="PRODUCT_NAME"/>
          akan memungkinkan penggunaan host Native Messaging pada tingkat pengguna.</translation>
<translation id="410478022164847452">Menentukan panjang waktu tanpa masukan pengguna sebelum tindakan menganggur diambil saat menggunakan daya AC.

          Saat kebijakan ini disetel, kebijakan menentukan panjang waktu pengguna harus tetap menganggur sebelum <ph name="PRODUCT_OS_NAME"/> melakukan tindakan menganggur, yang dapat dikonfigurasikan secara terpisah.

          Saat kebijakan ini tidak disetel, panjang waktu default digunakan.

          Nilai kebijakan harus ditetapkan dalam milidetik.</translation>
<translation id="6598235178374410284">Gambar avatar pengguna</translation>
<translation id="1675391920437889033">Mengontrol jenis aplikasi/ekstensi mana yang diizinkan untuk dipasang.

          Setelan ini membuat daftar putih jenis ekstensi/aplikasi yang diizinkan yang dapat dipasang di <ph name="PRODUCT_NAME"/>. Nilai tersebut adalah daftar string, setiap nilai harus salah satu dari yang berikut: &quot;extension&quot;, &quot;theme&quot;, &quot;user_script&quot;, &quot;hosted_app&quot;, &quot;legacy_packaged_app&quot;, &quot;platform_app&quot;. Lihat dokumentasi ekstensi Chrome untuk informasi selengkapnya untuk jenis-jenis ini.

          Perhatikan bahwa kebijakan ini juga memengaruhi ekstensi dan aplikasi untuk dipaksakan pemasangannya melalui ExtensionInstallForcelist.

          Jika setelan ini dikonfigurasi, ekstensi/aplikasi yang jenisnya tidak ada dalam daftar tidak akan dipasang.

          Jika setelan ini dibiarkan tidak dikonfigurasi, tidak ada larangan yang diterapkan pada jenis ekstensi/aplikasi yang dapat diterima.</translation>
<translation id="6378076389057087301">Tentukan apakah aktivitas audio memengaruhi pengelolaan daya</translation>
<translation id="8818173863808665831">Melaporkan lokasi geografis perangkat.

      Jika kebijakan tidak disetel, atau disetel ke false, lokasi tidak akan dilaporkan.</translation>
<translation id="4899708173828500852">Aktifkan Penjelajahan Aman</translation>
<translation id="4442582539341804154">Aktifkan kunci bila perangkat menganggur atau ditangguhkan</translation>
<translation id="7719251660743813569">Mengontrol apakah metrik penggunaan dilaporkan kembali ke Google. Jika disetel ke true, <ph name="PRODUCT_OS_NAME"/> akan melaporkan metrik penggunaan. Jika tidak dikonfigurasi atau disetel ke false, pelaporan metrik akan dinonaktifkan.</translation>
<translation id="2372547058085956601">Penundaan masuk otomatis sesi publik.

      Jika kebijakan |DeviceLocalAccountAutoLoginId| tidak disetel, kebijakan ini tidak akan berpengaruh.

      Jika kebijakan ini disetel, jumlah waktu akan ditentukan tanpa aktivitas pengguna yang harus dilalui sebelum masuk otomatis ke sesi publik yang ditentukan oleh kebijakan |DeviceLocalAccountAutoLoginId|.

      Jika kebijakan ini tidak disetel, waktu tunggunya akan menjadi 0 milidetik.

      Kebijakan ini ditentukan dalam milidetik.</translation>
<translation id="7275334191706090484">Bookmark yang Terkelola</translation>
<translation id="3570008976476035109">Mencekal plugin di situs ini</translation>
<translation id="8749370016497832113">Mengaktifkan penghapusan riwayat browser dan riwayat unduhan di <ph name="PRODUCT_NAME"/> dan mencegah pengguna mengubah setelan berikut.

      Perhatikan bahwa meskipun kebijakan ini dinonaktifkan, riwayat unduhan dan penjelajahan tidak dijamin akan tersimpan: pengguna dapat mengedit atau menghapus file basis data riwayat secara langsung, dan browser itu sendiri mungkin kedaluwarsa atau mengarsipkan beberapa atau semua item riwayat setiap saat.

      Jika setelan ini diaktifkan atau tidak disetel, riwayat penjelajahan atau unduhan dapat dihapus.

      Jika setelan ini dinonaktifkan, riwayat penjelajahan dan unduhan tidak dapat dihapus.</translation>
<translation id="2884728160143956392">Izinkan cookie sesi saja di situs-situs tersebut</translation>
<translation id="3021272743506189340">Menonaktifkan sinkronisasi Google Drive di aplikasi Files Chrome OS ketika menggunakan sambungan seluler saat disetel ke True. Dalam kasus tersebut, data hanya disinkronkan ke Google Drive saat tersambung melalui WiFi atau Ethernet.

          Jika tidak disetel atau disetel ke False, pengguna akan dapat mentransfer file Google Drive melalui sambungan seluler.</translation>
<translation id="4655130238810647237">Mengaktifkan atau menonaktifkan pengeditan bookmark di <ph name="PRODUCT_NAME"/>. Jika Anda mengaktifkan setelan ini, bookmark dapat ditambahkan, dihapus, atau diubah. Ini juga merupakan setelan default meskipun kebijakan ini tidak disetel. Jika Anda menonaktifkan setelan ini, bookmark tidak dapat ditambahkan, dihapus, atau diubah. Bookmark yang ada masih tersedia.</translation>
<translation id="3496296378755072552">Pengelola sandi</translation>
<translation id="4372704773119750918">Jangan izinkan pengguna perusahaan untuk menjadi bagian dari multiprofil (primer atau sekunder)</translation>
<translation id="7027785306666625591">Mengonfigurasi pengelolaan daya di <ph name="PRODUCT_OS_NAME"/>.

      Kebijakan ini memungkinkan Anda mengonfigurasi cara <ph name="PRODUCT_OS_NAME"/> berperilaku saat pengguna tetap menganggur dalam beberapa waktu.</translation>
<translation id="2565967352111237512">Memungkinkan pelaporan anonim atas data penggunaan dan kerusakan yang terkait dengan <ph name="PRODUCT_NAME"/> ke Google dan mencegah pengguna mengubah setelan ini. Jika Anda mengaktifkan setelan ini, pelaporan anonim atas data penggunaan dan kerusakan yang terkait akan dikirim ke Google. Jika Anda menonaktifkan setelan ini, pelaporan anonim atas data penggunaan dan kerusakan yang terkait tidak akan pernah dikirim ke Google. Jika Anda mengaktifkan atau menonaktifkan setelan ini, pengguna tidak dapat mengubah atau menimpa setelan ini di <ph name="PRODUCT_NAME"/>. Jika kebijakan ini dibiarkan tidak disetel, setelan yang digunakan akan berdasarkan pada pilihan pengguna saat pemasangan / pertama kali dijalankan.</translation>
<translation id="6256787297633808491">Tanda di seluruh sistem yang akan diterapkan di waktu mulai Chrome</translation>
<translation id="2516600974234263142">Mengaktifkan pencetakan di <ph name="PRODUCT_NAME"/> dan mencegah pengguna mengubah setelan ini.

      Jika setelan ini diaktifkan atau tidak dikonfigurasi, pengguna dapat mencetak.

      Jika setelan ini dinonaktifkan, pengguna tidak dapat mencetak dari <ph name="PRODUCT_NAME"/>. Pencetakan dinonaktifkan di menu perkakas, ekstensi, aplikasi JavaScript, dll. Masih mungkin untuk dapat mencetak dari plugin yang melewati <ph name="PRODUCT_NAME"/> saat mencetak. Contohnya, aplikasi Flash tertentu memiliki opsi cetak di menu konteks, yang tidak termasuk dalam kebijakan ini.</translation>
<translation id="9135033364005346124">Mengaktifkan proxy <ph name="CLOUD_PRINT_NAME"/></translation>
<translation id="4519046672992331730">Mengaktifkan saran penelusuran dalam omnibox <ph name="PRODUCT_NAME"/> dan mencegah pengguna mengganti setelan ini.

      Jika Anda mengaktifkan setelan ini, saran penelusuran akan digunakan.

      Jika Anda menonaktifkan setelan ini, saran penelusuran tidak akan pernah digunakan.

      Jika Anda mengaktifkan atau menonaktifkan setelan ini, pengguna tidak akan dapat mengubah atau mengganti setelan ini di <ph name="PRODUCT_NAME"/>.

      Jika kebijakan ini dibiarkan tidak disetel, kebijakan ini akan diaktifkan namun pengguna akan dapat mengubahnya.</translation>
<translation id="6943577887654905793">Nama preferensi Mac/Linux:</translation>
<translation id="8176035528522326671">Memungkinkan pengguna perusahaan menjadi pengguna banyak profil primer saja (Perilaku default untuk pengguna yang dikelola perusahaan)</translation>
<translation id="6925212669267783763">Mengonfigurasi direktori yang akan gunakan <ph name="PRODUCT_FRAME_NAME"/> untuk menyimpan data pengguna.

      Jika Anda menyetel kebijakan ini, <ph name="PRODUCT_FRAME_NAME"/> akan menggunakan direktori yang diberikan.

      Lihat http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables untuk daftar variabel yang dapat digunakan.

      Jika setelan ini dibiarkan tidak disetel, direktori profil default akan digunakan.</translation>
<translation id="8906768759089290519">Aktifkan mode tamu</translation>
<translation id="348495353354674884">Aktifkan keyboard virtual</translation>
<translation id="2168397434410358693">Menunda waktu menganggur saat menggunakan daya AC</translation>
<translation id="838870586332499308">Aktifkan roaming data</translation>
<translation id="2292084646366244343"><ph name="PRODUCT_NAME"/> dapat menggunakan layanan web Google untuk membantu mengatasi masalah ejaan yang salah. Jika setelan ini diaktifkan, layanan ini akan selalu digunakan. Jika setelan ini dinonaktifkan, layanan ini tidak akan pernah digunakan.

      Memeriksa ejaan tetap dapat dilakukan menggunakan kamus yang diunduh; kebijakan ini hanya mengontrol penggunaan layanan online.

      Jika setelan ini tidak dikonfigurasi, maka pengguna dapat memilih apakah layanan memeriksa ejaan harus digunakan atau tidak.</translation>
<translation id="8782750230688364867">Menentukan persentase yang digunakan untuk menskalakan penundaan layar redup saat perangkat dalam mode presentasi.

          Jika kebijakan ini disetel, kebijakan menentukan persentase yang digunakan untuk menskalakan penundaan layar redup saat perangkat dalam mode presentasi. Saat penundaan layar redup diskalakan, penundaan status menganggur, kunci layar, layar mati akan disesuaikan agar jarak waktu dari penundaan layar redup seperti konfigurasi asal.

          Jika kebijakan ini tidak disetel, faktor skala default akan digunakan.

          Faktor skala harus 100% atau lebih. Nilai yang akan membuat penundaan layar redup dalam mode presentasi jadi lebih pendek daripada versi reguler tidak diizinkan.</translation>
<translation id="254524874071906077">Setel Chrome sebagai Browser Default</translation>
<translation id="8112122435099806139">Menentukan format jam yang digunakan untuk perangkat.

      Kebijakan ini mengonfigurasi format jam yang akan digunakan di layar masuk dan sebagai default untuk sesi pengguna. Pengguna masih dapat mengganti format jam untuk akunnya.

      Jika kebijakan ini disetel ke true, perangkat akan menggunakan format 24 jam. Jika kebijakan disetel ke false, perangkat akan menggunakan format 12 jam.

      Jika kebijakan ini tidak disetel, perangkat akan menggunakan format default 24 jam.</translation>
<translation id="8764119899999036911">Menentukan apakah Kerberos SPN yang dihasilkan didasarkan pada nama DNS kanonik atau nama asli yang dimasukkan. Jika Anda mengaktifkan setelan ini, pencarian CNAME akan dilewati dan nama server akan digunakan seperti saat dimasukkan. Jika Anda menonaktifkan setelan ini atau membiarkannya tidak disetel, nama kanonik server akan ditentukan melalui pencarian CNAME.</translation>
<translation id="5056708224511062314">Lup dinonaktifkan</translation>
<translation id="4377599627073874279">Izinkan semua situs menampilkan semua gambar</translation>
<translation id="7195064223823777550">Tentukan tindakan yang akan diambil saat pengguna menutup penutupnya.

          Saat kebijakan ini disetel, kebijakan menentukan tindakan yang diambil oleh <ph name="PRODUCT_OS_NAME"/> saat pengguna menutup penutup perangkat.

          Saat kebijakan ini tidak disetel, tindakan default yang ditangguhkan diambil.

          Jika tindakan ini ditangguhkan, <ph name="PRODUCT_OS_NAME"/> dapat dikonfigurasi secara terpisah baik untuk mengunci atau tidak mengunci layar sebelum menangguhkan.</translation>
<translation id="3915395663995367577">URL untuk proxy file .pac</translation>
<translation id="1022361784792428773">ID ekstensi yang tidak diizinkan dipasang pengguna (atau * untuk semua)</translation>
<translation id="6064943054844745819">Menentukan daftar fitur platform web usang untuk diaktifkan kembali.

      Kebijakan ini memberi kemampuan kepada administrator untuk mengaktifkan kembali fitur platform web usang dalam waktu yang terbatas. Fitur yang diidentifikasi dengan tag string dan fitur yang sesuai dengan tag yang termasuk dalam daftar yang ditentukan oleh kebijakan ini akan diaktifkan kembali.

      Tag berikut saat ini didefinisikan:
      - ShowModalDialog_EffectiveUntil20150430

      Jika kebijakan ini tidak disetel atau daftar kosong, semua fitur platform web usang akan tetap dinonaktifkan.</translation>
<translation id="3805659594028420438">Aktifkan ekstensi sertifikat terikat domain TLS (tidak lagi digunakan)</translation>
<translation id="5499375345075963939">Kebijakan ini hanya aktif pada mode ritel.

      Saat nilai kebijakan ini disetel dan tidak 0, maka pengguna demo yang saat ini telah masuk akan dikeluarkan secara otomatis setelah waktu tidak aktif selama durasi yang ditentukan telah habis.

      Nilai kebijakan sebaiknya ditentukan dalam milidetik.</translation>
<translation id="7683777542468165012">Penyegaran Kebijakan Dinamis</translation>
<translation id="1160939557934457296">Menonaktifkan untuk melanjutkan dari laman peringatan Penjelajahan Aman</translation>
<translation id="8987262643142408725">Nonaktifkan pembagian catatan SSL</translation>
<translation id="4529945827292143461">Sesuaikan daftar pola URL yang harus selalu dirender oleh browser host. Jika kebijakan ini tidak disetel, perender default akan digunakan untuk semua situs yang ditentukan oleh kebijakan 'ChromeFrameRendererSettings'. Untuk contoh pola, lihat http://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="8044493735196713914">Laporkan mode boot perangkat</translation>
<translation id="2746016768603629042">Kebijakan ini sudah tidak digunakan lagi, sebaiknya gunakan DefaultJavaScriptSetting.

      Dapat digunakan untuk menonaktifkan JavaScript pada <ph name="PRODUCT_NAME"/>.

      Jika setelan ini dinonaktifkan, laman web tidak dapat menggunakan JavaScript dan pengguna tidak dapat mengubah setelan ini.

      Jika setelan ini diaktifkan atau tidak disetel, laman web dapat menggunakan JavaScript, namun pengguna dapat mengubah setelan tersebut.</translation>
<translation id="1942957375738056236">Anda dapat menentukan URL proxy server di sini. Kebijakan ini hanya berlaku jika Anda telah memilih setelan proxy manual di 'Pilih cara menentukan setelan server proxy'. Anda harus membiarkan kebijakan ini tidak disetel jika Anda telah memilih mode lain untuk menyetel kebijakan proxy. Untuk opsi lain dan contoh mendetail, kunjungi: <ph name="PROXY_HELP_URL"/></translation>
<translation id="6076008833763548615">Menonaktifkan pemasangan penyimpanan eksternal.

      Saat kebijakan ini disetel ke True, penyimpanan eksternal tidak akan tersedia dalam browser file.

      Kebijakan ini berpengaruh pada semua jenis media penyimpanan. Contohnya: flash disk USB, hard disk eksternal, kartu memori SD dan kartu memori lainnya, penyimpanan optik, dll. Penyimpanan internal tidak dipengaruhi oleh kebijakan ini, jadi file yang disimpan pada folder Unduhan tetap dapat diakses. Google Drive juga tidak dipengaruhi oleh kebijakan ini.

      Jika setelan ini dinonaktifkan atau tidak dikonfigurasi, pengguna dapat menggunakan semua jenis penyimpanan eksternal yang didukung di perangkat mereka.</translation>
<translation id="6936894225179401731">Menentukan jumlah maksimum sambungan bersama ke server proxy.

      Beberapa server proxy tidak dapat menangani sambungan bersama per klien dalam jumlah besar dan hal ini dapat ditangani dengan menyetel kebijakan ini ke nilai yang lebih rendah.

      Nilai kebijakan ini harus lebih rendah dari 100 dan lebih tinggi dari 6 dan nilai defaultnya adalah 32.

      Beberapa aplikasi web diketahui memakan banyak sambungan dengan GET yang macet, jadi menyetelnya lebih rendah dari 32 dapat mengakibatkan jaringan browser macet jika terlalu banyak aplikasi web semacam itu yang dibuka. Turunkan di bawah default, risiko ditanggung sendiri.

      Jika kebijakan ini tidak disetel, nilai default 32 akan digunakan.</translation>
<translation id="5395271912574071439">Mengaktifkan pemberian tirai hosting akses jarak jauh saat sambungan berlangsung.

          Jika setelan ini diaktifkan, perangkat keluaran dan masukan fisik hosting akan dinonaktifkan saat sambungan jarak jauh berlangsung.

          Jika setelan ini dinonaktifkan atau tidak disetel, baik pengguna lokal maupun pengguna jarak jauh dapat berinteraksi dengan hosting ketika sedang dibagikan.</translation>
<translation id="2488010520405124654">Aktifkan permintaan konfigurasi jaringan saat offline.

      Jika kebijakan ini tidak disetel atau disetel ke True dan akun lokal perangkat dikonfigurasikan untuk masuk otomatis tanpa penundaan dan perangkat tidak memiliki akses ke internet, <ph name="PRODUCT_OS_NAME"/> akan memunculkan permintaan konfigurasi jaringan.

      Jika kebijakan ini disetel ke False, pesan kesalahan akan muncul, bukan permintaan konfigurasi jaringan.</translation>
<translation id="1426410128494586442">Ya</translation>
<translation id="4897928009230106190">Menentukan parameter yang digunakan saat melakukan penelusuran saran dengan POST. Terdiri dari pasangan nama/nilai yang dipisahkan koma. Jika nilai  parameter template, seperti {searchTerms} pada contoh di atas, akan diganti dengan data istilah penelusuran nyata.

          Kebijakan ini bersifat opsional. Jika tidak disetel, sarankan permintaan saran penelusuran akan dikirim menggunakan metode GET.

          Kebijakan ini hanya dipatuhi jika kebijakan 'DefaultSearchProviderEnabled' diaktifkan.</translation>
<translation id="8140204717286305802">Laporkan daftar antarmuka jaringan dengan alamat perangkat keras dan jenisnya ke server.

      Jika kebijakan disetel ke false, daftar antarmuka tidak akan dilaporkan.</translation>
<translation id="4962195944157514011">Menentukan URL mesin telusur yang digunakan saat melakukan penelusuran default. URL sebaiknya berisi string '<ph name="SEARCH_TERM_MARKER"/>', yang akan diganti pada waktu kueri dengan istilah yang ditelusuri oleh pengguna. Opsi ini harus disetel ketika kebijakan 'DefaultSearchProviderEnabled' diaktifkan dan hanya akan diberlakukan jika opsi tersebut digunakan.</translation>
<translation id="6009903244351574348">Memungkinkan <ph name="PRODUCT_FRAME_NAME"/> menangani jenis konten yang tercantum. Jika kebijakan ini tidak disetel, perender default akan digunakan untuk semua situs yang ditentukan oleh kebijakan 'ChromeFrameRendererSettings'.</translation>
<translation id="3381968327636295719">Gunakan browser host jika tidak diubah</translation>
<translation id="3627678165642179114">Mengaktifkan atau menonaktifkan layanan web memeriksa ejaan</translation>
<translation id="6520802717075138474">Impor mesin telusur dari browser default saat pertama kali dijalankan</translation>
<translation id="4039085364173654945">Mengontrol apakah sub-konten pihak ketiga pada laman diizinkan untuk memunculkan kotak dialog HTTP Otorisasi Dasar. Biasanya, kebijakan ini dinonaktifkan sebagai pertahanan atas phishing. Jika tidak disetel, kebijakan ini akan dinonaktifkan dan sub-konten pihak ketiga tidak akan diizinkan untuk memunculkan kotak dialog HTTP Otorisasi Dasar.</translation>
<translation id="4946368175977216944">Menentukan tanda yang harus diterapkan ke Chrome saat dimulai. Tanda yang ditentukan diterapkan sebelum Chrome dimulai bahkan untuk layar masuk.</translation>
<translation id="7447786363267535722">Mengaktifkan penyimpanan sandi dan menggunakan sandi yang disimpan di <ph name="PRODUCT_NAME"/>. Jika Anda mengaktifkan setelan ini, pengguna dapat membuat <ph name="PRODUCT_NAME"/> mengingat sandi dan menyediakan sandi tersebut secara otomatis saat pengguna masuk ke sebuah situs di masa mendatang. Jika Anda menonaktifkan setelan ini, pengguna tidak dapat menyimpan sandi atau menggunakan sandi yang sudah disimpan. Jika Anda mengaktifkan atau menonaktifkan setelan ini, pengguna tidak dapat mengubah atau menimpa setelan ini di <ph name="PRODUCT_NAME"/>. Jika kebijakan ini dibiarkan tidak disetel, kebijakan ini akan diaktifkan, namun pengguna dapat mengubahnya.</translation>
<translation id="1138294736309071213">Kebijakan ini aktif dalam mode eceran saja.

      Menentukan durasi sebelum tirai layar ditampilkan di layar masuk dalam mode eceran.

      Nilai kebijakan harus ditentukan dalam milidetik.</translation>
<translation id="6368011194414932347">Mengonfigurasi URL beranda</translation>
<translation id="2877225735001246144">Nonaktifkan pencarian CNAME saat menegosiasikan autentikasi Kerberos</translation>
<translation id="9120299024216374976">Menentukan zona waktu yang akan digunakan di perangkat. Pengguna dapat mengganti zona waktu yang telah ditentukan untuk sesi ini. Namun, zona waktu tersebut akan kembali ke zona waktu yang telah ditentukan saat keluar. Jika nilai yang diberikan tidak valid, maka kebijakan ini tetap diaktifkan menggunakan &quot;GMT&quot; sebagai gantinya. Jika string yang diberikan kosong, kebijakan tersebut diabaikan

      Jika kebijakan ini tidak digunakan, zona waktu yang aktif saat ini akan digunakan. Namun, pengguna dapat mengubah zona waktu ini dan perubahan tersebut akan tetap digunakan. Perubahan yang dilakukan oleh pengguna itu memengaruhi layar masuk dan semua pengguna lain.

      Perangkat baru memulai dengan zona waktu disetel ke &quot;AS/Pasifik&quot;.

      Format nilai mengikuti nama zona waktu dalam &quot;Basis Data Zona Waktu IANA&quot; (lihat &quot;http://en.wikipedia.org/wiki/List_of_tz_database_time&quot;). Secara khusus, hampir semua zona waktu dapat direferensikan dengan &quot;continent/large_city&quot; atau &quot;ocean/large_city&quot;.</translation>
<translation id="3646859102161347133">Menyetel jenis lup</translation>
<translation id="3528000905991875314">Mengaktifkan laman kesalahan alternatif</translation>
<translation id="1283072268083088623">Menentukan skema Autentikasi HTTP yang didukung oleh <ph name="PRODUCT_NAME"/>. Nilai yang mungkin keluar adalah 'basic', 'digest', 'NTLM', dan 'negotiate'. Pisahkan beberapa nilai dengan koma. Jika kebijakan ini dibiarkan tidak disetel, keempat skema akan digunakan.</translation>
<translation id="1017967144265860778">Pengelolaan daya di layar masuk</translation>
<translation id="4914647484900375533">Mengaktifkan fitur Instan <ph name="PRODUCT_NAME"/> dan mencegah pengguna mengubah setelan ini.

      Jika Anda mengaktifkan setelan ini, <ph name="PRODUCT_NAME"/> Instan akan diaktifkan.

      Jika Anda menonaktifkan setelan ini, <ph name="PRODUCT_NAME"/> Instan akan dinonaktifkan.

      Jika Anda mengaktifkan atau menonaktifkan setelan ini, pengguna tidak dapat mengubah atau menimpa setelan ini.

      Jika setelan ini tidak disetel, pengguna dapat memutuskan untuk menggunakan fungsi ini atau tidak.

      Setelan ini telah dihapus dari Chrome 29 dan versi yang lebih tinggi.</translation>
<translation id="6114416803310251055">tak lagi digunakan</translation>
<translation id="8493645415242333585">Menonaktifkan penyimpanan riwayat browser</translation>
<translation id="2747783890942882652">Mengonfigurasi nama domain hosting yang dibutuhkan yang akan diberlakukan pada hosting akses jarak jauh dan mencegah pengguna mengubahnya.

          Jika setelan ini diaktifkan, maka hosting dapat dibagikan hanya dengan menggunakan akun yang terdaftar pada nama domain yang ditentukan.

          Jika setelan ini dinonaktifkan atau tidak disetel, hosting dapat dibagikan menggunakan akun apa pun.</translation>
<translation id="6417861582779909667">Memungkinkan Anda menyetel daftar pola url yang menentukan situs yang tidak diizinkan untuk menyetel cookie. Jika kebijakan ini dibiarkan tidak disetel, nilai default global akan digunakan untuk semua situs, baik dari kebijakan 'DefaultCookiesSetting', jika disetel, atau konfigurasi pribadi pengguna.</translation>
<translation id="5776485039795852974">Tanyakan setiap kali situs ingin menampilkan pemberitahuan desktop</translation>
<translation id="5047604665028708335">Memungkinkan akses ke situs di luar paket konten</translation>
<translation id="5052081091120171147">Kebijakan ini memaksa riwayat browseran diimpor dari browser default saat ini, jika diaktifkan. Jika diaktifkan, kebijakan ini juga memengaruhi dialog impor. Jika dinonaktifkan, tidak ada riwayat browseran yang diimpor. Jika tidak disetel, pengguna mungkin ditanya apakah akan mengimpor, atau pengimporan dapat terjadi secara otomatis.</translation>
<translation id="6786747875388722282">Ekstensi</translation>
<translation id="7132877481099023201">URL yang akan diberi akses ke perangkat perekam video tanpa peringatan</translation>
<translation id="8947415621777543415">Laporkan lokasi perangkat</translation>
<translation id="1655229863189977773">Setel ukuran cache disk dalam bita</translation>
<translation id="3358275192586364144">Mengaktifkan pengoptimalan WPAD pada <ph name="PRODUCT_NAME"/> dan mencegah pengguna mengubah setelan ini.

      Menyetel kebijakan ini menjadi aktif akan menyebabkan Chrome menunggu dalam interval yang lebih pendek bagi server WPAD berbasis DNS.

      Jika tidak disetel, kebijakan ini akan diaktifkan dan pengguna tidak
      akan dapat mengubahnya.</translation>
<translation id="6376842084200599664">Memungkinkan Anda untuk menentukan daftar ekstensi yang akan dipasang secara diam-diam, tanpa interaksi pengguna.

          Setiap item dari daftar merupakan string yang berisi ID ekstensi dan URL pembaruan yang dibatasi dengan titik koma (<ph name="SEMICOLON"/>). ID ekstensi merupakan string 32 huruf yang ditemukan misalnya, di <ph name="CHROME_EXTENSIONS_LINK"/> saat dalam mode pengembang. URL pembaruan harus mengarah ke dokumen XML Manifes Pembaruan seperti yang dideskripsikan di <ph name="LINK_TO_EXTENSION_DOC1"/>. Perhatikan bahwa URL pembaruan yang disetel dalam kebijakan ini hanya digunakan untuk pemasangan awal; pembaruan ekstensi berikutnya akan menggunakan URL pembaruan yang ditunjukkan dalam manifes ekstensi.

          Untuk setiap item, <ph name="PRODUCT_NAME"/> akan mengambil ekstensi yang ditentukan oleh ID ekstensi dari layanan pembaruan dalam URL pembaruan yang ditentukan dan memasangnya secara diam-diam.

          Misalnya, <ph name="EXTENSION_POLICY_EXAMPLE"/> memasang ekstensi <ph name="EXTENSION_POLICY_EXAMPLE_EXTENSION_NAME"/> dari URL pembaruan Toko Web Chrome standar. Untuk informasi selengkapnya tentang ekstensi hosting, lihat: <ph name="LINK_TO_EXTENSION_DOC2"/>.

          Pengguna tidak akan dapat mencopot pemasangan yang ditentukan oleh kebijakan ini. Jika Anda menghapus ekstensi dari daftar, maka ekstensi akan dicopot pemasangannya secara otomatis oleh <ph name="PRODUCT_NAME"/>. Ekstensi yang ditentukan dalam daftar ini juga akan masuk dalam daftar putih secara otomatis untuk pemasangan; ExtensionsInstallBlacklist tidak akan memengaruhinya.

          Jika kebijakan ini dibiarkan tidak disetel, pengguna dapat mencopot pemasangan ekstensi apa saja di <ph name="PRODUCT_NAME"/>.</translation>
<translation id="6899705656741990703">Mendeteksi setelan proxy secara otomatis</translation>
<translation id="4639407427807680016">Nama hosting perpesanan asli untuk dikeluarkan dari daftar hitam</translation>
<translation id="8382184662529825177">Mengaktifkan penggunaan pengesahan jarak jauh untuk perlindungan konten bagi perangkat</translation>
<translation id="7003334574344702284">Kebijakan ini memaksa sandi tersimpan untuk diimpor dari browser default sebelumnya, jika diaktifkan. Jika diaktifkan, kebijakan ini juga memengaruhi dialog impor. Jika dinonaktifkan, sandi yang disimpan tidak diimpor. Jika tidak disetel, pengguna mungkin ditanya apakah akan mengimpor, atau pengimporan dapat terjadi secara otomatis.</translation>
<translation id="6258193603492867656">Menentukan apakah SPN Kerberos yang dihasilkan harus mencakup port non-standar. Jika Anda mengaktifkan setelan ini, dan port non-standar (selain port 80 atau 443) dimasukkan, port ini akan dimasukkan ke SPN Kerberos yang dihasilkan. Jika Anda menonaktifkan setelan ini atau membiarkannya tidak disetel, SPN Kerberos yang dihasilkan tidak akan pernah mencakup port.</translation>
<translation id="3236046242843493070">Pola URL untuk memungkinkan pemasangan skrip pengguna, aplikasi, dan ekstensi dari</translation>
<translation id="2498238926436517902">Selalu sembunyikan rak secara otomatis</translation>
<translation id="253135976343875019">Menunda peringatan waktu menganggur saat menggunakan daya AC</translation>
<translation id="480987484799365700">Jika disetel ke aktif, kebijakan ini memaksa profil dialihkan ke mode singkat. Jika kebijakan ini dikhususkan sebagai kebijakan OS (misalnya GPO pada Windows), kebijakan tersebut akan berlaku pada setiap profil dalam sistem; jika kebijakan disetel sebagai kebijakan Cloud, kebijakan akan berlaku pada profil yang dimasuki menggunakan akun terkelola.

      Pada mode ini, data profil ditahan di disk hanya selama sesi pengguna. Fitur seperti riwayat browser, ekstensi dan datanya, data web seperti cookie dan basis data web tidak disimpan setelah browser ditutup. Namun, hal ini tidak mencegah pengguna mengunduh data apa pun ke disk secara manual, menyimpan laman, atau mencetaknya.

      Jika pengguna telah mengaktifkan sinkronisasi, semua data ini disimpan di profil sinkronisasinya sama seperti profil reguler. Mode penyamaran juga tersedia jika tidak dinonaktifkan secara eksplisit oleh kebijakan.

      Jika kebijakan disetel ke nonaktif atau tidak disetel, proses masuk mengarah ke profil reguler.</translation>
<translation id="6997592395211691850">Meskipun OCSP/CRL sedang online dibutuhkan tautan lokal yang dipercaya ataupun tidak</translation>
<translation id="152657506688053119">Daftar URL pengganti untuk penyedia penelusuran default</translation>
<translation id="8992176907758534924">Jangan izinkan situs apa pun menampilkan gambar</translation>
<translation id="262740370354162807">Aktifkan penyerahan dokumen ke <ph name="CLOUD_PRINT_NAME"/></translation>
<translation id="7717938661004793600">Mengonfigurasikan fitur aksesibilitas <ph name="PRODUCT_OS_NAME"/>.</translation>
<translation id="5182055907976889880">Konfigurasi Google Drive di <ph name="PRODUCT_OS_NAME"/>.</translation>
<translation id="8704831857353097849">Daftar plugin yang dinonaktifkan</translation>
<translation id="467449052039111439">Buka daftar URL</translation>
<translation id="1988371335297483117">Payload pembaruan otomatis di <ph name="PRODUCT_OS_NAME"/> dapat diunduh via HTTP, bukan HTTPS. Cara ini memungkinkan penyimpanan cache HTTP yang transparan dari unduhan HTTP.

      Jika kebijakan ini disetel ke true, <ph name="PRODUCT_OS_NAME"/> akan berupaya mengunduh payload pembaruan otomatis via HTTP. Jika kebijakan ini disetel ke false atau tidak disetel, HTTPS akan digunakan untuk mengunduh payload pembaruan otomatis.</translation>
<translation id="5883015257301027298">Setelan cookie default</translation>
<translation id="5017500084427291117">Memblokir akses ke URL yang tercantum.

      Kebijakan ini mencegah pengguna memuat laman web dari URL yang masuk daftar hitam.

      URL memiliki format 'scheme://host:port/path'.
      Skema opsional dapat berupa http, https, atau ftp. Hanya skema ini yang akan diblokir; jika tidak ada satu pun yang ditentukan, semua skema akan diblokir.
      Host dapat berupa nama host atau alamat IP. Subdomain nama host juga akan diblokir. Untuk mencegah pemblokiran subdomain, termasuk '.' sebelum nama host. Nama host khusus '*' akan memblokir semua domain.
      Port opsional merupakan nomor port valid mulai dari 1 hingga 65535. Jika tidak ada satu pun yang ditentukan, semua port akan diblokir.
      Jika jalur opsional ditentukan, hanya jalur dengan prefiks tersebut yang akan diblokir.

      Pengecualian dapat ditentukan dalam kebijakan daftar putih URL. Kebijakan ini dibatasi hanya untuk 1000 entri; entri berikutnya akan diabaikan.

      Jika kebijakan ini tidak disetel, tidak ada URL yang akan dimasukkan dalam daftar hitam dalam browser.</translation>
<translation id="2762164719979766599">Menentukan daftar akun lokal perangkat untuk ditampilkan di layar masuk.

      Setiap entri daftar menentukan pengenal, yang digunakan secara internal untuk menunjukkan akun lokal perangkat yang berbeda secara terpisah.</translation>
<translation id="8955719471735800169">Kembali ke atas</translation>
<translation id="4557134566541205630">URL laman tab baru penyedia penelusuran default</translation>
<translation id="546726650689747237">Penundaan peredupan layar saat menggunakan daya AC</translation>
<translation id="4988291787868618635">Tindakan yang akan diambil saat penundaan waktu menganggur tercapai</translation>
<translation id="7260277299188117560">Pembaruan p2p otomatis diaktifkan</translation>
<translation id="5316405756476735914">Memungkinkan Anda menyetel apakah situs web diizinkan untuk menyetel data lokal. Setelan data lokal dapat diizinkan untuk semua situs web atau ditolak untuk semua situs web. Jika kebijakan ini dibiarkan tidak disetel, 'AllowCookies' akan digunakan dan pengguna dapat mengubahnya.</translation>
<translation id="4250680216510889253">Tidak</translation>
<translation id="1522425503138261032">Izinkan situs melacak lokasi fisik pengguna</translation>
<translation id="6467433935902485842">Memungkinkan Anda menyetel daftar pola url yang menentukan situs yang tidak diizinkan untuk menjalankan plugin. Jika kebijakan ini dibiarkan tidak disetel, nilai default global akan digunakan untuk semua situs baik dari kebijakan 'DefaultPluginsSetting' jika disetel, atau konfigurasi pribadi pengguna.</translation>
<translation id="4423597592074154136">Tentukan setelan proxy secara manual</translation>
<translation id="209586405398070749">Saluran stabil</translation>
<translation id="8170878842291747619">Mengaktifkan layanan Google Terjemahan terpadu di <ph name="PRODUCT_NAME"/>. Jika Anda mengaktifkan setelan ini, <ph name="PRODUCT_NAME"/> akan menunjukkan penawaran bilah alat terpadu untuk menerjemahkan laman bagi pengguna, bila diperlukan. Jika Anda menonaktifkan setelan ini, pengguna tidak akan melihat bilah terjemahan. Jika Anda mengaktifkan atau menonaktifkan setelan ini, pengguna tidak dapat mengubah atau menimpa setelan ini di <ph name="PRODUCT_NAME"/>. Jika setelan ini dibiarkan tidak disetel, pengguna dapat memutuskan untuk menggunakan fungsi ini atau tidak.</translation>
<translation id="9035964157729712237">ID Ekstensi yang dikeluarkan dari daftar hitam</translation>
<translation id="8244525275280476362">Penundaan mengambil maksimum setelah kebijakan invalidasi</translation>
<translation id="8587229956764455752">Mengizinkan pembuatan akun pengguna baru</translation>
<translation id="7417972229667085380">Persentase yang digunakan untuk menskalakan penundaan status menganggur dalam mode presentasi (tidak digunakan lagi)</translation>
<translation id="6211428344788340116">Laporkan waktu aktivitas perangkat.

      Jika pengaturan ini tidak disetel atau disetel ke True, perangkat yang terdaftar akan melaporkan periode waktu saat pengguna aktif di perangkat. Jika setelan disetel ke False, waktu akvititas perangkat tidak akan dicatat atau dilaporkan.</translation>
<translation id="3964909636571393861">Memungkinkan akses ke daftar URL</translation>
<translation id="1811270320106005269">Mengaktifkan kunci bila perangkat <ph name="PRODUCT_OS_NAME"/> menganggur atau ditangguhkan.

      Jika Anda mengaktifkan setelan ini, pengguna akan dimintai sandi untuk membuka kunci perangkat dari mode tidur.

      Jika Anda menonaktifkan setelan ini, pengguna tidak akan dimintai sandi untuk membuka kunci perangkat dari mode tidur.

      Jika Anda mengaktifkan atau menonaktifkan setelan ini, pengguna tidak dapat mengubah atau menimpa setelan ini.

      Jika kebijakan dibiarkan tidak disetel, maka pengguna dapat memilih apakah mereka ingin diminta untuk memasukkan sandi untuk membuka kunci perangkat atau tidak.</translation>
<translation id="383466854578875212">Memungkinkan Anda menentukan hosting perpesanan asli mana yang tidak termasuk daftar hitam.

          Nilai daftar hitam * menunjukkan bahwa semua hosting perpesanan asli dimasukkan dalam daftar hitam dan hanya hosting perpesanan asli yang tercantum dalam daftar putih yang akan dimuat.

          Secara default, semua hosting perpesanan asli dimasukkan dalam daftar putih, namun jika semua hosting perpesanan asli telah dimasukkan dalam daftar hitam sesuai dengan kebijakan, daftar putih dapat digunakan untuk menggantikan kebijakan tersebut.</translation>
<translation id="6022948604095165524">Tindakan saat permulaan</translation>
<translation id="9042911395677044526">Memungkinkan konfigurasi jaringan dorongan untuk diterapkan per pengguna ke perangkat <ph name="PRODUCT_OS_NAME"/>. Konfigurasi jaringan adalah string berformat JSON seperti yang didefinisikan oleh format Konfigurasi Jaringan Terbuka yang diuraikan di <ph name="ONC_SPEC_URL"/></translation>
<translation id="7128918109610518786">Mendaftar pengenal aplikasi yang ditampilkan <ph name="PRODUCT_OS_NAME"/> sebagai aplikasi tersemat pada bilah peluncur.

      Jika kebijakan ini dikonfigurasi, kumpulan aplikasi akan ditetapkan dan tidak dapat diubah oleh pengguna.

      Jika kebijakan ini dibiarkan tanpa disetel, pengguna dapat mengubah daftar aplikasi tersemat pada peluncur.</translation>
<translation id="1679420586049708690">Sesi publik untuk masuk otomatis</translation>
<translation id="5836064773277134605">Batasi jangkauan port UDP yang digunakan oleh hosting akses jarak jauh</translation>
<translation id="7625444193696794922">Menentukan saluran rilis yang harus dikunci oleh perangkat ini.</translation>
<translation id="2552966063069741410">Zona Waktu</translation>
<translation id="3788662722837364290">Setelan pengelolaan daya saat pengguna sedang menganggur</translation>
<translation id="2240879329269430151">Memungkinkan Anda menyetel apakah situs web diizinkan untuk menampilkan munculan. Menampilkan munculan dapat diizinkan untuk semua situs web atau ditolak untuk semua situs web. Jika kebijakan ini dibiarkan tidak disetel, 'BlockPopups' akan digunakan dan pengguna dapat mengubahnya.</translation>
<translation id="2529700525201305165">Membatasi pengguna yang diizinkan untuk masuk ke <ph name="PRODUCT_NAME"/></translation>
<translation id="8971221018777092728">Pewaktu masuk otomatis sesi publik</translation>
<translation id="8285435910062771358">Lup layar penuh diaktifkan</translation>
<translation id="5141670636904227950">Menyetel jenis lup default yang diaktifkan di layar masuk</translation>
<translation id="3864818549971490907">Setelan plugin default</translation>
<translation id="7151201297958662315">Menentukan apakah proses <ph name="PRODUCT_NAME"/> dimulai saat masuk OS dan tetap berjalan saat jendela browser terakhir ditutup, yang memungkinkan aplikasi latar belakang tetap aktif. Proses latar belakang menampilkan ikon dalam baki sistem dan dapat selalu ditutup dari sana.

      Jika kebijakan ini disetel ke True, mode latar belakang diaktifkan dan tidak dapat dikontrol oleh pengguna dalam setelan browser.

      Jika kebijakan ini disetel ke False, mode latar belakang dinonaktifkan dan tidak dapat dikontrol oleh pengguna dalam setelan browser.

      Jika kebijakan ini dibiarkan tanpa disetel, mode latar belakang awalnya dinonaktifkan dan dapat dikontrol oleh pengguna dalam setelan browser.</translation>
<translation id="4320376026953250541">Microsoft Windows XP SP2 atau yang lebih baru</translation>
<translation id="5148753489738115745">Memungkinkan Anda menentukan parameter tambahan yang digunakan saat <ph name="PRODUCT_FRAME_NAME"/> meluncurkan <ph name="PRODUCT_NAME"/>.

          Jika kebijakan ini tidak disetel, baris perintah default akan digunakan.</translation>
<translation id="2646290749315461919">Memungkinkan Anda mengatur apakah situs web diizinkan untuk melacak lokasi fisik pengguna. Melacak lokasi fisik pengguna dapat diizinkan secara default, ditolak secara default, atau pengguna dapat ditanya setiap kali sebuah situs web meminta lokasi fisik. Jika kebijakan ini dibiarkan tidak disetel, 'AskGeolocation' akan digunakan dan pengguna dapat mengubahnya.</translation>
<translation id="6394350458541421998">Kebijakan ini tidak lagi digunakan sejak <ph name="PRODUCT_OS_NAME"/> versi 29. Gunakan kebijakan PresentationScreenDimDelayScale sebagai gantinya.</translation>
<translation id="2956777931324644324">Kebijakan ini dihentikan sejak <ph name="PRODUCT_NAME"/> versi 36.

      Menentukan apakah ekstensi sertifikat terikat domain TLS sebaiknya diaktifkan atau tidak.

      Setelan ini digunakan untuk mengaktifkan ekstensi sertifikat terikat domain TLS untuk pengujian.  Setelan eksperimental ini akan dibuang di masa mendatang.</translation>
<translation id="5770738360657678870">Saluran pengembang (mungkin tidak stabil)</translation>
<translation id="2959898425599642200">Peraturan mengabaikan proxy</translation>
<translation id="228659285074633994">Menentukan panjang waktu tanpa masukan pengguna yang setelahnya dialog peringatan akan ditampilkan saat menggunakan daya AC.

          Saat kebijakan ini disetel, ini menentukan panjang waktu yang harus dilalui pengguna dalam kondisi menganggur sebelum <ph name="PRODUCT_OS_NAME"/> menampilkan dialog peringatan yang memberi tahu pengguna bahwa tindakan menganggur akan dijalankan.

          Saat kebijakan ini tidak disetel, dialog peringatan tidak akan ditampilkan.

          Nilai kebijakan harus ditentukan dalam milidetik. Nilai dibatasi agar kurang dari atau sama dengan penundaan menganggur.</translation>
<translation id="1327466551276625742">Aktifkan permintaan konfigurasi jaringan saat offline</translation>
<translation id="7937766917976512374">Izinkan atau tolak penangkapan video</translation>
<translation id="427632463972968153">Menentukan parameter yang digunakan saat melakukan penelusuran gambar dengan POST. Berisi pasangan nama/nilai yang dipisahkan koma. Jika nilai adalah parameter template, seperti {imageGambar kecil} contoh di atas, akan diganti dengan data thumbnail gambar nyata.

          Kebijakan ini bersifat opsional. Jika tidak disetel, permintaan penelusuran akan dikirim menggunakan metode GET.

          Kebijakan ini hanya dipatuhi jika kebijakan 'DefaultSearchProviderEnabled' diaktifkan.</translation>
<translation id="8818646462962777576">Pola dalam daftar ini akan dicocokkan dengan asal
      keamanan URL yang meminta.  Jika ditemukan kecocokan, akses ke perangkat
      penangkap audio akan diberikan tanpa meminta.

      CATATAN: Kebijakan ini saat ini hanya didukung saat menjalankan dalam mode Kios.</translation>
<translation id="489803897780524242">Parameter yang mengendalikan penempatan istilah penelusuran untuk penyedia penelusuran default</translation>
<translation id="316778957754360075">Setelan ini tidak lagi digunakan sejak <ph name="PRODUCT_NAME"/> versi 29. Cara yang disarankan untuk menyiapkan koleksi aplikasi/ekstensi yang dihosting organisasi adalah dengan menyertakan situs yang menghosting paket CRX di ExtensionInstallSources dan meletakkan tautan unduhan langsung di paket dalam laman web. Peluncur untuk laman web tersebut dapat dibuat menggunakan kebijakan ExtensionInstallForcelist.</translation>
<translation id="6401669939808766804">Keluarkan pengguna</translation>
<translation id="4826326557828204741">Tindakan yang diperlukan saat penundaan nganggur tercapai ketika menjalankan daya baterai</translation>
<translation id="7912255076272890813">Konfigurasikan jenis aplikasi/ekstensi yang diizinkan</translation>
<translation id="817455428376641507">Memungkinkan akses ke URL yang tercantum, kecuali untuk URL yang masuk dalam daftar hitam.

      Lihat deskripsi kebijakan daftar hitam URL untuk format entri daftar ini.

      Kebijakan ini dapat digunakan untuk membuka pengecualian untuk daftar hitam terbatas. Misalnya, '*' dapat dimasukkan dalam daftar hitam untuk memblokir semua permintaan, dan kebijakan ini dapat digunakan untuk mengizinkan akses ke daftar URL yang dibatasi. Kebijakan ini juga dapat digunakan untuk membuka pengecualian untuk skema tertentu, subdomain dari domain lain, port, atau jalur khusus.

      Filter yang paling spesifik akan menentukan apakah URL diblokir atau diizinkan. Daftar putih akan didahulukan daripada daftar hitam.

      Kebijakan ini terbatas untuk 1000 entri; entri berikutnya akan diabaikan.

      Jika kebijakan ini tidak disetel, tidak akan ada pengecualian untuk daftar hitam dari kebijakan 'URLBlacklist'.</translation>
<translation id="8148901634826284024">Mengaktifkan fitur aksesibilitas mode kontras tinggi.

          Jika kebijakan ini disetel ke true, mode kontras tinggi akan selalu diaktifkan.

          Jika kebijakan ini disetel ke false, mode kontras tinggi akan selalu dinonaktifkan.

          Jika Anda menyetel kebijakan ini, pengguna tidak dapat mengubah atau menimpanya.

          Jika kebijakan ini tidak disetel, mode kontras tinggi pertama-tama dinonaktifkan, namun dapat diaktifkan oleh pengguna kapan saja.</translation>
<translation id="2201555246697292490">Konfigurasikan daftar putih perpesanan asli</translation>
<translation id="6177482277304066047">Menyetel versi target untuk Pembaruan Otomatis.

      Menentukan awalan versi target <ph name="PRODUCT_OS_NAME"/> yang harus diperbarui. Jika perangkat menjalankan versi sebelum awalan ditentukan, perangkat akan diperbarui ke versi teranyar dengan awalan yang diberikan. Jika perangkat sudah pada versi terbaru, tidak akan ada pengaruh yang terjadi (tidak dilakukan penurunan versi) dan perangkat akan tetap pada versi sekarang. Format awalan bekerja secara bijak-komponen seperti yang diperagakan pada contoh berikut:

      &quot;&quot; (atau tidak dikonfigurasi): pembaruan ke versi terbaru yang tersedia.
      &quot;1412.&quot;: pembaruan ke versi minor apa pun dari 1412 (misal: 1412.24.34 atau 1412.60.2)
      &quot;1412.2.&quot;: pembaruan ke versi minor apa pun dari 1412.2 (misal: 1412.2.34 atau 1412.2.2)
      &quot;1412.24.34&quot;: pembaruan ke versi spesifik ini saja</translation>
<translation id="8102913158860568230">Setelan streaming media default</translation>
<translation id="6641981670621198190">Nonaktifkan dukungan untuk API grafis 3D</translation>
<translation id="5196805177499964601">Blokir mode pengembang.

      Jika kebijakan ini disetel ke True, <ph name="PRODUCT_OS_NAME"/> akan mencegah perangkat melakukan booting ke mode pengembang. Sistem akan menolak melakukan booting dan menampilkan layar kesalahan saat pengalih pengembang diaktifkan.

      Jika kebijakan ini tidak disetel atau disetel ke False, mode pengembang akan tetap tersedia untuk perangkat.</translation>
<translation id="1265053460044691532">Batasi waktu bagi pengguna yang diautentikasi melalui SAML untuk dapat masuk saat offline.</translation>
<translation id="5703863730741917647">Tentukan tindakan yang akan diambil saat penundaan nganggur dicapai.

          Perlu dicatat bahwa kebijakan ini tidak digunakan lagi dan akan dihapus di masa mendatang.

          Kebijakan ini memberikan nilai pengganti untuk kebijakan yang lebih spesifik <ph name="IDLEACTIONAC_POLICY_NAME"/> dan <ph name="IDLEACTIONBATTERY_POLICY_NAME"/>. Jika kebijakan disetel, nilainya yang didapat dapat digunakan jika masing-masing kebijakan yang lebih spesifik tidak disetel.

          Saat kebijakan tidak disetel, perilaku kebijakan yang lebih spesifik tidak dibiarkan terpengaruh.</translation>
<translation id="5997543603646547632">Menggunakan 24 jam sebagai default</translation>
<translation id="7003746348783715221">Preferensi <ph name="PRODUCT_NAME"/></translation>
<translation id="4723829699367336876">Mengaktifkan firewall traversal dari klien akses jarak jauh</translation>
<translation id="2744751866269053547">Daftarkan penangan protokol</translation>
<translation id="6367755442345892511">Apakah saluran rilis dapat dikonfigurasi oleh pengguna atau tidak</translation>
<translation id="3868347814555911633">Kebijakan ini hanya aktif dalam mode ritel.

      Mendaftar ekstensi yang dipasang secara otomatis untuk pengguna Demo, untuk perangkat dalam mode ritel. Ekstensi ini disimpan dalam perangkat dan dapat dipasang saat offline, setelah pemasangan.

      Setiap entri cantuman berisi kamus yang harus menyertakan ID ekstensi dalam bidang 'extension-id', dan URL pembaruannya dalam bidang 'update-url'.</translation>
<translation id="9096086085182305205">Daftar putih server autentikasi</translation>
<translation id="4980301635509504364">Mengizinkan atau menolak tangkapan video.

      Jika diaktifkan atau tidak dikonfigurasi (default), pengguna akan dimintai
      akses tangkapan video kecuali untuk URL yang dikonfigurasi di
      daftar VideoCaptureAllowedUrls yang akan diberikan akses tanpa meminta.

      Saat kebijakan ini dinonaktifkan, pengguna tidak akan pernah diminta dan tangkapan
      video hanya tersedia untuk URL yang dikonfigurasi dalam VideoCaptureAllowedUrls.

      Kebijakan ini memengaruhi semua jenis masukan video, bukan hanya kamera yang ada di dalamnya.</translation>
<translation id="7063895219334505671">Izinkan munculan di situs ini</translation>
<translation id="3756011779061588474">Blokir mode pengembang</translation>
<translation id="4052765007567912447">Mengontrol apakah pengguna dapat menampilkan sandi dalam teks yang jelas di dalam pengelola sandi. Jika Anda menonaktifkan penyetelan ini, pengelola sandi tidak mengizinkan untuk menampilkan sandi yang disimpan dalam bentuk teks yang jelas pada jendela pengelola sandi. Jika Anda mengaktifkan atau tidak menyetel kebijakan ini, pengguna dapat melihat sandi mereka dalam teks yang jelas di dalam pengelola sandi.</translation>
<translation id="5936622343001856595">Memaksa kueri di Google Penelusuran Web harus dilakukan dengan TelusurAman yang disetel ke aktif dan mencegah pengguna mengubah setelan ini.

      Jika Anda mengaktifkan setelan ini, TelusurAman di Google Penelusuran akan selalu aktif.

      Jika Anda menonaktifkan setelan ini atau tidak menyetel suatu nilai, TelusurAman di Google Penelusuran tidak akan diterapkan.</translation>
<translation id="6017568866726630990">Tampilkan dialog cetak sistem, bukan pratinjau cetak.

      Jika setelan ini diaktifkan, <ph name="PRODUCT_NAME"/> akan membuka dialog cetak sistem, bukan pratinjau cetak yang ada di dalamnya saat pengguna meminta laman agar dicetak.

      Jika kebijakan ini tidak disetel atau disetel ke salah, perintah cetak memicu layar pratinjau cetak.</translation>
<translation id="7933141401888114454">Mengaktifkan pembuatan pengguna yang dilindungi</translation>
<translation id="2824715612115726353">Aktifkan mode Penyamaran</translation>
<translation id="1057535219415338480">Mengaktifkan prediksi jaringan dalam <ph name="PRODUCT_NAME"/> dan cegah pengguna agar tidak mengubah setelan ini.

      Tindakan ini tidak hanya mengontrol pengambilan DNS, tetapi juga TCP dan SSL pra-koneksi dan prapenguraian laman web. Nama kebijakan mengacu pada pra-pengambilan DNS untuk alasan historis.

      Jika Anda mengaktifkan atau menonaktifkan setelan ini, pengguna tidak dapat mengubah atau menggantikan setelan ini untuk <ph name="PRODUCT_NAME"/>.

      Jika kebijakan ini dibiarkan tidak disetel, maka akan tetap diaktifkan, namun pengguna dapat mengubahnya.</translation>
<translation id="4541530620466526913">Akun lokal perangkat</translation>
<translation id="5815129011704381141">Booting ulang otomatis setelah pembaruan</translation>
<translation id="1757688868319862958">Mengizinkan <ph name="PRODUCT_NAME"/> menjalankan plugin yang membutuhkan otorisasi. Jika Anda mengaktifkan setelan ini, plugin yang tidak kedaluwarsa selalu berjalan. Jika setelan ini dinonaktifkan atau tidak disetel, pengguna akan dimintai izin untuk menjalankan plugin yang membutuhkan otorisasi. Ini adalah plugin yang dapat meretas keamanan.</translation>
<translation id="6392973646875039351">Mengaktifkan fitur IsiOtomatis <ph name="PRODUCT_NAME"/> dan memungkinkan pengguna melengkapi formulir web secara otomatis menggunakan informasi yang tersimpan sebelumnya seperti alamat atau informasi kartu kredit. Jika Anda menonaktifkan setelan ini, IsiOtomatis tidak akan dapat diakses pengguna. Jika Anda mengaktifkan setelan ini atau tidak menyetel nilai, IsiOtomatis akan tetap berada di bawah kontrol pengguna. Cara ini akan memungkinkan pengguna mengonfigurasi profil IsiOtomatis dan mengaktifkan atau menonaktifkan IsiOtomatis sesuai keinginan mereka.</translation>
<translation id="6157537876488211233">Peraturan mengabaikan proxy yang dipisahkan koma</translation>
<translation id="7788511847830146438">Per Profil</translation>
<translation id="2516525961735516234">Menentukan apakah aktivitas video memengaruhi pengelolaan daya.

          Jika kebijakan ini disetel ke True atau tidak disetel, pengguna tidak dianggap menganggur saat video berputar. Hal ini mencegah penundaan waktu menganggur, penundaan peredupan layar, penundaan mematikan layar, dan penundaan penguncian layar tercapai serta mencegah tindakan tersebut dilakukan.

          Jika kebijakan ini disetel ke Salah, aktivitas video tidak mencegah pengguna untuk dianggap menganggur.</translation>
<translation id="3965339130942650562">Waktu tunggu sampai proses keluar pengguna nganggur dieksekusi</translation>
<translation id="5814301096961727113">Menyetel status default masukan yang diucapkan di layar masuk</translation>
<translation id="1950814444940346204">Aktifkan fitur platform web usang</translation>
<translation id="9084985621503260744">Tentukan apakah aktivitas video memengaruhi pengelolaan daya</translation>
<translation id="7091198954851103976">Selalu jalankan plugin yang membutuhkan otorisasi</translation>
<translation id="1708496595873025510">Setel batasan pada pengambilan bibit Varietas</translation>
<translation id="8870318296973696995">Beranda</translation>
<translation id="1240643596769627465">Menentukan URL mesin telusur yang digunakan untuk memberikan hasil sekejap. URL harus berisi string <ph name="SEARCH_TERM_MARKER"/>, yang akan diganti pada waktu kueri dengan teks yang dimasukkan oleh pengguna hingga saat ini. Kebijakan ini bersifat opsional. Jika tidak disetel, tidak ada hasil penelusuran sekejap yang akan disediakan. Kebijakan ini hanya diterapkan jika kebijakan 'DefaultSearchProviderEnabled' diaktifkan.</translation>
<translation id="6693751878507293182">Jika Anda menyetel setelan ini untuk mengaktifkan penelusuran otomatis, pemasangan plugin yang hilang akan dinonaktifkan dalam <ph name="PRODUCT_NAME"/>. Menyetel opsi ini menjadi nonaktif atau membiarkannya tidak disetel akan mengaktifkan pencari plugin.</translation>
<translation id="2650049181907741121">Tindakan yang akan diambil saat pengguna menutup penutupnya</translation>
<translation id="7880891067740158163">Memungkinkan Anda menentukan daftar pola url yang menentukan situs agar <ph name="PRODUCT_NAME"/> otomatis memilih sertifikat klien, jika situs meminta sertifikat. Jika kebijakan ini dibiarkan tidak disetel, pemilihan otomatis tidak akan dilakukan di situs mana pun.</translation>
<translation id="3866249974567520381">Deskripsi</translation>
<translation id="5192837635164433517">Memungkinkan penggunaan laman kesalahan alternatif yang disertakan di dalam <ph name="PRODUCT_NAME"/> (misalnya 'laman tidak ditemukan') dan mencegah pengguna mengubah setelan ini. Jika Anda mengaktifkan setelan ini, laman kesalahan alternatif akan digunakan. Jika Anda menonaktifkan setelan ini, laman kesalahan alternatif tidak akan pernah digunakan. Jika Anda mengaktifkan atau menonaktifkan setelan ini, pengguna tidak dapat mengubah atau menimpa setelan di <ph name="PRODUCT_NAME"/>. Jika kebijakan ini dibiarkan tidak disetel, setelan ini akan diaktifkan, namun pengguna dapat mengubahnya.</translation>
<translation id="2236488539271255289">Jangan izinkan situs mana pun menyetel data lokal</translation>
<translation id="4467952432486360968">Cekal cookie pihak ketiga</translation>
<translation id="1305864769064309495">Kamus yang memetakan URL ke bendera boolean yang menentukan apakah akses ke hosting harus diizinkan (true) atau diblokir (false).

          Kebijakan ini untuk penggunaan internal oleh Chrome itu sendiri.</translation>
<translation id="5586942249556966598">Tidak melakukan apa-apa</translation>
<translation id="131353325527891113">Tampilkan nama pengguna pada layar masuk</translation>
<translation id="5365946944967967336">Tampilkan tombol Beranda di bilah alat</translation>
<translation id="3709266154059827597">Konfigurasikan daftar hitam pemasangan ekstensi</translation>
<translation id="1933378685401357864">Gambar wallpaper</translation>
<translation id="8451988835943702790">Gunakan Laman Tab Baru sebagai beranda</translation>
<translation id="4617338332148204752">Lewati pemeriksaan tag meta pada <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="8469342921412620373">Mengaktifkan penggunaan penyedia penelusuran default. Jika Anda mengaktifkan setelan ini, penelusuran default dilakukan ketika pengguna mengetikkan teks bukan URL di omnibox. Anda dapat menentukan penyedia penelusuran default yang akan digunakan dengan menyetel seluruh sisa kebijakan penelusuran default. Jika ini dibiarkan kosong, pengguna dapat memilih penyedia default. Jika Anda menonaktifkan setelan ini, tidak ada penelusuran yang dilakukan ketika pengguna memasukkan teks non-URL di omnibox. Jika Anda mengaktifkan atau menonaktifkan setelan ini, pengguna tidak dapat mengubah atau menimpa setelan ini di <ph name="PRODUCT_NAME"/>. Jika kebijakan ini dibiarkan tidak disetel, penyedia penelusuran default diaktifkan, dan pengguna dapat menyetel daftar penyedia penelusuran.</translation>
<translation id="4791031774429044540">Mengaktifkan fitur aksesibilitas kursor besar.

          Jika kebijakan ini disetel ke true, kursor besar akan selalu diaktifkan.

          Jika kebijakan ini disetel ke false, kursor besar akan selalu dinonaktifkan.

          Jika Anda menyetel kebijakan ini, pengguna tidak dapat mengubah atau menimpanya.

          Jika kebijakan ini tidak disetel, kursor besar pertama-tama akan dinonaktifkan, namun dapat diaktifkan oleh pengguna kapan saja.</translation>
<translation id="2633084400146331575">Aktifkan masukan lisan</translation>
<translation id="687046793986382807">Kebijakan ini telah dihentikan pada <ph name="PRODUCT_NAME"/> versi 35.

      Bagaimanapun juga info memori dilaporkan ke laman, terlepas dari nilai opsinya, namun ukuran yang dilaporkan
      dikuantisasi dan tingkat pembaruan dibatasi karena alasan keamanan. Untuk memperoleh data akurat dalam waktu nyata,
      silakan gunakan alat seperti Telemetri.</translation>
<translation id="8731693562790917685">Setelan Konten memungkinkan Anda menentukan bagaimana konten jenis tertentu (misalnya Cookie, Gambar, atau JavaScript) ditangani.</translation>
<translation id="2411919772666155530">Mencekal pemberitahuan di situs ini</translation>
<translation id="7332963785317884918">Kebijakan ini tidak lagi digunakan. <ph name="PRODUCT_OS_NAME"/> akan selalu menggunakan strategi pembersihan 'RemoveLRU'.

      Mengontrol perilaku pembersihan otomatis di perangkat <ph name="PRODUCT_OS_NAME"/>. Pembersihan otomatis dipicu saat jumlah ruang disk kosong mencapai level kritis guna memulihkan sejumlah ruang disk.

      Jika kebijakan ini disetel ke 'RemoveLRU', pembersihan otomatis akan terus membuang pengguna dari perangkat dalam urutan yang paling lama tidak diakses hingga terdapat ruang kosong yang memadai.

      Jika kebijakan ini disetel ke 'RemoveLRUIfDormant', pembersihan otomatis akan tetap membuang pengguna yang tidak melakukan proses masuk minimal selama 3 bulan dalam urutan yang paling lama tidak diakses hingga terdapat ruang kosong yang memadai.

      Jika kebijakan ini tidak disetel, pembersihan otomatis menggunakan strategi yang tertanam secara default. Saat ini, itu adalah strategi 'RemoveLRUIfDormant'.</translation>
<translation id="6923366716660828830">Menentukan nama penyedia penelusuran default. Jika dibiarkan kosong atau tidak disetel, nama host yang ditentukan oleh URL penelusuran akan digunakan. Kebijakan ini hanya dipertimbangkan jika kebijakan 'DefaultSearchProviderEnabled' diaktifkan.</translation>
<translation id="4869787217450099946">Menentukan apakah penguncian layar saat bangun diizinkan atau tidak. Penguncian layar saat bangun dapat diminta dengan ekstensi melalui API ekstensi pengelola daya.

          Jika kebijakan ini disetel ke true atau tidak disetel, penguncian layar saat bangun akan diterima demi pengelolaan daya.

          Jika kebijakan ini disetel ke false, permintaan penguncian layar saat bangun akan diabaikan.</translation>
<translation id="467236746355332046">Fitur yang didukung:</translation>
<translation id="5447306928176905178">Aktifkan pelaporan info memori (JS heap size) ke laman (dipensiunkan)</translation>
<translation id="7632724434767231364">Nama pustaka GSSAPI</translation>
<translation id="3038323923255997294">Terus jalankan aplikasi latar belakang saat <ph name="PRODUCT_NAME"/> ditutup</translation>
<translation id="8909280293285028130">Menentukan panjang waktu tanpa masukan pengguna sebelum layar terkunci ketika menggunakan daya AC.

          Saat kebijakan ini disetel ke nilai yang lebih besar dari nol, nilai tersebut akan menentukan panjang waktu pengguna tetap menganggur sebelum <ph name="PRODUCT_OS_NAME"/> mengunci layar.

          Saat kebijakan ini disetel ke nol, <ph name="PRODUCT_OS_NAME"/> tidak mengunci layar saat pengguna menganggur.

          Saat kebijakan ini tidak disetel, panjang waktu default digunakan.

          Cara yang disarankan untuk mengunci layar saat menganggur adalah dengan mengaktifkan penangguhan penguncian layar dan meminta <ph name="PRODUCT_OS_NAME"/> menangguhkan setelah masa menganggur ditunda. Kebijakan ini seharusnya hanya digunakan saat penguncian layar harus berlangsung selama jumlah waktu signifikan yang lebih cepat daripada ditangguhkan atau saat penundaan pada masa menganggur tidak diinginkan sama sekali.

          Nilai kebijakan ini harus ditentukan dalam milidetik. Nilai dijepit menjadi lebih sedikit dari penundaan waktu menganggur.</translation>
<translation id="7651739109954974365">Menentukan apakah roaming data harus diaktifkan untuk perangkat. Jika disetel ke true, roaming data akan diizinkan. Jika dibiarkan tanpa konfigurasi atau disetel ke false, roaming data tidak akan tersedia.</translation>
<translation id="6244210204546589761">URL untuk membuka saat permulaan</translation>
<translation id="7468416082528382842">Lokasi registry Windows:</translation>
<translation id="1808715480127969042">Cekal cookie di situs ini</translation>
<translation id="1908884158811109790">Menonaktifkan Google Drive melalui sambungan Seluler di aplikasi Files Chrome OS</translation>
<translation id="7340034977315324840">Laporkan waktu aktivitas perangkat</translation>
<translation id="4928632305180102854">Mengontrol apakah <ph name="PRODUCT_OS_NAME"/> mengizinkan akun pengguna baru dibuat atau tidak. Jika kebijakan ini disetel ke false, pengguna yang belum memiliki akun tidak akan dapat masuk.

      Jika kebijakan ini disetel ke true atau tidak dikonfigurasi, akun pengguna baru akan dizinkan untuk dibuat dengan syarat <ph name="DEVICEUSERWHITELISTPROTO_POLICY_NAME"/> tidak mencegah pengguna untuk masuk.</translation>
<translation id="4389091865841123886">Mengonfigurasi pengesahan jarak jauh dengan mekanisme TPM.</translation>
<translation id="9175109938712007705">Mengingat bahwa pemeriksaan pembatalan online, kegagalan-lunak tidak memberikan manfaat keamanan yang efektif, pemeriksaan tersebut dinonaktifkan secara default di <ph name="PRODUCT_NAME"/> versi 19 dan yang lebih baru. Dengan menyetel kebijakan ini ke true, perilaku sebelumnya akan dipulihkan dan akan dilakukan pemeriksaan OCSP/CRL online.

      Jika kebijakan tidak disetel, atau disetel ke false, maka Chrome tidak akan melakukan pemeriksaan pembatalan online di Chrome 19 dan yang lebih baru.</translation>
<translation id="8256688113167012935">Mengontrol nama akun yang ditampilkan <ph name="PRODUCT_OS_NAME"/> di layar masuk untuk akun lokal perangkat yang sesuai.

      Jika kebijakan ini disetel, layar masuk akan menggunakan string yang ditentukan dalam pemilih masuk berdasarkan gambar untuk akun lokal perangkat yang sesuai.

      Jika kebijakan dibiarkan tidak disetel, <ph name="PRODUCT_OS_NAME"/> akan menggunakan ID akun email dari akun lokal perangkat sebagai nama tampilan di layar masuk.

      Kebijakan ini diabaikan untuk akun pengguna reguler.</translation>
<translation id="267596348720209223">Menentukan penyandiaksaraan karakter yang didukung oleh penyedia penelusuran. Penyandiaksaraan adalah nama-nama laman kode seperti UTF-8, GB2312, dan ISO-8859-1. Kode tersebut dicoba dalam urutan yang disediakan. Kebijakan ini bersifat opsional. Jika tidak disetel, default yang akan digunakan adalah UTF-8. Kebijakan ini hanya dipatuhi jika kebijakan 'DefaultSearchProviderEnabled' diaktifkan.</translation>
<translation id="1349276916170108723">Menonaktifkan sinkronisasi Google Drive di aplikasi Files Chrome OS ketika disetel ke True. Dalam kasus ini, tidak ada data yang diunggah ke Google Drive.

          Jika tidak disetel atau disetel ke False, maka pengguna akan dapat mentransfer file ke Google Drive.</translation>
<translation id="1964634611280150550">Mode penyamaran dinonaktifkan</translation>
<translation id="5971128524642832825">Menonaktifkan Drive di aplikasi Files Chrome OS</translation>
<translation id="1847960418907100918">Menentukan parameter yang digunakan saat melakukan penelusuran instan dengan POST. Berisi pasangan nama/nilai yang dipisahkan koma. Jika nilai adalah parameter template, seperti {searchTerms} dalam contoh di atas, akan diganti dengan data istilah penelusuran nyata.

          Kebijakan ini bersifat opsional. Jika tidak disetel, permintaan penelusuran instan akan dikirim menggunakan metode GET.

          Kebijakan ini hanya dipatuhi jika kebijakan 'DefaultSearchProviderEnabled' diaktifkan.</translation>
<translation id="6095999036251797924">Menentukan lamanya waktu tanpa masukan pengguna sebelum layar dikunci saat berjalan menggunakan daya AC atau baterai.

          Jika lamanya waktu disetel ke nilai yang lebih besar dari nol, nilai tersebut mewakili lamanya waktu pengguna tetap menganggur sebelum <ph name="PRODUCT_OS_NAME"/> mengunci layar.

          Jika lamanya waktu disetel ke nol, <ph name="PRODUCT_OS_NAME"/> tidak mengunci layar ketika pengguna menganggur.

          Jika lamanya waktu tidak disetel, lama waktu default akan digunakan.

          Cara yang disarankan untuk mengunci layar saat menganggur adalah dengan mengaktifkan penangguhan penguncian layar dan meminta <ph name="PRODUCT_OS_NAME"/> menangguhkan setelah penundaan waktu menganggur. Sebaiknya hanya gunakan kebijakan ini saat penguncian layar perlu terjadi jauh lebih awal dibandingkan penangguhan atau saat penangguhan ketika menganggur tidak diinginkan sama sekali.

          Nilai kebijakan harus ditetapkan dalam milidetik. Nilai dijepit agar kurang dari penundaan waktu menganggur.</translation>
<translation id="1454846751303307294">Memungkinkan Anda menyetel daftar pola url yang menentukan situs yang tidak diizinkan untuk menjalankan JavaScript. Jika kebijakan ini tidak disetel, nilai default global akan digunakan untuk semua situs, baik dari kebijakan 'DefaultJavaScriptSetting', jika disetel, ataupun dari konfigurasi pribadi pengguna.</translation>
<translation id="538108065117008131">Izinkan <ph name="PRODUCT_FRAME_NAME"/> menangani jenis konten berikut.</translation>
<translation id="2312134445771258233">Memungkinkan Anda mengonfigurasi laman yang dimuat saat permulaan. Isi daftar 'URL yang dibuka saat permulaan' diabaikan kecuali jika Anda memilih 'Buka daftar URL' dalam 'Tindakan saat permulaan'.</translation>
<translation id="1464848559468748897">Mengontrol perilaku pengguna di sesi multi profil di perangkat <ph name="PRODUCT_OS_NAME"/>.

      Jika kebijakan ini disetel ke 'MultiProfileUserBehaviorUnrestricted', pengguna dapat menjadi pengguna utama atau sekunder di sesi multi profil.

      Jika kebijakan ini disetel ke 'MultiProfileUserBehaviorMustBePrimary', pengguna hanya dapat menjadi pengguna utama di sesi multi profil.

      Jika kebijakan ini disetel ke 'MultiProfileUserBehaviorNotAllowed', pengguna tidak dapat menjadi bagian sesi multi profil.

      Jika Anda menyetel setelan ini, pengguna tidak dapat mengubah atau membatalkannya.

      Jika setelan diubah saat pengguna masuk ke sesi multi profil, semua pengguna di sesi ini akan diperiksa berdasarkan setelan mereka yang terkait. Sesi akan ditutup jika salah satu pengguna tidak lagi diizinkan berada di sesi tersebut.

      Jika kebijakan dibiarkan tidak disetel, nilai default 'MultiProfileUserBehaviorMustBePrimary' berlaku untuk pengguna yang dikelola oleh perusahaan dan 'MultiProfileUserBehaviorUnrestricted' akan digunakan untuk pengguna yang tidak dikelola.</translation>
<translation id="243972079416668391">Tentukan tindakan saat penundaan nganggur dicapai ketika menjalankan daya AC.

          Saat kebijakan ini disetel, menentukan tindakan <ph name="PRODUCT_OS_NAME"/> yang diambil saat pengguna membiarkan menganggur untuk lamanya waktu yang diberikan oleh penundaan nganggur, yang dapat dikonfigurasikan secara terpisah.

          Saat kebijakan tidak disetel, tindakan default diambil, yang ditangguhkan

          Jika tindakan ditangguhkan, <ph name="PRODUCT_OS_NAME"/> dapat dikonfigurasikan secara terpisah baik dengan layar terkunci atau tidak sebelum penangguhan.</translation>
<translation id="7750991880413385988">Buka Laman Tab Baru</translation>
<translation id="5761030451068906335">Mengonfigurasi setelan proxy untuk <ph name="PRODUCT_NAME"/>. Kebijakan ini belum siap untuk digunakan, jangan menggunakannya.</translation>
<translation id="8344454543174932833">Impor bookmark dari browser default saat pertama kali dijalankan</translation>
<translation id="1019101089073227242">Menyetel direktori data pengguna</translation>
<translation id="5826047473100157858">Menentukan apakah pengguna dapat membuka laman dalam mode Penyamaran di <ph name="PRODUCT_NAME"/>. Jika 'Aktifkan' dipilih atau kebijakan dibiarkan tidak disetel, laman dapat dibuka dalam mode Penyamaran. Jika 'Nonaktifkan' dipilih, laman tidak dapat dibuka dalam mode Penyamaran. Jika 'Paksa' dipilih, laman dapat dibuka HANYA dalam mode Penyamaran.</translation>
<translation id="2988031052053447965">Menyembunyikan aplikasi Toko Web Chrome dan tautan footer dari Laman Tab Baru dan peluncur aplikasi Chrome OS.

      Jika kebijakan ini disetel ke true, ikon akan disembunyikan.

      Jika kebijakan ini disetel ke false atau tidak dikonfigurasikan, ikon akan terlihat.</translation>
<translation id="5085647276663819155">Nonaktifkan Pratinjau Cetak</translation>
<translation id="8672321184841719703">Versi Pembaruan Otomatis Target</translation>
<translation id="553658564206262718">Mengonfigurasi setelan pengelolaan daya saat pengguna menganggur.

          Kebijakan ini mengontrol beberapa setelan untuk strategi pengelolaan daya saat pengguna menganggur.

          Ada empat macam tindakan:
          * Layar akan diredupkan apabila pengguna tetap menganggur selama waktu yang ditentukan oleh |ScreenDim|.
          * Layar akan dinonaktifkan apabila pengguna tetap menganggur selama waktu yang ditentukan oleh |ScreenOff|.
          * Dialog peringatan akan ditampilkan apabila pengguna tetap menganggur selama waktu yang ditentukan oleh |IdleWarning|, yang memberitahukan kepada pengguna bahwa tindakan menganggur akan dilakukan.
          * Tindakan yang ditentukan oleh |IdleAction| akan dilakukan apabila pengguna tetap menganggur selama waktu yang ditentukan oleh |Idle|.

          Untuk setiap tindakan di atas, penundaan harus ditetapkan dalam milidetik, dan perlu disetel dalam nilai yang lebih besar dari nol agar memicu tindakan yang sesuai. Apabila penundaan disetel ke nol, <ph name="PRODUCT_OS_NAME"/> tidak akan melakukan tindakan yang sesuai.

          Untuk setiap penundaan di atas, jika lamanya waktu tidak disetel, nilai default akan digunakan.

          Perhatikan bahwa nilai |ScreenDim| akan dijepit kurang dari atau sama dengan |ScreenOff|, |ScreenOff| dan |IdleWarning| akan dijepit kurang dari atau sama dengan |Idle|.

          |IdleAction| dapat merupakan salah satu dari empat tindakan berikut:
          * |Suspend|
          * |Logout|
          * |Shutdown|
          * |DoNothing|

          Jika |IdleAction| tidak disetel, tindakan default (penangguhan) akan dilakukan.

          Juga ada setelan terpisah untuk daya AC dan baterai.
          </translation>
<translation id="1689963000958717134">Memungkinkan konfigurasi jaringan dorong untuk diterapkan pada semua pengguna perangkat <ph name="PRODUCT_OS_NAME"/>. Konfigurasi jaringan adalah string berformat JSON seperti yang didefinisikan oleh format Konfigurasi Jaringan Terbuka yang dideskripsikan di <ph name="ONC_SPEC_URL"/></translation>
<translation id="6699880231565102694">Mengaktifkan autentikasi dua faktor untuk hosting akses jarak jauh</translation>
<translation id="2030905906517501646">Kata kunci penyedia penelusuran default</translation>
<translation id="3072045631333522102">Tirai layar untuk digunakan pada layar masuk dalam mode eceran</translation>
<translation id="4550478922814283243">Mengaktifkan atau menonaktifkan autentikasi PIN</translation>
<translation id="7712109699186360774">Tanyakan setiap kali situs ingin mengakses kamera dan/atau mikrofon</translation>
<translation id="350797926066071931">Aktifkan Terjemahan</translation>
<translation id="3711895659073496551">Tangguhkan</translation>
<translation id="4010738624545340900">Izinkan permintaan dialog pemilihan file</translation>
<translation id="4518251772179446575">Tanyakan setiap kali situs ingin melacak lokasi fisik pengguna</translation>
<translation id="402759845255257575">Jangan izinkan situs apa pun menjalankan JavaScript</translation>
<translation id="5457924070961220141">Memungkinkan Anda mengonfigurasi perender HTML default saat <ph name="PRODUCT_FRAME_NAME"/> dipasang. Setelan default yang digunakan ketika kebijakan ini tidak disetel adalah mengizinkan browser host melakukan perenderan, tetapi Anda dapat menimpanya secara opsional dan membiarkan <ph name="PRODUCT_FRAME_NAME"/> merender laman HTML secara default.</translation>
<translation id="706669471845501145">Izinkan situs menampilkan pemberitahuan desktop</translation>
<translation id="7529144158022474049">Faktor penyebaran pembaruan otomatis</translation>
<translation id="2188979373208322108">Mengaktifkan bilah bookmark di <ph name="PRODUCT_NAME"/>. Jika Anda mengaktifkan setelan ini, <ph name="PRODUCT_NAME"/> akan menampilkan bilah bookmark. Jika Anda menonaktifkan setelan ini, pengguna tidak akan pernah melihat bilah bookmark. Jika Anda mengaktifkan atau menonaktifkan setelan ini, pengguna tidak dapat mengubah atau menimpanya di <ph name="PRODUCT_NAME"/>. Jika setelan ini tidak disetel, pengguna dapat memutuskan untuk menggunakan fungsi ini atau tidak.</translation>
<translation id="7593523670408385997">Mengonfigurasi ukuran cache yang akan digunakan <ph name="PRODUCT_NAME"/> untuk menyimpan file dalam cache di disk.

      Jika Anda menyetel kebijakan ini, <ph name="PRODUCT_NAME"/> akan menggunakan ukuran cache yang disediakan terlepas dari apakah pengguna menentukan tanda '--disk-cache-size' atau tidak. Nilai yang ditentukan dalam kebijakan ini bukan merupakan batas mutlak namun merupakan saran terhadap sistem penyimpanan dalam cache, nilai apa pun di bawah beberapa megabyte dianggap terlalu kecil dan akan dibulatkan ke nilai minimum yang lebih wajar.

      Jika nilai kebijakan ini 0, ukuran cache default akan digunakan namun pengguna tidak akan dapat mengubahnya.

      Jika kebijakan ini tidak disetel, ukuran default akan digunakan dan pengguna dapat menimpanya dengan tanda --disk-cache-size.</translation>
<translation id="5475361623548884387">Aktifkan pencetakan</translation>
<translation id="7287359148642300270">Menentukan server yang harus dimasukkan ke daftar putih untuk autentikasi yang terintegrasi. Autentikasi yang terintegrasi hanya diaktifkan saat <ph name="PRODUCT_NAME"/> menerima tantangan autentikasi dari proxy atau dari server yang ada dalam daftar yang diizinkan ini.

          Pisahkan beberapa nama server dengan koma. Karakter pengganti (*) diizinkan.

          Jika Anda meninggalkan kebijakan ini tidak disetel, Chrome akan mencoba mendeteksi apakah server ada di internet dan setelah itu akan menanggapi permintaan IWA.  Jika server terdeteksi sebagai internet maka permintaan IWA darinya akan diabaikan oleh Chrome.</translation>
<translation id="3653237928288822292">Ikon penyedia penelusuran default</translation>
<translation id="4721232045439708965">Memungkinkan Anda menentukan perilaku saat memulai.

          Jika Anda memilih 'Buka Laman Tab Baru', Laman Tab Baru akan selalu dibuka saat Anda memulai <ph name="PRODUCT_NAME"/>.

          Jika Anda memilih 'Pulihkan sesi terakhir', URL yang dibuka saat <ph name="PRODUCT_NAME"/> terakhir ditutup akan kembali dibuka dan sesi penjelajahan akan dipulihkan seperti saat ditinggalkan.
          Memilih opsi ini akan menonaktifkan beberapa setelan yang bergantung pada sesi atau yang melakukan tindakan saat keluar (misalnya, Hapus data penjelajahan saat keluar atau cookie sesi saja).

          Jika Anda memilih 'Buka daftar URL', daftar 'URL untuk dibuka saat mulai' akan dibuka saat pengguna memulai <ph name="PRODUCT_NAME"/>.

          Jika Anda mengaktifkan setelan ini, pengguna tidak dapat mengubah atau menggantinya di <ph name="PRODUCT_NAME"/>.

          Menonaktifkan setelan ini sama dengan membiarkannya tidak dikonfigurasi. Pengguna masih dapat mengubahnya di <ph name="PRODUCT_NAME"/>.</translation>
<translation id="2872961005593481000">Matikan</translation>
<translation id="4445684791305970001">Menonaktifkan Alat Pengembang dan konsol JavaScript. Jika Anda mengaktifkan setelan ini, alat Pengembang tidak dapat diakses dan elemen situs web tidak dapat diperiksa lagi. Setiap pintasan keyboard dan menu atau entri menu konteks untuk membuka Alat Pengembang atau Konsol JavaScript akan dinonaktifkan. Dengan menyetel opsi menjadi nonaktif atau membiarkannya tanpa disetel akan memungkinkan penggunaan konsol JavaScript dan Alat Pengembang.</translation>
<translation id="9203071022800375458">Menonaktifkan pengambilan tangkapan layar.

      Jika diaktifkan, tangkapan layar tidak akan dapat dilakukan dengan menggunakan pintasan keyboard atau API ekstensi.

      Jika dinonaktifkan atau tidak ditentukan, pengambilan tangkapan layar akan diizinkan.</translation>
<translation id="5697306356229823047">Laporkan pengguna perangkat</translation>
<translation id="8649763579836720255">Perangkat Chrome OS dapat menggunakan atestasi jarak jauh (Akses Terverifikasi) untuk mendapatkan sertifikat yang diberikan oleh Chrome OS CA yang menyatakan bahwa perangkat tersebut memenuhi syarat untuk memutar konten yang dilindungi. Proses ini mencakup pengiriman informasi dukungan perangkat keras ke Chrome OS CA yang mengidentifikasi perangkat tersebut secara unik.

          Jika disetel ke false, perangkat tidak akan menggunakan atestasi perlindungan konten jarak jauh dan tidak dapat memutar konten yang dilindungi.

          Jika disetel ke true, atau tidak disetel, atestasi jarak jauh dapat digunakan untuk perlindungan konten.</translation>
<translation id="4632343302005518762">Izinkan <ph name="PRODUCT_FRAME_NAME"/> menangani jenis konten yang tercantum</translation>
<translation id="13356285923490863">Nama Kebijakan</translation>
<translation id="557658534286111200">Mengaktifkan atau menonaktifkan pengeditan bookmark</translation>
<translation id="5378985487213287085">Memungkinkan Anda menyetel apakah situs web diizinkan untuk menampilkan pemberitahuan desktop. Menampilkan pemberitahuan desktop dapat diizinkan secara default, ditolak secara default, atau pengguna dapat ditanya setiap kali sebuah situs web ingin menampilkan pemberitahuan desktop. Jika kebijakan ini tidak disetel, 'AskNotifications' akan digunakan dan pengguna dapat mengubahnya.</translation>
<translation id="2386362615870139244">Izinkan penguncian layar saat bangun</translation>
<translation id="6908640907898649429">Mengonfigurasi penyedia penelusuran default. Anda dapat menentukan penyedia penelusuran default yang akan digunakan pengguna atau memilih menonaktifkan penelusuran default.</translation>
<translation id="6544897973797372144">Jika kebijakan ini disetel ke True dan kebijakan ChromeOsReleaseChannel tidak ditentukan, maka pengguna domain yang mendaftar akan diizinkan mengubah saluran rilis perangkat. Jika kebijakan ini disetel ke false, perangkat akan dikunci pada saluran apa pun yang disetel terakhir kali.

      Saluran yang dipilih pengguna akan ditimpa oleh kebijakan ChromeOsReleaseChannel, namun jika saluran kebijakan lebih stabil dari saluran kebijakan yang telah terpasang pada perangkat, maka saluran ini hanya akan beralih setelah versi saluran yang lebih stabil mencapai jumlah versi yang lebih tinggi dari saluran kebijakan yang telah terpasang pada perangkat.</translation>
<translation id="389421284571827139">Memungkinkan Anda menentukan server proxy yang digunakan oleh <ph name="PRODUCT_NAME"/> dan mencegah pengguna mengubah setelan proxy. Jika Anda memilih untuk tidak pernah menggunakan server proxy dan selalu terhubung secara langsung, semua opsi lain akan diabaikan. Jika Anda memilih untuk mendeteksi server proxy secara otomatis, semua opsi lain akan diabaikan. Untuk contoh mendetail, kunjungi: <ph name="PROXY_HELP_URL"/> Jika Anda mengaktifkan setelan ini, <ph name="PRODUCT_NAME"/> akan mengabaikan semua opsi yang berhubungan dengan proxy yang ditentukan dari baris perintah. Membiarkan kebijakan ini tidak disetel akan memungkinkan pengguna memilih setelan proxy mereka sendiri.</translation>
<translation id="681446116407619279">Skema autentikasi yang didukung</translation>
<translation id="4027608872760987929">Aktifkan penyedia penelusuran default</translation>
<translation id="2223598546285729819">Setelan pemberitahuan default</translation>
<translation id="6158324314836466367">Nama toko web perusahaan (tidak digunakan)</translation>
<translation id="3984028218719007910">Menentukan apakah <ph name="PRODUCT_OS_NAME"/> menyimpan data akun lokal setelah keluar. Jika disetel ke true, maka tidak ada akun yang terus menerus disimpan oleh <ph name="PRODUCT_OS_NAME"/> dan semua data dari sesi pengguna akan dihapus setelah keluar. Jika kebijakan ini disetel ke false atau tidak dikonfigurasi, perangkat dapat menyimpan data pengguna lokal (yang dienkripsi).</translation>
<translation id="3793095274466276777">Mengonfigurasi pemeriksaan browser default di <ph name="PRODUCT_NAME"/> dan mencegah pengguna mengubahnya. Jika Anda mengaktifkan setelan ini, <ph name="PRODUCT_NAME"/> akan selalu memeriksa saat permulaan apakah itu browser default dan mendaftar sendiri secara otomatis jika memungkinkan. Jika setelan ini dinonaktifkan, <ph name="PRODUCT_NAME"/> tidak akan memeriksa apakah itu browser default dan akan menonaktifkan kontrol pengguna untuk setelan opsi ini. Jika setelan ini tidak disetel, <ph name="PRODUCT_NAME"/> akan mengizinkan pengguna mengontrol apakah itu browser default dan apakah pemberitahuan pengguna harus ditampilkan ketika tidak muncul.</translation>
<translation id="3504791027627803580">Menentukan URL mesin telusur yang digunakan untuk menyediakan penelusuran gambar. Permintaan penelusuran akan dikirim menggunakan metode GET. Jika kebijakan DefaultSearchProviderImageURLPostParams disetel kemudian permintaan penelusuran gambar akan menggunakan metode POST.

          Kebijakan ini bersifat opsional. Jika tidak disetel, penelusuran gambar akan digunakan.

          Kebijakan ini hanya dipatuhi jika kebijakan 'DefaultSearchProviderEnabled' diaktifkan.</translation>
<translation id="7529100000224450960">Memungkinkan Anda menyetel daftar pola url yang menentukan situs yang diizinkan membuka munculan. Jika kebijakan ini tidak disetel, nilai default global akan digunakan untuk semua situs, baik dari kebijakan 'DefaultPopupsSetting', jika disetel, atau konfigurasi pribadi pengguna.</translation>
<translation id="6155936611791017817">Setel status default kursor besar di layar masuk</translation>
<translation id="1530812829012954197">Selalu urai pola URL berikut di browser host</translation>
<translation id="9026000212339701596">Kamus yang memetakan nama hosting ke bendera boolean yang menentukan apakah akses ke hosting harus diizinkan (true) atau diblokir (false).

          Kebijakan ini untuk penggunaan internal oleh Chrome itu sendiri.</translation>
<translation id="913195841488580904">Cekal akses ke daftar URL</translation>
<translation id="5461308170340925511">Mengonfigurasi kebijakan terkait ekstensi. Pengguna tidak diizinkan untuk memasang ekstensi dalam daftar hitam kecuali tercantum dalam daftar putih, Selain itu, Anda juga dapat memaksa <ph name="PRODUCT_NAME"/> agar otomatis memasang ekstensi dengan menentukannya dalam <ph name="EXTENSIONINSTALLFORCELIST_POLICY_NAME"/>. Ekstensi pasang paksa akan dipasang meskipun ada dalam daftar hitam.</translation>
<translation id="3292147213643666827">Memungkinkan <ph name="PRODUCT_NAME"/> bertindak sebagai proxy antara <ph name="CLOUD_PRINT_NAME"/> dan printer lawas yang tersambung ke komputer.

      Jika setelan ini diaktifkan atau tidak dikonfigurasi, pengguna dapat mengaktifkan proxy cloud print lewat autentikasi dengan akun Google.

      Jika setelan ini dinonaktifkan, pengguna tidak dapat mengaktifkan proxy tersebut, dan komputer tidak akan diizinkan berbagi printernya dengan <ph name="CLOUD_PRINT_NAME"/>.</translation>
<translation id="6373222873250380826">Menonaktifkan pembaruan otomatis saat disetel ke True.

      Perangkat <ph name="PRODUCT_OS_NAME"/> memeriksa pembaruan secara otomatis saat setelan ini tidak dikonfigurasikan atau disetel ke False.</translation>
<translation id="6190022522129724693">Setelan munculan default</translation>
<translation id="847472800012384958">Jangan izinkan situs mana pun menampilkan munculan</translation>
<translation id="4733471537137819387">Kebijakan yang terkait dengan autentikasi HTTP terintegrasi.</translation>
<translation id="8501011084242226370">Menentukan daftar plugin yang dapat diaktifkan atau dinonaktifkan oleh pengguna di <ph name="PRODUCT_NAME"/>.

      Karakter pengganti '*' dan '?' dapat digunakan untuk mencocokkan rangkaian karakter acak. '*' mencocokkan sejumlah karakter acak sedangkan '?' menentukan karakter tunggal opsional, yaitu mencocokkan karakter nol atau satu. Karakter lepasan adalah '\', sehingga untuk mencocokkan karakter '*', '?', atau '\' aktual, Anda dapat meletakkan '\' di depannya.

      Jika Anda mengaktifkan setelan ini, daftar plugin yang ditentukan dapat digunakan di <ph name="PRODUCT_NAME"/>. Pengguna dapat mengaktifkan atau menonaktifkannya dalam 'about:plugins', walaupun plugin juga mencocokkan pola di DisabledPlugins. Pengguna juga dapat mengaktifkan dan menonaktifkan plugin yang tidak mencocokkan dengan pola apa pun di DisabledPlugins, DisabledPluginsExceptions, dan EnabledPlugins.

      Kebijakan ini ditujukan agar pencantuman plugin ke daftar hitam secara ketat dapat dilakukan apabila daftar 'DisabledPlugins' berisi entri berkarakter pengganti seperti menonaktifkan semua plugin '*' atau menonaktifkan semua plugin Java '*Java*', namun administrator ingin mengaktifkan beberapa versi tertentu misalnya 'IcedTea Java 2.3'. Versi tertentu ini dapat ditentukan dalam kebijakan ini.

      Harap diingat bahwa baik nama plugin dan nama grup plugin perlu dibebaskan. Setiap grup plugin ditampilkan dalam bagian yang terpisah di about:plugins; masing-masing bagian dapat memiliki satu plugin atau lebih. Misalnya, plugin &quot;Shockwave Flash&quot; adalah milik grup &quot;Adobe Flash Player&quot;, dan kedua nama tersebut perlu memiliki kecocokan dalam daftar pengecualian apabila plugin tersebut akan dibebaskan dari daftar hitam.

      Jika kebijakan ini tidak disetel, plugin apa pun yang mencocokan pola di 'DisabledPlugins' akan terus dinonaktifkan dan pengguna tidak akan dapat mengaktifkannya.</translation>
<translation id="8951350807133946005">Setel direktori cache disk</translation>
<translation id="603410445099326293">Parameter untuk URL yang disarankan yang menggunakan POST</translation>
<translation id="2592091433672667839">Durasi keadaan tidak aktif sebelum tirai layar ditampilkan di layar masuk dalam mode eceran</translation>
<translation id="166427968280387991">Server proxy</translation>
<translation id="2805707493867224476">Izinkan semua situs menampilkan munculan</translation>
<translation id="1727394138581151779">Cekal semua plugin</translation>
<translation id="8118665053362250806">Menyetel ukuran cache disk media</translation>
<translation id="6565312346072273043">Menyetel status default fitur aksesibilitas keyboard di layar pada layar masuk.

          Jika kebijakan ini disetel ke true, keyboard di layar akan diaktifkan saat layar masuk ditampilkan.

          Jika kebijakan ini disetel ke false, keyboard di layar akan dinonaktifkan saat layar masuk ditampilkan.

          Jika Anda menyetel kebijakan ini, pengguna dapat menggantinya untuk sementara dengan mengaktifkan atau menonaktifkan keyboard di layar. Akan tetapi, pilihan pengguna tidak bersifat tetap dan setelan default akan dipulihkan ketika layar masuk ditampilkan kembali atau pengguna menganggur di layar masuk selama satu menit.

          Jika kebijakan ini tidak disetel, keyboard di layar akan dinonaktifkan ketika layar masuk ditampilkan untuk pertama kali. Pengguna dapat mengaktifkan atau menonaktifkan keyboard di layar kapan saja dan statusnya pada layar masuk bersifat tetap antarpengguna.</translation>
<translation id="7079519252486108041">Cekal munculan di situs ini</translation>
<translation id="1859633270756049523">Batasi lamanya sesi</translation>
<translation id="7433714841194914373">Aktifkan Instan</translation>
<translation id="4983201894483989687">Izinkan menjalankan plugin yang kedaluwarsa</translation>
<translation id="443665821428652897">Hapus data situs saat browser ditutup (tidak digunakan lagi)</translation>
<translation id="3823029528410252878">Menonaktifkan penyimpanan riwayat browser di <ph name="PRODUCT_NAME"/> dan mencegah pengguna mengubah setelan ini. Jika setelan ini diaktifkan, riwayat browseran tidak disimpan. Jika setelan ini dinonaktifkan atau tidak disetel, riwayat browseran disimpan.</translation>
<translation id="7295019613773647480">Aktifkan pengguna yang dilindungi</translation>
<translation id="2759224876420453487">Mengontrol perilaku pengguna pada sesi multiprofil</translation>
<translation id="3844092002200215574">Mengonfigurasi direktori yang akan digunakan oleh <ph name="PRODUCT_NAME"/> untuk menyimpan file yang tersimpan dalam cache di disk.

      Jika Anda menyetel kebijakan ini, <ph name="PRODUCT_NAME"/> akan menggunakan direktori yang diberikan terlepas apakah pengguna telah menandai '--disk-cache-dir' atau belum.

      Lihat http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables untuk daftar variabel yang dapat digunakan.

      Jika kebijakan ini dibiarkan tidak disetel, direktori cache default akan digunakan dan pengguna akan dapat menggantikannya dengan tanda baris perintah '--disk-cache-dir'.</translation>
<translation id="3034580675120919256">Memungkinkan Anda menyetel apakah situs web diizinkan menjalankan JavaScript. Menjalankan JavaScript dapat diizinkan atau ditolak untuk semua situs web. Jika kebijakan ini tidak disetel, 'AllowJavaScript' akan digunakan dan pengguna dapat mengubahnya.</translation>
<translation id="193900697589383153">Menambahkan tombol keluar di baki sistem.

      Jika diaktifkan, tombol keluar yang besar dan berwarna merah ditampilkan di baki sistem saat sesi aktif dan layar tidak dikunci.

      Jika dinonaktifkan atau tidak ditentukan, tidak ada tombol keluar yang besar dan berwarna merah yang ditampilkan di baki sistem.</translation>
<translation id="5111573778467334951">Tentukan tindakan yang akan diambil saat penundaan nganggur dicapai ketika menjalankan daya baterai.

          Saat kebijakan ini disetel, menentukan tindakan <ph name="PRODUCT_OS_NAME"/> yang diambil saat pengguna membiarkan nganggur untuk lamanya waktu yang diberikan oleh penundaan nganggur, yang dapat dikonfigurasikan secara terpisah.

          Saat kebijakan tidak disetel, tindakan default diambil, yaitu yang ditangguhkan

          Jika tindakan ditangguhkan, <ph name="PRODUCT_OS_NAME"/> dapat dikonfigurasikan secara terpisah baik layar terkunci atau pun tidak sebelum penangguhan.</translation>
<translation id="3195451902035818945">Menentukan apakah pembagian catatan SSL harus dinonaktifkan. Pembagian catatan merupakan solusi untuk kelemahan dalam SSL 3.0 dan TLS 1.0 tetapi dapat menyebabkan masalah kompatibilitas dengan beberapa server HTTPS dan proxy. Jika kebijakan ini tidak disetel, atau disetel ke false, maka pembagian catatan akan digunakan di sambungan SSL/TLS yang menggunakan ciphersuite CBC.</translation>
<translation id="6903814433019432303">Kebijakan ini aktif dalam mode eceran saja.

      Menentukan kumpulan URL yang akan dimuat saat sesi demo dimulai. Kebijakan ini mengganti mekanisme lain untuk menyetel URL awal, sehingga hanya dapat diterapkan ke sesi yang tidak terkait dengan pengguna tertentu.</translation>
<translation id="5868414965372171132">Konfigurasi jaringan tingkat pengguna</translation>
<translation id="8519264904050090490">URL pengecualian manual pengguna yang dikelola</translation>
<translation id="4480694116501920047">Paksakan TelusurAman</translation>
<translation id="465099050592230505">URL toko web perusahaan (tidak digunakan)</translation>
<translation id="2006530844219044261">Pengelolaan daya</translation>
<translation id="1221359380862872747">Muat url yang ditentukan di proses masuk demo</translation>
<translation id="8711086062295757690">Menentukan kata kunci yang merupakan pintasan yang digunakan dalam omnibox guna memicu penelusuran untuk operator ini. Kebijakan ini bersifat opsional. Jika tidak disetel, kata kunci tidak akan mengaktifkan penyedia penelusuran. Kebijakan ini hanya dipertimbangkan jika kebijakan 'DefaultSearchProviderEnabled' diaktifkan.</translation>
<translation id="1152117524387175066">Laporkan status pengalih dev perangkat ketika boot.

      Jika kebijakan ini disetel ke false, status pengalih dev tidak akan dilaporkan.</translation>
<translation id="5774856474228476867">URL penelusuran penyedia penelusuran default</translation>
<translation id="4650759511838826572">Nonaktifkan skema protokol URL</translation>
<translation id="7831595031698917016">Menentukan penundaan maksimum dalam milidetik antara penerimaan invalidasi kebijakan dan pengambilan kebijakan baru dari layanan pengelola perangkat.

      Setelan kebijakan ini menimpa nilai default 5000 milidetik. Nilai yang valid untuk kebijakan ini berkisar antara 1000 (1 detik) dan 300000 (5 menit). Setiap nilai yang tidak berada dalam jangkauan akan dikunci ke masing-masing batas.

      Membiarkan kebijakan ini tidak disetel akan membuat penggunaan <ph name="PRODUCT_NAME"/> menggunakan nilai default 5000 milidetik.</translation>
<translation id="8099880303030573137">Menunda waktu menganggur saat menggunakan daya baterai</translation>
<translation id="1709037111685927635">Mengonfigurasi gambar wallpaper.

      Kebijakan ini memungkinkan Anda mengonfigurasi gambar wallpaper yang ditampilkan di desktop dan pada latar belakang layar masuk bagi pengguna. Kebijakan ini disetel dengan menentukan URL tempat <ph name="PRODUCT_OS_NAME"/> dapat mengunduh gambar wallpaper dan hash kriptografi yang digunakan untuk memverifikasi integritas unduhan. Gambar harus dalam format JPEG, dan ukurannya tidak boleh melebihi 16 MB. URL harus dapat diakses tanpa autentikasi apa pun.

      Gambar wallpaper diunduh dan disimpan dalam cache. Gambar akan diunduh kembali saat URL atau hash berubah.

      Kebijakan harus ditentukan sebagai string yang mengekspresikan URL dan hash dalam format JSON, sesuai dengan skema berikut:
      {
        &quot;type&quot;: &quot;object&quot;,
        &quot;properties&quot;: {
          &quot;url&quot;: {
            &quot;description&quot;: &quot;URL tempat gambar wallpaper dapat diunduh.&quot;,
            &quot;type&quot;: &quot;string&quot;
          },
          &quot;hash&quot;: {
            &quot;description&quot;: &quot;Hash SHA-256 gambar wallpaper.&quot;,
            &quot;type&quot;: &quot;string&quot;
          }
        }
      }

      Jika kebijakan ini disetel, <ph name="PRODUCT_OS_NAME"/> akan mengunduh dan menggunakan gambar wallpaper.

      Jika Anda menyetel kebijakan ini, pengguna tidak dapat mengubah atau menggantinya.

      Jika kebijakan ini dibiarkan tidak disetel, pengguna dapat memilih gambar untuk ditampilkan di desktop dan di latar belakang layar masuk.</translation>
<translation id="2761483219396643566">Menunda peringatan waktu menganggur saat menggunakan daya baterai</translation>
<translation id="6281043242780654992">Mengonfigurasikan kebijakan untuk Perpesanan Asli. Hosting perpesanan asli yang dimasukkan dalam daftar hitam tidak akan diizinkan kecuali telah dimasukkan dalam daftar putih.</translation>
<translation id="1468307069016535757">Menyetel status default fitur aksesibilitas mode kontras tinggi di layar masuk.

          Jika kebijakan ini disetel ke true, mode kontras tinggi akan diaktifkan saat layar masuk ditampilkan.

          Jika kebijakan ini disetel ke false, mode kontras tinggi akan dinonaktifkan saat layar masuk ditampilkan.

          Jika Anda menyetel kebijakan ini, pengguna dapat menimpanya untuk sementara dengan mengaktifkan atau menonaktifkan mode kontras tinggi. Namun, pilihan pengguna tidak bersifat permanen dan setelan default akan dipulihkan kapan pun layar masuk ditampilkan lagi atau pengguna tetap menganggur di layar masuk selama satu menit.

          Jika kebijakan ini tidak disetel, mode kontras tinggi dinonaktifkan saat layar masuk ditampilkan untuk pertama kali. Pengguna dapat mengaktifkan atau menonaktifkan mode kontras tinggi kapan saja dan statusnya di layar masuk bersifat permanen antar pengguna.</translation>
<translation id="602728333950205286">URL sekejap penyedia penelusuran default</translation>
<translation id="3030000825273123558">Aktifkan pelaporan metrik</translation>
<translation id="8465065632133292531">Parameter untuk URL instan yang menggunakan POST</translation>
<translation id="6559057113164934677">Jangan izinkan situs apa pun mengakses kamera dan mikrofon</translation>
<translation id="7273823081800296768">Jika setelan diaktifkan atau dikonfigurasikan, pengguna dapat memilih untuk menyandingkan klien dan host pada waktu tersambung, menghilangkan keharusan untuk memasukkan PIN setiap waktu.

          Jika setelan ini dinonaktifkan, fitur ini tidak akan tersedia.</translation>
<translation id="1675002386741412210">Didukung di:</translation>
<translation id="1608755754295374538">URL yang akan diberi akses ke perangkat perekam audio tanpa peringatan</translation>
<translation id="3547954654003013442">Setelan proxy</translation>
<translation id="5921713479449475707">Izinkan pengunduhan pembaruan otomatis melalui HTTP</translation>
<translation id="4482640907922304445">Menampilkan tombol Beranda di bilah alat <ph name="PRODUCT_NAME"/>. Jika Anda mengaktifkan setelan ini, tombol Beranda akan selalu ditampilkan. Jika Anda menonaktifkan setelan ini, tombol Beranda tidak akan pernah ditampilkan. Jika Anda mengaktifkan atau menonaktifkan setelan ini, pengguna tidak dapat mengubah atau menimpa setelan ini di <ph name="PRODUCT_NAME"/>. Membiarkan kebijakan ini tidak disetel akan memungkinkan pengguna memilih apakah akan menampilkan tombol beranda.</translation>
<translation id="2518231489509538392">Mengizinkan pemutaran audio</translation>
<translation id="8146727383888924340">Memungkinkan pengguna menukarkan penawaran melalui Pendaftaran Chrome OS</translation>
<translation id="7301543427086558500">Menentukan daftar URL pengganti yang dapat digunakan untuk mengekstrak istilah penelusuran dari mesin telusur. URL harus berisi string <ph name="SEARCH_TERM_MARKER"/>, yang akan digunakan untuk mengekstrak istilah penelusuran.

          Kebijakan ini bersifat opsional. Jika tidak disetel, tidak ada URL pengganti akan digunakan untuk mengekstrak istilah penelusuran.

          Kebijakan ini hanya diterapkan jika kebijakan 'DefaultSearchProviderEnabled' diaktifkan.</translation>
<translation id="436581050240847513">Melaporkan antarmuka jaringan perangkat</translation>
<translation id="6282799760374509080">Izinkan atau tolak penangkapan audio</translation>
<translation id="8864975621965365890">Menimpa permintaan penghentian yang muncul saat situs dirender oleh <ph name="PRODUCT_FRAME_NAME"/>.</translation>
<translation id="3264793472749429012">Penyandiaksaraan penyedia penelusuran default</translation>
<translation id="285480231336205327">Aktifkan mode kontras tinggi</translation>
<translation id="5366977351895725771">Jika disetel ke false, pembuatan pengguna yang dilindungi oleh pengguna ini akan dinonaktifkan. Pengguna diawasi mana pun yang sudah ada akan tetap tersedia.

          Jika disetel ke true atau tidak dikonfigurasi, pengguna yang dilindungi dapat dibuat dan dikelola oleh pengguna ini.</translation>
<translation id="5469484020713359236">Memungkinkan Anda menyetel daftar pola url yang menentukan situs yang diizinkan untuk menyetel cookie. Jika kebijakan ini dibiarkan tidak disetel, nilai default global akan digunakan untuk semua situs, baik dari kebijakan 'DefaultCookiesSetting', jika disetel, atau konfigurasi pribadi pengguna.</translation>
<translation id="1504431521196476721">Pengesahan Jarak Jauh</translation>
<translation id="1881299719020653447">Menyembunyikan toko web dari laman tab baru dan peluncur aplikasi</translation>
<translation id="930930237275114205">Setel direktori data pengguna <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="244317009688098048">Aktifkan pintasan keyboard penyelamatan untuk masuk otomatis.

      Jika kebijakan ini tidak disetel atau disetel ke True dan akun lokal perangkat dikonfigurasikan untuk masuk otomatis tanpa penundaan, <ph name="PRODUCT_OS_NAME"/> akan menerima pintasan keyboard Ctrl+Alt+S untuk melewati masuk otomatis dan menampilkan layar masuk.

      Jika kebijakan ini disetel ke False, masuk otomatis tanpa penundaan (jika dikonfigurasi) tidak dapat dilewati.</translation>
<translation id="5208240613060747912">Memungkinkan Anda menyetel daftar pola url yang menentukan situs yang tidak diizinkan untuk menampilkan pemberitahuan. Jika kebijakan ini tidak disetel, nilai default global akan digunakan untuk semua situs, baik dari kebijakan 'DefaultNotificationsSetting', jika disetel, atau konfigurasi pribadi pengguna.</translation>
<translation id="346731943813722404">Menentukan apakah penundaan pengelolaan daya dan batas lama sesi hanya mulai berjalan setelah aktivitas pengguna pertama teramati dalam sebuah sesi.

          Jika kebijakan disetel ke True, penundaan pengelolaan daya dan batas lama sesi tidak mulai berjalan sampai aktivitas pengguna pertama teramati dalam sebuah sesi.

          Jika kebijakan ini disetel ke False atau dibiarkan tidak disetel, penundaan pengelolaan daya dan batas lama sesi mulai berjalan langsung saat sesi dimulai.</translation>
<translation id="4600786265870346112">Aktifkan kursor besar</translation>
<translation id="5887414688706570295">Mengonfigurasi awalan TalkGadget yang akan digunakan oleh hosting akses jarak jauh dan mencegah pengguna mengubahnya.

          Jika ditentukan, awalan ini ditambahkan di depan nama TalkGadget dasar untuk membuat nama domain TalkGadget lengkap. Nama domain TalkGadget dasar adalah '.talkgadget.google.com'.

          Jika setelan ini diaktifkan, hosting akan menggunakan nama domain khusus saat mengakses TalkGadget sebagai ganti nama domain default.

          Jika setelan ini dinonaktifkan atau tidak disetel, maka nama domain TalkGadget default ('chromoting-host.talkgadget.google.com') akan digunakan untuk semua hosting.

          Klien akses jarak jauh tidak dipengaruhi oleh setelan kebijakan ini. Klien akses jarak jauh akan selalu menggunakan 'chromoting-client.talkgadget.google.com' untuk mengakses TalkGadget.</translation>
<translation id="1103860406762205913">Mengaktifkan proses masuk berbasis web yang lama</translation>
<translation id="5765780083710877561">Deskripsi:</translation>
<translation id="6915442654606973733">Mengaktifkan fitur aksesibilitas masukan yang diucapkan.

          Jika kebijakan ini disetel ke true, masukan yang diucapkan akan selalu diaktifkan.

          Jika kebijakan ini disetel ke false, masukan yang diucapkan akan selalu dinonaktifkan.

          Jika Anda menyetel kebijakan ini, pengguna tidak dapat mengubah atau menimpanya.

          Jika kebijakan ini tidak disetel, masukan yang diucapkan pertama-tama dinonaktifkan, namun dapat diaktifkan oleh pengguna kapan saja.</translation>
<translation id="7796141075993499320">Memungkinkan Anda menyetel daftar pola url yang menentukan situs yang diizinkan untuk menjalankan plugin. Jika kebijakan ini tidak disetel, nilai default global akan digunakan untuk semua situs, baik dari kebijakan 'DefaultPluginsSetting', jika disetel, atau konfigurasi pribadi pengguna.</translation>
<translation id="3809527282695568696">Jika 'Buka daftar URL' dipilih sebagai tindakan saat memulai, tindakan ini memungkinkan Anda untuk menentukan daftar URL yang dibuka. Jika tidak disetel, tidak ada URL yang akan dibuka saat mulai. Kebijakan ini hanya bekerja jika kebijakan 'RestoreOnStartup' disetel ke 'RestoreOnStartupIsURLs'.</translation>
<translation id="649418342108050703">Menonaktifkan dukungan untuk API grafis 3D. Mengaktifkan setelan ini mencegah laman web mengakses unit pemrosesan grafik (GPU). Secara spesifik, laman web tidak dapat mengakses API WebGL dan plugin tidak dapat menggunakan API Pepper 3D. Menonaktifkan atau membiarkan setelan tidak disetel berpotensi memungkinkan laman web menggunakan API WebGL dan plugin menggunakan API Pepper 3D. Setelan default browser mungkin masih mengharuskan argumen baris perintah untuk diterapkan sebelum menggunakan API ini.</translation>
<translation id="2077273864382355561">Penundaan mematikan layar saat menggunakan daya baterai</translation>
<translation id="9112897538922695510">Memungkinkan Anda mendaftarkan daftar penangan protokol. Ini hanya dapat menjadi kebijakan yang disarankan. Properti |protokol| sebaiknya disetel ke skema seperti 'mailto' dan properti |url| sebaiknya disetel ke pola URL aplikasi yang menangani skema. Pola tersebut dapat berisi '%s', yang apabila disajikan akan menggantikan URL yang ditangani.

          Penangan protokol yang didaftarkan oleh kebijakan digabung dengan penangan protokol yang didaftarkan oleh pengguna dan keduanya tersedia untuk digunakan. Pengguna dapat mengganti penangan protokol yang dipasang oleh kebijakan dengan memasang penangan default baru, namun pengguna tidak dapat membuang penangan protokol yang didaftarkan oleh kebijakan.</translation>
<translation id="3417418267404583991">Jika kebijakan ini disetel ke true atau tidak dikonfigurasi, <ph name="PRODUCT_OS_NAME"/> akan mengaktifkan masuk sebagai tamu. Masuk sebagai tamu adalah sesi pengguna anonim dan tidak memerlukan sandi.

      Jika kebijakan ini disetel ke false, <ph name="PRODUCT_OS_NAME"/> tidak akan mengizinkan dimulainya sesi tamu.</translation>
<translation id="8329984337216493753">Kebijakan ini aktif dalam mode eceran saja.

      Jika DeviceIdleLogoutTimeout ditentukan, kebijakan ini menetapkan durasi kotak peringatan dengan pewaktu hitungan mundur yang ditampilkan ke pengguna sebelum proses keluar dieksekusi.

      Nilai kebijakan harus ditentukan dalam milidetik.</translation>
<translation id="237494535617297575">Memungkinkan Anda menyetel daftar pola url yang menentukan situs yang tidak diizinkan untuk menampilkan pemberitahuan. Jika kebijakan ini tidak disetel, nilai default global akan digunakan untuk semua situs, baik dari kebijakan 'DefaultNotificationsSetting', jika disetel, atau konfigurasi pribadi pengguna.</translation>
<translation id="527237119693897329">Memungkinkan Anda menentukan hosting perpesanan asli mana yang seharusnya tidak dimuat.

          Nilai daftar hitam '*' menunjukkan bahwa semua hosting perpesanan asli dimasukkan daftar hitam kecuali dicantumkan dalam daftar putih dengan jelas.

          Jika kebijakan ini tidak disetel, <ph name="PRODUCT_NAME"/> akan memuat semua hosting perpesanan asli yang terpasang.</translation>
<translation id="749556411189861380">Laporkan versi firmware dan OS perangkat yang terdaftar.

      Jika setelan ini tidak disetel atau disetel ke True, perangkat terdaftar akan melaporkan versi firmware dan OS secara berkala. Jika setelan ini disetel ke False, info versi tidak akan dilaporkan.</translation>
<translation id="7258823566580374486">Mengaktifkan pemberian tirai hosting akses jarak jauh</translation>
<translation id="5560039246134246593">Menambahkan parameter ke pengambilan bibit Variasi di <ph name="PRODUCT_NAME"/>.

      Jika ditentukan, akan menambahkan parameter kueri yang disebut 'bataso' ke URL yang digunakan untuk mengambil bibit Variasi. Nilai parameter akan menjadi nilai yang ditentukan dalam kebijakan ini.

      Jika tidak ditentukan, tidak akan mengubah URL bibit Variasi.</translation>
<translation id="944817693306670849">Setel ukuran cache disk</translation>
<translation id="8544375438507658205">Pengurai HTML default untuk <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="2371309782685318247">Menentukan periode dalam milidetik yang mana layanan pengelolaan perangkat dimintai informasi kebijakan pengguna.

      Menyetel kebijakan ini akan menimpa nilai defaukt 3 jam. Nilai yang valid untuk kebijakan ini adalah dalam rentang mulai dari 1800000 (30 menit) hingga 86400000 (1 hari). Nilai yang tidak berada dalam rentang tersebut akan dikunci ke batas masing-masing.

      Membiarkan kebijakan ini tidak disetel akan membuat <ph name="PRODUCT_NAME"/> menggunakan nilai default 3 jam.</translation>
<translation id="2571066091915960923">Mengaktifkan atau menonaktifkan proxy kompresi data dan mencegah agar pengguna tidak mengubah setelan ini.

      Jika Anda mengaktifkan atau menonaktifkan setelan ini, pengguna tidak dapat mengubah atau mengganti setelan ini.

      Jika kebijakan ini dibiarkan tidak disetel, pengguna dapat memilih untuk menggunakan atau tidak menggunakan fitur proxy kompresi data.</translation>
<translation id="2170233653554726857">Aktifkan pengoptimalan WPAD</translation>
<translation id="7424751532654212117">Daftar pengecualian untuk daftar plugin yang dinonaktifkan</translation>
<translation id="6233173491898450179">Setel direktori unduhan</translation>
<translation id="8908294717014659003">Memungkinkan Anda menyetel apakah situs web diizinkan untuk mengakses perangkat tangkap media. Akses ke perangkat tangkap media dapat diizinkan secara default, atau dapat ditanyakan pada pengguna setiap saat situs web ingin mendapatkan akses ke perangkat tangkap media.

          Jika kebijakan ini tidak disetel, 'PromptOnAccess' akan digunakan dan pengguna dapat mengubahnya.</translation>
<translation id="4429220551923452215">Mengaktifkan atau menonaktifkan pintasan aplikasi di bilah bookmark.

      Jika kebijakan ini tidak disetel, pengguna dapat memilih untuk menunjukkan atau menyembunyikan pintasan aplikasi dari menu konteks bilah bookmark.

      Jika kebijakan ini dikonfigurasi, pengguna tidak dapat mengubahnya, dan pintasan aplikasi selalu ditampilkan atau tidak pernah ditampilkan.</translation>
<translation id="2299220924812062390">Tentukan daftar plugin yang diaktifkan</translation>
<translation id="4325690621216251241">Tambahkan tombol keluar di baki sistem</translation>
<translation id="924557436754151212">Impor sandi yang disimpan dari browser default saat pertama kali dijalankan</translation>
<translation id="1465619815762735808">Klik untuk memainkan</translation>
<translation id="7227967227357489766">Menetapkan daftar pengguna yang diizinkan masuk ke perangkat. Entrinya berformat <ph name="USER_WHITELIST_ENTRY_FORMAT"/>, misalnya <ph name="USER_WHITELIST_ENTRY_EXAMPLE"/>. Untuk mengizinkan sembarang pengguna di domain, gunakan entri format <ph name="USER_WHITELIST_ENTRY_WILDCARD"/>.

      Jika kebijakan ini tidak dikonfigurasi, tidak ada batasan tentang pengguna yang diizinkan untuk masuk. Perhatikan bahwa membuat pengguna baru tetap memerlukan kebijakan <ph name="DEVICEALLOWNEWUSERS_POLICY_NAME"/> untuk dikonfigurasi dengan semestinya.</translation>
<translation id="2521581787935130926">Tampilkan pintasan aplikasi di bilah bookmark</translation>
<translation id="8135937294926049787">Menentukan panjang waktu tanpa masukan pengguna sebelum layar dimatikan ketika menggunakan daya AC.

          Saat kebijakan ini disetel ke nilai yang lebih besar dari nol, nilai tersebut akan menentukan panjang waktu pengguna tetap menganggur sebelum <ph name="PRODUCT_OS_NAME"/> mematikan layar.

          Saat kebijakan ini disetel ke nol, <ph name="PRODUCT_OS_NAME"/> tidak mematikan layar saat pengguna menganggur.

          Saat kebijakan ini tidak disetel, panjang waktu default akan digunakan.

          Nilai kebijakan ini harus ditentukan dalam milidetik. Nilai dijepit menjadi lebih sedikit dari penundaan waktu menganggur.</translation>
<translation id="1897365952389968758">Izinkan semua situs menjalankan JavaScript</translation>
<translation id="922540222991413931">Konfigurasi sumber pemasangan skrip pengguna, aplikasi, dan ekstensi</translation>
<translation id="7323896582714668701">Parameter baris perintah tambahan untuk <ph name="PRODUCT_NAME"/></translation>
<translation id="6931242315485576290">Nonaktifkan sinkronisasi data dengan Google</translation>
<translation id="1330145147221172764">Aktifkan keyboard di layar</translation>
<translation id="7006788746334555276">Setelan Konten</translation>
<translation id="450537894712826981">Mengonfigurasi ukuran cache yang akan digunakan <ph name="PRODUCT_NAME"/> untuk menyimpan file media di disk.

      Jika Anda menyetel kebijakan ini, <ph name="PRODUCT_NAME"/> akan menggunakan ukuran cache yang disediakan terlepas dari apakah pengguna menentukan tanda '--media-cache-size' atau tidak. Nilai yang ditentukan dalam kebijakan ini bukan merupakan batas mutlak namun merupakan saran terhadap sistem penyimpanan dalam cache, nilai apa pun di bawah beberapa megabyte dianggap terlalu kecil dan akan dibulatkan ke nilai minimum yang lebih wajar.

      Jika nilai kebijakan ini 0, ukuran cache default akan digunakan namun pengguna tidak akan dapat mengubahnya.

      Jika kebijakan ini tidak disetel, ukuran default akan digunakan dan pengguna dapat menimpanya dengan tanda --media-cache-size.</translation>
<translation id="5142301680741828703">Selalu mengurai pola URL berikut di <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="4625915093043961294">Mengonfigurasi daftar putih pemasangan ekstensi</translation>
<translation id="5893553533827140852">Jika setelan ini diaktifkan, permintaan autentikasi gnubby akan dilakukan melalui proxy lewat sambungan hosting jarak jauh.

          Jika setelan ini dinonaktifkan atau tidak dikonfigurasi, permintaan autentikasi gnubby tidak akan dilakukan melalui proxy.</translation>
<translation id="187819629719252111">Memungkinkan akses ke file lokal pada mesin dengan mengizinkan <ph name="PRODUCT_NAME"/> menampilkan dialog pemilihan file. Jika Anda mengaktifkan setelan ini, pengguna dapat membuka dialog pemilihan file seperti biasa. Jika Anda menonaktifkan setelan ini, setiap kali pengguna melakukan tindakan yang akan memicu dialog pemilihan file (seperti mengimpor bookmark, mengunggah file, menyimpan tautan, dll.), yang akan ditampilkan adalah pesan, dan pengguna dianggap telah mengeklik Batal pada dialog pemilihan file. Jika setelan ini tidak disetel, pengguna dapat membuka dialog pemilihan file seperti biasa.</translation>
<translation id="4507081891926866240">Mengubahsuai daftar pola URL yang harus selalu dirender oleh <ph name="PRODUCT_FRAME_NAME"/>. Jika kebijakan ini tidak disetel, perender default akan digunakan untuk semua situs yang ditentukan oleh kebijakan 'ChromeFrameRendererSettings'. Untuk contoh pola, lihat http://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="3101501961102569744">Pilih cara menentukan setelan server proxy</translation>
<translation id="1803646570632580723">Daftar aplikasi tersemat untuk ditampilkan pada peluncur</translation>
<translation id="1062011392452772310">Mengaktifkan pengesahan jarak jauh untuk perangkat tersebut</translation>
<translation id="7774768074957326919">Gunakan setelan proxy sistem</translation>
<translation id="3891357445869647828">Mengaktifkan JavaScript</translation>
<translation id="2274864612594831715">Kebijakan ini mengonfigurasi pengaktifkan keyboard virtual sebagai perangkat masukan di ChromeOS. Pengguna tidak dapat mengganti kebijakan ini.

      Jika kebijakan ini disetel ke true, keyboard virtual di layar akan selalu diaktifkan.

      Jika disetel ke false, keyboard virtual di layar akan selalu dinonaktifkan.

      Jika Anda menyetel kebijakan ini, pengguna tidak dapat mengubah atau menggantinya. Namun, pengguna akan tetap dapat mengaktifkan/menonaktifkan aksesibilitas keyboard di layar yang diutamakan atas keyboard virtual yang dikontrol oleh kebijakan ini. Lihat kebijakan |VirtualKeyboardEnabled| untuk mengontrol aksesibilitas keyboard di layar.

      Jika kebijakan ini tidak disetel, keyboard di layar akan dinonaktifkan pada awalnya namun dapat diaktifkan oleh pengguna kapan saja. Aturan heuristis juga dapat digunakan untuk menentukan waktu untuk menampilkan keyboard.</translation>
<translation id="6774533686631353488">Izinkan host Native Messaging tingkat pengguna (dipasang tanpa izin admin).</translation>
<translation id="868187325500643455">Izinkan semua situs menjalankan plugin secara otomatis</translation>
<translation id="7421483919690710988">Setel ukuran cache disk media dalam bita</translation>
<translation id="5226033722357981948">Menentukan apakah pencari plugin harus dinonaktifkan</translation>
<translation id="7234280155140786597">Nama hosting perpesanan asli yang dilarang (atau * untuk semua)</translation>
<translation id="4890209226533226410">Menyetel jenis lup yang diaktifkan.

          Jika kebijakan ini disetel, kebijakan ini mengontrol jenis lup layar yang diaktifkan. Menyetel kebijakan ke &quot;None&quot; akan menonaktifkan lup.

          Jika Anda menyetel kebijakan ini, pengguna tidak dapat mengubah atau menimpanya.

          Jika kebijakan ini tidak disetel, pertama-tama lup dinonaktifkan, namun dapat diaktifkan oleh pengguna kapan saja.</translation>
<translation id="3428247105888806363">Aktifkan prediksi jaringan</translation>
<translation id="3460784402832014830">Menentukan URL yang digunakan oleh mesin telusur untuk memberikan laman tab baru.

          Kebijakan ini bersifat opsional. Jika tidak disetel, laman tab baru tidak akan diberikan.

          Kebijakan ini dipatuhi hanya jika kebijakan 'DefaultSearchProviderEnabled' diaktifkan.</translation>
<translation id="6145799962557135888">Memungkinkan Anda menyetel daftar pola url yang menentukan situs yang tidak diizinkan untuk menjalankan JavaScript. Jika kebijakan ini tidak disetel, nilai default global akan digunakan untuk semua situs, baik dari kebijakan 'DefaultJavaScriptSetting', jika disetel, ataupun dari konfigurasi pribadi pengguna.</translation>
<translation id="2757054304033424106">Ketik ekstensi/aplikasi yang diizinkan untuk dipasang</translation>
<translation id="7053678646221257043">Kebijakan ini memaksa bookmark diimpor dari browser default saat ini, jika diaktifkan. Jika diaktifkan, kebijakan ini juga memengaruhi dialog impor. Jika dinonaktifkan, tidak ada bookmark yang diimpor. Jika tidak disetel, pengguna mungkin akan diminta untuk mengimpor, atau pengimporan dapat terjadi secara otomatis.</translation>
<translation id="5757829681942414015">Mengonfigurasi direktori yang akan digunakan oleh <ph name="PRODUCT_NAME"/> untuk menyimpan data pengguna.

      Jika Anda menyetel kebijakan ini, <ph name="PRODUCT_NAME"/> akan menggunakan direktori yang diberikan terlepas apakah pengguna telah menandai '--user-data-dir' atau belum.

      Lihat http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables untuk daftar variabel yang dapat digunakan.

      Jika kebijakan ini dibiarkan tidak disetel, jalur profil default akan digunakan dan pengguna akan dapat menggantikannya dengan tanda baris perintah '--user-data-dir'.</translation>
<translation id="5067143124345820993">Daftar putih pengguna masuk</translation>
<translation id="2514328368635166290">Menentukan URL ikon favorit dari penyedia penelusuran default. Kebijakan ini bersifat opsional. Jika tidak disetel, ikon tidak akan ada untuk penyedia penelusuran. Kebijakan ini hanya berlaku jika kebijakan 'DefaultSearchProviderEnabled' diaktifkan.</translation>
<translation id="7194407337890404814">Nama penyedia penelusuran default</translation>
<translation id="1843117931376765605">Segarkan peringkat untuk kebijakan pengguna</translation>
<translation id="5535973522252703021">Daftar putih server delegasi Kerberos</translation>
<translation id="9187743794267626640">Menonaktifkan pemasangan penyimpanan eksternal</translation>
<translation id="6353901068939575220">Menentukan parameter yang digunakan saat menelusuri URL dengan POST. Berisi pasangan nama/nilai yang dipisahkan koma. Jika nilai adalah parameter template, seperti {searchTerms} dalam contoh di atas, akan diganti dengan data istilah penelusuran nyata.

          Kebijakan ini bersifat opsional. Jika tidak disetel, permintaan penelusuran instan akan dikirim menggunakan metode GET.

          Kebijakan ini hanya dikhususkan jika kebijakan 'DefaultSearchProviderEnabled' diaktifkan.</translation>
<translation id="5307432759655324440">Ketersediaan mode penyamaran</translation>
<translation id="4056910949759281379">Nonaktifkan protokol SPDY</translation>
<translation id="3808945828600697669">Tentukan daftar plugin yang dinonaktifkan</translation>
<translation id="4525521128313814366">Memungkinkan Anda menyetel daftar pola URL yang menentukan situs yang tidak diizinkan untuk menampilkan gambar. Jika kebijakan ini tidak disetel, nilai global default akan digunakan untuk semua situs, baik dari kebijakan 'DefaultImagesSetting', jika disetel, atau konfigurasi pribadi pengguna.</translation>
<translation id="8499172469244085141">Setelan Default (pengguna dapat menggantinya)</translation>
<translation id="4816674326202173458">Memungkinkan pengguna perusahaan menjadi primer dan sekunder (Perilaku default untuk pengguna yang tidak dikelola)</translation>
<translation id="8693243869659262736">Gunakan klien DNS di dalamnya</translation>
<translation id="3072847235228302527">Menyetel Persyaratan Layanan untuk akun lokal perangkat</translation>
<translation id="5523812257194833591">Sesi publik untuk masuk secara otomatis setelah penundaan.

      Jika kebijakan ini disetel, sesi yang ditentukan akan secara otomatis masuk setelah jangka waktu tersebut berlalu pada layar masuk tanpa interaksi pengguna. Sesi publik harus sudah dikonfigurasi (lihat |DeviceLocalAccounts|).

      Jika kebijakan ini tidak disetel, tidak akan ada masuk secara otomatis.</translation>
<translation id="5983708779415553259">Perilaku default untuk situs tidak ada dalam paket konten mana pun</translation>
<translation id="3866530186104388232">Jika kebijakan ini diatur ke true atau tidak dikonfigurasi, <ph name="PRODUCT_OS_NAME"/> akan menampilkan pengguna yang ada pada layar masuk dan diizinkan untuk memilih salah satu. Jika kebijakan ini diatur ke false, <ph name="PRODUCT_OS_NAME"/> akan menggunakan permintaan nama pengguna/sandi untuk masuk.</translation>
<translation id="7384902298286534237">Memungkinkan Anda menyetel daftar pola URL yang menentukan situs yang diizinkan untuk menyetel cookie hanya sesi.

          Jika kebijakan ini dibiarkan tidak disetel, nilai default global akan digunakan untuk semua situs baik dari kebijakan 'DefaultCookiesSetting' jika disetel, ataupun konfigurasi pribadi pengguna.

          Jika kebijakan &quot;RestoreOnStartup&quot; disetel untuk memulihkan URL dari sesi sebelumnya, kebijakan ini tidak akan dipatuhi dan cookie akan disimpan secara permanen untuk situs tersebut.</translation>
<translation id="2098658257603918882">Aktifkan laporan data penggunaan dan yang terkait kerusakan</translation>
<translation id="4633786464238689684">Mengubah perilaku default tombol baris teratas ke tombol fungsi.

          Jika kebijakan ini disetel ke true, tombol baris teratas keyboard akan membuat perintah tombol fungsi per default. Tombol penelusuran harus ditekan untuk mengembalikan perilakunya ke tombol media.

          Jika kebijakan ini disetel ke false atau dibiarkan tidak disetel, keyboard akan membuat perintah tombol media per default dan perintah tombol fungsi saat tombol penelusuran ditahan.</translation>
<translation id="2324547593752594014">Mengizinkan masuk ke Chrome</translation>
<translation id="172374442286684480">Izinkan semua situs menyetel data lokal</translation>
<translation id="1151353063931113432">Izinkan gambar di situs ini</translation>
<translation id="1297182715641689552">Gunakan skrip proxy .pac</translation>
<translation id="2976002782221275500">Menentukan panjang waktu tanpa masukan pengguna sebelum layar meredup saat menggunakan daya baterai.

          Saat kebijakan ini desetel ke nilai lebih besar dari nol, kebijakan menentukan panjang waktu pengguna tetap menganggur sebelum <ph name="PRODUCT_OS_NAME"/> meredupkan layar.

          Saat kebijakan ini disetel ke nol, <ph name="PRODUCT_OS_NAME"/> tidak meredupkan layar saat pengguna menganggur.

          Saat kebijakan ini tidak disetel, panjang waktu default akan digunakan.

          Nilai kebijakan harus ditentukan dalam milidetik. Nilai dijepit hingga kurang dari atau setara dengan penundaan mematikan layar (jika disetel) dan penundaan waktu menganggur.</translation>
<translation id="8631434304112909927">sampai versi <ph name="UNTIL_VERSION"/></translation>
<translation id="7469554574977894907">Aktifkan saran penelusuran</translation>
<translation id="4906194810004762807">Segarkan peringkat untuk Kebijakan Perangkat</translation>
<translation id="8922668182412426494">Server yang dapat didelegasikan oleh <ph name="PRODUCT_NAME"/>.

          Memisahkan beberapa nama server dengan koma. Karakter pengganti (*) diizinkan.

          Jika Anda membiarkan kebijakan ini tidak disetel, Chrome tidak akan mendelegasikan kredensial pengguna meskipun server terdeteksi sebagai Intranet.</translation>
<translation id="1398889361882383850">Memungkinkan Anda untuk menyetel apakah situs web diizinkan untuk menjalankan plugin secara otomatis. Plugin yang berjalan secara otomatis dapat diizinkan untuk semua situs web atau ditolak untuk semua situs web.

          Klik untuk mainkan memungkinkan plugin berjalan, tetapi pengguna harus mengekliknya untuk memulai eksekusi.

          Jika kebijakan ini tidak disetel, 'AllowPlugins' akan digunakan dan pengguna akan dapat mengubahnya.</translation>
<translation id="7974114691960514888">Kebijakan ini tidak lagi didukung. Mengaktifkan penggunaan STUN dan server relay saat menyambungkan ke klien jarak jauh. Jika setelan ini diaktifkan, maka komputer ini dapat menemukan dan tersambung ke komputer host jarak jauh bahkan jika dipisahkan oleh firewall. Jika setelan ini dinonaktifkan dan sambungan UDP keluar difilter oleh firewall, maka komputer ini hanya dapat tersambung ke komputer host dalam jaringan lokal.</translation>
<translation id="7694807474048279351">Menjadwalkan mulai ulang otomatis setelah pembaruan <ph name="PRODUCT_OS_NAME"/> diterapkan.

      Saat kebijakan ini disetel ke true, mulai ulang otomatis akan dijadwalkan saat pembaruan <ph name="PRODUCT_OS_NAME"/> diterapkan dan diperlukan mulai ulang untuk menyelesaikan proses pembaruan. Mulai ulang dijadwalkan langsung namun mungkin ditunda di perangkat hingga 24 jam jika pengguna sedang menggunakan perangkat.

      Saat kebijakan ini disetel ke false, mulai ulang otomatis tidak akan dijadwalkan setelah menerapkan pembaruan <ph name="PRODUCT_OS_NAME"/>. Proses pembaruan diselesaikan saat pengguna memulai ulang perangkat lagi.

      Jika Anda menyetel kebijakan ini, pengguna tidak dapat mengubah atau menimpanya.

      Catatan: Saat ini, mulai ulang otomatis hanya diaktifkan saat layar masuk ditampilkan atau sesi aplikasi kios sedang berjalan. Hal ini akan berubah di masa mendatang dan kebijakan akan terus diterapkan, terlepas dari apakah sesi dari jenis tertentu apa pun sedang dijalankan atau tidak.</translation>
<translation id="5511702823008968136">Aktifkan Bilah Bookmark</translation>
<translation id="5105313908130842249">Penundaan penguncian layar saat menggunakan daya baterai</translation>
<translation id="7882585827992171421">Kebijakan ini hanya aktif dalam mode ritel.

      Menentukan id ekstensi untuk digunakan sebagai tirai layar pada layar masuk. Ekstensi haruslah bagian dari AppPack yang dikonfigurasi untuk domain ini melalui kebijakan DeviceAppPack.</translation>
<translation id="1796466452925192872">Memungkinkan Anda menentukan URL mana yang diizinkan memasang ekstensi, aplikasi, dan tema.

          Sejak Chrome 21, pemasangan ekstensi, aplikasi, dan skrip pengguna dari luar Toko Web Chrome akan semakin sulit. Sebelumnya, pengguna dapat mengeklik tautan ke file *.crx, dan Chrome akan menawarkan untuk memasang file ini setelah beberapa peringatan. Pada Chrome 21 ke atas, file seperti itu harus diunduh dan diseret ke laman setelan Chrome. Setelan ini memungkinkan URL tertentu memiliki alur pemasangan lama yang lebih mudah.

          Setiap item dalam daftar ini adalah pola yang cocok dengan gaya ekstensi (lihat http://code.google.com/chrome/extensions/match_patterns.html). Pengguna dapat mudah memasang item dari URL apa pun yang cocok dengan item dalam daftar ini. Lokasi file *.crx dan laman tempat unduhan dimulai (perujuk) harus diizinkan dengan pola ini.

          ExtensionInstallBlacklist lebih diutamakan dibandingkan dengan kebijakan ini. Artinya, ekstensi dalam daftar hitam tidak akan dipasang, meskipun berasal dari situs dalam daftar ini.</translation>
<translation id="2113068765175018713">Membatasi waktu operasi perangkat dengan melakukan booting ulang secara otomatis</translation>
<translation id="4224610387358583899">Penundaan kunci layar</translation>
<translation id="5388730678841939057">Memilih strategi yang digunakan untuk mengosongkan ruang disk selama pembersihan otomatis (tidak lagi digunakan)</translation>
<translation id="7848840259379156480">Memungkinkan Anda mengonfigurasi pengurai HTML default ketika <ph name="PRODUCT_FRAME_NAME"/> terpasang. Setelan defaultnya adalah mengizinkan browser host melakukan penguraian, tetapi Anda dapat mengganti ini secara opsional dan memerintahkan <ph name="PRODUCT_FRAME_NAME"/> agar mengurai laman HTML jika tidak diubah.</translation>
<translation id="186719019195685253">Kebijakan yang diambil saat penundaan nganggur tercapai ketika dijalankan pada daya AC</translation>
<translation id="197143349065136573">Memungkinkan alur proses masuk lama berbasis web.

      Setelan ini berguna untuk pelanggan perusahaan yang menggunakan solusi SSO yang belum kompatibel dengan alur proses masuk sebaris yang baru.
      Jika Anda mengaktifkan setelan ini, alur proses masuk lama berbasis web akan digunakan.
      Jika Anda menonaktifkan setelan ini atau membiarkannya tidak disetel, alur proses masuk sebaris yang baru akan digunakan secara default. Pengguna masih dapat mengaktifkan alur proses masuk lama berbasis web melalui tanda baris perintah --aktifkan proses masuk berbasis web.

      Setelan eksperimental akan dibuang di masa mendatang saat proses masuk sebaris sepenuhnya mendukung semua alur proses masuk SSO.</translation>
<translation id="4121350739760194865">Mencegah promosi apl muncul di laman tab baru</translation>
<translation id="2127599828444728326">Izinkan pemberitahuan di situs ini</translation>
<translation id="3973371701361892765">Jangan sembunyikan rak secara otomatis</translation>
<translation id="7635471475589566552">Mengonfigurasi lokal aplikasi di <ph name="PRODUCT_NAME"/> dan mencegah pengguna mengubah lokal tersebut. Jika Anda mengaktifkan setelan ini, <ph name="PRODUCT_NAME"/> akan menggunakan lokal yang ditentukan. Jika lokal terkonfigurasi tidak didukung, 'en-US' akan digunakan. Jika setelan ini dinonaktifkan atau tidak disetel, <ph name="PRODUCT_NAME"/> akan menggunakan lokal terpilih yang ditentukan pengguna (jika dikonfigurasi), lokal sistem, atau lokal pengganti 'en-US'.</translation>
<translation id="2948087343485265211">Menentukan apakah aktivitas audio mempengaruhi pengelolaan daya.

          Jika kebijakan ini disetel ke True atau tidak disetel, pengguna tidak dianggap menganggur saat audio berputar. Hal ini mencegah waktu tunggu menganggur tercapai dan mencegah tindakan menganggur. Namun, peredupan layar, mematikan layar, dan penguncian layar akan dilakukan setelah waktu tunggu yang dikonfigurasikan, terlepas dari aktivitas audio.

          Jika kebijakan ini disetel ke False, aktivitas audio tidak mencegah pengguna untuk dianggap menganggur.</translation>
<translation id="7842869978353666042">Konfigurasi opsi Google Drive</translation>
<translation id="718956142899066210">Jenis sambungan yang diizinkan untuk pembaruan</translation>
<translation id="1734716591049455502">Mengonfigurasi opsi akses jarak jauh</translation>
<translation id="7336878834592315572">Menyimpan cookie selama durasi sesi</translation>
<translation id="7715711044277116530">Persentase yang digunakan untuk menskalakan penundaan layar redup dalam mode presentasi</translation>
<translation id="8777120694819070607">Mengizinkan <ph name="PRODUCT_NAME"/> menjalankan plugin yang kedaluwarsa. Jika Anda mengaktifkan setelan ini, plugin yang kedaluwarsa digunakan sebagai plugin normal. Jika Anda menonaktifkan setelan ini, plugin yang kedaluwarsa tidak akan digunakan dan pengguna tidak akan dimintai izin untuk menjalankannya. Jika setelan ini tidak disetel, pengguna akan dimintai izin untuk menjalankan plugin yang kedaluwarsa.</translation>
<translation id="2629448496147630947">Mengonfigurasi opsi akses jarak jauh di <ph name="PRODUCT_NAME"/>. Fitur ini diabaikan kecuali jika aplikasi web Akses Jarak Jauh dipasang.</translation>
<translation id="4001275826058808087">Admin TI untuk perangkat perusahaan dapat menggunakan tanda ini untuk mengontrol apakah mengizinkan pengguna menukarkan penawaran melalui Pendaftaran Chrome OS atau tidak.

      Jika kebijakan ini disetel ke true atau tidak disetel, pengguna akan dapat menukarkan penawaran melalui Pendaftaran Chrome OS.

      Jika kebijakan ini disetel ke false, pengguna tidak akan dapat menukarkan penawaran.</translation>
<translation id="1310699457130669094">Anda dapat menentukan URL ke file .pac proxy di sini. Kebijakan ini hanya berlaku jika Anda telah memilih setelan proxy manual di 'Pilih cara menentukan setelan server proxy'. Anda harus membiarkan kebijakan ini tidak disetel jika telah memilih mode lain untuk kebijakan proxy setelan. Untuk contoh mendetail, kunjungi: <ph name="PROXY_HELP_URL"/></translation>
<translation id="1509692106376861764">Kebijakan ini tidak lagi digunakan mulai <ph name="PRODUCT_NAME"/> versi 29.</translation>
<translation id="5464816904705580310">Mengonfigurasi setelan untuk pengguna yang dikelola.</translation>
<translation id="3219421230122020860">Mode penyamaran tersedia</translation>
<translation id="7690740696284155549">Mengonfigurasi direktori yang akan digunakan oleh <ph name="PRODUCT_NAME"/> untuk mengunduh file.

      Jika Anda menyetel kebijakan ini, <ph name="PRODUCT_NAME"/> akan menggunakan direktori yang diberikan terlepas apakah pengguna telah menentukan satu tanda atau menonaktifkan tanda untuk dimintai lokasi unduhan setiap saat.

      Lihat http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables untuk daftar variabel yang dapat digunakan.

      Jika kebijakan ini dibiarkan tidak disetel, direktori unduhan default akan digunakan dan pengguna akan dapat mengubahnya.</translation>
<translation id="7381326101471547614">Menonaktifkan penggunaan protokol SPDY di <ph name="PRODUCT_NAME"/>. Jika kebijakan ini diaktifkan, protokol SPDY tidak akan tersedia di <ph name="PRODUCT_NAME"/>. Menyetel kebijakan ini sebagai dinonaktifkan akan mengizinkan penggunaan SPDY. Jika kebijakan ini tidak disetel, SPDY akan tersedia.</translation>
<translation id="2208976000652006649">Parameter untuk URL penelusuran yang menggunakan POST</translation>
<translation id="1583248206450240930">Gunakan <ph name="PRODUCT_FRAME_NAME"/> jika tidak diubah</translation>
<translation id="1047128214168693844">Jangan izinkan situs mana pun melacak lokasi fisik pengguna</translation>
<translation id="4101778963403261403">Mengonfigurasi jenis laman beranda default di <ph name="PRODUCT_NAME"/> dan mencegah pengguna mengubah preferensi laman beranda. Laman beranda dapat disetel ke URL yang Anda tentukan atau disetel ke Laman Tab Baru. Jika Anda mengaktifkan setelan ini, Laman Tab Baru akan selalu digunakan untuk laman beranda, dan lokasi URL laman beranda diabaikan. Jika Anda menonaktifkan setelan ini, laman beranda pengguna tidak akan pernah menjadi Laman Tab Baru, kecuali URL-nya disetel ke 'chrome://newtab'. Jika Anda mengaktifkan atau menonaktifkan setelan ini, pengguna tidak dapat mengubah jenis laman beranda mereka di <ph name="PRODUCT_NAME"/>. Membiarkan kebijakan ini tidak disetel akan memungkinkan pengguna memilih apakah laman tab baru menjadi laman berandanya sendiri.</translation>
<translation id="8970205333161758602">Tindas permintaan penghentian <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="3273221114520206906">Setelan JavaScript default</translation>
<translation id="4025586928523884733">Mencekal cookie pihak ketiga. Mengaktifkan setelan ini akan mencegah cookie disetel oleh elemen laman web yang tidak berasal dari domain yang ada di bilah alamat browser. Menonaktifkan setelan ini akan mengizinkan cookie disetel oleh elemen laman web yang tidak berasal dari domain yang ada di bilah alamat browser dan mencegah pengguna mengubah setelan tersebut. Jika kebijakan ini tidak disetel, cookie pihak ketiga akan diaktifkan, namun pengguna dapat mengubahnya.</translation>
<translation id="4604931264910482931">Konfigurasikan daftar hitam perpesanan asli</translation>
<translation id="6810445994095397827">Cekal JavaScript di situs ini</translation>
<translation id="6672934768721876104">Kebijakan ini sudah usang, gunakan ProxyMode sebagai gantinya. Memungkinkan Anda menentukan server proxy yang digunakan oleh <ph name="PRODUCT_NAME"/> dan mencegah pengguna mengubah setelan proxy. Jika Anda memilih untuk tidak pernah menggunakan server proxy dan selalu tersambung secara langsung, semua opsi lain akan diabaikan. Jika Anda memilih menggunakan setelan proxy sistem atau mendeteksi server proxy secara otomatis, semua opsi lain akan diabaikan. Jika Anda memilih setelan proxy manual, Anda dapat menentukan opsi lebih lanjut di 'Alamat atau URL server proxy', 'URL ke file .pac proxy', dan 'Daftar peraturan pengabaian proxy yang dipisahkan koma'. Untuk contoh mendetailnya, kunjungi: <ph name="PROXY_HELP_URL"/> Jika Anda mengaktifkan setelan ini, <ph name="PRODUCT_NAME"/> mengabaikan semua opsi yang berhubungan dengan proxy yang ditentukan dari baris perintah. Membiarkan kebijakan ini tidak disetel akan mengizinkan pengguna memilih setelan proxy sendiri.</translation>
<translation id="3780152581321609624">Sertakan port non-standar di SPN Kerberos</translation>
<translation id="1749815929501097806">Menyetel Persyaratan Layanan yang harus diterima oleh pengguna sebelum sebelum memulai sesi akun lokal perangkat.

      Jika kebijakan ini disetel, <ph name="PRODUCT_OS_NAME"/> akan mengunduh Persyaratan Layanan dan menyajikannya kepada pengguna saat sesi akun lokal perangkat dimulai. Pengguna hanya akan diizinkan menuju sesi tersebut setelah menerima Persyaratan Layanan.

      Jika kebijakan ini tidak disetel, tidak ada Persyaratan Layanan yang ditampilkan.

      Kebijakan ini harus disetel ke URL di tempat <ph name="PRODUCT_OS_NAME"/> dapat mengunduh Persyaratan Layanan tersebut. Persyaratan Layanan ini harus dalam teks biasa, yang disajikan sebagai teks/biasa jenis MIME. Tidak ada markup yang diizinkan.</translation>
<translation id="2623014935069176671">Tunggu aktivitas pengguna awal</translation>
<translation id="2660846099862559570">Jangan pernah gunakan proxy</translation>
<translation id="637934607141010488">Melaporkan daftar pengguna perangkat yang saat ini masuk.

      Jika kebijakan disetel ke false, pengguna tidak akan dilaporkan.</translation>
<translation id="1956493342242507974">Mengonfigurasi pengelolaan daya di layar masuk pada <ph name="PRODUCT_OS_NAME"/>.

      Kebijakan ini memungkinkan Anda mengonfigurasi bagaimana <ph name="PRODUCT_OS_NAME"/> berperilaku saat tidak ada aktivitas pengguna untuk jangka waktu tertentu saat layar masuk ditampilkan. Kebijakan mengontrol beberapa setelan. Untuk rentang nilai dan semantik individunya, lihat kebijakan terkait yang mengontrol pengelolaan daya dalam satu sesi. Penyimpangan dari kebijakan ini hanya:
      * Tindakan untuk menganggur atau menutup penutup tidak dapat digunakan untuk mengakhiri sesi.
      * Tindakan default yang dilakukan saat menganggur saat menjalankan daya AC adalah mematikan perangkat.

      Jika setelan tidak ditetapkan, nilai default akan digunakan.

      Jika kebijakan ini tidak disetel, setelan default digunakan untuk semua setelan.</translation>
<translation id="1435659902881071157">Konfigurasi jaringan tingkat perangkat</translation>
<translation id="8071636581296916773">Memungkinkan penggunaan server relay saat klien jarak jauh sedang mencoba membuat koneksi ke komputer ini.

          Jika setelan diaktifkan, klien jarak jauh dapat menggunakan server relay untuk tersambung ke komputer ini saat koneksi langsung tidak tersedia (misalnya karena pembatasan firewall).

          Perhatikan bahwa jika kebijakan <ph name="REMOTEACCESSHOSTFIREWALLTRAVERSAL_POLICY_NAME"/> dinonaktifkan, kebijakan ini akan diabaikan.

          Jika kebijakan dibiarkan tidak disetel, setelan tersebut akan diaktifkan.</translation>
<translation id="2131902621292742709">Penundaan peredupan layar saat menggunakan daya baterai</translation>
<translation id="5781806558783210276">Menentukan panjang waktu tanpa masukan pengguna sebelum tindakan menganggur diambil saat menggunakan daya baterai.

          Saat kebijakan ini disetel, kebijakan menentukan panjang waktu pengguna harus tetap menganggur sebelum <ph name="PRODUCT_OS_NAME"/> melakukan tindakan menganggur, yang dapat dikonfigurasikan secara terpisah.

          Saat kebijakan ini tidak disetel, panjang waktu default digunakan.

          Nilai kebijakan harus ditetapkan dalam milidetik.</translation>
<translation id="5512418063782665071">URL beranda</translation>
<translation id="2948381198510798695"><ph name="PRODUCT_NAME"/> akan mengabaikan setiap proxy untuk daftar host yang diberikan di sini. Kebijakan ini hanya berlaku jika Anda telah memilih setelan proxy manual di 'Pilih cara menentukan setelan server proxy'. Anda harus membiarkan kebijakan ini tidak disetel jika telah memilih setiap mode lain untuk kebijakan proxy setelan. Untuk contoh yang lebih mendetail, kunjungi: <ph name="PROXY_HELP_URL"/></translation>
<translation id="6658245400435704251">Menentukan jumlah waktu (dalam detik) sebuah perangkat dapat menunda pengunduhan pembaruannya secara acak dari saat pembaruan tersebut pertama kali didorong ke server. Perangkat dapat menunggu dengan sebagian dari waktu ini dari segi prediksi waktu penyelesaian tugas dan sisa waktunya dari segi jumlah pemeriksaan pembaruan. Dalam keadaan apa pun, penyebaran dibatasi dengan jumlah waktu yang konstan sehingga perangkat tidak akan terus menunggu pengunduhan pembaruan selamanya.</translation>
<translation id="102492767056134033">Menyetel status default keyboard di layar di layar masuk</translation>
<translation id="523505283826916779">Setelan aksesibilitas</translation>
<translation id="1948757837129151165">Kebijakan untuk Autentikasi HTTP</translation>
<translation id="5946082169633555022">Saluran beta</translation>
<translation id="7187256234726597551">Jika true, pengesahan jarak jauh diizinkan untuk perangkat dan sertifikat akan otomatis dibuat serta diunggah ke Server Pengelolaan Perangkat.

          Jika disetel ke false, atau jika tidak disetel, sertifikat tidak akan dibuat dan panggilan ke API ekstensi enterprise.platformKeysPrivate akan gagal.</translation>
<translation id="5242696907817524533">Mengonfigurasikan daftar bookmark yang dikelola.

      Kebijakan adalah daftar bookmark, dan tiap bookmark adalah kamus yang berisi &quot;nama&quot; bookmark dan &quot;URL&quot; target.

      Bookmark ditempatkan pada folder bookmark yang Dikelola di dalam bookmark Seluler. Bookmark ini tidak dapat dimodifikasi oleh pengguna.

      Saat kebijakan ini disetel lalu bookmark Dikelola adalah folder default yang dibuka saat tampilan bookmark dibuka pada Chrome.

      Bookmark yang dikelola tidak disinkronkan ke akun pengguna.</translation>
<translation id="6757375960964186754">Menampilkan opsi aksesibilitas <ph name="PRODUCT_OS_NAME"/> dalam menu sistem.

          Jika kebijakan ini disetel ke true, opsi Aksesibilitas selalu muncul dalam menu baki sistem.

          Jika kebijakan ini disetel ke false, opsi Aksesibilitas tidak akan pernah muncul di menu baki sistem.

          Jika Anda menyetel kebijakan ini, pengguna tidak dapat mengubah atau menggantinya.

          Jika kebijakan ini tidak disetel, opsi Aksesibilitas tidak akan muncul di menu baki sistem, namun pengguna dapat menyebabkan opsi Aksesibilitas untuk muncul via laman Setelan.</translation>
<translation id="8303314579975657113">Menentukan pustaka GSSAPI mana yang digunakan untuk Autentikasi HTTP. Anda dapat menyetel nama pustaka saja, ataupun jalur selengkapnya. Jika setelan tidak tersedia, <ph name="PRODUCT_NAME"/> akan kembali menggunakan nama pustaka default.</translation>
<translation id="8549772397068118889">Memperingatkan saat mengunjungi situs di luar paket konten</translation>
<translation id="7749402620209366169">Mengaktifkan autentikasi dua faktor untuk hosting akses jarak jauh sebagai ganti PIN yang ditentukan pengguna.

          Jika setelan ini diaktifkan, maka pengguna harus memberikan kode dua faktor yang valid saat mengakses hosting.

          Jika setelan ini dinonaktifkan atau tidak disetel, maka dua faktor tidak akan diaktifkan dan perilaku default yaitu menggunakan PIN yang ditentukan pengguna, akan digunakan.</translation>
<translation id="6698424063018171973">Membatasi jangkauan port UDP yang digunakan oleh hosting akses jarak jauh di komputer ini.

          Jika kebijakan ini dibiarkan tidak disetel, atau jika disetel ke string kosong, hosting akses jarak jauh akan diizinkan untuk menggunakan port apa pun yang tersedia, kecuali kebijakan <ph name="REMOTEACCESSHOSTFIREWALLTRAVERSAL_POLICY_NAME"/> dinonaktifkan, dalam hal ini hosting akses jarak jauh akan menggunakan port UDP dalam jangkauan 12400-12409.</translation>
<translation id="7329842439428490522">Menentukan panjang waktu tanpa masukan pengguna sebelum layar dimatikan ketika menggunakan daya baterai.

          Saat kebijakan ini disetel ke nilai yang lebih besar dari nol, nilai tersebut akan menentukan panjang waktu pengguna tetap menganggur sebelum <ph name="PRODUCT_OS_NAME"/> mematikan layar.

          Saat kebijakan ini disetel ke nol, <ph name="PRODUCT_OS_NAME"/> tidak mematikan layar saat pengguna menganggur.

          Saat kebijakan ini tidak disetel, panjang waktu default akan digunakan.

          Nilai kebijakan ini harus ditentukan dalam milidetik. Nilai dijepit menjadi lebih sedikit dari penundaan waktu menganggur.</translation>
<translation id="384743459174066962">Memungkinkan Anda menyetel daftar pola URL yang menentukan situs yang tidak diizinkan untuk membuka munculan. Jika kebijakan ini tidak disetel, nilai default global akan digunakan untuk semua situs baik dari kebijakan 'DefaultPopupsSetting', jika disetel, atau konfigurasi pribadi pengguna.</translation>
<translation id="5645779841392247734">Izinkan cookie di situs ini</translation>
<translation id="4043912146394966243">Jenis sambungan yang diizinkan penggunaannya untuk pembaruan OS. Pembaruan OS berpotensi memberikan beban berat pada sambungan Internet karena ukurannya dan mungkin mengakibatkan biaya tambahan. Oleh karena itu, sambungan secara default tidak aktif untuk jenis sambungan yang dianggap mahal, yang meliputi WiMax, Bluetooth, dan Seluler untuk saat ini.

      Pengenal jenis sambungan yang diketahui saat ini adalah &quot;ethernet&quot;, &quot;wifi&quot;, &quot;wimax&quot;, &quot;bluetooth&quot;, dan &quot;cellular&quot;.</translation>
<translation id="6652197835259177259">Setelan pengguna yang dikelola secara lokal</translation>
<translation id="2808013382476173118">Memungkinkan penggunaan server STUN saat klien jarak jauh mencoba untuk membuat koneksi ke komputer ini.

          Jika setelan ini diaktifkan, klien jarak jauh dapat menemukan dan tersambung ke komputer ini meskipun terpisah oleh firewall.

          Jika setelan ini dinonaktifkan dan koneksi UDP yang keluar disaring oleh firewall, komputer ini hanya akan mengizinkan koneksi dari komputer klien dalam jaringan lokal.

          Jika kebijakan ini dibiarkan tidak disetel, setelan tersebut akan diaktifkan.</translation>
<translation id="3243309373265599239">Menentukan panjang waktu tanpa masukan pengguna sebelum layar meredup saat menggunakan daya AC.

          Saat kebijakan ini desetel ke nilai lebih besar dari nol, kebijakan menentukan panjang waktu pengguna tetap menganggur sebelum <ph name="PRODUCT_OS_NAME"/> meredupkan layar.

          Saat kebijakan ini disetel ke nol, <ph name="PRODUCT_OS_NAME"/> tidak meredupkan layar saat pengguna menganggu.

          Saat kebijakan ini tidak disetel, panjang waktu default akan digunakan.

          Nilai kebijakan harus ditentukan dalam milidetik. Nilai dijepit hingga kurang dari atau setara dengan penundaan mematikan layar (jika disetel) dan penundaan waktu menganggur.</translation>
<translation id="3859780406608282662">Tambahkan parameter untuk mengambil sumber Variasi di <ph name="PRODUCT_OS_NAME"/>.

      Jika ditentukan, akan menambahkan parameter kueri yang disebut 'membatasi' ke URL yang digunakan untuk mengambil sumber Variasi. Nilai parameter akan menjadi nilai yang ditentukan dalam kebijakan ini.

      Jika tidak ditentukan, tidak akan memodifikasi URL sumber Variasi.</translation>
<translation id="7049373494483449255">Mengizinkan <ph name="PRODUCT_NAME"/> mengirimkan dokumen ke <ph name="CLOUD_PRINT_NAME"/> untuk pencetakan. CATATAN: Setelan ini hanya memengaruhi dukungan <ph name="CLOUD_PRINT_NAME"/> dalam <ph name="PRODUCT_NAME"/>. Setelan ini tidak mencegah pengguna mengirimkan pekerjaan cetak di situs web. Jika setelan ini diaktifkan atau tidak dikonfigurasi, pengguna dapat mencetak ke <ph name="CLOUD_PRINT_NAME"/> dari dialog cetak <ph name="PRODUCT_NAME"/>. Jika setelan ini dinonaktifkan, pengguna tidak dapat mencetak ke <ph name="CLOUD_PRINT_NAME"/> dari dialog pencetakan <ph name="PRODUCT_NAME"/></translation>
<translation id="4088589230932595924">Mode penyamaran dipaksakan</translation>
<translation id="5862253018042179045">Menyetel status default fitur aksesibilitas masukan yang diucapkan di layar masuk.

          Jika kebijakan ini disetel ke true, masukan yang diucapkan akan diaktifkan saat layar masuk ditampilkan.

          Jika kebijakan ini disetel ke false, masukan yang diucapkan akan dinonaktifkan saat layar masuk ditampilkan.

          Jika Anda menyetel kebijakan ini, pengguna dapat menimpanya untuk sementara dengan mengaktifkan atau menonaktifkan masukan yang diucapkan. Namun, pilihan pengguna tidak bersifat permanen dan setelan default akan dipulihkan kapan pun layar masuk ditampilkan lagi atau pengguna tetap menganggur di layar masuk selama satu menit.

          Jika kebijakan ini tidak disetel, masukan yang diucapkan akan dinonaktifkan saat layar masuk ditampilkan untuk pertama kali. Pengguna dapat mengaktifkan atau menonaktifkan masukan yang diucapkan kapan saja dan statusnya di layar masuk bersifat permanen antar pengguna.</translation>
<translation id="8197918588508433925">Kebijakan ini menentukan ekstensi yang diizinkan untuk menggunakan API Kunci Platform Perusahaan chrome.enterprise.platformKeysPrivate.challengeUserKey() untuk pengesahan jarak jauh. Ekstensi harus ditambahkan ke daftar ini untuk menggunakan API.

          Jika ekstensi tidak ada dalam daftar, atau daftar tidak disetel, panggilan ke API akan gagal dengan suatu kode kesalahan.</translation>
<translation id="2811293057593285123">Layanan Penjelajahan Aman menampilkan laman peringatan saat pengguna bernavigasi ke situs yang diberi tanda sebagai berpotensi berbahaya. Mengaktifkan setelan ini mencegah pengguna terus melanjutkan dari laman peringatan ke situs yang berbahaya.

      Jika setelan ini dinonaktifkan atau tidak dikonfigurasi, pengguna dapat memilih untuk melanjutkan ke situs yang diberi tanda setelah peringatan ditampilkan.</translation>
<translation id="7649638372654023172">Mengonfigurasi URL default beranda di <ph name="PRODUCT_NAME"/> dan mencegah pengguna mengubahnya.

          Beranda adalah laman yang dibuka oleh tombol Beranda. Laman yang terbuka saat memulai diatur oleh kebijakan RestoreOnStartup.

          Jenis beranda dapat disetel ke URL yang Anda tentukan di sini atau disetel ke Laman Tab Baru. Jika Anda memilih Laman Tab Baru, maka kebijakan ini tidak akan berpengaruh.

          Jika Anda mengaktifkan setelan ini, pengguna tidak akan dapat mengubah URL beranda di <ph name="PRODUCT_NAME"/>, namun mereka tetap dapat memilih Laman Tab Baru sebagai beranda.

          Membiarkan kebijakan ini tidak disetel akan memungkinkan pengguna memilih beranda mereka sendiri jika HomepageIsNewTabPage juga tidak disetel.</translation>
<translation id="3806576699227917885">Mengizinkan pemutaran audio.

      Jika kebijakan ini disetel ke false, keluaran audio tidak akan tersedia pada perangkat ketika pengguna masuk.

      Kebijakan ini memengaruhi semua jenis keluaran audio dan bukan hanya pengeras suara yang ada di dalamnya. Fitur aksesibilitas audio juga dilarang oleh kebijakan ini. Jangan aktifkan kebijakan ini jika pengguna membutuhkan pembaca layar.

      Jika kebijakan ini disetel ke true atau tidak dikonfigurasi, pengguna dapat menggunakan semua keluaran audio yang didukung pada perangkatnya.</translation>
<translation id="6517678361166251908">Izinkan autentikasi gnubby</translation>
<translation id="4858735034935305895">Izinkan mode layar penuh</translation>
</translationbundle>