<?xml version="1.0" encoding="UTF-8"?>
<!-- 
/**
 * Copyright (C) 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 -->

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="app_label" msgid="1527793174155125990">"Penyiapan Profil Kerja"</string>
    <string name="provisioning_error_title" msgid="6320515739861578118">"Ups!"</string>
    <string name="setup_work_profile" msgid="1468934631731845267">"Siapkan profil kerja"</string>
    <string name="company_controls_workspace" msgid="2808025277267917221">"Organisasi Anda mengontrol profil ini dan membuatnya tetap aman. Anda mengontrol hal-hal lain di perangkat."</string>
    <string name="company_controls_device" msgid="8230957518758871390">"Organisasi akan mengontrol perangkat ini dan menjaga keamanannya."</string>
    <string name="the_following_is_your_mdm" msgid="6613658218262376404">"Aplikasi berikut perlu mengakses profil ini:"</string>
    <string name="the_following_is_your_mdm_for_device" msgid="6717973404364414816">"Aplikasi berikut akan mengelola perangkat Anda:"</string>
    <string name="next" msgid="1004321437324424398">"Berikutnya"</string>
    <string name="setting_up_workspace" msgid="7862472373642601041">"Menyiapkan profil kerja..."</string>
    <string name="admin_has_ability_to_monitor_profile" msgid="7051310668406162979">"Admin IT Anda memiliki kemampuan untuk memantau dan mengelola setelan, akses perusahaan, aplikasi, izin, dan data yang terkait dengan profil ini, termasuk aktivitas jaringan, lokasi perangkat, histori panggilan, dan histori penelusuran kontak Anda.<xliff:g id="LINE_BREAK">&lt;br&gt;&lt;br&gt;</xliff:g>Untuk informasi selengkapnya, termasuk kebijakan privasi organisasi Anda, hubungi admin IT Anda."</string>
    <string name="admin_has_ability_to_monitor_device" msgid="6303112630697870695">"Admin IT Anda memiliki kemampuan untuk memantau dan mengelola setelan, akses perusahaan, aplikasi, izin, dan data yang terkait dengan perangkat ini, termasuk aktivitas jaringan, lokasi perangkat, histori panggilan, dan histori penelusuran kontak Anda.<xliff:g id="LINE_BREAK">&lt;br&gt;&lt;br&gt;</xliff:g>Untuk informasi selengkapnya, termasuk kebijakan privasi organisasi Anda, hubungi admin IT Anda."</string>
    <string name="theft_protection_disabled_warning" msgid="3708092473574738478">"Untuk menggunakan fitur perlindungan dari pencurian, Anda harus memiliki kunci layar yang dilindungi sandi untuk perangkat."</string>
    <string name="contact_your_admin_for_more_info" msgid="9209568156969966347">"Hubungi admin IT untuk informasi selengkapnya, termasuk kebijakan privasi organisasi Anda."</string>
    <string name="learn_more_link" msgid="3012495805919550043">"Pelajari lebih lanjut"</string>
    <string name="cancel_setup" msgid="2949928239276274745">"Batal"</string>
    <string name="ok_setup" msgid="4593707675416137504">"Oke"</string>
    <string name="user_consent_msg" msgid="8820951802130353584">"Saya setuju"</string>
    <string name="url_error" msgid="5958494012986243186">"Link tak bisa ditampilkan."</string>
    <string name="terms" msgid="8295436105384703903">"Persyaratan"</string>
    <string name="work_profile_info" msgid="5433388376309583996">"Info profil kerja"</string>
    <string name="managed_device_info" msgid="1529447646526616811">"Info perangkat yang dikelola"</string>
    <string name="default_managed_profile_name" msgid="5370257687074907055">"Profil kerja"</string>
    <string name="default_first_meat_user_name" msgid="7540515892748490540">"Pengguna utama"</string>
    <string name="delete_profile_title" msgid="2841349358380849525">"Hapus profil yang ada?"</string>
    <string name="opening_paragraph_delete_profile" msgid="4913885310795775967">"Anda telah memiliki profil kerja. profil tersebut dikelola menggunakan aplikasi berikut:"</string>
    <string name="read_more_delete_profile" msgid="7789171620401666343">"Sebelum melanjutkan, "<a href="#read_this_link">"baca ini"</a>"."</string>
    <string name="sure_you_want_to_delete_profile" msgid="6927697984573575564">"Jika Anda melanjutkan, semua aplikasi dan data dalam profil ini akan dihapus."</string>
    <string name="delete_profile" msgid="2299218578684663459">"Hapus"</string>
    <string name="cancel_delete_profile" msgid="5155447537894046036">"Batal"</string>
    <string name="encrypt_device_text_for_profile_owner_setup" msgid="7828515754696057140">"Untuk menyiapkan profil kerja, Anda perlu mengenkripsi perangkat. Tindakan ini mungkin memakan waktu beberapa saat."</string>
    <string name="encrypt_device_text_for_device_owner_setup" msgid="5194673142404735676">"Enkripsikan terlebih dahulu untuk menyiapkan perangkat. Tindakan ini mungkin memakan waktu beberapa saat."</string>
    <string name="encrypt_this_device_question" msgid="8719916619866892601">"Enkripsikan perangkat ini?"</string>
    <string name="encrypt" msgid="1749320161747489212">"Enkripsikan"</string>
    <string name="continue_provisioning_notify_title" msgid="5191449100153186648">"Enkripsi selesai"</string>
    <string name="continue_provisioning_notify_text" msgid="1066841819786425980">"Ketuk untuk melanjutkan penyiapan profil kerja"</string>
    <string name="managed_provisioning_error_text" msgid="7063621174570680890">"Tidak dapat menyiapkan profil kerja Anda. Hubungi departemen TI atau coba lagi nanti."</string>
    <string name="cant_add_work_profile" msgid="9217268909964154934">"Tidak dapat menambahkan profil kerja"</string>
    <string name="cant_replace_or_remove_work_profile" msgid="7861054306792698290">"Tidak dapat menggantikan atau menghapus profil kerja"</string>
    <string name="work_profile_cant_be_added_contact_admin" msgid="5393019630297157418">"Profil kerja tidak dapat ditambahkan ke perangkat ini. Jika ada pertanyaan, hubungi admin IT Anda."</string>
    <string name="change_device_launcher" msgid="4523563368433637980">"Ubah peluncur perangkat"</string>
    <string name="launcher_app_cant_be_used_by_work_profile" msgid="3524366082000739743">"Aplikasi peluncur ini tidak dapat digunakan oleh profil kerja"</string>
    <string name="cancel_provisioning" msgid="3408069559452653724">"Batal"</string>
    <string name="pick_launcher" msgid="4257084827403983845">"Oke"</string>
    <string name="user_setup_incomplete" msgid="6494920045526591079">"Penyiapan Pelanggan Belum Selesai"</string>
    <string name="default_owned_device_username" msgid="3915120202811807955">"Pengguna perangkat kerja"</string>
    <string name="setup_work_device" msgid="6003988351437862369">"Menyiapkan perangkat kerja…"</string>
    <string name="progress_data_process" msgid="1707745321954672971">"Memproses data penyiapan..."</string>
    <string name="progress_connect_to_wifi" msgid="472251154628863539">"Menyambungkan ke Wi-Fi..."</string>
    <string name="progress_connect_to_mobile_network" msgid="3852054186860657088">"Menghubungkan ke jaringan seluler…"</string>
    <string name="progress_download" msgid="3522436271691064624">"Mendownload aplikasi admin..."</string>
    <string name="progress_install" msgid="2258045670385866183">"Memasang aplikasi admin..."</string>
    <string name="progress_delete_non_required_apps" msgid="7633458399262691256">"Menghapus aplikasi sistem yang tidak diperlukan..."</string>
    <string name="progress_finishing_touches" msgid="9037776404089697198">"Menambahkan sentuhan akhir..."</string>
    <string name="progress_set_owner" msgid="8214062820093757961">"Menyetel pemilik perangkat..."</string>
    <string name="progress_initialize" msgid="1104643492713424939">"Memulai perangkat..."</string>
    <string name="device_doesnt_allow_encryption_contact_admin" msgid="5124643338424539794">"Perangkat ini tidak mengizinkan enkripsi yang diperlukan untuk penyiapan. Hubungi admin IT untuk meminta bantuan."</string>
    <string name="stop_setup_reset_device_question" msgid="7547191251522623210">"Hentikan penyiapan &amp; setel ulang perangkat?"</string>
    <string name="this_will_reset_take_back_first_screen" msgid="4623290347188404725">"Tindakan ini akan menyetel ulang perangkat dan membawa Anda kembali ke layar pertama"</string>
    <string name="device_owner_cancel_message" msgid="2529288571742712065">"Berhenti menyiapkan dan hapus data perangkat?"</string>
    <string name="device_owner_cancel_cancel" msgid="1052951540909389275">"Batal"</string>
    <string name="device_owner_error_ok" msgid="2002250763093787051">"Oke"</string>
    <string name="reset" msgid="6467204151306265796">"Setel ulang"</string>
    <string name="cant_set_up_profile" msgid="4341825293970158436">"Tidak dapat menyiapkan profil"</string>
    <string name="cant_set_up_device" msgid="4120090138983350714">"Tidak dapat menyiapkan perangkat"</string>
    <string name="couldnt_set_up_device" msgid="5137950404283642302">"Tidak dapat menyiapkan perangkat. Hubungi admin IT Anda untuk mendapatkan bantuan."</string>
    <string name="contact_your_admin_for_help" msgid="2009904021552323731">"Hubungi admin IT Anda untuk mendapatkan bantuan"</string>
    <string name="device_already_set_up" msgid="507881934487140294">"Perangkat sudah disiapkan"</string>
    <string name="error_wifi" msgid="1850288843966836571">"Tidak dapat terhubung ke Wi-Fi"</string>
    <string name="device_has_reset_protection_contact_admin" msgid="2662050020376475656">"Perangkat telah mengaktifkan perlindungan penyetelan ulang. Hubungi admin IT untuk meminta bantuan."</string>
    <string name="frp_clear_progress_title" msgid="8628074089458234965">"Menghapus"</string>
    <string name="frp_clear_progress_text" msgid="1740164332830598827">"Harap tunggu..."</string>
    <string name="error_hash_mismatch" msgid="1145488923243178454">"Tidak dapat menggunakan aplikasi admin karena terjadi error checksum. Harap hubungi admin IT Anda untuk meminta bantuan."</string>
    <string name="error_download_failed" msgid="3274283629837019452">"Tidak dapat mendownload aplikasi admin"</string>
    <string name="error_package_invalid" msgid="555402554502033988">"Tidak dapat menggunakan aplikasi admin. Ada komponen yang hilang atau rusak. Harap hubungi admin IT untuk meminta bantuan."</string>
    <string name="error_installation_failed" msgid="2282903750318407285">"Tidak dapat menginstal aplikasi admin"</string>
    <string name="profile_owner_cancel_message" msgid="6868736915633023477">"Berhenti menyiapkan?"</string>
    <string name="profile_owner_cancel_cancel" msgid="4408725524311574891">"Tidak"</string>
    <string name="profile_owner_cancel_ok" msgid="5951679183850766029">"Ya"</string>
    <string name="profile_owner_cancelling" msgid="5679573829145112822">"Membatalkan…"</string>
    <string name="work_profile_setup_later_title" msgid="9069148190226279892">"Hentikan penyiapan profil?"</string>
    <string name="work_profile_setup_later_message" msgid="122069011117225292">"Anda dapat menyiapkan profil kerja nanti di aplikasi pengelolaan perangkat organisasi"</string>
    <string name="continue_button" msgid="7177918589510964446">"Lanjutkan"</string>
    <string name="work_profile_setup_stop" msgid="6772128629992514750">"Berhenti"</string>
    <string name="dismiss" msgid="9009534756748565880">"Tutup"</string>
    <string name="profile_owner_info" msgid="8975319972303812298">"Anda akan membuat profil kerja yang dikelola dan dipantau oleh organisasi Anda. Persyaratan berlaku."</string>
    <string name="profile_owner_info_with_terms_headers" msgid="7373591910245655373">"Anda akan membuat profil kerja yang dikelola dan dipantau oleh organisasi Anda. Persyaratan dari <xliff:g id="TERMS_HEADERS">%1$s</xliff:g> akan berlaku."</string>
    <string name="profile_owner_info_comp" msgid="9190421701126119142">"Profil akan dibuat untuk aplikasi kerja. Profil ini dan perangkat Anda akan dikelola serta dipantau oleh organisasi. Persyaratan berlaku."</string>
    <string name="profile_owner_info_with_terms_headers_comp" msgid="2012766614492554556">"Profil akan dibuat untuk aplikasi kerja. Profil ini dan perangkat Anda akan dikelola serta dipantau oleh organisasi. Persyaratan dari <xliff:g id="TERMS_HEADERS">%1$s</xliff:g> akan berlaku."</string>
    <string name="device_owner_info" msgid="3716661456037934467">"Perangkat ini akan dikelola, dipantau, dan dijaga keamanannya oleh <xliff:g id="YOUR_ORGANIZATION">%1$s</xliff:g>. Persyaratan berlaku. <xliff:g id="VIEW_TERMS">%2$s</xliff:g>"</string>
    <string name="device_owner_info_with_terms_headers" msgid="1254243288669282977">"Perangkat ini akan dikelola, dipantau, dan dijaga keamanannya oleh <xliff:g id="YOUR_ORGANIZATION">%1$s</xliff:g>. Persyaratan dari <xliff:g id="TERMS_HEADERS">%2$s</xliff:g> akan berlaku. <xliff:g id="VIEW_TERMS">%3$s</xliff:g>"</string>
    <string name="link_isnt_secure_and_cant_be_opened_until_device_setup_finished" msgid="1604497932637832657">"Link ini tidak aman dan tidak dapat dibuka sampai penyiapan perangkat selesai: <xliff:g id="LINK_RAW_TEST">%1$s</xliff:g>"</string>
    <string name="contact_device_provider" msgid="2843488903902493030">"Untuk mempelajari lebih lanjut, hubungi <xliff:g id="IT_ADMIN">%1$s</xliff:g> Anda."</string>
    <string name="if_questions_contact_admin" msgid="3509427015901582047">"Jika ada pertanyaan, hubungi admin IT"</string>
    <string name="setup_isnt_finished_contact_admin" msgid="8849644190723875952">"Penyiapan belum selesai. Hubungi admin IT untuk meminta bantuan."</string>
    <string name="for_help_contact_admin" msgid="5922538077702487859">"Hubungi admin IT Anda untuk meminta bantuan"</string>
    <string name="organization_admin" msgid="5975914478148511290">"Admin IT"</string>
    <string name="your_org_app_used" msgid="5336414768293540831">"<xliff:g id="YOUR_ORGANIZATION">%1$s</xliff:g> akan mengelola dan memantau perangkat ini menggunakan aplikasi berikut:"</string>
    <string name="your_organization_beginning" msgid="5952561489910967255">"Organisasi Anda"</string>
    <string name="your_organization_middle" msgid="8288538158061644733">"organisasi Anda"</string>
    <string name="view_terms" msgid="7230493092383341605">"Lihat persyaratan"</string>
    <string name="accept_and_continue" msgid="1632679734918410653">"Terima &amp; lanjutkan"</string>
    <string name="back" msgid="6455622465896147127">"Kembali"</string>
    <string name="set_up_your_device" msgid="1896651520959894681">"Siapkan perangkat"</string>
    <string name="info_anim_title_0" msgid="3285414600215959704">"Ubah cara kerja Anda"</string>
    <string name="info_anim_title_1" msgid="2657512519467714760">"Pisahkan data kerja dari data pribadi"</string>
    <string name="one_place_for_work_apps" msgid="2595597562302953960">"Satu tempat untuk aplikasi kerja"</string>
    <string name="info_anim_title_2" msgid="4629781398620470204">"Nonaktifkan profil kerja jika sudah selesai"</string>
    <string name="provisioning" msgid="4512493827019163451">"Penyediaan"</string>
    <string name="copying_certs" msgid="5697938664953550881">"Menyiapkan Sertifikat CA"</string>
    <string name="setup_profile" msgid="5573950582159698549">"Siapkan profil Anda"</string>
    <string name="profile_benefits_description" msgid="758432985984252636">"Dengan menggunakan profil kerja, Anda dapat memisahkan data kerja dari data pribadi"</string>
    <string name="comp_profile_benefits_description" msgid="379837075456998273">"Dengan menggunakan profil kerja, Anda dapat menyimpan aplikasi kerja di 1 tempat"</string>
    <string name="setup_profile_encryption" msgid="5241291404536277038">"Menyiapkan profil. Enkripsi"</string>
    <string name="setup_profile_progress" msgid="7742718527853325656">"Menyiapkan profil. Menampilkan kemajuan"</string>
    <string name="setup_device" msgid="6725265673245816366">"Siapkan perangkat Anda"</string>
    <string name="setup_device_encryption" msgid="7852944465414197103">"Menyiapkan perangkat. Enkripsi"</string>
    <string name="setup_device_progress" msgid="7035335208571175393">"Menyiapkan perangkat. Menampilkan kemajuan"</string>
    <string name="learn_more_label" msgid="2723716758654655009">"Tombol pelajari lebih lanjut"</string>
    <string name="mdm_icon_label" msgid="3399134595549660561">"Ikon <xliff:g id="ICON_LABEL">%1$s</xliff:g>"</string>
    <string name="section_heading" msgid="3924666803774291908">"Judul rubrik <xliff:g id="SECTION_HEADING">%1$s</xliff:g>."</string>
    <string name="section_content" msgid="8875502515704374394">"Konten rubrik <xliff:g id="SECTION_HEADING">%1$s</xliff:g>: <xliff:g id="SECTION_CONTENT">%2$s</xliff:g>"</string>
    <string name="expand" msgid="37188292156131304">"Luaskan"</string>
    <string name="collapse" msgid="7817530505064432580">"Ciutkan"</string>
    <string name="access_list_of_links" msgid="7094123315959323372">"Mengakses daftar link"</string>
    <string name="access_links" msgid="7991363727326168600">"Mengakses link"</string>
    <string name="access_terms" msgid="1982500872249763745">"Mengakses istilah"</string>
    <string name="read_terms" msgid="1745011123626640728">"Baca persyaratan"</string>
    <string name="close_list" msgid="9053538299788717597">"Tutup daftar"</string>
    <string name="cancel_setup_and_factory_reset_dialog_title" msgid="5416045931532004811">"Selesaikan dan kembalikan ke setelan pabrik?"</string>
    <string name="cancel_setup_and_factory_reset_dialog_msg" msgid="808442439937994485">"Menyelesaikan penyiapan ini akan mengembalikan perangkat ke setelan pabrik dan membawa Anda kembali ke layar pertama."</string>
    <string name="cancel_setup_and_factory_reset_dialog_cancel" msgid="2810966091829264727">"Batal"</string>
    <string name="cancel_setup_and_factory_reset_dialog_ok" msgid="7168008267496150529">"Setel ulang perangkat"</string>
    <string name="join_two_items" msgid="6110273439759895837">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g> dan <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_last" msgid="7469666990442158802">"<xliff:g id="ALL_BUT_LAST_ITEM">%1$s</xliff:g>, dan <xliff:g id="LAST_ITEM_0">%2$s</xliff:g>"</string>
    <string name="join_many_items_first" msgid="8365482726853276608">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="ALL_BUT_FIRST_AND_LAST_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_middle" msgid="8569294838319639963">"<xliff:g id="ADDED_ITEM">%1$s</xliff:g>, <xliff:g id="REST_OF_ITEMS">%2$s</xliff:g>"</string>
    <string name="take_a_few_minutes" msgid="6282806501305322838">"Proses ini mungkin perlu beberapa menit"</string>
    <string name="work_profile_description" msgid="8524116010729569213">"Aplikasi kerja Anda akan disimpan di profil ini dan dikelola oleh organisasi"</string>
    <string name="device_owner_description" msgid="168013145812679664">"Perangkat ini akan dijaga agar tetap aman dan dikelola oleh organisasi Anda"</string>
    <string name="setup_provisioning_header" msgid="4282483198266806271">"Bersiap menyiapkan perangkat kerja…"</string>
    <string name="setup_provisioning_header_description" msgid="2567041263563823566">"Menyiapkan aplikasi admin"</string>
    <string name="set_up_everything_else" msgid="4407706086957916501">"Menyiapkan lainnya"</string>
    <string name="now_lets_set_up_everything_else" msgid="2905102208584231894">"Sekarang, mari siapkan lainnya"</string>
    <string name="brand_screen_header" msgid="8865808542690116648">"Perangkat ini milik organisasi"</string>
    <string name="brand_screen_subheader" msgid="7664792208784456436">"Aplikasi berikut akan digunakan untuk mengelola dan memantau ponsel ini"</string>
    <string name="downloading_administrator_header" msgid="8660294318893902915">"Menyiapkan perangkat untuk kerja…"</string>
    <string name="work_profile_provisioning_accept_header" msgid="462916780311392444">"Pertama-tama, mari siapkan profil kerja Anda"</string>
    <string name="work_profile_provisioning_accept_header_post_suw" msgid="1353127953275291089">"Mari siapkan profil kerja Anda"</string>
    <string name="work_profile_provisioning_step_1_header" msgid="7914961694921466366">"Aplikasi kerja disimpan dalam profil kerja Anda"</string>
    <string name="work_profile_provisioning_step_2_header" msgid="6001172190404670248">"Jeda aplikasi kerja saat Anda selesai bekerja untuk hari itu"</string>
    <string name="work_profile_provisioning_step_3_header" msgid="7495564624887776704">"Hanya data dalam profil kerja Anda yang terlihat oleh admin IT"</string>
    <string name="work_profile_provisioning_progress_label" msgid="2627905308998389193">"Menyiapkan profil kerja…"</string>
    <string name="work_profile_provisioning_summary" msgid="3917907344897144246">"Aplikasi kerja disimpan dalam profil kerja Anda. Aplikasi kerja dapat dijeda saat Anda selesai bekerja untuk hari itu. Hanya data dalam profil kerja Anda yang terlihat oleh admin IT."</string>
    <string name="fully_managed_device_provisioning_accept_header" msgid="2944032660440403130">"Mari siapkan perangkat kerja Anda"</string>
    <string name="fully_managed_device_provisioning_step_1_header" msgid="6396274703116708592">"Simpan aplikasi kerja di tempat yang mudah Anda akses"</string>
    <string name="fully_managed_device_provisioning_step_2_header" msgid="7165472083121590030">"Perangkat ini tidak bersifat pribadi"</string>
    <string name="fully_managed_device_provisioning_step_2_subheader" msgid="2848998570491578119">"Admin IT mungkin dapat melihat data dan aktivitas Anda di perangkat ini."</string>
    <string name="fully_managed_device_provisioning_progress_label" msgid="3925516135130021966">"Menyiapkan perangkat…"</string>
    <string name="fully_managed_device_provisioning_summary" msgid="1176062866187662479">"Gunakan perangkat ini untuk mengakses aplikasi kerja Anda dengan mudah. Perangkat ini tidak bersifat pribadi, jadi admin IT mungkin dapat melihat data dan aktivitas Anda. Untuk mempelajari lebih lanjut, hubungi admin IT Anda."</string>
    <string name="fully_managed_device_provisioning_privacy_title" msgid="4017627906103556021">"Pengingat privasi"</string>
    <string name="fully_managed_device_provisioning_privacy_body" msgid="2219074604343348608">"Admin IT mungkin dapat melihat data dan aktivitas Anda di perangkat ini"</string>
    <string name="device_provisioning_finished" msgid="3981783240592092906">"Perangkat Anda siap digunakan!"</string>
    <string name="done" msgid="7755227776955952318">"Selesai"</string>
</resources>
