b'DocType: Employee',b'Salary Mode',b'Mode Gaji'
b'DocType: Patient',b'Divorced',b'Bercerai'
b'DocType: Buying Settings',b'Allow Item to be added multiple times in a transaction',b'Izinkan Stok Barang yang sama untuk ditambahkan beberapa kali dalam suatu transaksi'
b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33',b'Cancel Material Visit {0} before cancelling this Warranty Claim',b'Batal Bahan Kunjungan {0} sebelum membatalkan Garansi Klaim ini'
b'apps/erpnext/erpnext/config/education.py +118',b'Assessment Reports',b'Laporan Penilaian'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19',b'Consumer Products',b'Produk Pelanggan'
b'DocType: Purchase Receipt',b'Subscription Detail',b'Detail Langganan'
b'DocType: Supplier Scorecard',b'Notify Supplier',b'Beritahu Pemasok'
b'DocType: Item',b'Customer Items',b'Produk Pelanggan'
b'DocType: Project',b'Costing and Billing',b'Biaya dan Penagihan'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +48',b'Account {0}: Parent account {1} can not be a ledger',b'Akun {0}: akun Induk {1} tidak dapat berupa buku besar'
b'DocType: Item',b'Publish Item to hub.erpnext.com',b'Publikasikan Item untuk hub.erpnext.com'
b'apps/erpnext/erpnext/config/setup.py +88',b'Email Notifications',b'Notifikasi Email'
b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26',b'Evaluation',b'Evaluasi'
b'DocType: Item',b'Default Unit of Measure',b'Standar Satuan Ukur'
b'DocType: SMS Center',b'All Sales Partner Contact',b'Semua Kontak Mitra Penjualan'
b'DocType: Employee',b'Leave Approvers',b'Approval Cuti'
b'DocType: Sales Partner',b'Dealer',b'Dealer (Pelaku)'
b'DocType: Work Order',b'WO-',b'WO-'
b'DocType: Consultation',b'Investigations',b'Investigasi'
b'DocType: Restaurant Order Entry',b'Click Enter To Add',b'Klik Enter To Add'
b'DocType: Employee',b'Rented',b'Sewaan'
b'DocType: Purchase Order',b'PO-',b'po'
b'DocType: Vehicle Service',b'Mileage',b'Jarak tempuh'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +253',b'Do you really want to scrap this asset?',b'Apakah Anda benar-benar ingin membatalkan aset ini?'
b'DocType: Drug Prescription',b'Update Schedule',b'Perbarui Jadwal'
b'apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44',b'Select Default Supplier',b'Pilih Default Pemasok'
b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37',b'Currency is required for Price List {0}',b'Mata Uang diperlukan untuk Daftar Harga {0}'
b'DocType: Sales Taxes and Charges Template',b'* Will be calculated in the transaction.',b'* Akan dihitung dalam transaksi.'
b'DocType: Purchase Order',b'Customer Contact',b'Kontak Pelanggan'
b'DocType: Patient Appointment',b'Check availability',b'Cek ketersediaan'
b'DocType: Job Applicant',b'Job Applicant',b'Pemohon Kerja'
b'apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6',b'This is based on transactions against this Supplier. See timeline below for details',b'Hal ini didasarkan pada transaksi terhadap Pemasok ini. Lihat timeline di bawah untuk rincian'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120',b'Legal',b'Hukum'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191',b'Actual type tax cannot be included in Item rate in row {0}',b'Jenis pajak aktual tidak dapat dimasukkan dalam tarif di baris {0}'
b'DocType: Bank Guarantee',b'Customer',b'Pelanggan'
b'DocType: Purchase Receipt Item',b'Required By',b'Diperlukan Oleh'
b'DocType: Delivery Note',b'Return Against Delivery Note',b'Retur Terhadap Nota Pengiriman'
b'DocType: Purchase Order',b'% Billed',b'Ditagih %'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43',b'Exchange Rate must be same as {0} {1} ({2})',b'Kurs harus sama dengan {0} {1} ({2})'
b'DocType: Sales Invoice',b'Customer Name',b'Nama Pelanggan'
b'DocType: Vehicle',b'Natural Gas',b'Gas alam'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64',b'Bank account cannot be named as {0}',b'Rekening bank tidak dapat namakan sebagai {0}'
b'DocType: Account',b'Heads (or groups) against which Accounting Entries are made and balances are maintained.',b'Kepala (atau kelompok) terhadap yang Entri Akuntansi dibuat dan saldo dipertahankan.'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196',b'Outstanding for {0} cannot be less than zero ({1})',b'Posisi untuk {0} tidak bisa kurang dari nol ({1})'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +348',b'There are no submitted Salary Slips to process.',b'Tidak ada slip Saldo yang diajukan untuk diproses.'
b'DocType: Manufacturing Settings',b'Default 10 mins',b'Standar 10 menit'
b'DocType: Leave Type',b'Leave Type Name',b'Nama Tipe Cuti'
b'apps/erpnext/erpnext/templates/pages/projects.js +62',b'Show open',b'Tampilkan terbuka'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8',b'It is necessary to take this action today itself for the above mentioned recurring',b'Hal ini diperlukan untuk mengambil tindakan ini hari ini sendiri untuk berulang di atas'
b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +156',b'Series Updated Successfully',b'Nomor Seri Berhasil Diperbarui'
b'apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6',b'Checkout',b'Periksa'
b'DocType: Pricing Rule',b'Apply On',b'Terapkan Pada'
b'DocType: Item Price',b'Multiple Item prices.',b'Multiple Item harga.'
,b'Purchase Order Items To Be Received',b'Order Pembelian Stok Barang Akan Diterima'
b'DocType: SMS Center',b'All Supplier Contact',b'Kontak semua Supplier'
b'DocType: Support Settings',b'Support Settings',b'Pengaturan dukungan'
b'apps/erpnext/erpnext/projects/doctype/project/project.py +75',b'Expected End Date can not be less than Expected Start Date',b'Diharapkan Tanggal Berakhir tidak bisa kurang dari yang diharapkan Tanggal Mulai'
b'apps/erpnext/erpnext/utilities/transaction_base.py +121',b'Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ',b'Row # {0}: Tingkat harus sama dengan {1}: {2} ({3} / {4})'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +241',b'New Leave Application',b'Aplikasi Cuti Baru'
,b'Batch Item Expiry Status',b'Status Kadaluarsa Persediaan Batch'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184',b'Bank Draft',b'Bank Draft'
b'DocType: Membership',b'membership validaty section',b'bagian keanggotaan validitas'
b'DocType: Mode of Payment Account',b'Mode of Payment Account',b'Mode Akun Pembayaran Rekening'
b'DocType: Consultation',b'Consultation',b'Konsultasi'
b'DocType: Accounts Settings',b'Show Payment Schedule in Print',b'Tampilkan Jadwal Pembayaran di Cetak'
b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19',b'Sales and Returns',b'Penjualan dan Pengembalian'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +56',b'Show Variants',b'Tampilkan Varian'
b'DocType: Academic Term',b'Academic Term',b'Jangka Akademis'
b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14',b'Material',b'Bahan'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66',b'Making website',b'Membuat website'
b'DocType: Opening Invoice Creation Tool Item',b'Quantity',b'Kuantitas'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546',b'Accounts table cannot be blank.',b'Tabel account tidak boleh kosong.'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154',b'Loans (Liabilities)',b'Kredit (Kewajiban)'
b'DocType: Employee Education',b'Year of Passing',b'Tahun Berjalan'
b'DocType: Item',b'Country of Origin',b'Negara Asal'
b'DocType: Soil Texture',b'Soil Texture Criteria',b'Kriteria Tekstur Tanah'
b'apps/erpnext/erpnext/templates/includes/product_page.js +25',b'In Stock',b'Dalam Persediaan'
b'apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16',b'Primary Contact Details',b'Rincian Kontak Utama'
b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46',b'Open Issues',b'terbuka Isu'
b'DocType: Production Plan Item',b'Production Plan Item',b'Rencana Produksi Stok Barang'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +149',b'User {0} is already assigned to Employee {1}',b'Pengguna {0} sudah ditugaskan untuk Karyawan {1}'
b'DocType: Lab Test Groups',b'Add new line',b'Tambahkan baris baru'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31',b'Health Care',b'Kesehatan'
b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65',b'Delay in payment (Days)',b'Keterlambatan pembayaran (Hari)'
b'DocType: Payment Terms Template Detail',b'Payment Terms Template Detail',b'Rincian Syarat Pembayaran'
b'DocType: Hotel Room Reservation',b'Guest Name',b'Nama tamu'
b'DocType: Lab Prescription',b'Lab Prescription',b'Resep Lab'
,b'Delay Days',b'Tunda hari'
b'apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26',b'Service Expense',b'Beban layanan'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +899',b'Serial Number: {0} is already referenced in Sales Invoice: {1}',b'Nomor Seri: {0} sudah dirujuk dalam Faktur Penjualan: {1}'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +889',b'Invoice',b'Faktur'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +145',b'Make Retention Stock Entry',b'Buat Entri Stok Retensi'
b'DocType: Purchase Invoice Item',b'Item Weight Details',b'Rincian Berat Item'
b'DocType: Asset Maintenance Log',b'Periodicity',b'Periode'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21',b'Fiscal Year {0} is required',b'Tahun fiskal {0} diperlukan'
b'DocType: Crop Cycle',b'The minimum distance between rows of plants for optimum growth',b'Jarak minimum antara deretan tanaman untuk pertumbuhan optimum'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21',b'Defense',b'Pertahanan'
b'DocType: Salary Component',b'Abbr',b'Singkatan'
b'DocType: Appraisal Goal',b'Score (0-5)',b'Skor (0-5)'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +225',b'Row {0}: {1} {2} does not match with {3}',b'Baris {0}: {1} {2} tidak cocok dengan {3}'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +77',b'Row # {0}:',b'Row # {0}:'
b'DocType: Timesheet',b'Total Costing Amount',b'Jumlah Total Biaya'
b'DocType: Delivery Note',b'Vehicle No',b'Nomor Kendaraan'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +163',b'Please select Price List',b'Silakan pilih Daftar Harga'
b'DocType: Accounts Settings',b'Currency Exchange Settings',b'Pengaturan Pertukaran Mata Uang'
b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +94',b'Row #{0}: Payment document is required to complete the trasaction',b'Row # {0}: Dokumen Pembayaran diperlukan untuk menyelesaikan trasaction yang'
b'DocType: Work Order Operation',b'Work In Progress',b'Pekerjaan dalam proses'
b'apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13',b'Please select date',b'Silakan pilih tanggal'
b'DocType: Daily Work Summary Group',b'Holiday List',b'Daftar Hari Libur'
b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88',b'Please setup numbering series for Attendance via Setup &gt; Numbering Series',b'Silakan mengatur seri penomoran untuk Kehadiran melalui Pengaturan&gt; Seri Penomoran'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127',b'Accountant',b'Akuntan'
b'DocType: Hub Settings',b'Selling Price List',b'Daftar Harga Jual'
b'DocType: Patient',b'Tobacco Current Use',b'Penggunaan Saat Ini Tembakau'
b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +56',b'Selling Rate',b'Tingkat penjualan'
b'DocType: Cost Center',b'Stock User',b'Pengguna Persediaan'
b'DocType: Soil Analysis',b'(Ca+Mg)/K',b'(Ca+Mg)/K'
b'DocType: Company',b'Phone No',b'No Telepon yang'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +239',b'New {0}: #{1}',b'Baru {0}: # {1}'
b'DocType: Delivery Trip',b'Initial Email Notification Sent',b'Pemberitahuan email awal terkirim'
,b'Sales Partners Commission',b'Komisi Mitra Penjualan'
b'DocType: Soil Texture',b'Sandy Clay Loam',b'Sandy Clay Loam'
b'DocType: Purchase Invoice',b'Rounding Adjustment',b'Penyesuaian Pembulatan'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +46',b'Abbreviation cannot have more than 5 characters',b'Singkatan tidak boleh melebihi 5 karakter'
b'DocType: Physician Schedule Time Slot',b'Physician Schedule Time Slot',b'Jadwal Waktu Slot Dokter'
b'DocType: Payment Request',b'Payment Request',b'Permintaan pembayaran'
b'DocType: Asset',b'Value After Depreciation',b'Nilai Setelah Penyusutan'
b'DocType: Student',b'O+',b'O +'
b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan_dashboard.py +8',b'Related',b'terkait'
b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43',"b""Attendance date can not be less than employee's joining date""",b'tanggal kehadiran tidak bisa kurang dari tanggal bergabung karyawan'
b'DocType: Grading Scale',b'Grading Scale Name',b'Skala Grading Nama'
b'DocType: Subscription',b'Repeat on Day',b'Ulangi pada hari'
b'apps/erpnext/erpnext/accounts/doctype/account/account.js +41',b'This is a root account and cannot be edited.',b'Ini adalah account root dan tidak dapat diedit.'
b'DocType: Sales Invoice',b'Company Address',b'Alamat perusahaan'
b'DocType: BOM',b'Operations',b'Operasi'
b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38',b'Cannot set authorization on basis of Discount for {0}',b'Tidak dapat mengatur otorisasi atas dasar Diskon untuk {0}'
b'DocType: Rename Tool',"b'Attach .csv file with two columns, one for the old name and one for the new name'","b'Melampirkan file .csv dengan dua kolom, satu untuk nama lama dan satu untuk nama baru'"
b'apps/erpnext/erpnext/accounts/utils.py +73',b'{0} {1} not in any active Fiscal Year.',b'{0} {1} tidak dalam Tahun Anggaran aktif.'
b'DocType: Packed Item',b'Parent Detail docname',b'Induk Detil docname'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69',"b'Reference: {0}, Item Code: {1} and Customer: {2}'","b'Referensi: {0}, Kode Item: {1} dan Pelanggan: {2}'"
b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Kg',b'Kg'
b'apps/erpnext/erpnext/config/hr.py +45',b'Opening for a Job.',b'Lowongan untuk Pekerjaan.'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +114',b'BOM is not specified for subcontracting item {0} at row {1}',b'BOM belum ditentukan untuk subkontrak barang {0} pada baris {1}'
b'apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149',b'{0} Result submittted',b'{0} Hasil terkirim'
b'DocType: Item Attribute',b'Increment',b'Kenaikan'
b'apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +74',b'Timespan',b'Rentang waktu'
b'apps/erpnext/erpnext/public/js/stock_analytics.js +58',b'Select Warehouse...',b'Pilih Gudang ...'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6',b'Advertising',b'Periklanan (Promosi)'
b'apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22',b'Same Company is entered more than once',b'Perusahaan yang sama dimasukkan lebih dari sekali'
b'DocType: Patient',b'Married',b'Menikah'
b'apps/erpnext/erpnext/accounts/party.py +41',b'Not permitted for {0}',b'Tidak diizinkan untuk {0}'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593',b'Get items from',b'Mendapatkan Stok Barang-Stok Barang dari'
b'DocType: Price List',b'Price Not UOM Dependant',b'Harga UOM Tidak Tergantung'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +467',b'Stock cannot be updated against Delivery Note {0}',b'Persediaan tidak dapat diperbarui terhadap Nota Pengiriman {0}'
b'apps/erpnext/erpnext/templates/pages/home.py +25',b'Product {0}',b'Produk {0}'
b'apps/erpnext/erpnext/templates/generators/item_group.html +43',b'No items listed',b'Tidak ada item yang terdaftar'
b'DocType: Asset Repair',b'Error Description',b'Deskripsi kesalahan'
b'DocType: Payment Reconciliation',b'Reconcile',b'Rekonsiliasi'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30',b'Grocery',b'Toko Kelontongan'
b'DocType: Quality Inspection Reading',b'Reading 1',b'Membaca 1'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40',b'Pension Funds',b'Dana pensiun'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +91',b'Next Depreciation Date cannot be before Purchase Date',b'Berikutnya Penyusutan Tanggal tidak boleh sebelum Tanggal Pembelian'
b'DocType: Crop',b'Perennial',b'Abadi'
b'DocType: Consultation',b'Consultation Date',b'Tanggal Konsultasi'
b'DocType: Accounts Settings',b'Use Custom Cash Flow Format',b'Gunakan Format Arus Kas Khusus'
b'DocType: SMS Center',b'All Sales Person',b'Semua Salesmen'
b'DocType: Monthly Distribution',b'**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.',b'** Distribusi Bulanan ** membantu Anda mendistribusikan Anggaran / Target di antara bulan-bulan jika bisnis Anda memiliki musim.'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1753',b'Not items found',b'Tidak item yang ditemukan'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +184',b'Salary Structure Missing',b'Struktur Gaji Hilang'
b'DocType: Lead',b'Person Name',b'Nama orang'
b'DocType: Sales Invoice Item',b'Sales Invoice Item',b'Faktur Penjualan Stok Barang'
b'DocType: Account',b'Credit',b'Kredit'
b'DocType: POS Profile',b'Write Off Cost Center',b'Write Off Biaya Pusat'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +117',"b'e.g. ""Primary School"" or ""University""'",b'misalnya &quot;Sekolah Dasar&quot; atau &quot;Universitas&quot;'
b'apps/erpnext/erpnext/config/stock.py +28',b'Stock Reports',b'Laporan Persediaan'
b'DocType: Warehouse',b'Warehouse Detail',b'Detail Gudang'
b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +33',b'The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.',b'Jangka Tanggal Akhir tidak bisa lebih lambat dari Akhir Tahun Tanggal Tahun Akademik yang istilah terkait (Tahun Akademik {}). Perbaiki tanggal dan coba lagi.'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +269',"b'""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item'","b'""Aset Tetap"" tidak dapat tidak dicentang, karena ada data Asset terhadap barang'"
b'DocType: Delivery Trip',b'Departure Time',b'Waktu keberangkatan'
b'DocType: Vehicle Service',b'Brake Oil',b'Minyak Rem'
b'DocType: Tax Rule',b'Tax Type',b'Jenis pajak'
,b'Completed Work Orders',b'Perintah Kerja Selesai'
b'apps/erpnext/erpnext/controllers/taxes_and_totals.py +581',b'Taxable Amount',b'Jumlah Kena Pajak'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160',b'You are not authorized to add or update entries before {0}',b'Anda tidak diizinkan menambah atau memperbarui entri sebelum {0}'
b'DocType: BOM',b'Item Image (if not slideshow)',b'Gambar Stok Barang (jika tidak slideshow)'
b'DocType: Work Order Operation',b'(Hour Rate / 60) * Actual Operation Time',b'(Tarif per Jam / 60) * Masa Beroperasi Sebenarnya'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1103',b'Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry',b'Baris # {0}: Jenis Dokumen Referensi harus menjadi salah satu Klaim Biaya atau Entri Jurnal'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +975',b'Select BOM',b'Pilih BOM'
b'DocType: SMS Log',b'SMS Log',b'SMS Log'
b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27',b'Cost of Delivered Items',b'Biaya Produk Terkirim'
b'apps/erpnext/erpnext/config/hr.py +127',b'Manage advance amount given to the Employee',b'Mengelola jumlah uang muka yang diberikan kepada Karyawan'
b'apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38',b'The holiday on {0} is not between From Date and To Date',b'Liburan di {0} bukan antara Dari Tanggal dan To Date'
b'DocType: Student Log',b'Student Log',b'Mahasiswa Log'
b'apps/erpnext/erpnext/config/buying.py +165',b'Templates of supplier standings.',b'Template dari klasemen pemasok.'
b'DocType: Lead',b'Interested',b'Tertarik'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +216',b'Opening',b'Pembukaan'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +32',b'From {0} to {1}',b'Dari {0} ke {1}'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +234',b'Program: ',b'Program:'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50',b'Failed to setup taxes',b'Gagal menyetorkan pajak'
b'DocType: Item',b'Copy From Item Group',b'Salin Dari Grup Stok Barang'
b'DocType: Delivery Trip',b'Delivery Notification',b'Pemberitahuan pengiriman'
b'DocType: Journal Entry',b'Opening Entry',b'Entri Pembukaan'
b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25',b'Account Pay Only',b'Akun Pembayaran Saja'
b'DocType: Employee Loan',b'Repay Over Number of Periods',b'Membayar Lebih dari Jumlah Periode'
b'DocType: Stock Entry',b'Additional Costs',b'Biaya-biaya tambahan'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +138',b'Account with existing transaction can not be converted to group.',b'Akun dengan transaksi yang ada tidak dapat dikonversi ke grup.'
b'DocType: Lead',b'Product Enquiry',b'Produk Enquiry'
b'DocType: Education Settings',b'Validate Batch for Students in Student Group',b'Validasi Batch untuk Siswa di Kelompok Pelajar'
b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35',b'No leave record found for employee {0} for {1}',b'Tidak ada cuti record yang ditemukan untuk karyawan {0} untuk {1}'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23',b'Please enter company first',b'Silahkan masukkan perusahaan terlebih dahulu'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +365',b'Please select Company first',b'Silakan pilih Perusahaan terlebih dahulu'
b'DocType: Employee Education',b'Under Graduate',b'Sarjana'
b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27',b'Target On',b'Sasaran On'
b'DocType: BOM',b'Total Cost',b'Total Biaya'
b'DocType: Soil Analysis',b'Ca/K',b'Ca / K'
b'DocType: Journal Entry Account',b'Employee Loan',b'Pinjaman karyawan'
b'DocType: Fee Schedule',b'Send Payment Request Email',b'Kirim Permintaan Pembayaran Email'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +268',b'Item {0} does not exist in the system or has expired',b'Item {0} tidak ada dalam sistem atau telah berakhir'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44',b'Real Estate',b'Real Estate'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1',b'Statement of Account',b'Laporan Rekening'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41',b'Pharmaceuticals',b'Farmasi'
b'DocType: Purchase Invoice Item',b'Is Fixed Asset',b'Apakah Aset Tetap'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +273',"b'Available qty is {0}, you need {1}'","b'Tersedia qty adalah {0}, Anda perlu {1}'"
b'DocType: Expense Claim Detail',b'Claim Amount',b'Nilai Klaim'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +653',b'Work Order has been {0}',b'Perintah Kerja telah {0}'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56',b'Duplicate customer group found in the cutomer group table',b'kelompok pelanggan duplikat ditemukan di tabel kelompok cutomer'
b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31',b'Supplier Type / Supplier',b'Supplier Type / Supplier'
b'DocType: Naming Series',b'Prefix',b'Awalan'
b'apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7',b'Event Location',b'Lokasi acara'
b'DocType: Asset Settings',b'Asset Settings',b'Pengaturan Aset'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68',b'Consumable',b'Consumable'
b'DocType: Student',b'B-',b'B-'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +98',b'Successfully unregistered.',b'Berhasil tidak terdaftar'
b'DocType: Assessment Result',b'Grade',b'Kelas'
b'DocType: Restaurant Table',b'No of Seats',b'Tidak ada tempat duduk'
b'DocType: Subscription',"b'To add dynamic subject, use jinja tags like\n\n<div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>'","b'Untuk menambahkan subjek dinamis, gunakan tag jinja seperti <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>'"
b'DocType: Sales Invoice Item',b'Delivered By Supplier',b'Terkirim Oleh Supplier'
b'DocType: Asset Maintenance Task',b'Asset Maintenance Task',b'Tugas Pemeliharaan Aset'
b'DocType: SMS Center',b'All Contact',b'Semua Kontak'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232',b'Annual Salary',b'Gaji Tahunan'
b'DocType: Daily Work Summary',b'Daily Work Summary',b'Ringkasan Pekerjaan sehari-hari'
b'DocType: Period Closing Voucher',b'Closing Fiscal Year',b'Penutup Tahun Anggaran'
b'apps/erpnext/erpnext/accounts/party.py +392',b'{0} {1} is frozen',b'{0} {1} dibekukan'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +140',b'Please select Existing Company for creating Chart of Accounts',b'Silakan pilih Perusahaan yang ada untuk menciptakan Chart of Account'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80',b'Stock Expenses',b'Beban Persediaan'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +111',b'Select Target Warehouse',b'Pilih Target Warehouse'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.js +80',b'Please enter Preferred Contact Email',b'Silahkan masukkan Kontak Email Utama'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45',b'CompAuxNum',b'CompAuxNum'
b'DocType: Journal Entry',b'Contra Entry',b'Contra Entri'
b'DocType: Journal Entry Account',b'Credit in Company Currency',b'Kredit di Perusahaan Mata'
b'DocType: Lab Test UOM',b'Lab Test UOM',b'Uji Lab UOM'
b'DocType: Delivery Note',b'Installation Status',b'Status Instalasi'
b'DocType: BOM',b'Quality Inspection Template',b'Template Inspeksi Kualitas'
b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +135',b'Do you want to update attendance?<br>Present: {0}\\\n\t\t\t\t\t<br>Absent: {1}',b'Apakah Anda ingin memperbarui kehadiran? <br> Hadir: {0} \\ <br> Absen: {1}'
b'apps/erpnext/erpnext/controllers/buying_controller.py +334',b'Accepted + Rejected Qty must be equal to Received quantity for Item {0}',b'Jumlah Diterima + Ditolak harus sama dengan jumlah yang diterima untuk Item {0}'
b'DocType: Request for Quotation',b'RFQ-',b'RFQ-'
b'DocType: Item',b'Supply Raw Materials for Purchase',b'Bahan pasokan baku untuk Pembelian'
b'DocType: Agriculture Analysis Criteria',b'Fertilizer',b'Pupuk'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +152',b'At least one mode of payment is required for POS invoice.',b'Setidaknya satu cara pembayaran diperlukan untuk POS faktur.'
b'DocType: Products Settings',b'Show Products as a List',b'Tampilkan Produk sebagai sebuah Daftar'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +532',b'Item {0} is not active or end of life has been reached',b'Item {0} tidak aktif atau akhir hidup telah tercapai'
b'DocType: Student Admission Program',b'Minimum Age',b'Usia Minimum'
b'apps/erpnext/erpnext/utilities/user_progress.py +190',b'Example: Basic Mathematics',b'Contoh: Matematika Dasar'
b'DocType: Customer',b'Primary Address',b'alamat utama'
b'DocType: Production Plan',b'Material Request Detail',b'Detail Permintaan Material'
b'DocType: Selling Settings',b'Default Quotation Validity Days',b'Hari Validasi Kutipan Default'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +800',"b'To include tax in row {0} in Item rate, taxes in rows {1} must also be included'","b'Untuk mencakup pajak berturut-turut {0} di tingkat Stok Barang, pajak dalam baris {1} juga harus disertakan'"
b'apps/erpnext/erpnext/config/hr.py +223',b'Settings for HR Module',b'Pengaturan untuk modul HR'
b'DocType: SMS Center',b'SMS Center',b'SMS Center'
b'DocType: Sales Invoice',b'Change Amount',b'perubahan Jumlah'
b'DocType: GST Settings',b'Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.',b'Tetapkan Nilai Faktur untuk B2C. B2CL dan B2CS dihitung berdasarkan nilai faktur ini.'
b'DocType: BOM Update Tool',b'New BOM',b'BOM Baru'
b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36',b'Show only POS',b'Hanya tampilkan POS'
b'DocType: Driver',b'Driving License Categories',b'Kategori Lisensi Mengemudi'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118',b'Please enter Delivery Date',b'Harap masukkan Tanggal Pengiriman'
b'DocType: Depreciation Schedule',b'Make Depreciation Entry',b'Membuat Penyusutan Masuk'
b'DocType: Appraisal Template Goal',b'KRA',b'KRA'
b'DocType: Lead',b'Request Type',b'Permintaan Type'
b'apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +17',b'Make Employee',b'membuat Karyawan'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14',b'Broadcasting',b'Penyiaran'
b'apps/erpnext/erpnext/config/accounts.py +313',b'Setup mode of POS (Online / Offline)',b'Modus setup POS (Online / Offline)'
b'DocType: Manufacturing Settings',b'Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order',b'Menonaktifkan pembuatan log waktu terhadap Perintah Kerja. Operasi tidak akan dilacak terhadap Perintah Kerja'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191',b'Execution',b'Eksekusi'
b'apps/erpnext/erpnext/config/manufacturing.py +62',b'Details of the operations carried out.',b'Rincian operasi yang dilakukan.'
b'DocType: Asset Maintenance Log',b'Maintenance Status',b'Status pemeliharaan'
b'apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10',b'Membership Details',b'Rincian Keanggotaan'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56',b'{0} {1}: Supplier is required against Payable account {2}',b'{0} {1}: Pemasok diperlukan untuk akun Hutang {2}'
b'apps/erpnext/erpnext/config/selling.py +52',b'Items and Pricing',b'Item dan Harga'
b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2',b'Total hours: {0}',b'Jumlah jam: {0}'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43',b'From Date should be within the Fiscal Year. Assuming From Date = {0}',b'Dari tanggal harus dalam Tahun Anggaran. Dengan asumsi Dari Tanggal = {0}'
b'DocType: Drug Prescription',b'Interval',b'Selang'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +253',b'Preference',b'Pilihan'
b'DocType: Grant Application',b'Individual',b'Individu'
b'DocType: Academic Term',b'Academics User',b'Pengguna Akademis'
b'DocType: Cheque Print Template',b'Amount In Figure',b'Jumlah Dalam Gambar'
b'DocType: Employee Loan Application',b'Loan Info',b'Info kredit'
b'apps/erpnext/erpnext/config/maintenance.py +12',b'Plan for maintenance visits.',b'Rencana kunjungan pemeliharaan.'
b'DocType: Supplier Scorecard Period',b'Supplier Scorecard Period',b'Periode Scorecard Supplier'
b'DocType: Share Transfer',b'Share Transfer',b'Bagikan Transfer'
b'DocType: POS Profile',b'Customer Groups',b'Grup Pelanggan'
b'apps/erpnext/erpnext/public/js/financial_statements.js +51',b'Financial Statements',b'Laporan keuangan'
b'DocType: Guardian',b'Students',b'siswa'
b'apps/erpnext/erpnext/config/selling.py +91',b'Rules for applying pricing and discount.',b'Aturan untuk menerapkan harga dan diskon.'
b'DocType: Daily Work Summary',b'Daily Work Summary Group',b'Kelompok Ringkasan Pekerjaan Harian'
b'DocType: Physician Schedule',b'Time Slots',b'Slot waktu'
b'apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14',b'Price List must be applicable for Buying or Selling',b'Harga List harus berlaku untuk Membeli atau Jual'
b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79',b'Installation date cannot be before delivery date for Item {0}',b'Tanggal instalasi tidak bisa sebelum tanggal pengiriman untuk Item {0}'
b'DocType: Pricing Rule',b'Discount on Price List Rate (%)',b'Diskon Harga Daftar Rate (%)'
b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112',b'Item Template',b'Item Template'
b'apps/erpnext/erpnext/healthcare/setup.py +215',b'Biochemistry',b'Biokimia'
b'DocType: Job Offer',b'Select Terms and Conditions',b'Pilih Syarat dan Ketentuan'
b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72',b'Out Value',b'out Nilai'
b'DocType: Production Plan',b'Sales Orders',b'Order Penjualan'
b'DocType: Purchase Taxes and Charges',b'Valuation',b'Valuation'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +390',b'Set as Default',b'Set sebagai Default'
b'DocType: Production Plan',b'PLN-',b'PLN-'
,b'Purchase Order Trends',b'Trend Order Pembelian'
b'apps/erpnext/erpnext/utilities/user_progress.py +78',b'Go to Customers',b'Pergi ke pelanggan'
b'DocType: Hotel Room Reservation',b'Late Checkin',b'Late Checkin'
b'apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7',b'The request for quotation can be accessed by clicking on the following link',b'Permintaan untuk kutipan dapat diakses dengan mengklik link berikut'
b'apps/erpnext/erpnext/config/hr.py +81',b'Allocate leaves for the year.',b'Alokasi cuti untuk tahun berjalan.'
b'DocType: SG Creation Tool Course',b'SG Creation Tool Course',b'SG Penciptaan Alat Course'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +275',b'Insufficient Stock',b'Persediaan tidak cukup'
b'DocType: Manufacturing Settings',b'Disable Capacity Planning and Time Tracking',b'Nonaktifkan Perencanaan Kapasitas dan Waktu Pelacakan'
b'DocType: Email Digest',b'New Sales Orders',b'Penjualan New Orders'
b'DocType: Bank Guarantee',b'Bank Account',b'Rekening Bank'
b'DocType: Leave Type',b'Allow Negative Balance',b'Izinkan Saldo Negatif'
b'apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13',"b""You cannot delete Project Type 'External'""","b""Anda tidak bisa menghapus Jenis Proyek 'External'"""
b'DocType: Employee',b'Create User',b'Buat pengguna'
b'DocType: Selling Settings',b'Default Territory',b'Wilayah Standar'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53',b'Television',b'Televisi'
b'DocType: Work Order Operation',"b""Updated via 'Time Log'""","b""Diperbarui melalui 'Log Waktu'"""
b'apps/erpnext/erpnext/controllers/taxes_and_totals.py +430',b'Advance amount cannot be greater than {0} {1}',b'Jumlah muka tidak dapat lebih besar dari {0} {1}'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42',b'JournalCode',b'Jurnalistik'
b'DocType: Naming Series',b'Series List for this Transaction',b'Daftar Series Transaksi ini'
b'DocType: Company',b'Enable Perpetual Inventory',b'Aktifkan Inventaris Abadi'
b'DocType: Company',b'Default Payroll Payable Account',b'Default Payroll Hutang Akun'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51',b'Update Email Group',b'Perbarui Email Kelompok'
b'DocType: Sales Invoice',b'Is Opening Entry',b'Entri Pembuka?'
b'DocType: Lab Test Template',"b'If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. '","b'Jika tidak dicentang, item tersebut tidak akan muncul dalam Sales Invoice, namun dapat digunakan dalam pembuatan uji kelompok.'"
b'DocType: Customer Group',b'Mention if non-standard receivable account applicable',b'Sebutkan jika akun non-standar piutang yang berlaku'
b'DocType: Course Schedule',b'Instructor Name',b'instruktur Nama'
b'DocType: Supplier Scorecard',b'Criteria Setup',b'Setup kriteria'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +206',b'For Warehouse is required before Submit',b'Untuk Gudang diperlukan sebelum Submit'
b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8',b'Received On',b'Diterima pada'
b'DocType: Sales Partner',b'Reseller',b'Reseller'
b'DocType: Codification Table',b'Medical Code',b'Kode medis'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20',b'Please enter Company',b'Pilih Perusahaan'
b'DocType: Delivery Note Item',b'Against Sales Invoice Item',b'Terhadap Barang di Faktur Penjualan'
b'DocType: Agriculture Analysis Criteria',b'Linked Doctype',b'Linked Doctype'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +44',b'Net Cash from Financing',b'Kas Bersih dari Pendanaan'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2375',"b'LocalStorage is full , did not save'","b'LocalStorage penuh, tidak menyimpan'"
b'DocType: Lead',b'Address & Contact',b'Alamat & Kontak'
b'DocType: Leave Allocation',b'Add unused leaves from previous allocations',"b""Tambahkan 'cuti tak terpakai' dari alokasi sebelumnya"""
b'DocType: Sales Partner',b'Partner website',b'situs mitra'
b'DocType: Restaurant Order Entry',b'Add Item',b'Tambahkan Barang'
b'DocType: Lab Test',b'Custom Result',b'Hasil Kustom'
b'DocType: Delivery Stop',b'Contact Name',b'Nama Kontak'
b'DocType: Course Assessment Criteria',b'Course Assessment Criteria',b'Kriteria Penilaian saja'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +18',b'Tax Id: ',b'Id pajak:'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +216',b'Student ID: ',b'Identitas Siswa:'
b'DocType: POS Customer Group',b'POS Customer Group',b'POS Pelanggan Grup'
b'DocType: Land Unit',b'Land Unit describing various land assets',b'Unit Tanah yang menggambarkan berbagai aset pertanahan'
b'DocType: Cheque Print Template',b'Line spacing for amount in words',b'spasi untuk jumlah kata'
b'DocType: Vehicle',b'Additional Details',b'Rincian Tambahan'
b'apps/erpnext/erpnext/templates/generators/bom.html +85',b'No description given',b'Tidak diberikan deskripsi'
b'apps/erpnext/erpnext/config/buying.py +13',b'Request for purchase.',b'Form Permintaan pembelian.'
b'DocType: Lab Test',b'Submitted Date',b'Tanggal dikirim'
b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6',b'This is based on the Time Sheets created against this project',b'Hal ini didasarkan pada Lembar Waktu diciptakan terhadap proyek ini'
,b'Open Work Orders',b'Buka Perintah Kerja'
b'DocType: Payment Term',b'Credit Months',b'Bulan kredit'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +409',b'Net Pay cannot be less than 0',b'Pay bersih yang belum bisa kurang dari 0'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5',"b'To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription'","b'Untuk berhenti mengirim pemberitahuan kesalahan berulang dari sistem, kami telah memeriksa kolom Nonaktif dalam langganan'"
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +121',b'Relieving Date must be greater than Date of Joining',b'Menghilangkan Tanggal harus lebih besar dari Tanggal Bergabung'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +240',b'Leaves per Year',b'cuti per Tahun'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130',"b""Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.""","b""Baris {0}: Silakan periksa 'Apakah Muka' terhadap Rekening {1} jika ini adalah sebuah entri muka."""
b'apps/erpnext/erpnext/stock/utils.py +219',b'Warehouse {0} does not belong to company {1}',b'Gudang {0} bukan milik perusahaan {1}'
b'DocType: Email Digest',b'Profit & Loss',b'Rugi laba'
b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Litre',b'Liter'
b'DocType: Task',b'Total Costing Amount (via Time Sheet)',b'Total Costing Jumlah (via Waktu Lembar)'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +76',b'Please setup Students under Student Groups',b'Tolong atur Siswa di Kelompok Siswa'
b'DocType: Item Website Specification',b'Item Website Specification',b'Item Situs Spesifikasi'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +449',b'Leave Blocked',b'Cuti Diblokir'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +740',b'Item {0} has reached its end of life on {1}',b'Item {0} telah mencapai akhir hidupnya pada {1}'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +83',b'Bank Entries',b'Entri Bank'
b'DocType: Crop',b'Annual',b'Tahunan'
b'DocType: Stock Reconciliation Item',b'Stock Reconciliation Item',b'Barang Rekonsiliasi Persediaan'
b'DocType: Stock Entry',b'Sales Invoice No',b'Nomor Faktur Penjualan'
b'DocType: Material Request Item',b'Min Order Qty',b'Min Order Qty'
b'DocType: Student Group Creation Tool Course',b'Student Group Creation Tool Course',b'Kursus Grup Pelajar Penciptaan Alat'
b'DocType: Lead',b'Do Not Contact',b'Jangan Hubungi'
b'apps/erpnext/erpnext/utilities/user_progress.py +210',b'People who teach at your organisation',b'Orang-orang yang mengajar di organisasi Anda'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135',b'Software Developer',b'Software Developer'
b'DocType: Item',b'Minimum Order Qty',b'Minimum Order Qty'
b'DocType: Pricing Rule',b'Supplier Type',b'Supplier Type'
b'DocType: Course Scheduling Tool',b'Course Start Date',b'Tentu saja Tanggal Mulai'
,b'Student Batch-Wise Attendance',b'Mahasiswa Batch-Wise Kehadiran'
b'DocType: POS Profile',b'Allow user to edit Rate',b'Memungkinkan pengguna untuk mengedit Tingkat'
b'DocType: Item',b'Publish in Hub',b'Publikasikan di Hub'
b'DocType: Student Admission',b'Student Admission',b'Mahasiswa Pendaftaran'
,b'Terretory',b'Terretory'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +762',b'Item {0} is cancelled',b'Item {0} dibatalkan'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1064',b'Material Request',b'Permintaan Material'
b'DocType: Bank Reconciliation',b'Update Clearance Date',b'Perbarui Tanggal Kliring'
,b'GSTR-2',b'GSTR-2'
b'DocType: Item',b'Purchase Details',b'Rincian pembelian'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +407',"b""Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1}""",b'Item {0} tidak ditemukan dalam &#39;Bahan Baku Disediakan&#39; tabel dalam Purchase Order {1}'
b'DocType: Salary Slip',b'Total Principal Amount',b'Jumlah Pokok Jumlah'
b'DocType: Student Guardian',b'Relation',b'Hubungan'
b'DocType: Student Guardian',b'Mother',b'Ibu'
b'DocType: Restaurant Reservation',b'Reservation End Time',b'Reservasi Akhir Waktu'
b'DocType: Crop',b'Biennial',b'Dua tahunan'
b'apps/erpnext/erpnext/config/selling.py +18',b'Confirmed orders from Customers.',b'Pesanan terkonfirmasi dari Pelanggan.'
b'DocType: Purchase Receipt Item',b'Rejected Quantity',b'Kuantitas Ditolak'
b'apps/erpnext/erpnext/education/doctype/fees/fees.py +80',b'Payment request {0} created',b'Permintaan pembayaran {0} dibuat'
b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72',b'Open Orders',b'Pesanan Terbuka'
b'apps/erpnext/erpnext/healthcare/setup.py +255',b'Low Sensitivity',b'Sensitivitas rendah'
b'DocType: Notification Control',b'Notification Control',b'Pemberitahuan Kontrol'
b'apps/erpnext/erpnext/templates/emails/training_event.html +17',b'Please confirm once you have completed your training',b'Harap konfirmasi setelah Anda menyelesaikan pelatihan Anda'
b'DocType: Lead',b'Suggestions',b'Saran'
b'DocType: Territory',b'Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.',b'Menetapkan anggaran Group-bijaksana Stok Barang di Wilayah ini. Anda juga bisa memasukkan musiman dengan menetapkan Distribusi.'
b'DocType: Payment Term',b'Payment Term Name',b'Nama Istilah Pembayaran'
b'DocType: Healthcare Settings',b'Create documents for sample collection',b'Buat dokumen untuk koleksi sampel'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276',b'Payment against {0} {1} cannot be greater than Outstanding Amount {2}',b'Pembayaran terhadap {0} {1} tidak dapat lebih besar dari Posisi Jumlah {2}'
b'DocType: Shareholder',b'Address HTML',b'Alamat HTML'
b'DocType: Lead',b'Mobile No.',b'Nomor Ponsel'
b'DocType: Maintenance Schedule',b'Generate Schedule',b'Hasilkan Jadwal'
b'DocType: Purchase Invoice Item',b'Expense Head',b'Akun Kepala Biaya'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +138',b'Please select Charge Type first',b'Silakan pilih Mengisi Tipe terlebih dahulu'
b'DocType: Crop',"b'You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. '","b'Anda dapat menentukan semua tugas yang perlu dilakukan untuk tanaman ini di sini. Bidang hari digunakan untuk menyebutkan hari dimana tugas tersebut perlu dilakukan, 1 menjadi hari pertama, dll.'"
b'DocType: Student Group Student',b'Student Group Student',b'Mahasiswa Grup Pelajar'
b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41',b'Latest',b'Terbaru'
b'DocType: Asset Maintenance Task',b'2 Yearly',b'2 Tahunan'
b'DocType: Education Settings',b'Education Settings',b'Pengaturan Pendidikan'
b'DocType: Vehicle Service',b'Inspection',b'Inspeksi'
b'DocType: Supplier Scorecard Scoring Standing',b'Max Grade',b'Max Grade'
b'DocType: Email Digest',b'New Quotations',b'Kutipan Baru'
b'DocType: HR Settings',b'Emails salary slip to employee based on preferred email selected in Employee',b'Surel slip gaji ke karyawan berdasarkan surel utama yang dipilih dalam Karyawan'
b'DocType: Employee',b'The first Leave Approver in the list will be set as the default Leave Approver',b'The Approver Cuti terlebih dahulu dalam daftar akan ditetapkan sebagai default Cuti Approver'
b'DocType: Tax Rule',b'Shipping County',b'Pengiriman County'
b'apps/erpnext/erpnext/config/desktop.py +167',b'Learn',b'Belajar'
b'DocType: Asset',b'Next Depreciation Date',b'Berikutnya Penyusutan Tanggal'
b'apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3',b'Activity Cost per Employee',b'Biaya Aktivitas Per Karyawan'
b'DocType: Accounts Settings',b'Settings for Accounts',b'Pengaturan Akun'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +673',b'Supplier Invoice No exists in Purchase Invoice {0}',b'Pemasok Faktur ada ada di Purchase Invoice {0}'
b'apps/erpnext/erpnext/config/selling.py +118',b'Manage Sales Person Tree.',b'Pengelolaan Tingkat Salesman'
b'DocType: Job Applicant',b'Cover Letter',b'Sampul surat'
b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37',b'Outstanding Cheques and Deposits to clear',b'Penghapusan Cek dan Deposito yang Jatuh Tempo'
b'DocType: Item',b'Synced With Hub',b'Disinkronkan Dengan Hub'
b'DocType: Driver',b'Fleet Manager',b'armada Manajer'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542',b'Row #{0}: {1} can not be negative for item {2}',b'Row # {0}: {1} tidak bisa menjadi negatif untuk item {2}'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59',b'Wrong Password',b'Kata Sandi Salah'
b'DocType: Item',b'Variant Of',b'Varian Of'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +406',"b""Completed Qty can not be greater than 'Qty to Manufacture'""","b""Selesai Qty tidak dapat lebih besar dari 'Jumlah untuk Produksi'"""
b'DocType: Period Closing Voucher',b'Closing Account Head',b'Penutupan Akun Kepala'
b'DocType: Employee',b'External Work History',b'Pengalaman Kerja Diluar'
b'apps/erpnext/erpnext/projects/doctype/task/task.py +111',b'Circular Reference Error',b'Referensi Kesalahan melingkar'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +206',b'Student Report Card',b'Kartu Laporan Siswa'
b'DocType: Appointment Type',b'Is Inpatient',b'Apakah rawat inap'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55',b'Guardian1 Name',b'Nama Guardian1'
b'DocType: Delivery Note',b'In Words (Export) will be visible once you save the Delivery Note.',b'Dalam Kata-kata (Ekspor) akan terlihat sekali Anda menyimpan Delivery Note.'
b'DocType: Cheque Print Template',b'Distance from left edge',b'Jarak dari tepi kiri'
b'apps/erpnext/erpnext/utilities/bot.py +29',b'{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2})',b'{0} unit [{1}] (#Formulir/Barang/{1}) ditemukan di [{2}] (#Formulir/Gudang/{2})'
b'DocType: Lead',b'Industry',b'Industri'
b'DocType: Employee',b'Job Profile',b'Profil Pekerjaan'
b'DocType: BOM Item',b'Rate & Amount',b'Tarif &amp; Jumlah'
b'apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6',b'This is based on transactions against this Company. See timeline below for details',b'Hal ini didasarkan pada transaksi terhadap Perusahaan ini. Lihat garis waktu di bawah untuk rinciannya'
b'DocType: Stock Settings',b'Notify by Email on creation of automatic Material Request',b'Beritahu melalui Surel pada pembuatan Permintaan Material otomatis'
b'apps/erpnext/erpnext/healthcare/setup.py +259',b'Resistant',b'Tahan'
b'apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +77',b'Please set Hotel Room Rate on {}',b'Harap atur Tarif Kamar Hotel di {}'
b'DocType: Journal Entry',b'Multi Currency',b'Multi Mata Uang'
b'DocType: Opening Invoice Creation Tool',b'Invoice Type',b'Tipe Faktur'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +939',b'Delivery Note',b'Nota Pengiriman'
b'DocType: Consultation',b'Encounter Impression',b'Tayangan Pertemuan'
b'apps/erpnext/erpnext/config/learn.py +82',b'Setting up Taxes',b'Persiapan Pajak'
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134',b'Cost of Sold Asset',b'Biaya Asset Terjual'
b'DocType: Volunteer',b'Morning',b'Pagi'
b'apps/erpnext/erpnext/accounts/utils.py +350',b'Payment Entry has been modified after you pulled it. Please pull it again.',b'Entri pembayaran telah dimodifikasi setelah Anda menariknya. Silakan menariknya lagi.'
b'DocType: Program Enrollment Tool',b'New Student Batch',b'Batch Siswa Baru'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +479',b'{0} entered twice in Item Tax',b'{0} dimasukan dua kali dalam Pajak Barang'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113',b'Summary for this week and pending activities',b'Ringkasan untuk minggu ini dan kegiatan yang tertunda'
b'DocType: Student Applicant',b'Admitted',b'Diterima'
b'DocType: Workstation',b'Rent Cost',b'Biaya Sewa'
b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81',b'Amount After Depreciation',b'Jumlah Setelah Penyusutan'
b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97',b'Upcoming Calendar Events',b'Mendatang Kalender Acara'
b'apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1',b'Variant Attributes',b'Atribut varian'
b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85',b'Please select month and year',b'Silakan pilih bulan dan tahun'
b'DocType: Employee',b'Company Email',b'Email Perusahaan'
b'DocType: GL Entry',b'Debit Amount in Account Currency',b'Jumlah Debit di Akun Mata Uang'
b'DocType: Supplier Scorecard',b'Scoring Standings',b'Klasemen Skor'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21',b'Order Value',b'Nilai pesanan'
b'apps/erpnext/erpnext/config/accounts.py +27',b'Bank/Cash transactions against party or for internal transfer',b'Transaksi Bank / Cash terhadap partai atau untuk internal transfer'
b'DocType: Shipping Rule',b'Valid for Countries',b'Berlaku untuk Negara'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +55',"b""This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set""","b""Stok Barang ini adalah Template dan tidak dapat digunakan dalam transaksi. Item atribut akan disalin ke dalam varian kecuali 'Tidak ada Copy' diatur"""
b'DocType: Grant Application',b'Grant Application',b'Permohonan Hibah'
b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69',b'Total Order Considered',b'Total Order Diperhitungkan'
b'apps/erpnext/erpnext/config/hr.py +243',"b'Employee designation (e.g. CEO, Director etc.).'","b'Penunjukan Karyawan (misalnya CEO, Direktur dll).'"
b'DocType: Sales Invoice',"b""Rate at which Customer Currency is converted to customer's base currency""",b'Tingkat di mana Mata Uang Pelanggan dikonversi ke mata uang dasar pelanggan'
b'DocType: Course Scheduling Tool',b'Course Scheduling Tool',b'Tentu saja Penjadwalan Perangkat'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +623',b'Row #{0}: Purchase Invoice cannot be made against an existing asset {1}',b'Row # {0}: Pembelian Faktur tidak dapat dilakukan terhadap aset yang ada {1}'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +257',b'[Urgent] Error while creating recurring %s for %s',b'[Penting] Kesalahan saat membuat perulangan %s untuk %s'
b'DocType: Land Unit',b'LInked Analysis',b'Analisis LInked'
b'DocType: Item Tax',b'Tax Rate',b'Tarif Pajak'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +73',b'Application period cannot be across two allocation records',b'Periode aplikasi tidak dapat melewati dua catatan alokasi'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59',b'{0} already allocated for Employee {1} for period {2} to {3}',b'{0} sudah dialokasikan bagi Karyawan {1} untuk periode {2} ke {3}'
b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +141',b'Purchase Invoice {0} is already submitted',b'Faktur Pembelian {0} sudah Terkirim'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +92',b'Row # {0}: Batch No must be same as {1} {2}',b'Row # {0}: Batch ada harus sama {1} {2}'
b'DocType: Material Request Plan Item',b'Material Request Plan Item',b'Item Rencana Permintaan Material'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52',b'Convert to non-Group',b'Dikonversi ke non-Grup'
b'DocType: Project Update',b'Good/Steady',b'Baik / Mantap'
b'DocType: C-Form Invoice Detail',b'Invoice Date',b'Faktur Tanggal'
b'DocType: GL Entry',b'Debit Amount',b'Jumlah Debit'
b'apps/erpnext/erpnext/accounts/party.py +248',b'There can only be 1 Account per Company in {0} {1}',b'Hanya ada 1 Akun per Perusahaan di {0} {1}'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +426',b'Please see attachment',b'Silakan lihat lampiran'
b'DocType: Purchase Order',b'% Received',b'% Diterima'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3',b'Create Student Groups',b'Buat Grup Mahasiswa'
b'DocType: Volunteer',b'Weekends',b'Akhir pekan'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +118',b'Credit Note Amount',b'Jumlah Catatan Kredit'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +187',b'{0} ({1}) cannot be greater than planned quanitity ({2}) in Work Order {3}',b'{0} ({1}) tidak bisa lebih besar dari yang direncanakan quanitity ({2}) di Work Order {3}'
b'DocType: Setup Progress Action',b'Action Document',b'Dokumen tindakan'
b'DocType: Chapter Member',b'Website URL',b'URL situs'
,b'Finished Goods',b'Stok Barang Jadi'
b'DocType: Delivery Note',b'Instructions',b'Instruksi'
b'DocType: Quality Inspection',b'Inspected By',b'Diperiksa Oleh'
b'DocType: Asset Maintenance Log',b'Maintenance Type',b'Tipe Pemeliharaan'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45',b'{0} - {1} is not enrolled in the Course {2}',b'{0} - {1} tidak terdaftar di Kursus {2}'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +225',b'Student Name: ',b'Nama siswa:'
b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59',b'Serial No {0} does not belong to Delivery Note {1}',b'Serial ada {0} bukan milik Pengiriman Note {1}'
b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +97',"b""There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.""","b'Sepertinya ada masalah dengan konfigurasi GoCardless server. Jangan khawatir, jika terjadi kegagalan, jumlah itu akan dikembalikan ke akun Anda.'"
b'apps/erpnext/erpnext/templates/pages/demo.html +47',b'ERPNext Demo',b'ERPNext Demo'
b'apps/erpnext/erpnext/public/js/utils/item_selector.js +20',b'Add Items',b'Tambahkan Item'
b'DocType: Item Quality Inspection Parameter',b'Item Quality Inspection Parameter',b'Stok Barang Kualitas Parameter Inspeksi'
b'DocType: Depreciation Schedule',b'Schedule Date',b'Jadwal Tanggal'
b'apps/erpnext/erpnext/config/hr.py +116',"b'Earnings, Deductions and other Salary components'","b'Laba, Pengurangan dan komponen Gaji lainnya'"
b'DocType: Packed Item',b'Packed Item',b'Stok Barang Kemasan'
b'DocType: Job Offer Term',b'Job Offer Term',b'Job Offer Term'
b'apps/erpnext/erpnext/config/buying.py +65',b'Default settings for buying transactions.',b'Pengaturan default untuk transaksi Pembelian.'
b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29',b'Activity Cost exists for Employee {0} against Activity Type - {1}',b'Terdapat Biaya Kegiatan untuk Karyawan {0} untuk Jenis Kegiatan - {1}'
b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15',b'Mandatory field - Get Students From',b'Wajib lapangan - Dapatkan Siswa Dari'
b'DocType: Program Enrollment',b'Enrolled courses',b'Kursus yang terdaftar'
b'DocType: Currency Exchange',b'Currency Exchange',b'Kurs Mata Uang'
b'DocType: Opening Invoice Creation Tool Item',b'Item Name',b'Nama Item'
b'DocType: Authorization Rule',b'Approving User  (above authorized value)',b'Approving User (di atas nilai yang berwenang)'
b'DocType: Email Digest',b'Credit Balance',b'Saldo kredit'
b'DocType: Employee',b'Widowed',b'Janda'
b'DocType: Request for Quotation',b'Request for Quotation',b'Permintaan Quotation'
b'DocType: Healthcare Settings',b'Require Lab Test Approval',b'Memerlukan Lab Test Approval'
b'DocType: Salary Slip Timesheet',b'Working Hours',b'Jam Kerja'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +59',b'Total Outstanding',b'Total Posisi'
b'DocType: Naming Series',b'Change the starting / current sequence number of an existing series.',b'Mengubah mulai / nomor urut saat ini dari seri yang ada.'
b'DocType: Dosage Strength',b'Strength',b'Kekuatan'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1534',b'Create a new Customer',b'Buat Pelanggan baru'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59',"b'If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.'","b'Jika beberapa Aturan Harga terus menang, pengguna akan diminta untuk mengatur Prioritas manual untuk menyelesaikan konflik.'"
b'apps/erpnext/erpnext/utilities/activation.py +90',b'Create Purchase Orders',b'Buat Purchase Order'
,b'Purchase Register',b'Register Pembelian'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +116',b'Patient not found',b'Pasien tidak ditemukan'
b'DocType: Scheduling Tool',b'Rechedule',b'Rechedule'
b'DocType: Landed Cost Item',b'Applicable Charges',b'Biaya yang Berlaku'
b'DocType: Workstation',b'Consumable Cost',b'Biaya Consumable'
b'DocType: Purchase Receipt',b'Vehicle Date',b'Tanggal Kendaraan'
b'DocType: Student Log',b'Medical',b'Medis'
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175',b'Reason for losing',b'Alasan Kehilangan'
b'apps/erpnext/erpnext/accounts/doctype/account/account.js +52',b'Update Account Number',b'Perbarui Nomor Akun'
b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +44',b'Lead Owner cannot be same as the Lead',b'Pemilik Prospek tidak bisa sama dengan Prospek'
b'apps/erpnext/erpnext/accounts/utils.py +356',b'Allocated amount can not greater than unadjusted amount',b'jumlah yang dialokasikan tidak bisa lebih besar dari jumlah yang disesuaikan'
b'DocType: Announcement',b'Receiver',b'Penerima'
b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83',b'Workstation is closed on the following dates as per Holiday List: {0}',b'Workstation ditutup pada tanggal berikut sesuai Hari Libur Daftar: {0}'
b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32',b'Opportunities',b'Peluang'
b'DocType: Lab Test Template',b'Single',b'Tunggal'
b'DocType: Salary Slip',b'Total Loan Repayment',b'Total Pembayaran Pinjaman'
b'DocType: Account',b'Cost of Goods Sold',b'Harga Pokok Penjualan'
b'DocType: Subscription',b'Yearly',b'Tahunan'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230',b'Please enter Cost Center',b'Harap Masukan Jenis Biaya Pusat'
b'DocType: Drug Prescription',b'Dosage',b'Dosis'
b'DocType: Journal Entry Account',b'Sales Order',b'Order Penjualan'
b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69',b'Avg. Selling Rate',b'Harga Jual Rata-rata'
b'DocType: Assessment Plan',b'Examiner Name',b'Nama pemeriksa'
b'DocType: Lab Test Template',b'No Result',b'Tidak ada hasil'
b'DocType: Purchase Invoice Item',b'Quantity and Rate',b'Kuantitas dan Harga'
b'DocType: Delivery Note',b'% Installed',b'% Terpasang'
b'apps/erpnext/erpnext/utilities/user_progress.py +230',b'Classrooms/ Laboratories etc where lectures can be scheduled.',b'Ruang kelas / Laboratorium dll di mana kuliah dapat dijadwalkan.'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46',b'Please enter company name first',b'Silahkan masukkan nama perusahaan terlebih dahulu'
b'DocType: Purchase Invoice',b'Supplier Name',b'Nama Supplier'
b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25',b'Read the ERPNext Manual',b'Baca Pedoman ERPNEXT'
b'DocType: Purchase Invoice',b'01-Sales Return',b'01-Sales Return'
b'DocType: Account',b'Is Group',b'Apakah Group?'
b'DocType: Email Digest',b'Pending Purchase Orders',b'Pending Pembelian Pesanan'
b'DocType: Stock Settings',b'Automatically Set Serial Nos based on FIFO',b'Nomor Seri Otomatis berdasarkan FIFO'
b'DocType: Accounts Settings',b'Check Supplier Invoice Number Uniqueness',b'Periksa keunikan nomor Faktur Supplier'
b'apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34',b'Primary Address Details',b'Rincian Alamat Utama'
b'DocType: Vehicle Service',b'Oil Change',b'Ganti oli'
b'DocType: Asset Maintenance Log',b'Asset Maintenance Log',b'Log pemeliharaan aset'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57',"b""'To Case No.' cannot be less than 'From Case No.'""","b""'Sampai Kasus No.' tidak bisa kurang dari 'Dari Kasus No.'"""
b'DocType: Chapter',b'Non Profit',b'Non Profit'
b'DocType: Production Plan',b'Not Started',b'Tidak Dimulai'
b'DocType: Lead',b'Channel Partner',b'Chanel Mitra'
b'DocType: Account',b'Old Parent',b'Old Parent'
b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19',b'Mandatory field - Academic Year',b'Bidang Wajib - Tahun Akademik'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +220',b'{0} {1} is not associated with {2} {3}',b'{0} {1} tidak terkait dengan {2} {3}'
b'DocType: Notification Control',b'Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.',b'Sesuaikan teks pengantar yang menjadi bagian dari surel itu. Setiap transaksi memiliki teks pengantar yang terpisah.'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +176',b'Please set default payable account for the company {0}',b'Harap atur akun hutang default untuk perusahaan {0}'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +511',b'Transaction not allowed against stopped Work Order {0}',b'Transaksi tidak diizinkan melawan Stop Work Order {0}'
b'DocType: Setup Progress Action',b'Min Doc Count',b'Min Doc Count'
b'apps/erpnext/erpnext/config/manufacturing.py +84',b'Global settings for all manufacturing processes.',b'Pengaturan global untuk semua proses manufaktur.'
b'DocType: Accounts Settings',b'Accounts Frozen Upto',b'Akun dibekukan sampai dengan'
b'DocType: SMS Log',b'Sent On',b'Dikirim Pada'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +700',b'Attribute {0} selected multiple times in Attributes Table',b'Atribut {0} karena beberapa kali dalam Atribut Tabel'
b'DocType: HR Settings',b'Employee record is created using selected field. ',b''
b'DocType: Sales Order',b'Not Applicable',b'Tidak Berlaku'
b'apps/erpnext/erpnext/config/hr.py +70',b'Holiday master.',b'master Hari Libur.'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +85',b'Opening Invoice Item',b'Membuka Item Faktur'
b'DocType: Request for Quotation Item',b'Required Date',b'Diperlukan Tanggal'
b'DocType: Delivery Note',b'Billing Address',b'Alamat Penagihan'
b'DocType: BOM',b'Costing',b'Biaya'
b'DocType: Tax Rule',b'Billing County',b'Daerah Penagihan'
b'DocType: Purchase Taxes and Charges',"b'If checked, the tax amount will be considered as already included in the Print Rate / Print Amount'","b'Jika dicentang, jumlah pajak akan dianggap sebagai sudah termasuk dalam Jumlah Tingkat Cetak / Print'"
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46',b'PieceRef',b'PieceRef'
b'DocType: Request for Quotation',b'Message for Supplier',b'Pesan Supplier'
b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +40',b'Work Order',b'Perintah kerja'
b'DocType: Driver',b'DRIVER-.#####',b'SOPIR-.#####'
b'DocType: Sales Invoice',b'Total Qty',b'Jumlah Qty'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62',b'Guardian2 Email ID',b'ID Email Guardian2'
b'DocType: Item',b'Show in Website (Variant)',b'Tampilkan Website (Variant)'
b'DocType: Employee',b'Health Concerns',b'Kekhawatiran Kesehatan'
b'DocType: Payroll Entry',b'Select Payroll Period',b'Pilih Payroll Periode'
b'DocType: Purchase Invoice',b'Unpaid',b'Tunggakan'
b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49',b'Reserved for sale',b'Dicadangkan untuk dijual'
b'DocType: Packing Slip',b'From Package No.',b'Dari Package No'
b'DocType: Item Attribute',b'To Range',b'Berkisar'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29',b'Securities and Deposits',b'Efek Saham dan Deposit'
b'apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +46',"b""Can't change valuation method, as there are transactions against some items which does not have it's own valuation method""","b'Tidak dapat mengubah metode valuasi, karena ada transaksi terhadap beberapa item yang tidak memiliki metode penilaian sendiri'"
b'DocType: Student Report Generation Tool',b'Attended by Parents',b'Diikuti oleh Orangtua'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82',b'Total leaves allocated is mandatory',b'Jumlah cuti wajib dialokasikan'
b'DocType: Patient',b'AB Positive',b'AB Positif'
b'DocType: Job Opening',b'Description of a Job Opening',b'Deskripsi dari Lowongan Pekerjaan'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +110',b'Pending activities for today',b'Kegiatan tertunda untuk hari ini'
b'apps/erpnext/erpnext/config/hr.py +24',b'Attendance record.',b'Laporan Absensi.'
b'DocType: Salary Structure',b'Salary Component for timesheet based payroll.',b'Komponen gaji untuk gaji berdasarkan absen.'
b'DocType: Sales Order Item',b'Used for Production Plan',b'Digunakan untuk Rencana Produksi'
b'DocType: Employee Loan',b'Total Payment',b'Total pembayaran'
b'DocType: Manufacturing Settings',b'Time Between Operations (in mins)',b'Waktu diantara Operasi (di menit)'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +132',b'{0} {1} is cancelled so the action cannot be completed',b'{0} {1} dibatalkan sehingga tindakan tidak dapat diselesaikan'
b'DocType: Customer',b'Buyer of Goods and Services.',b'Pembeli Stok Barang dan Jasa.'
b'DocType: Journal Entry',b'Accounts Payable',b'Hutang'
b'DocType: Patient',b'Allergies',b'Alergi'
b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +33',b'The selected BOMs are not for the same item',b'BOMs yang dipilih tidak untuk item yang sama'
b'DocType: Supplier Scorecard Standing',b'Notify Other',b'Beritahu Lainnya'
b'DocType: Vital Signs',b'Blood Pressure (systolic)',b'Tekanan Darah (sistolik)'
b'DocType: Pricing Rule',b'Valid Upto',b'Valid Upto'
b'DocType: Training Event',b'Workshop',b'Bengkel'
b'DocType: Supplier Scorecard Scoring Standing',b'Warn Purchase Orders',b'Peringatkan untuk Pesanan Pembelian'
b'apps/erpnext/erpnext/utilities/user_progress.py +67',b'List a few of your customers. They could be organizations or individuals.',b'Daftar beberapa pelanggan anda. Bisa organisasi atau individu.'
b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +23',b'Enough Parts to Build',b'Bagian yang cukup untuk Membangun'
b'DocType: POS Profile User',b'POS Profile User',b'Profil Pengguna POS'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128',b'Direct Income',b'Pendapatan Langsung'
b'DocType: Patient Appointment',b'Date TIme',b'Tanggal Waktu'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +45',"b'Can not filter based on Account, if grouped by Account'","b'Tidak dapat memfilter berdasarkan Account, jika dikelompokkan berdasarkan Account'"
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +130',b'Administrative Officer',b'Petugas Administrasi'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39',b'Setting up company and taxes',b'Menyiapkan perusahaan dan pajak'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22',b'Please select Course',b'Silakan pilih Kursus'
b'DocType: Codification Table',b'Codification Table',b'Tabel Kodifikasi'
b'DocType: Timesheet Detail',b'Hrs',b'Hrs'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +349',b'Please select Company',b'Silakan pilih Perusahaan'
b'DocType: Stock Entry Detail',b'Difference Account',b'Perbedaan Akun'
b'DocType: Purchase Invoice',b'Supplier GSTIN',b'Pemasok GSTIN'
b'apps/erpnext/erpnext/projects/doctype/task/task.py +47',b'Cannot close task as its dependant task {0} is not closed.',b'Tidak bisa tugas sedekat tugas yang tergantung {0} tidak tertutup.'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +435',b'Please enter Warehouse for which Material Request will be raised',b'Entrikan Gudang yang Material Permintaan akan dibangkitkan'
b'DocType: Work Order',b'Additional Operating Cost',b'Biaya Operasi Tambahan'
b'DocType: Lab Test Template',b'Lab Routine',b'Lab Rutin'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20',b'Cosmetics',b'Kosmetik'
b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18',b'Please select Completion Date for Completed Asset Maintenance Log',b'Silakan pilih Tanggal Penyelesaian untuk Pemeriksaan Pemeliharaan Aset Selesai'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +552',"b'To merge, following properties must be same for both items'","b'Untuk bergabung, sifat berikut harus sama untuk kedua item'"
b'DocType: Shipping Rule',b'Net Weight',b'Berat Bersih'
b'DocType: Employee',b'Emergency Phone',b'Telepon Darurat'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +82',b'{0} {1} does not exist.',b'{0} {1} tidak ada'
b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29',b'Buy',b'Membeli'
,b'Serial No Warranty Expiry',b'Nomor Serial Garansi telah kadaluarsa'
b'DocType: Sales Invoice',b'Offline POS Name',b'POS Offline Nama'
b'apps/erpnext/erpnext/utilities/user_progress.py +180',b'Student Application',b'Aplikasi siswa'
b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20',b'Please define grade for Threshold 0%',b'Harap tentukan nilai untuk Threshold 0%'
b'DocType: Sales Order',b'To Deliver',b'Mengirim'
b'DocType: Purchase Invoice Item',b'Item',b'Barang'
b'apps/erpnext/erpnext/healthcare/setup.py +256',b'High Sensitivity',b'Sensitivitas tinggi'
b'apps/erpnext/erpnext/config/non_profit.py +48',b'Volunteer Type information.',b'Informasi Tipe Sukarela.'
b'DocType: Cash Flow Mapping Template',b'Cash Flow Mapping Template',b'Template Pemetaan Arus Kas'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2555',b'Serial no item cannot be a fraction',b'Serial Item tidak dapat pecahan'
b'DocType: Journal Entry',b'Difference (Dr - Cr)',b'Perbedaan (Dr - Cr)'
b'DocType: Account',b'Profit and Loss',b'Laba Rugi'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +104',"b'Not permitted, configure Lab Test Template as required'","b'Tidak diizinkan, konfigurasikan Lab Test Template sesuai kebutuhan'"
b'DocType: Patient',b'Risk Factors',b'Faktor risiko'
b'DocType: Patient',b'Occupational Hazards and Environmental Factors',b'Bahaya Kerja dan Faktor Lingkungan'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +239',b'Stock Entries already created for Work Order ',b'Entri Saham sudah dibuat untuk Perintah Kerja'
b'DocType: Vital Signs',b'Respiratory rate',b'Tingkat pernapasan'
b'apps/erpnext/erpnext/config/stock.py +334',b'Managing Subcontracting',b'Pengaturan Subkontrak'
b'DocType: Vital Signs',b'Body Temperature',b'Suhu tubuh'
b'DocType: Project',b'Project will be accessible on the website to these users',b'Proyek akan dapat diakses di website pengguna ini'
b'DocType: Detected Disease',b'Disease',b'Penyakit'
b'apps/erpnext/erpnext/config/projects.py +29',b'Define Project type.',b'Tentukan jenis proyek.'
b'DocType: Supplier Scorecard',b'Weighting Function',b'Fungsi pembobotan'
b'DocType: Physician',b'OP Consulting Charge',b'OP Consulting Charge'
b'apps/erpnext/erpnext/utilities/user_progress.py +28',b'Setup your ',b'Setup Anda'
b'DocType: Student Report Generation Tool',b'Show Marks',b'Tampilkan Tanda'
b'DocType: Quotation',"b""Rate at which Price list currency is converted to company's base currency""",b'Tingkat di mana mata uang Daftar Harga dikonversi ke mata uang dasar perusahaan'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +70',b'Account {0} does not belong to company: {1}',b'Akun {0} bukan milik perusahaan: {1}'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +52',b'Abbreviation already used for another company',b'Singkatan sudah digunakan untuk perusahaan lain'
b'DocType: Selling Settings',b'Default Customer Group',b'Kelompok Pelanggan Standar'
b'DocType: Asset Repair',b'ARLOG-',b'ARLOG-'
b'DocType: Global Defaults',"b""If disable, 'Rounded Total' field will not be visible in any transaction""","b""Jika disable, lapangan 'Rounded Jumlah' tidak akan terlihat dalam setiap transaksi"""
b'DocType: BOM',b'Operating Cost',b'Biaya Operasi'
b'DocType: Crop',b'Produced Items',b'Item yang Diproduksi'
b'DocType: Sales Order Item',b'Gross Profit',b'Laba Kotor'
b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49',b'Increment cannot be 0',b'Kenaikan tidak bisa 0'
b'DocType: Company',b'Delete Company Transactions',b'Hapus Transaksi Perusahaan'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +364',b'Reference No and Reference Date is mandatory for Bank transaction',b'Referensi ada dan Tanggal referensi wajib untuk transaksi Bank'
b'DocType: Purchase Receipt',b'Add / Edit Taxes and Charges',b'Tambah / Edit Pajak dan Biaya'
b'DocType: Payment Entry Reference',b'Supplier Invoice No',b'Nomor Faktur Supplier'
b'DocType: Territory',b'For reference',b'Untuk referensi'
b'DocType: Healthcare Settings',b'Appointment Confirmation',b'Konfirmasi perjanjian'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158',"b'Cannot delete Serial No {0}, as it is used in stock transactions'","b'Tidak dapat menghapus No. Seri {0}, karena digunakan dalam transaksi persediaan'"
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +256',b'Closing (Cr)',b'Penutup (Cr)'
b'apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1',b'Hello',b'Halo'
b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118',b'Move Item',b'Pindahkan Barang'
b'DocType: Serial No',b'Warranty Period (Days)',b'Masa Garansi (Hari)'
b'DocType: Installation Note Item',b'Installation Note Item',b'Laporan Instalasi Stok Barang'
b'DocType: Production Plan Item',b'Pending Qty',b'Qty Tertunda'
b'DocType: Budget',b'Ignore',b'Diabaikan'
b'apps/erpnext/erpnext/accounts/party.py +396',b'{0} {1} is not active',b'{0} {1} tidak aktif'
b'apps/erpnext/erpnext/config/accounts.py +272',b'Setup cheque dimensions for printing',b'dimensi penyiapan cek untuk pencetakan'
b'DocType: Salary Slip',b'Salary Slip Timesheet',b'Daftar Absen Slip Gaji'
b'apps/erpnext/erpnext/controllers/buying_controller.py +160',b'Supplier Warehouse mandatory for sub-contracted Purchase Receipt',b'Supplier Gudang wajib untuk Pembelian Penerimaan sub-kontrak'
b'DocType: Pricing Rule',b'Valid From',b'Valid Dari'
b'DocType: Sales Invoice',b'Total Commission',b'Jumlah Nilai Komisi'
b'DocType: Pricing Rule',b'Sales Partner',b'Mitra Penjualan'
b'apps/erpnext/erpnext/config/buying.py +150',b'All Supplier scorecards.',b'Semua kartu pemilih Pemasok.'
b'DocType: Buying Settings',b'Purchase Receipt Required',b'Diperlukan Nota Penerimaan'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +188',b'Target warehouse in row {0} must be same as Work Order',b'Gudang target di baris {0} harus sama dengan Pesanan Kerja'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +155',b'Valuation Rate is mandatory if Opening Stock entered',b'Tingkat Valuasi adalah wajib jika menggunakan Persediaan Pembukaan'
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +143',b'No records found in the Invoice table',b'Tidak ada catatan yang ditemukan dalam tabel Faktur'
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +34',b'Please select Company and Party Type first',b'Silakan pilih Perusahaan dan Partai Jenis terlebih dahulu'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31',"b'Already set default in pos profile {0} for user {1}, kindly disabled default'","b'Sudah menetapkan default pada profil pos {0} untuk pengguna {1}, dengan baik dinonaktifkan secara default'"
b'apps/erpnext/erpnext/config/accounts.py +293',b'Financial / accounting year.',b'Keuangan / akuntansi Tahun Berjalan'
b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9',b'Accumulated Values',b'Nilai akumulasi'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162',"b'Sorry, Serial Nos cannot be merged'","b'Maaf, Nomor Seri tidak dapat digabungkan'"
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +72',b'Territory is Required in POS Profile',b'Wilayah Diperlukan di Profil POS'
b'DocType: Supplier',b'Prevent RFQs',b'Mencegah RFQs'
b'apps/erpnext/erpnext/utilities/activation.py +83',b'Make Sales Order',b'Membuat Sales Order'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168',b'Salary Slip submitted for period from {0} to {1}',b'Slip Gaji dikirim untuk periode dari {0} sampai {1}'
b'DocType: Project Task',b'Project Task',b'Tugas Proyek'
,b'Lead Id',b'Id Prospek'
b'DocType: C-Form Invoice Detail',b'Grand Total',b'Nilai Jumlah Total'
b'DocType: Assessment Plan',b'Course',b'kuliah'
b'DocType: Timesheet',b'Payslip',b'payslip'
b'apps/erpnext/erpnext/public/js/pos/pos.html +4',b'Item Cart',b'Item Cart'
b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38',b'Fiscal Year Start Date should not be greater than Fiscal Year End Date',b'Tahun Anggaran Tanggal Mulai tidak boleh lebih besar dari Fiscal Year End Tanggal'
b'DocType: Issue',b'Resolution',b'Resolusi'
b'DocType: C-Form',b'IV',b'IV'
b'apps/erpnext/erpnext/templates/pages/order.html +76',b'Delivered: {0}',b'Terkirim: {0}'
b'DocType: Expense Claim',b'Payable Account',b'Akun Hutang'
b'DocType: Payment Entry',b'Type of Payment',b'Jenis Pembayaran'
b'DocType: Sales Order',b'Billing and Delivery Status',b'Status Penagihan dan Pengiriman'
b'DocType: Job Applicant',b'Resume Attachment',b'Lanjutkan Lampiran'
b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58',b'Repeat Customers',b'Pelanggan Rutin'
b'DocType: Leave Control Panel',b'Allocate',b'Alokasi'
b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108',b'Create Variant',b'Buat Varian'
b'DocType: Sales Invoice',b'Shipping Bill Date',b'Tanggal Tagihan Pengiriman'
b'DocType: Production Plan',b'Production Plan',b'Rencana produksi'
b'DocType: Opening Invoice Creation Tool',b'Opening Invoice Creation Tool',b'Membuka Invoice Creation Tool'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +853',b'Sales Return',b'Retur Penjualan'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96',"b""Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period""",b'Catatan: Jumlah daun dialokasikan {0} tidak boleh kurang dari daun yang telah disetujui {1} untuk periode'
,b'Total Stock Summary',b'Ringkasan Persediaan Total'
b'DocType: Announcement',b'Posted By',b'Dikirim oleh'
b'DocType: Item',b'Delivered by Supplier (Drop Ship)',b'Dikirim oleh Supplier (Drop Shipment)'
b'DocType: Healthcare Settings',b'Confirmation Message',b'Pesan Konfirmasi'
b'apps/erpnext/erpnext/config/crm.py +12',b'Database of potential customers.',b'Database pelanggan potensial.'
b'DocType: Authorization Rule',b'Customer or Item',b'Pelanggan atau Produk'
b'apps/erpnext/erpnext/config/selling.py +28',b'Customer database.',b'Database Pelanggan.'
b'DocType: Quotation',b'Quotation To',b'Penawaran Kepada'
b'DocType: Lead',b'Middle Income',b'Penghasilan Menengah'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +228',b'Opening (Cr)',b'Pembukaan (Cr)'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +872',b'Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.',b'Standar Satuan Ukur untuk Item {0} tidak dapat diubah secara langsung karena Anda telah membuat beberapa transaksi (s) dengan UOM lain. Anda akan perlu untuk membuat item baru menggunakan default UOM berbeda.'
b'apps/erpnext/erpnext/accounts/utils.py +354',b'Allocated amount can not be negative',b'Jumlah yang dialokasikan tidak dijinkan negatif'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11',b'Please set the Company',b'Harap atur Perusahaan'
b'DocType: Share Balance',b'Share Balance',b'Saldo Saham'
b'DocType: Purchase Order Item',b'Billed Amt',b'Nilai Tagihan'
b'DocType: Training Result Employee',b'Training Result Employee',b'Pelatihan Hasil Karyawan'
b'DocType: Warehouse',b'A logical Warehouse against which stock entries are made.',b'Suatu Gudang maya dimana entri persediaan dibuat.'
b'DocType: Repayment Schedule',b'Principal Amount',b'Jumlah pokok'
b'DocType: Employee Loan Application',b'Total Payable Interest',b'Total Utang Bunga'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +57',b'Total Outstanding: {0}',b'Total Posisi: {0}'
b'DocType: Sales Invoice Timesheet',b'Sales Invoice Timesheet',b'Penjualan Faktur Timesheet'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118',b'Reference No & Reference Date is required for {0}',b'Referensi ada & Referensi Tanggal diperlukan untuk {0}'
b'DocType: Payroll Entry',b'Select Payment Account to make Bank Entry',b'Pilih Account Pembayaran untuk membuat Bank Masuk'
b'DocType: Hotel Settings',b'Default Invoice Naming Series',b'Seri Penamaan Faktur Default'
b'apps/erpnext/erpnext/utilities/activation.py +136',"b'Create Employee records to manage leaves, expense claims and payroll'","b'Buat catatan Karyawan untuk mengelola daun, klaim biaya dan gaji'"
b'DocType: Restaurant Reservation',b'Restaurant Reservation',b'Reservasi Restoran'
b'DocType: Land Unit',b'Land Unit Name',b'Nama unit tanah'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190',b'Proposal Writing',b'Penulisan Proposal'
b'DocType: Payment Entry Deduction',b'Payment Entry Deduction',b'Pembayaran Masuk Pengurangan'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14',b'Wrapping up',b'Membungkus'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35',b'Notify Customers via Email',b'Beritahu Pelanggan via Email'
b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35',b'Another Sales Person {0} exists with the same Employee id',b'Sales Person lain {0} ada dengan id Karyawan yang sama'
b'DocType: Employee Advance',b'Claimed Amount',b'Jumlah klaim'
b'apps/erpnext/erpnext/config/education.py +180',b'Masters',b'Masters'
b'DocType: Assessment Plan',b'Maximum Assessment Score',b'Skor Penilaian Maksimum'
b'apps/erpnext/erpnext/config/accounts.py +138',b'Update Bank Transaction Dates',b'Perbarui Tanggal Transaksi Bank'
b'apps/erpnext/erpnext/config/projects.py +41',b'Time Tracking',b'Pelacakan waktu'
b'DocType: Purchase Invoice',b'DUPLICATE FOR TRANSPORTER',b'DUPLICATE FOR TRANSPORTER'
b'apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49',b'Row {0}# Paid Amount cannot be greater than requested advance amount',b'Baris {0} # Jumlah yang Dibayar tidak boleh lebih besar dari jumlah uang muka yang diminta'
b'DocType: Fiscal Year Company',b'Fiscal Year Company',b'Tahun Fiskal Perusahaan'
b'DocType: Packing Slip Item',b'DN Detail',b'DN Detil'
b'DocType: Training Event',b'Conference',b'Konferensi'
b'DocType: Timesheet',b'Billed',b'Ditagih'
b'DocType: Batch',b'Batch Description',b'Kumpulan Keterangan'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12',b'Creating student groups',b'Menciptakan kelompok siswa'
b'apps/erpnext/erpnext/accounts/utils.py +727',"b'Payment Gateway Account not created, please create one manually.'","b'Gateway Akun pembayaran tidak dibuat, silakan membuat satu secara manual.'"
b'DocType: Supplier Scorecard',b'Per Year',b'Per tahun'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51',b'Not eligible for the admission in this program as per DOB',b'Tidak memenuhi syarat untuk masuk dalam program ini sesuai DOB'
b'DocType: Sales Invoice',b'Sales Taxes and Charges',b'Pajak Penjualan dan Biaya'
b'DocType: Employee',b'Organization Profile',b'Profil Organisasi'
b'DocType: Vital Signs',b'Height (In Meter)',b'Tinggi (In Meter)'
b'DocType: Student',b'Sibling Details',b'Detail saudara'
b'DocType: Vehicle Service',b'Vehicle Service',b'Layanan kendaraan'
b'apps/erpnext/erpnext/config/setup.py +101',b'Automatically triggers the feedback request based on conditions.',b'Secara otomatis memicu permintaan umpan balik berdasarkan kondisi.'
b'DocType: Employee',b'Reason for Resignation',b'Alasan pengunduran diri'
b'apps/erpnext/erpnext/config/hr.py +152',b'Template for performance appraisals.',b'Template untuk penilaian kinerja.'
b'DocType: Sales Invoice',b'Credit Note Issued',b'Kredit Catatan Ditempatkan'
b'DocType: Project Task',b'Weight',b'Berat'
b'DocType: Payment Reconciliation',b'Invoice/Journal Entry Details',b'Faktur / Jurnal entri Detail'
b'apps/erpnext/erpnext/accounts/utils.py +83',"b""{0} '{1}' not in Fiscal Year {2}""","b""{0} '{1}' tidak dalam Tahun Anggaran {2}"""
b'DocType: Buying Settings',b'Settings for Buying Module',b'Pengaturan untuk Modul Pembelian'
b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +21',b'Asset {0} does not belong to company {1}',b'Aset {0} bukan milik perusahaan {1}'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70',b'Please enter Purchase Receipt first',b'Cukup masukkan Nota Penerimaan terlebih dahulu'
b'DocType: Buying Settings',b'Supplier Naming By',b'Penamaan Supplier Berdasarkan'
b'DocType: Activity Type',b'Default Costing Rate',b'Standar Tingkat Biaya'
b'DocType: Maintenance Schedule',b'Maintenance Schedule',b'Jadwal Pemeliharaan'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36',"b'Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.'","b'Kemudian Aturan Harga disaring berdasarkan Pelanggan, Kelompok Pelanggan, Wilayah, Pemasok, Jenis Pemasok, Kampanye, Mitra Penjualan, dll.'"
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +29',b'Net Change in Inventory',b'Perubahan Nilai bersih dalam Persediaan'
b'apps/erpnext/erpnext/config/hr.py +162',b'Employee Loan Management',b'Manajemen Kredit Karyawan'
b'DocType: Employee',b'Passport Number',b'Nomor Paspor'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60',b'Relation with Guardian2',b'Hubungan dengan Guardian2'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124',b'Manager',b'Manajer'
b'DocType: Payment Entry',b'Payment From / To',b'Pembayaran Dari / Untuk'
b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +170',b'New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0}',b'batas kredit baru kurang dari jumlah yang luar biasa saat ini bagi pelanggan. batas kredit harus minimal {0}'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +428',b'Please set account in Warehouse {0}',b'Harap setel akun di Gudang {0}'
b'apps/erpnext/erpnext/controllers/trends.py +39',"b""'Based On' and 'Group By' can not be same""","b""'Berdasarkan' dan 'Kelompokkan Menurut' tidak boleh sama"""
b'DocType: Sales Person',b'Sales Person Targets',b'Target Sales Person'
b'DocType: Installation Note',b'IN-',b'DI-'
b'DocType: Work Order Operation',b'In minutes',b'Dalam menit'
b'DocType: Issue',b'Resolution Date',b'Tanggal Resolusi'
b'DocType: Lab Test Template',b'Compound',b'Senyawa'
b'DocType: Student Batch Name',b'Batch Name',b'Nama Kumpulan'
b'DocType: Fee Validity',b'Max number of visit',b'Jumlah kunjungan maksimal'
,b'Hotel Room Occupancy',b'Kamar Hotel Okupansi'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +358',b'Timesheet created:',b'Absen dibuat:'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +931',b'Please set default Cash or Bank account in Mode of Payment {0}',b'Silakan set Cash standar atau rekening Bank Mode Pembayaran {0}'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24',b'Enroll',b'Mendaftar'
b'DocType: GST Settings',b'GST Settings',b'Pengaturan GST'
b'DocType: Selling Settings',b'Customer Naming By',b'Penamaan Pelanggan Dengan'
b'DocType: Student Leave Application',b'Will show the student as Present in Student Monthly Attendance Report',b'Akan menampilkan siswa sebagai Hadir di Student Bulanan Kehadiran Laporan'
b'DocType: Depreciation Schedule',b'Depreciation Amount',b'penyusutan Jumlah'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56',b'Convert to Group',b'Konversikan ke Grup'
b'DocType: Delivery Trip',b'TOUR-.#####',b'WISATA-.#####'
b'DocType: Activity Cost',b'Activity Type',b'Jenis Kegiatan'
b'DocType: Request for Quotation',b'For individual supplier',b'Untuk pemasok individual'
b'DocType: BOM Operation',b'Base Hour Rate(Company Currency)',b'Dasar Tarif Perjam (Mata Uang Perusahaan)'
b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47',b'Delivered Amount',b'Jumlah Telah Terikirim'
b'DocType: Quotation Item',b'Item Balance',b'Item Balance'
b'DocType: Sales Invoice',b'Packing List',b'Packing List'
b'apps/erpnext/erpnext/config/buying.py +28',b'Purchase Orders given to Suppliers.',b'Order Pembelian yang diberikan kepada Supplier.'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43',b'Publishing',b'Penerbitan'
b'DocType: Accounts Settings',b'Report Settings',b'Setelan Laporan'
b'DocType: Activity Cost',b'Projects User',b'Pengguna Proyek'
b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40',b'Consumed',b'Dikonsumsi'
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +158',b'{0}: {1} not found in Invoice Details table',b'{0}: {1} tidak ditemukan dalam tabel Rincian Tagihan'
b'DocType: Asset',b'Asset Owner Company',b'Perusahaan Pemilik Aset'
b'DocType: Company',b'Round Off Cost Center',b'Pembulatan Pusat Biaya'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242',b'Maintenance Visit {0} must be cancelled before cancelling this Sales Order',b'Pemeliharaan Kunjungan {0} harus dibatalkan sebelum membatalkan Sales Order ini'
b'DocType: Asset Maintenance Log',b'AML-',b'AML-'
b'DocType: Item',b'Material Transfer',b'Transfer Barang'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24',b'Could not find path for ',b'Tidak dapat menemukan jalan untuk'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +221',b'Opening (Dr)',b'Pembukaan (Dr)'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39',b'Posting timestamp must be after {0}',b'Posting timestamp harus setelah {0}'
b'apps/erpnext/erpnext/config/accounts.py +39',b'To make recurring documents',b'Membuat dokumen berulang'
,b'GST Itemised Purchase Register',b'Daftar Pembelian Item GST'
b'DocType: Course Scheduling Tool',b'Reschedule',b'Penjadwalan ulang'
b'DocType: Employee Loan',b'Total Interest Payable',b'Total Utang Bunga'
b'DocType: Landed Cost Taxes and Charges',b'Landed Cost Taxes and Charges',b'Biaya Pajak dan Landing Cost'
b'DocType: Work Order Operation',b'Actual Start Time',b'Waktu Mulai Aktual'
b'DocType: BOM Operation',b'Operation Time',b'Waktu Operasi'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +316',b'Finish',b'Selesai'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412',b'Base',b'Dasar'
b'DocType: Timesheet',b'Total Billed Hours',b'Total Jam Ditagih'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1530',b'Write Off Amount',b'Jumlah Nilai Write Off'
b'DocType: Leave Block List Allow',b'Allow User',b'Izinkan Pengguna'
b'DocType: Journal Entry',b'Bill No',b'Nomor Tagihan'
b'DocType: Company',b'Gain/Loss Account on Asset Disposal',b'Gain / Loss Account pada Asset Disposal'
b'DocType: Vehicle Log',b'Service Details',b'Rincian layanan'
b'DocType: Subscription',b'Quarterly',b'Triwulan'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +47',b'EcritureLib',b'EcritureLib'
b'DocType: Lab Test Template',b'Grouped',b'Dikelompokkan'
b'DocType: Selling Settings',b'Delivery Note Required',b'Nota Pengiriman Diperlukan'
b'DocType: Bank Guarantee',b'Bank Guarantee Number',b'Nomor Bank Garansi'
b'DocType: Assessment Criteria',b'Assessment Criteria',b'Kriteria penilaian'
b'DocType: BOM Item',b'Basic Rate (Company Currency)',b'Tarif Dasar (Mata Uang Perusahaan)'
b'DocType: Student Attendance',b'Student Attendance',b'Kehadiran mahasiswa'
b'DocType: Sales Invoice Timesheet',b'Time Sheet',b'Lembar waktu'
b'DocType: Manufacturing Settings',b'Backflush Raw Materials Based On',b'Backflush Bahan Baku Berbasis Pada'
b'DocType: Sales Invoice',b'Port Code',b'Kode port'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +957',b'Reserve Warehouse',b'Gudang Cadangan'
b'DocType: Lead',b'Lead is an Organization',b'Lead adalah sebuah Organisasi'
b'DocType: Guardian Interest',b'Interest',b'Bunga'
b'apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10',b'Pre Sales',b'Pra penjualan'
b'DocType: Instructor Log',b'Other Details',b'Detail lainnya'
b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18',b'Suplier',b'suplier'
b'DocType: Lab Test',b'Test Template',b'Uji Template'
b'DocType: Restaurant Order Entry Item',b'Served',b'Melayani'
b'apps/erpnext/erpnext/config/non_profit.py +13',b'Chapter information.',b'Informasi pasal'
b'DocType: Account',b'Accounts',b'Akun / Rekening'
b'DocType: Vehicle',b'Odometer Value (Last)',b'Odometer Nilai (terakhir)'
b'apps/erpnext/erpnext/config/buying.py +160',b'Templates of supplier scorecard criteria.',b'Template dari kriteria scorecard pemasok.'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109',b'Marketing',b'Marketing'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +303',b'Payment Entry is already created',b'Entri pembayaran sudah dibuat'
b'DocType: Request for Quotation',b'Get Suppliers',b'Dapatkan Pemasok'
b'DocType: Purchase Receipt Item Supplied',b'Current Stock',b'Persediaan saat ini'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +610',b'Row #{0}: Asset {1} does not linked to Item {2}',b'Row # {0}: Aset {1} tidak terkait dengan Butir {2}'
b'apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15',b'Please setup Instructor Naming System in Education &gt; Education Settings',b'Silakan siapkan Sistem Penamaan Pengajar di Pendidikan&gt; Pengaturan Pendidikan'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +394',b'Preview Salary Slip',b'Slip Gaji Preview'
b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54',b'Account {0} has been entered multiple times',b'Akun {0} telah dimasukkan beberapa kali'
b'DocType: Account',b'Expenses Included In Valuation',b'Biaya Termasuk di Dalam Penilaian Barang'
b'apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +37',b'You can only renew if your membership expires within 30 days',b'Anda hanya bisa memperpanjang jika keanggotaan Anda akan berakhir dalam 30 hari'
b'DocType: Land Unit',b'Longitude',b'Garis bujur'
,b'Absent Student Report',b'Laporan Absen Siswa'
b'DocType: Crop',b'Crop Spacing UOM',b'Tanaman Jarak UOM'
b'DocType: Accounts Settings',b'Only select if you have setup Cash Flow Mapper documents',b'Pilih saja apakah Anda sudah menyiapkan dokumen Flow Flow Mapper'
b'DocType: Email Digest',b'Next email will be sent on:',b'Email berikutnya akan dikirim pada:'
b'DocType: Supplier Scorecard',b'Per Week',b'Per minggu'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +666',b'Item has variants.',b'Item memiliki varian.'
b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154',b'Total Student',b'Jumlah Siswa'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65',b'Item {0} not found',b'Item {0} tidak ditemukan'
b'DocType: Bin',b'Stock Value',b'Nilai Persediaan'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +239',b'Company {0} does not exist',b'Perusahaan {0} tidak ada'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40',b'{0} has fee validity till {1}',b'{0} memiliki validitas biaya sampai {1}'
b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +54',b'Tree Type',b'Jenis Tingkat Tree'
b'DocType: BOM Explosion Item',b'Qty Consumed Per Unit',b'Kuantitas Dikonsumsi Per Unit'
b'DocType: GST Account',b'IGST Account',b'Akun IGST'
b'DocType: Serial No',b'Warranty Expiry Date',b'Tanggal Berakhir Garansi'
b'DocType: Material Request Item',b'Quantity and Warehouse',b'Kuantitas dan Gudang'
b'DocType: Hub Settings',b'Unregister',b'Unregister'
b'DocType: Sales Invoice',b'Commission Rate (%)',b'Komisi Rate (%)'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24',b'Please select Program',b'Silahkan pilih Program'
b'DocType: Project',b'Estimated Cost',b'Estimasi biaya'
b'DocType: Purchase Order',b'Link to material requests',b'Link ke permintaan bahan'
b'DocType: Hub Settings',b'Publish',b'Menerbitkan'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7',b'Aerospace',b'Dirgantara'
,b'Fichier des Ecritures Comptables [FEC]',b'Fichier des Ecritures Comptables [FEC]'
b'DocType: Journal Entry',b'Credit Card Entry',b'Entri Kartu Kredit'
b'apps/erpnext/erpnext/config/accounts.py +57',b'Company and Accounts',b'Perusahaan dan Account'
b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70',b'In Value',b'Nilai'
b'DocType: Asset Settings',b'Depreciation Options',b'Opsi Penyusutan'
b'apps/erpnext/erpnext/utilities/transaction_base.py +35',b'Invalid Posting Time',b'Waktu posting tidak valid'
b'DocType: Lead',b'Campaign Name',b'Nama Promosi Kampanye'
b'DocType: Hotel Room',b'Capacity',b'Kapasitas'
b'DocType: Selling Settings',b'Close Opportunity After Days',b'Tutup Peluang Setelah Days'
,b'Reserved',b'Ditahan'
b'DocType: Driver',b'License Details',b'Rincian lisensi'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +85',b'The field From Shareholder cannot be blank',b'Bidang Dari Pemegang Saham tidak boleh kosong'
b'DocType: Purchase Order',b'Supply Raw Materials',b'Pasokan Bahan Baku'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10',b'Current Assets',b'Aset Lancar'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +121',b'{0} is not a stock Item',b'{0} bukan Barang persediaan'
b'apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6',"b""Please share your feedback to the training by clicking on 'Training Feedback' and then 'New'""",b'Silakan bagikan umpan balik Anda ke pelatihan dengan mengklik &#39;Feedback Training&#39; dan kemudian &#39;New&#39;'
b'DocType: Mode of Payment Account',b'Default Account',b'Akun Standar'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +273',b'Please select Sample Retention Warehouse in Stock Settings first',b'Silahkan pilih Sampel Retention Warehouse di Stock Settings terlebih dahulu'
b'DocType: Payment Entry',b'Received Amount (Company Currency)',b'Menerima Jumlah (Perusahaan Mata Uang)'
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192',b'Lead must be set if Opportunity is made from Lead',b'Prospek harus diatur apabila Peluang berasal dari Prospek'
b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +136',b'Payment Cancelled. Please check your GoCardless Account for more details',b'Pembayaran Dibatalkan. Silakan periksa Akun GoCardless Anda untuk lebih jelasnya'
b'apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29',b'Please select weekly off day',b'Silakan pilih dari hari mingguan'
b'DocType: Patient',b'O Negative',b'O negatif'
b'DocType: Work Order Operation',b'Planned End Time',b'Rencana Waktu Berakhir'
,b'Sales Person Target Variance Item Group-Wise',b'Sales Person Sasaran Variance Stok Barang Group-Wise'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +93',b'Account with existing transaction cannot be converted to ledger',b'Akun dengan transaksi yang ada tidak dapat dikonversi ke buku besar'
b'apps/erpnext/erpnext/config/non_profit.py +33',b'Memebership Type Details',b'Rincian Jenis Memebership'
b'DocType: Delivery Note',"b""Customer's Purchase Order No""",b'Nomor Order Pembelian Pelanggan'
b'DocType: Budget',b'Budget Against',b'anggaran Terhadap'
b'DocType: Employee',b'Cell Number',b'Nomor HP'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +450',"b""There's no employee for the given criteria. Check that Salary Slips have not already been created.""",b'Tidak ada karyawan untuk kriteria yang diberikan. Periksa bahwa Slip Gaji belum pernah dibuat.'
b'apps/erpnext/erpnext/stock/reorder_item.py +194',b'Auto Material Requests Generated',b'Pembuatan Form Permintaan Material Otomatis'
b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7',b'Lost',b'Kalah'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +152',"b""You can not enter current voucher in 'Against Journal Entry' column""","b""Anda tidak dapat memasukkan voucher saat ini di kolom 'Terhadap Entri Jurnal'"""
b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50',b'Reserved for manufacturing',b'Dicadangkan untuk manufaktur'
b'DocType: Soil Texture',b'Sand',b'Pasir'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25',b'Energy',b'Energi'
b'DocType: Opportunity',b'Opportunity From',b'Peluang Dari'
b'apps/erpnext/erpnext/config/hr.py +98',b'Monthly salary statement.',b'Laporan gaji bulanan.'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +887',b'Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.',b'Baris {0}: {1} Nomor seri diperlukan untuk Item {2}. Anda telah memberikan {3}.'
b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79',b'Please select a table',b'Silahkan pilih sebuah tabel'
b'DocType: BOM',b'Website Specifications',b'Website Spesifikasi'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78',"b""{0} is an invalid email address in 'Recipients'""",b'{0} adalah alamat email yang tidak valid di &#39;Penerima&#39;'
b'DocType: Special Test Items',b'Particulars',b'Particulars'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24',b'{0}: From {0} of type {1}',b'{0}: Dari {0} tipe {1}'
b'DocType: Warranty Claim',b'CI-',b'cipher'
b'apps/erpnext/erpnext/controllers/buying_controller.py +300',b'Row {0}: Conversion Factor is mandatory',b'Row {0}: Faktor Konversi adalah wajib'
b'DocType: Student',b'A+',b'A +'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +344',"b'Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}'","b'Beberapa Aturan Harga ada dengan kriteria yang sama, silahkan menyelesaikan konflik dengan menetapkan prioritas. Harga Aturan: {0}'"
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +519',b'Cannot deactivate or cancel BOM as it is linked with other BOMs',b'Tidak bisa menonaktifkan atau membatalkan BOM seperti yang terkait dengan BOMs lainnya'
b'DocType: Asset',b'Maintenance',b'Pemeliharaan'
b'DocType: Item Attribute Value',b'Item Attribute Value',b'Nilai Item Atribut'
b'apps/erpnext/erpnext/projects/doctype/project/project.py +406',b'Please Update your Project Status',b'Harap Perbarui Status Proyek Anda'
b'DocType: Item',b'Maximum sample quantity that can be retained',b'Jumlah sampel maksimal yang bisa dipertahankan'
b'DocType: Project Update',b'How is the Project Progressing Right Now?',b'Bagaimana Kemajuan Proyek Sekarang?'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +418',b'Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3}',b'Baris {0} # Item {1} tidak dapat ditransfer lebih dari {2} terhadap Pesanan Pembelian {3}'
b'apps/erpnext/erpnext/config/selling.py +158',b'Sales campaigns.',b'Kampanye penjualan.'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +117',b'Make Timesheet',b'membuat Timesheet'
b'DocType: Sales Taxes and Charges Template',"b'Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.'","b'Format pajak standar yang dapat diterapkan untuk semua Transaksi Penjualan. Format ini dapat berisi daftar kepala pajak dan juga kepala pengeluaran / penghasilan lain seperti ""Pengiriman"", ""Asuransi"", ""Penanganan"" dll. #### Catatan: Tarif pajak yang Anda definisikan disini akan menjadi tarif pajak standar untuk semua **Barang**. Jika ada **Barang** yang memiliki tarif yang berbeda, mereka harus ditambahkan ke dalam tabel **Pajak Barang** dalam daftar utama **Barang**. #### Deskripsi Kolom 1. Jenis Perhitungan: - Bisa berdasarkan **Jumlah Netto** (yaitu total dari jumlah dasar). - **Jumlah Baris Sebelumnya** (untuk pajak atau biaya kumulatif). Jika Anda memilih opsi ini, pajak akan diterapkan sebagai prosentase dari jumlah baris sebelumnya (dalam tabel pajak). - **Aktual** (seperti yang disebutkan). 2. Akun Kepala: Akun buku di mana pajak ini akan dibukukan. 3. Pusat Biaya: Jika pajak / ongkos adalah penghasilan (seperti pengiriman) atau beban maka harus dibukukan terhadap Pusat Biaya. 4. Keterangan: Deskripsi pajak (yang akan dicetak dalam faktur / penawaran). 5. Tarif: Tarif Pajak. 6. Jumlah: Jumlah Pajak. 7. Total: Total kumulatif sampai baris ini. 8. Baris Entri: Jika berdasarkan ""Jumlah Baris Sebelumnya"" Anda dapat memilih nomor baris yang akan diambil sebagai dasar perhitungan (standarnya adalah baris sebelumnya). 9. Apakah Pajak ini termasuk dalam Tarif Dasar?: Jika Anda tandai ini, berarti pajak ini tidak akan ditampilkan di bawah tabel barang, tapi akan dimasukkan dalam Tarif Dasar dalam tabel utama barang Anda. Hal ini berguna jika Anda ingin memberikan harga datar /flat price (semua pajak sudah termasuk) untuk pelanggan.'"
b'DocType: Employee',b'Bank A/C No.',b'Rekening Bank No.'
b'DocType: Bank Guarantee',b'Project',b'Proyek'
b'DocType: Quality Inspection Reading',b'Reading 7',b'Membaca 7'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9',b'Partially Ordered',b'sebagian Memerintahkan'
b'DocType: Lab Test',b'Lab Test',b'Uji Lab'
b'DocType: Student Report Generation Tool',b'Student Report Generation Tool',b'Alat Pembangkitan Laporan Siswa'
b'DocType: Expense Claim Detail',b'Expense Claim Type',b'Tipe Beban Klaim'
b'DocType: Shopping Cart Settings',b'Default settings for Shopping Cart',b'Pengaturan default untuk Belanja'
b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +27',b'Add Timeslots',b'Tambahkan Timeslots'
b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138',b'Asset scrapped via Journal Entry {0}',b'Aset membatalkan via Journal Entri {0}'
b'DocType: Employee Loan',b'Interest Income Account',b'Akun Pendapatan Bunga'
b'apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58',b'Review Invitation Sent',b'Tinjau Undangan Dikirim'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13',b'Biotechnology',b'Bioteknologi'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109',b'Office Maintenance Expenses',b'Beban Pemeliharaan Kantor'
b'apps/erpnext/erpnext/utilities/user_progress.py +54',b'Go to ',b'Pergi ke'
b'apps/erpnext/erpnext/config/learn.py +47',b'Setting up Email Account',b'Mengatur Akun Email'
b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +21',b'Please enter Item first',b'Entrikan Stok Barang terlebih dahulu'
b'DocType: Asset Repair',b'Downtime',b'Downtime'
b'DocType: Account',b'Liability',b'Kewajiban'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +220',b'Sanctioned Amount cannot be greater than Claim Amount in Row {0}.',b'Sanksi Jumlah tidak dapat lebih besar dari Klaim Jumlah dalam Row {0}.'
b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11',b'Academic Term: ',b'Istilah Akademik:'
b'DocType: Salary Detail',b'Do not include in total',b'Jangan termasuk secara total'
b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +206',b'Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series',b'Silakan tetapkan Seri Penamaan untuk {0} melalui Pengaturan&gt; Pengaturan&gt; Seri Penamaan'
b'DocType: Company',b'Default Cost of Goods Sold Account',b'Standar Harga Pokok Penjualan'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1019',b'Sample quantity {0} cannot be more than received quantity {1}',b'Kuantitas sampel {0} tidak boleh lebih dari jumlah yang diterima {1}'
b'apps/erpnext/erpnext/stock/get_item_details.py +369',b'Price List not selected',b'Daftar Harga tidak dipilih'
b'DocType: Employee',b'Family Background',b'Latar Belakang Keluarga'
b'DocType: Request for Quotation Supplier',b'Send Email',b'Kirim Email'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +228',b'Warning: Invalid Attachment {0}',b'Peringatan: Lampiran tidak valid {0}'
b'DocType: Item',b'Max Sample Quantity',b'Jumlah Kuantitas Maks'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +766',b'No Permission',b'Tidak ada Izin'
b'DocType: Vital Signs',b'Heart Rate / Pulse',b'Heart Rate / Pulse'
b'DocType: Company',b'Default Bank Account',b'Standar Rekening Bank'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +59',"b'To filter based on Party, select Party Type first'","b'Untuk menyaring berdasarkan Party, pilih Partai Ketik terlebih dahulu'"
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48',"b""'Update Stock' can not be checked because items are not delivered via {0}""","b""'Pembaruan Persediaan\xe2\x80\x99 tidak dapat dipilih karena barang tidak dikirim melalui {0}"""
b'DocType: Vehicle',b'Acquisition Date',b'Tanggal akuisisi'
b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Nos',b'Nos'
b'DocType: Item',b'Items with higher weightage will be shown higher',b'Item dengan weightage lebih tinggi akan ditampilkan lebih tinggi'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14',b'Lab Tests and Vital Signs',b'Tes Laboratorium dan Tanda Vital'
b'DocType: Bank Reconciliation Detail',b'Bank Reconciliation Detail',b'Rincian Rekonsiliasi Bank'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +614',b'Row #{0}: Asset {1} must be submitted',b'Row # {0}: Aset {1} harus diserahkan'
b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40',b'No employee found',b'Tidak ada karyawan yang ditemukan'
b'DocType: Subscription',b'Stopped',b'Terhenti'
b'DocType: Item',b'If subcontracted to a vendor',b'Jika subkontrak ke pemasok'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111',b'Student Group is already updated.',b'Kelompok Siswa sudah diperbarui.'
b'apps/erpnext/erpnext/config/projects.py +18',b'Project Update.',b'Pembaruan Proyek.'
b'DocType: SMS Center',b'All Customer Contact',b'Semua Kontak Pelanggan'
b'DocType: Land Unit',b'Tree Details',b'Detail pohon'
b'DocType: Training Event',b'Event Status',b'Status acara'
b'DocType: Volunteer',b'Availability Timeslot',b'Ketersediaan Timeslot'
,b'Support Analytics',b'Dukungan Analytics'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +365',"b'If you have any questions, please get back to us.'","b'Jika Anda memiliki pertanyaan, silakan kembali ke kami.'"
b'DocType: Cash Flow Mapper',b'Cash Flow Mapper',b'Kas Arus Mapper'
b'DocType: Item',b'Website Warehouse',b'Situs Gudang'
b'DocType: Payment Reconciliation',b'Minimum Invoice Amount',b'Nilai Minimum Faktur'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111',b'{0} {1}: Cost Center {2} does not belong to Company {3}',b'{0} {1}: Pusat Biaya {2} bukan milik Perusahaan {3}'
b'apps/erpnext/erpnext/utilities/user_progress.py +92',b'Upload your letter head (Keep it web friendly as 900px by 100px)',b'Upload kepala surat Anda (Jaga agar web semudah 900px dengan 100px)'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88',b'{0} {1}: Account {2} cannot be a Group',b'{0} {1}: Akun {2} tidak boleh Kelompok'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63',"b""Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table""",b'Item Row {idx}: {doctype} {DOCNAME} tidak ada di atas &#39;{doctype}&#39; table'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +295',b'Timesheet {0} is already completed or cancelled',b'Absen {0} sudah selesai atau dibatalkan'
b'apps/erpnext/erpnext/templates/pages/projects.html +42',b'No tasks',b'Tidak ada tugas'
b'DocType: Item Variant Settings',b'Copy Fields to Variant',b'Copy Fields ke Variant'
b'DocType: Asset',b'Opening Accumulated Depreciation',b'Membuka Penyusutan Akumulasi'
b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49',b'Score must be less than or equal to 5',b'Skor harus kurang dari atau sama dengan 5'
b'DocType: Program Enrollment Tool',b'Program Enrollment Tool',b'Program Pendaftaran Alat'
b'apps/erpnext/erpnext/config/accounts.py +335',b'C-Form records',b'C-Form catatan'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +73',b'The shares already exist',b'Sahamnya sudah ada'
b'apps/erpnext/erpnext/config/selling.py +316',b'Customer and Supplier',b'Pelanggan dan Pemasok'
b'DocType: Email Digest',b'Email Digest Settings',b'Pengaturan Surel Ringkasan'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +367',b'Thank you for your business!',b'Terima kasih untuk bisnis Anda!'
b'apps/erpnext/erpnext/config/support.py +12',b'Support queries from customers.',b'Permintaan dukungan dari pelanggan.'
b'DocType: Setup Progress Action',b'Action Doctype',b'Doctype Aksi'
b'DocType: HR Settings',b'Retirement Age',b'Umur pensiun'
b'DocType: Bin',b'Moving Average Rate',b'Tingkat Moving Average'
b'DocType: Production Plan',b'Select Items',b'Pilih Produk'
b'DocType: Share Transfer',b'To Shareholder',b'Kepada Pemegang Saham'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372',b'{0} against Bill {1} dated {2}',b'{0} terhadap Tagihan {1} tanggal {2}'
b'apps/erpnext/erpnext/utilities/user_progress.py +27',b'Setup Institution',b'Lembaga Penyiapan'
b'DocType: Program Enrollment',b'Vehicle/Bus Number',b'Kendaraan / Nomor Bus'
b'apps/erpnext/erpnext/education/doctype/course/course.js +17',b'Course Schedule',b'Jadwal Kuliah'
b'DocType: Request for Quotation Supplier',b'Quote Status',b'Status Penawaran'
b'DocType: GoCardless Settings',b'Webhooks Secret',b'Webhooks Secret'
b'DocType: Maintenance Visit',b'Completion Status',b'Status Penyelesaian'
b'DocType: Daily Work Summary Group',b'Select Users',b'Pilih Pengguna'
b'DocType: Hotel Room Pricing Item',b'Hotel Room Pricing Item',b'Item Harga Kamar Hotel'
b'DocType: HR Settings',b'Enter retirement age in years',b'Memasuki usia pensiun di tahun'
b'DocType: Crop',b'Target Warehouse',b'Target Gudang'
b'DocType: Payroll Employee Detail',b'Payroll Employee Detail',b'Daftar gaji karyawan'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128',b'Please select a warehouse',b'Silahkan pilih gudang'
b'DocType: Cheque Print Template',b'Starting location from left edge',b'Mulai lokasi dari tepi kiri'
b'DocType: Item',b'Allow over delivery or receipt upto this percent',b'Biarkan selama pengiriman atau penerimaan upto persen ini'
b'DocType: Stock Entry',b'STE-',b'Ste-'
b'DocType: Upload Attendance',b'Import Attendance',b'Impor Absensi'
b'apps/erpnext/erpnext/public/js/pos/pos.html +124',b'All Item Groups',b'Semua Grup Stok Barang/Item'
b'apps/erpnext/erpnext/config/setup.py +89',b'Automatically compose message on submission of transactions.',b'Secara otomatis menulis pesan pada pengajuan transaksi.'
b'DocType: Work Order',b'Item To Manufacture',b'Stok Barang Untuk Produksi'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44',b'CompteLib',b'CompteLib'
b'apps/erpnext/erpnext/buying/utils.py +80',b'{0} {1} status is {2}',b'{0} {1} status adalah {2}'
b'DocType: Water Analysis',b'Collection Temperature ',b'Suhu Koleksi'
b'DocType: Employee',b'Provide Email Address registered in company',b'Sediakan Alamat Email yang terdaftar di perusahaan'
b'DocType: Shopping Cart Settings',b'Enable Checkout',b'aktifkan Checkout'
b'apps/erpnext/erpnext/config/learn.py +202',b'Purchase Order to Payment',b'Order Pembelian untuk Dibayar'
b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48',b'Projected Qty',b'Proyeksi Qty'
b'DocType: Sales Invoice',b'Payment Due Date',b'Tanggal Jatuh Tempo Pembayaran'
b'DocType: Drug Prescription',b'Interval UOM',b'Interval UOM'
b'DocType: Customer',"b'Reselect, if the chosen address is edited after save'","b'Pilih ulang, jika alamat yang dipilih diedit setelah simpan'"
b'apps/erpnext/erpnext/stock/doctype/item/item.js +522',b'Item Variant {0} already exists with same attributes',b'Item Varian {0} sudah ada dengan atribut yang sama'
b'DocType: Item',b'Hub Publishing Details',b'Rincian Hub Publishing'
b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +117',"b""'Opening'""","b""'Awal'"""
b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130',b'Open To Do',b'Terbuka yang Harus Dilakukan'
b'DocType: Notification Control',b'Delivery Note Message',b'Pesan Nota Pengiriman'
b'DocType: Lab Test Template',b'Result Format',b'Format Hasil'
b'DocType: Expense Claim',b'Expenses',b'Biaya / Beban'
b'DocType: Item Variant Attribute',b'Item Variant Attribute',b'Item Varian Atribut'
,b'Purchase Receipt Trends',b'Tren Nota Penerimaan'
b'DocType: Payroll Entry',b'Bimonthly',b'Dua bulan sekali'
b'DocType: Vehicle Service',b'Brake Pad',b'Bantalan Rem'
b'DocType: Fertilizer',b'Fertilizer Contents',b'Isi pupuk'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119',b'Research & Development',b'Penelitian & Pengembangan'
b'apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20',b'Amount to Bill',b'Nilai Tertagih'
b'DocType: Company',b'Registration Details',b'Detail Pendaftaran'
b'DocType: Timesheet',b'Total Billed Amount',b'Jumlah Total Ditagih'
b'DocType: Item Reorder',b'Re-Order Qty',b'Re-order Qty'
b'DocType: Leave Block List Date',b'Leave Block List Date',b'Tanggal Block List Cuti'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +94',b'BOM #{0}: Raw material cannot be same as main Item',b'BOM #{0}: Bahan baku tidak boleh sama dengan Barang utamanya'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +92',b'Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges',b'Total Biaya Berlaku di Purchase meja Jenis Penerimaan harus sama dengan jumlah Pajak dan Biaya'
b'DocType: Sales Team',b'Incentives',b'Insentif'
b'DocType: SMS Log',b'Requested Numbers',b'Nomor yang Diminta'
b'DocType: Volunteer',b'Evening',b'Malam'
b'DocType: Customer',b'Bypass credit limit check at Sales Order',b'Bataskan cek batas kredit pada Sales Order'
b'apps/erpnext/erpnext/config/hr.py +147',b'Performance appraisal.',b'Penilaian kinerja.'
b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +100',"b""Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart""","b'Mengaktifkan &#39;Gunakan untuk Keranjang Belanja&#39;, sebagai Keranjang Belanja diaktifkan dan harus ada setidaknya satu Rule Pajak untuk Belanja'"
b'apps/erpnext/erpnext/controllers/accounts_controller.py +412',"b'Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.'","b'Masuk pembayaran {0} terkait terhadap Orde {1}, memeriksa apakah itu harus ditarik sebagai uang muka dalam faktur ini.'"
b'DocType: Sales Invoice Item',b'Stock Details',b'Rincian Persediaan'
b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29',b'Project Value',b'Nilai Proyek'
b'apps/erpnext/erpnext/config/selling.py +326',b'Point-of-Sale',b'POS'
b'DocType: Fee Schedule',b'Fee Creation Status',b'Status Penciptaan Biaya'
b'DocType: Vehicle Log',b'Odometer Reading',b'Pembacaan odometer'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +116',"b""Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'""","b""Saldo rekening telah berada di Kredit, Anda tidak diizinkan untuk mengatur 'Balance Harus' sebagai 'Debit'"""
b'DocType: Account',b'Balance must be',b'Saldo harus'
b'DocType: Hub Settings',b'Publish Pricing',b'Publikasikan Harga'
b'DocType: Notification Control',b'Expense Claim Rejected Message',b'Beban Klaim Ditolak Pesan'
,b'Available Qty',b'Qty Tersedia'
b'DocType: Purchase Taxes and Charges',b'On Previous Row Total',b'Jumlah Pada Row Sebelumnya'
b'DocType: Purchase Invoice Item',b'Rejected Qty',b'ditolak Qty'
b'DocType: Setup Progress Action',b'Action Field',b'Bidang Aksi'
b'DocType: Healthcare Settings',b'Manage Customer',b'Kelola Pelanggan'
b'DocType: Delivery Trip',b'Delivery Stops',b'Pengiriman Berhenti'
b'DocType: Salary Slip',b'Working Days',b'Hari Kerja'
b'DocType: Serial No',b'Incoming Rate',b'Harga Penerimaan'
b'DocType: Packing Slip',b'Gross Weight',b'Berat Kotor'
,b'Final Assessment Grades',b'Penilaian Akhir Kelas'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47',b'Enable Hub',b'Aktifkan Hub'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +110',b'The name of your company for which you are setting up this system.',b'Nama perusahaan Anda yang Anda sedang mengatur sistem ini.'
b'DocType: HR Settings',b'Include holidays in Total no. of Working Days',b'Sertakan Hari Libur di total no. dari Hari Kerja'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +108',b'Setup your Institute in ERPNext',b'Siapkan Institut Anda di ERPNext'
b'DocType: Agriculture Analysis Criteria',b'Plant Analysis',b'Analisis Tanaman'
b'DocType: Job Applicant',b'Hold',b'Ditahan'
b'DocType: Project Update',b'Progress Details',b'Detail Kemajuan'
b'DocType: Employee',b'Date of Joining',b'Tanggal Bergabung'
b'DocType: Naming Series',b'Update Series',b'Perbarui Seri'
b'DocType: Supplier Quotation',b'Is Subcontracted',b'Apakah Subkontrak?'
b'DocType: Restaurant Table',b'Minimum Seating',b'Tempat Duduk Minimal'
b'DocType: Item Attribute',b'Item Attribute Values',b'Item Nilai Atribut'
b'DocType: Examination Result',b'Examination Result',b'Hasil pemeriksaan'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +845',b'Purchase Receipt',b'Nota Penerimaan'
,b'Received Items To Be Billed',b'Produk Diterima Akan Ditagih'
b'apps/erpnext/erpnext/config/accounts.py +303',b'Currency exchange rate master.',b'Master Nilai Mata Uang'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209',b'Reference Doctype must be one of {0}',b'Referensi DOCTYPE harus menjadi salah satu {0}'
b'apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js +46',b'Filter Total Zero Qty',b'Filter Total Zero Qty'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +341',b'Unable to find Time Slot in the next {0} days for Operation {1}',b'Tidak dapat menemukan waktu Slot di {0} hari berikutnya untuk Operasi {1}'
b'DocType: Work Order',b'Plan material for sub-assemblies',b'Planning Material untuk Barang Rakitan'
b'apps/erpnext/erpnext/config/selling.py +97',b'Sales Partners and Territory',b'Mitra Penjualan dan Wilayah'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +600',b'BOM {0} must be active',b'BOM {0} harus aktif'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +414',b'No Items available for transfer',b'Tidak ada item yang tersedia untuk transfer'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +218',b'Closing (Opening + Total)',b'Penutupan (Pembukaan + Total)'
b'DocType: Journal Entry',b'Depreciation Entry',b'penyusutan Masuk'
b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +32',b'Please select the document type first',b'Silakan pilih jenis dokumen terlebih dahulu'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65',b'Cancel Material Visits {0} before cancelling this Maintenance Visit',b'Batal Kunjungan Material {0} sebelum membatalkan ini Maintenance Visit'
b'DocType: Crop Cycle',b'ISO 8016 standard',b'Standar ISO 8016'
b'DocType: Pricing Rule',b'Rate or Discount',b'Tarif atau Diskon'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213',b'Serial No {0} does not belong to Item {1}',b'Serial ada {0} bukan milik Stok Barang {1}'
b'DocType: Purchase Receipt Item Supplied',b'Required Qty',b'Qty Diperlukan'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +126',b'Warehouses with existing transaction can not be converted to ledger.',b'Gudang dengan transaksi yang ada tidak dapat dikonversi ke buku besar.'
b'DocType: Bank Reconciliation',b'Total Amount',b'Nilai Total'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32',b'Internet Publishing',b'Penerbitan Internet'
b'DocType: Prescription Duration',b'Number',b'Jumlah'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25',b'Creating {0} Invoice',b'Membuat {0} Faktur'
b'DocType: Medical Code',b'Medical Code Standard',b'Standar Kode Medis'
b'DocType: Soil Texture',b'Clay Composition (%)',b'Komposisi Tanah Liar (%)'
b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81',b'Please save before assigning task.',b'Harap simpan sebelum menugaskan tugas.'
b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +74',b'Balance Value',b'Nilai Saldo'
b'DocType: Lab Test',b'Lab Technician',b'Teknisi laboratorium'
b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38',b'Sales Price List',b'Daftar Harga Jual'
b'DocType: Healthcare Settings',"b'If checked, a customer will be created, mapped to Patient.\nPatient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.'","b'Jika dicek, pelanggan akan dibuat, dipetakan ke Patient. Faktur pasien akan dibuat terhadap Nasabah ini. Anda juga bisa memilih Customer yang ada saat membuat Patient.'"
b'DocType: Bank Reconciliation',b'Account Currency',b'Mata Uang Akun'
b'DocType: Lab Test',b'Sample ID',b'Contoh ID'
b'apps/erpnext/erpnext/accounts/general_ledger.py +167',b'Please mention Round Off Account in Company',b'Sebutkan Round Off Akun/ Akun Pembulatan di Perusahaan'
b'DocType: Purchase Receipt',b'Range',b'Jarak'
b'DocType: Supplier',b'Default Payable Accounts',b'Standar Akun Hutang'
b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49',b'Employee {0} is not active or does not exist',b'Karyawan {0} tidak aktif atau tidak ada'
b'DocType: Fee Structure',b'Components',b'komponen'
b'DocType: Item Barcode',b'Item Barcode',b'Item Barcode'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +329',b'Please enter Asset Category in Item {0}',b'Cukup masukkan Aset Kategori dalam angka {0}'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +661',b'Item Variants {0} updated',b'Varian Barang {0} diperbarui'
b'DocType: Quality Inspection Reading',b'Reading 6',b'Membaca 6'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +9',"b'to be generated. If delayed, you will have to manually change the ""Repeat on Day of Month"" field\nof this'","b'untuk dihasilkan. Jika tertunda, Anda harus mengubah secara manual bidang ""Ulangi pada Hari di Bulan"" ini'"
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +961',b'Cannot {0} {1} {2} without any negative outstanding invoice',b'Tidak bisa {0} {1} {2} tanpa faktur yang beredar negatif'
b'DocType: Share Transfer',b'From Folio No',b'Dari Folio No'
b'DocType: Purchase Invoice Advance',b'Purchase Invoice Advance',b'Uang Muka Faktur Pembelian'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199',b'Row {0}: Credit entry can not be linked with a {1}',b'Baris {0}: entry Kredit tidak dapat dihubungkan dengan {1}'
b'apps/erpnext/erpnext/config/accounts.py +246',b'Define budget for a financial year.',b'Tentukan anggaran untuk tahun keuangan.'
b'DocType: Lead',b'LEAD-',b'PROSPEK-'
b'DocType: Employee',b'Permanent Address Is',b'Alamat Permanen Adalah:'
b'DocType: Work Order Operation',b'Operation completed for how many finished goods?',b'Operasi selesai untuk berapa banyak Stok Barang jadi?'
b'DocType: Payment Terms Template',b'Payment Terms Template',b'Template Persyaratan Pembayaran'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +51',b'The Brand',b'Merek'
b'DocType: Employee',b'Exit Interview Details',b'Detail Exit Interview'
b'DocType: Item',b'Is Purchase Item',b'Stok Dibeli dari Supplier'
b'DocType: Journal Entry Account',b'Purchase Invoice',b'Faktur Pembelian'
b'DocType: Stock Ledger Entry',b'Voucher Detail No',b'Nomor Detail Voucher'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +789',b'New Sales Invoice',b'Baru Faktur Penjualan'
b'DocType: Stock Entry',b'Total Outgoing Value',b'Nilai Total Keluaran'
b'DocType: Physician',b'Appointments',b'Janji'
b'apps/erpnext/erpnext/public/js/account_tree_grid.js +223',b'Opening Date and Closing Date should be within same Fiscal Year',b'Tanggal dan Closing Date membuka harus berada dalam Tahun Anggaran yang sama'
b'DocType: Lead',b'Request for Information',b'Request for Information'
,b'LeaderBoard',b'LeaderBoard'
b'DocType: Sales Invoice Item',b'Rate With Margin (Company Currency)',b'Tingkat Dengan Margin (Mata Uang Perusahaan)'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +802',b'Sync Offline Invoices',b'Sinkronisasi Offline Faktur'
b'DocType: Payment Request',b'Paid',b'Dibayar'
b'DocType: Program Fee',b'Program Fee',b'Biaya Program'
b'DocType: BOM Update Tool',"b'Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.\nIt also updates latest price in all the BOMs.'","b'Ganti BOM tertentu di semua BOM lain yang menggunakannya. Hal ini akan mengganti link BOM lama, memperbarui biaya dan membuat ulang tabel ""Rincian Barang BOM"" sesuai BOM baru. Juga memperbarui harga terbaru di semua BOM.'"
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +447',b'The following Work Orders were created:',b'Perintah Kerja berikut dibuat:'
b'DocType: Salary Slip',b'Total in words',b'Jumlah kata'
b'DocType: Material Request Item',b'Lead Time Date',b'Tanggal Masa Tenggang'
,b'Employee Advance Summary',b'Ringkasan Uang Muka Karyawan'
b'DocType: Asset',b'Available-for-use Date',b'Tanggal yang tersedia untuk penggunaan'
b'DocType: Guardian',b'Guardian Name',b'Nama wali'
b'DocType: Cheque Print Template',b'Has Print Format',b'Memiliki Print Format'
b'DocType: Employee Loan',b'Sanctioned',b'sanksi'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +75',b' is mandatory. Maybe Currency Exchange record is not created for ',b'wajib diisi. Mungkin Kurs Mata Uang belum dibuat untuk'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +139',b'Row #{0}: Please specify Serial No for Item {1}',b'Row # {0}: Silakan tentukan Serial ada untuk Item {1}'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54',b'Supplier &gt; Supplier Type',b'Pemasok&gt; Jenis Pemasok'
b'DocType: Crop Cycle',b'Crop Cycle',b'Siklus Tanaman'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +633',"b""For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.""","b""Untuk barang-barang 'Bundel Produk', Gudang, Nomor Serial dan Nomor Batch akan diperhitungkan dari tabel 'Packing List'. Bila Gudang dan Nomor Batch sama untuk semua barang-barang kemasan dari segala barang 'Bundel Produk', maka nilai tersebut dapat dimasukkan dalam tabel Barang utama, nilai tersebut akan disalin ke tabel 'Packing List'."""
b'DocType: Student Admission',b'Publish on website',b'Mempublikasikan di website'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +651',b'Supplier Invoice Date cannot be greater than Posting Date',b'Pemasok Faktur Tanggal tidak dapat lebih besar dari Posting Tanggal'
b'DocType: Purchase Invoice Item',b'Purchase Order Item',b'Stok Barang Order Pembelian'
b'DocType: Agriculture Task',b'Agriculture Task',b'Tugas Pertanian'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132',b'Indirect Income',b'Pendapatan Tidak Langsung'
b'DocType: Student Attendance Tool',b'Student Attendance Tool',b'Alat Kehadiran Siswa'
b'DocType: Restaurant Menu',b'Price List (Auto created)',b'Daftar Harga (Auto dibuat)'
b'DocType: Cheque Print Template',b'Date Settings',b'Pengaturan Tanggal'
b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48',b'Variance',b'Variance'
,b'Company Name',b'Nama Perusahaan'
b'DocType: SMS Center',b'Total Message(s)',b'Total Pesan (s)'
b'DocType: Share Balance',b'Purchased',b'Dibeli'
b'DocType: Item Variant Settings',b'Rename Attribute Value in Item Attribute.',b'Ubah Nama Nilai Atribut di Atribut Item.'
b'DocType: Purchase Invoice',b'Additional Discount Percentage',b'Persentase Diskon Tambahan'
b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24',b'View a list of all the help videos',b'Lihat daftar semua bantuan video'
b'DocType: Agriculture Analysis Criteria',b'Soil Texture',b'Tekstur Tanah'
b'DocType: Bank Reconciliation',b'Select account head of the bank where cheque was deposited.',b'Pilih kepala rekening bank mana cek diendapkan.'
b'DocType: Selling Settings',b'Allow user to edit Price List Rate in transactions',b'Izinkan user/pengguna untuk mengubah rate daftar harga di dalam transaksi'
b'DocType: Pricing Rule',b'Max Qty',b'Qty Maksimum'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js +25',b'Print Report Card',b'Cetak Kartu Laporan'
b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +30',"b'Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \\\n\t\t\t\t\t\tPlease enter a valid Invoice'","b'Row {0}: Faktur {1} tidak valid, mungkin dibatalkan / tidak ada. \\ Masukkan Faktur valid'"
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +132',b'Row {0}: Payment against Sales/Purchase Order should always be marked as advance',b'Baris {0}: Pembayaran terhadap Penjualan / Purchase Order harus selalu ditandai sebagai muka'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16',b'Chemical',b'Kimia'
b'DocType: Salary Component Account',b'Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.',b'Akun standar Bank / Cash akan otomatis diperbarui di Entri Jurnal Gaji saat mode ini dipilih.'
b'DocType: BOM',b'Raw Material Cost(Company Currency)',b'Biaya Bahan Baku (Perusahaan Mata Uang)'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +88',b'Row # {0}: Rate cannot be greater than the rate used in {1} {2}',b'Baris # {0}: Tarif tidak boleh lebih besar dari tarif yang digunakan di {1} {2}'
b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Meter',b'Meter'
b'DocType: Workstation',b'Electricity Cost',b'Biaya Listrik'
b'apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +23',b'Lab testing datetime cannot be before collection datetime',b'Lab testing datetime tidak bisa sebelum koleksi datetime'
b'DocType: HR Settings',"b""Don't send Employee Birthday Reminders""",b'Jangan Kirim Pengingat Ulang Tahun'
b'DocType: Expense Claim',b'Total Advance Amount',b'Jumlah Uang Muka Total'
b'DocType: Delivery Stop',b'Estimated Arrival',b'perkiraan kedatangan'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +34',b'Save Settings',b'Simpan Pengaturan'
b'DocType: Delivery Stop',b'Notified by Email',b'Diberitahukan melalui email'
b'DocType: Item',b'Inspection Criteria',b'Kriteria Inspeksi'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14',b'Transfered',b'Ditransfer'
b'DocType: BOM Website Item',b'BOM Website Item',b'BOM Situs Persediaan'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +52',b'Upload your letter head and logo. (you can edit them later).',b'Unggah kop surat dan logo. (Anda dapat mengubahnya nanti).'
b'DocType: Timesheet Detail',b'Bill',b'Tagihan'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +88',b'Next Depreciation Date is entered as past date',b'Berikutnya Penyusutan Tanggal dimasukkan sebagai tanggal terakhir'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208',b'White',b'Putih'
b'DocType: SMS Center',b'All Lead (Open)',b'Semua Prospek (Terbuka)'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +270',b'Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3})',b'Row {0}: Qty tidak tersedia untuk {4} di gudang {1} pada postingan kali entri ({2} {3})'
b'apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18',b'You can only select a maximum of one option from the list of check boxes.',b'Anda hanya bisa memilih maksimal satu pilihan dari daftar kotak centang.'
b'DocType: Purchase Invoice',b'Get Advances Paid',b'Dapatkan Uang Muka Dibayar'
b'DocType: Item',b'Automatically Create New Batch',b'Buat Batch Baru secara otomatis'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +635',b'Assigning {0} to {1} (row {2})',b'Menugaskan {0} ke {1} (baris {2})'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810',b'Make ',b'Membuat'
b'DocType: Student Admission',b'Admission Start Date',b'Pendaftaran Mulai Tanggal'
b'DocType: Journal Entry',b'Total Amount in Words',b'Jumlah Total dalam Kata'
b'apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29',b'New Employee',b'Karyawan baru'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7',"b""There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.""",b'Ada kesalahan. Salah satu alasan yang mungkin bisa jadi Anda belum menyimpan formulir. Silahkan hubungi support@erpnext.com jika masalah terus berlanjut.'
b'apps/erpnext/erpnext/templates/pages/cart.html +5',b'My Cart',b'Cart saya'
b'apps/erpnext/erpnext/controllers/selling_controller.py +130',b'Order Type must be one of {0}',b'Order Type harus menjadi salah satu {0}'
b'DocType: Lead',b'Next Contact Date',b'Tanggal Komunikasi Selanjutnya'
b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36',b'Opening Qty',b'Qty Pembukaan'
b'DocType: Healthcare Settings',b'Appointment Reminder',b'Pengingat Penunjukan'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +478',b'Please enter Account for Change Amount',b'Silahkan masukkan account untuk Perubahan Jumlah'
b'DocType: Program Enrollment Tool Student',b'Student Batch Name',b'Mahasiswa Nama Batch'
b'DocType: Consultation',b'Doctor',b'Dokter'
b'DocType: Holiday List',b'Holiday List Name',b'Daftar Nama Hari Libur'
b'DocType: Repayment Schedule',b'Balance Loan Amount',b'Saldo Jumlah Pinjaman'
b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14',b'Schedule Course',b'Jadwal Kursus'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +236',b'Stock Options',b'Opsi Persediaan'
b'DocType: Buying Settings',b'Disable Fetching Last Purchase Details in Purchase Order',b'Nonaktifkan Mengambil Rincian Pembelian Terakhir di Pesanan Pembelian'
b'DocType: Journal Entry Account',b'Expense Claim',b'Biaya Klaim'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +267',b'Do you really want to restore this scrapped asset?',b'Apakah Anda benar-benar ingin mengembalikan aset dibuang ini?'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +381',b'Qty for {0}',b'Kuantitas untuk {0}'
b'DocType: Leave Application',b'Leave Application',b'Aplikasi Cuti'
b'DocType: Patient',b'Patient Relation',b'Hubungan Pasien'
b'apps/erpnext/erpnext/config/hr.py +80',b'Leave Allocation Tool',b'Alat Alokasi Cuti'
b'DocType: Item',b'Hub Category to Publish',b'Kategori Hub untuk Publikasikan'
b'DocType: Leave Block List',b'Leave Block List Dates',b'Tanggal Blok List Cuti'
b'DocType: Sales Invoice',b'Billing Address GSTIN',b'Alamat Penagihan GSTIN'
b'DocType: Assessment Plan',b'Evaluate',b'Evaluasi'
b'DocType: Workstation',b'Net Hour Rate',b'Jumlah Jam Bersih'
b'DocType: Landed Cost Purchase Receipt',b'Landed Cost Purchase Receipt',b'Biaya Landing Cost Nota Penerimaan'
b'DocType: Company',b'Default Terms',b'Persyaratan Standar'
b'DocType: Supplier Scorecard Period',b'Criteria',b'Kriteria'
b'DocType: Packing Slip Item',b'Packing Slip Item',b'Packing Slip Stok Barang'
b'DocType: Purchase Invoice',b'Cash/Bank Account',b'Rekening Kas / Bank'
b'apps/erpnext/erpnext/public/js/queries.js +96',b'Please specify a {0}',b'Tentukan {0}'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +73',b'Removed items with no change in quantity or value.',b'Item dihapus dengan tidak ada perubahan dalam jumlah atau nilai.'
b'DocType: Delivery Note',b'Delivery To',b'Pengiriman Untuk'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +415',b'Variant creation has been queued.',b'Pembuatan varian telah antri.'
b'apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +100',b'Work Summary for {0}',b'Ringkasan Kerja untuk {0}'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +696',b'Attribute table is mandatory',b'Tabel atribut wajib'
b'DocType: Production Plan',b'Get Sales Orders',b'Dapatkan Order Penjualan'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +68',b'{0} can not be negative',b'{0} tidak dapat negatif'
b'DocType: Training Event',b'Self-Study',b'Belajar sendiri'
b'apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +27',b'Soil compositions do not add up to 100',b'Komposisi tanah tidak bertambah hingga 100'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +558',b'Discount',b'Diskon'
b'DocType: Membership',b'Membership',b'Keanggotaan'
b'DocType: Asset',b'Total Number of Depreciations',b'Total Jumlah Penyusutan'
b'DocType: Sales Invoice Item',b'Rate With Margin',b'Tingkat Dengan Margin'
b'DocType: Workstation',b'Wages',b'Upah'
b'DocType: Asset Maintenance',b'Maintenance Manager Name',b'Nama Manajer Pemeliharaan'
b'DocType: Agriculture Task',b'Urgent',b'Mendesak'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174',b'Please specify a valid Row ID for row {0} in table {1}',b'Tentukan Row ID berlaku untuk baris {0} dalam tabel {1}'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84',b'Unable to find variable: ',b'Tidak dapat menemukan variabel:'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +794',b'Please select a field to edit from numpad',b'Harap pilih bidang yang akan diedit dari numpad'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +264',b'Cannot be a fixed asset item as Stock Ledger is created.',b'Tidak dapat menjadi item aset tetap karena Stock Ledger dibuat.'
b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23',b'Go to the Desktop and start using ERPNext',b'Pergi ke Desktop dan mulai menggunakan ERPNext'
b'DocType: Item',b'Manufacturer',b'Pabrikasi'
b'DocType: Landed Cost Item',b'Purchase Receipt Item',b'Nota Penerimaan Stok Barang'
b'DocType: Purchase Receipt',b'PREC-RET-',b'Prec-RET-'
b'DocType: POS Profile',b'Sales Invoice Payment',b'Pembayaran Faktur Penjualan'
b'DocType: Quality Inspection Template',b'Quality Inspection Template Name',b'Nama Template Inspeksi Kualitas'
b'DocType: Project',b'First Email',b'Email Pertama'
b'DocType: Production Plan Item',b'Reserved Warehouse in Sales Order / Finished Goods Warehouse',b'Reserved Gudang di Sales Order / Stok Barang Jadi Gudang'
b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71',b'Selling Amount',b'Nilai Penjualan'
b'DocType: Repayment Schedule',b'Interest Amount',b'Jumlah bunga'
b'DocType: Serial No',b'Creation Document No',b'Nomor Dokumen'
b'DocType: Share Transfer',b'Issue',b'Masalah / Isu'
b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11',b'Records',b'Catatan'
b'DocType: Asset',b'Scrapped',b'membatalkan'
b'DocType: Purchase Invoice',b'Returns',b'Retur'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +42',b'WIP Warehouse',b'WIP Gudang'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195',b'Serial No {0} is under maintenance contract upto {1}',b'Serial ada {0} berada di bawah kontrak pemeliharaan upto {1}'
b'apps/erpnext/erpnext/config/hr.py +35',b'Recruitment',b'Pengerahan'
b'DocType: Lead',b'Organization Name',b'Nama Organisasi'
b'DocType: Tax Rule',b'Shipping State',b'Negara Pengirim'
,b'Projected Quantity as Source',b'Proyeksi Jumlah sebagai Sumber'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61',"b""Item must be added using 'Get Items from Purchase Receipts' button""","b""Item harus ditambahkan dengan menggunakan 'Dapatkan Produk dari Pembelian Penerimaan' tombol"""
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +858',b'Delivery Trip',b'Perjalanan pengiriman'
b'DocType: Student',b'A-',b'A-'
b'DocType: Share Transfer',b'Transfer Type',b'Jenis transfer'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117',b'Sales Expenses',b'Beban Penjualan'
b'DocType: Consultation',b'Diagnosis',b'Diagnosa'
b'apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18',b'Standard Buying',b'Standar Pembelian'
b'DocType: GL Entry',b'Against',b'Terhadap'
b'DocType: Item',b'Default Selling Cost Center',b'Standar Pusat Biaya Jual'
b'apps/erpnext/erpnext/public/js/pos/pos.html +85',b'Disc',b'Cakram'
b'DocType: Sales Partner',b'Implementation Partner',b'Mitra Implementasi'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1624',b'ZIP Code',b'Kode Pos'
b'apps/erpnext/erpnext/controllers/selling_controller.py +252',b'Sales Order {0} is {1}',b'Sales Order {0} adalah {1}'
b'DocType: Opportunity',b'Contact Info',b'Informasi Kontak'
b'apps/erpnext/erpnext/config/stock.py +319',b'Making Stock Entries',b'Membuat Entri Persediaan'
b'DocType: Packing Slip',b'Net Weight UOM',b'Uom Berat Bersih'
b'DocType: Item',b'Default Supplier',b'Supplier Standar'
b'DocType: Manufacturing Settings',b'Over Production Allowance Percentage',b'Selama Penyisihan Produksi Persentase'
b'DocType: Employee Loan',b'Repayment Schedule',b'Jadwal pembayaran'
b'DocType: Shipping Rule Condition',b'Shipping Rule Condition',b'Kondisi / Aturan Pengiriman'
b'DocType: Holiday List',b'Get Weekly Off Dates',b'Dapatkan Tanggal Libur Mingguan'
b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33',b'End Date can not be less than Start Date',b'Tanggal Berakhir tidak boleh lebih awal dari Tanggal Mulai'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +337',"b""Invoice can't be made for zero billing hour""",b'Faktur tidak dapat dilakukan selama nol jam penagihan'
b'DocType: Sales Person',b'Select company name first.',b'Pilih nama perusahaan terlebih dahulu.'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +189',b'Email sent to {0}',b'Email dikirim ke {0}'
b'apps/erpnext/erpnext/config/buying.py +23',b'Quotations received from Suppliers.',b'Penawaran Diterima dari Supplier'
b'apps/erpnext/erpnext/config/manufacturing.py +74',b'Replace BOM and update latest price in all BOMs',b'Ganti BOM dan perbarui harga terbaru di semua BOM'
b'apps/erpnext/erpnext/controllers/selling_controller.py +27',b'To {0} | {1} {2}',b'Untuk {0} | {1} {2}'
b'DocType: Delivery Trip',b'Driver Name',b'Nama pengemudi'
b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40',b'Average Age',b'Rata-rata Usia'
b'DocType: Education Settings',b'Attendance Freeze Date',b'Tanggal Pembekuan Kehadiran'
b'apps/erpnext/erpnext/utilities/user_progress.py +110',b'List a few of your suppliers. They could be organizations or individuals.',b'Daftar beberapa Supplier Anda. Mereka bisa menjadi organisasi atau individu.'
b'apps/erpnext/erpnext/templates/pages/home.html +31',b'View All Products',b'Lihat Semua Produk'
b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20',b'Minimum Lead Age (Days)',b'Minimum Umur Prospek (Hari)'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +60',b'All BOMs',b'semua BOMs'
b'apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +35',b'Hotel Rooms of type {0} are unavailable on {1}',b'Kamar Hotel tipe {0} tidak tersedia pada {1}'
b'DocType: Patient',b'Default Currency',b'Standar Mata Uang'
b'DocType: Expense Claim',b'From Employee',b'Dari Karyawan'
b'DocType: Driver',b'Cellphone Number',b'Nomor ponsel'
b'DocType: Project',b'Monitor Progress',b'Pantau Kemajuan'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +472',b'Warning: System will not check overbilling since amount for Item {0} in {1} is zero',b'Peringatan: Sistem tidak akan memeriksa overbilling karena jumlahnya untuk Item {0} pada {1} adalah nol'
b'DocType: Journal Entry',b'Make Difference Entry',b'Buat Entri Perbedaan'
b'DocType: Upload Attendance',b'Attendance From Date',b'Absensi Kehadiran dari Tanggal'
b'DocType: Appraisal Template Goal',b'Key Performance Area',b'Area Kinerja Kunci'
b'DocType: Program Enrollment',b'Transportation',b'Transportasi'
b'apps/erpnext/erpnext/controllers/item_variant.py +94',b'Invalid Attribute',b'Atribut yang tidak valid'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +240',b'{0} {1} must be submitted',b'{0} {1} harus dikirim'
b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +159',b'Quantity must be less than or equal to {0}',b'Kuantitas harus kurang dari atau sama dengan {0}'
b'DocType: SMS Center',b'Total Characters',b'Jumlah Karakter'
b'DocType: Employee Advance',b'Claimed',b'Diklaim'
b'DocType: Crop',b'Row Spacing',b'Row Spacing'
b'apps/erpnext/erpnext/controllers/buying_controller.py +164',b'Please select BOM in BOM field for Item {0}',b'Silakan pilih BOM BOM di lapangan untuk Item {0}'
b'DocType: C-Form Invoice Detail',b'C-Form Invoice Detail',b'C-Form Faktur Detil'
b'DocType: Payment Reconciliation Invoice',b'Payment Reconciliation Invoice',b'Rekonsiliasi Faktur Pembayaran'
b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +38',b'Contribution %',b'Kontribusi%'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215',"b""As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}""","b'Sesuai dengan Setelan Pembelian jika Pesanan Pembelian Diperlukan == &#39;YA&#39;, maka untuk membuat Purchase Invoice, pengguna harus membuat Purchase Order terlebih dahulu untuk item {0}'"
b'DocType: Company',b'Company registration numbers for your reference. Tax numbers etc.',b'Nomor registrasi perusahaan untuk referensi Anda. Nomor pajak dll'
b'DocType: Sales Partner',b'Distributor',b'Distributor'
b'DocType: Shopping Cart Shipping Rule',b'Shopping Cart Shipping Rule',b'Aturan Pengiriman Belanja Shoping Cart'
b'apps/erpnext/erpnext/public/js/controllers/transaction.js +71',"b""Please set 'Apply Additional Discount On'""",b'Silahkan mengatur &#39;Terapkan Diskon tambahan On&#39;'
,b'Ordered Items To Be Billed',b'Item Pesanan Tertagih'
b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46',b'From Range has to be less than To Range',b'Dari Rentang harus kurang dari Untuk Rentang'
b'DocType: Global Defaults',b'Global Defaults',b'Standar Global'
b'apps/erpnext/erpnext/projects/doctype/project/project.py +230',b'Project Collaboration Invitation',b'Proyek Kolaborasi Undangan'
b'DocType: Salary Slip',b'Deductions',b'Pengurangan'
b'DocType: Leave Allocation',b'LAL/',b'LAL /'
b'DocType: Setup Progress Action',b'Action Name',b'Nama Aksi'
b'apps/erpnext/erpnext/public/js/financial_statements.js +75',b'Start Year',b'Mulai Tahun'
b'apps/erpnext/erpnext/regional/india/utils.py +25',b'First 2 digits of GSTIN should match with State number {0}',b'2 digit pertama GSTIN harus sesuai dengan nomor Negara {0}'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +68',b'PDC/LC',b'PDC / LC'
b'DocType: Purchase Invoice',"b""Start date of current invoice's period""",b'Tanggal faktur periode saat ini mulai'
b'DocType: Salary Slip',b'Leave Without Pay',b'Cuti Tanpa Bayar'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +385',b'Capacity Planning Error',b'Kesalahan Perencanaan Kapasitas'
,b'Trial Balance for Party',b'Trial Balance untuk Partai'
b'DocType: Lead',b'Consultant',b'Konsultan'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +356',b'Parents Teacher Meeting Attendance',b'Pertemuan Orangtua Guru Kehadiran'
b'DocType: Salary Slip',b'Earnings',b'Pendapatan'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +441',b'Finished Item {0} must be entered for Manufacture type entry',b'Selesai Stok Barang {0} harus dimasukkan untuk jenis Produksi entri'
b'apps/erpnext/erpnext/config/learn.py +87',b'Opening Accounting Balance',b'Saldo Pembukaan Akuntansi'
,b'GST Sales Register',b'Daftar Penjualan GST'
b'DocType: Sales Invoice Advance',b'Sales Invoice Advance',b'Uang Muka Faktur Penjualan'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +552',b'Nothing to request',b'Tidak ada Permintaan'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +18',b'Select your Domains',b'Pilih Domain Anda'
b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34',"b""Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3}""",b'record Anggaran lain &#39;{0}&#39; sudah ada terhadap {1} &#39;{2}&#39; untuk tahun fiskal {3}'
b'DocType: Item Variant Settings',b'Fields will be copied over only at time of creation.',b'Fields akan disalin hanya pada saat penciptaan.'
b'DocType: Setup Progress Action',b'Domains',b'Domain'
b'apps/erpnext/erpnext/projects/doctype/task/task.py +41',"b""'Actual Start Date' can not be greater than 'Actual End Date'""","b""'Tanggal Mulai Sebenarnya' tidak bisa lebih besar dari 'Tanggal Selesai Sebenarnya'"""
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117',b'Management',b'Manajemen'
b'DocType: Cheque Print Template',b'Payer Settings',b'Pengaturan Wajib'
b'DocType: Item Attribute Value',"b'This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""'","b'Ini akan ditambahkan ke Item Code dari varian. Sebagai contoh, jika Anda adalah singkatan ""SM"", dan kode Stok Barang adalah ""T-SHIRT"", kode item varian akan ""T-SHIRT-SM""'"
b'DocType: Salary Slip',b'Net Pay (in words) will be visible once you save the Salary Slip.',b'Pay Bersih (dalam kata-kata) akan terlihat setelah Anda menyimpan Slip Gaji.'
b'DocType: Purchase Invoice',b'Is Return',b'Retur Barang'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92',b'Caution',b'Peringatan'
b'apps/erpnext/erpnext/agriculture/doctype/disease/disease.py +17',"b""Start day is greater than end day in task '{0}'""",b'Hari mulai lebih besar dari hari akhir tugas &#39;{0}&#39;'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +815',b'Return / Debit Note',b'Nota Retur / Debit'
b'DocType: Price List Country',b'Price List Country',b'Negara Daftar Harga'
b'DocType: Item',b'UOMs',b'UOMs'
b'apps/erpnext/erpnext/stock/utils.py +212',b'{0} valid serial nos for Item {1}',b'{0} nomor seri berlaku untuk Item {1}'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57',b'Item Code cannot be changed for Serial No.',b'Item Code tidak dapat diubah untuk Serial Number'
b'DocType: Purchase Invoice Item',b'UOM Conversion Factor',b'Faktor Konversi UOM'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40',b'Please enter Item Code to get Batch Number',b'Masukkan Item Code untuk mendapatkan Nomor Batch'
b'DocType: Stock Settings',b'Default Item Group',b'Standar Item Grup'
b'DocType: Employee Loan',b'Partially Disbursed',b'sebagian Dicairkan'
b'apps/erpnext/erpnext/config/non_profit.py +73',b'Grant information.',b'Berikan informasi.'
b'apps/erpnext/erpnext/config/buying.py +38',b'Supplier database.',b'Database Supplier.'
b'DocType: Account',b'Balance Sheet',b'Neraca'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +750',"b""Cost Center For Item with Item Code '""","b""Biaya Center For Stok Barang dengan Item Code '"""
b'DocType: Fee Validity',b'Valid Till',b'Berlaku sampai'
b'DocType: Student Report Generation Tool',b'Total Parents Teacher Meeting',b'Pertemuan Guru Orang Tua Total'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2516',"b'Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.'","b'Modus pembayaran tidak dikonfigurasi. Silakan periksa, apakah akun telah ditetapkan pada Cara Pembayaran atau POS Profil.'"
b'apps/erpnext/erpnext/buying/utils.py +74',b'Same item cannot be entered multiple times.',b'item yang sama tidak dapat dimasukkan beberapa kali.'
b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +30',"b'Further accounts can be made under Groups, but entries can be made against non-Groups'","b'Account lebih lanjut dapat dibuat di bawah Grup, tapi entri dapat dilakukan terhadap non-Grup'"
b'DocType: Lead',b'Lead',b'Prospek'
b'DocType: Email Digest',b'Payables',b'Hutang'
b'DocType: Course',b'Course Intro',b'tentu saja Intro'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +105',b'Stock Entry {0} created',b'Entri Persediaan {0} dibuat'
b'apps/erpnext/erpnext/controllers/buying_controller.py +306',b'Row #{0}: Rejected Qty can not be entered in Purchase Return',b'Baris # {0}: Jumlah yang ditolak tidak dapat dimasukkan dalam Retur Pembelian'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +182',b'Changing Customer Group for the selected Customer is not allowed.',b'Mengubah Grup Pelanggan untuk Pelanggan yang dipilih tidak diizinkan.'
,b'Purchase Order Items To Be Billed',b'Purchase Order Items Akan Ditagih'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +63',b'Updating estimated arrival times.',b'Memperbarui perkiraan waktu kedatangan.'
b'DocType: Program Enrollment Tool',b'Enrollment Details',b'Rincian pendaftaran'
b'DocType: Purchase Invoice Item',b'Net Rate',b'Nilai Bersih / Net'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +152',b'Please select a customer',b'Silahkan pilih pelanggan'
b'DocType: Purchase Invoice Item',b'Purchase Invoice Item',b'Stok Barang Faktur Pembelian'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58',b'Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts',b'Entri Buku Persediaan dan Entri GL diposting ulang untuk Nota Pembelian yang dipilih'
b'DocType: Student Report Generation Tool',b'Assessment Terms',b'Ketentuan Penilaian'
b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8',b'Item 1',b'Item 1'
b'DocType: Holiday',b'Holiday',b'Hari Libur'
b'DocType: Support Settings',b'Close Issue After Days',b'Tutup Isu Setelah Days'
b'DocType: Leave Control Panel',b'Leave blank if considered for all branches',b'Biarkan kosong jika dipertimbangkan untuk semua cabang'
b'DocType: Bank Guarantee',b'Validity in Days',b'Validitas dalam hari'
b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21',b'C-form is not applicable for Invoice: {0}',b'C-bentuk tidak berlaku untuk Faktur: {0}'
b'DocType: Payment Reconciliation',b'Unreconciled Payment Details',b'Rincian Pembayaran Unreconciled'
b'apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6',b'Member Activity',b'Aktivitas Anggota'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20',b'Order Count',b'Order Count'
b'DocType: Global Defaults',b'Current Fiscal Year',b'Tahun Anggaran saat ini'
b'DocType: Purchase Order',b'Group same items',b'Kelompok item yang sama'
b'DocType: Purchase Invoice',b'Disable Rounded Total',b'Nonaktifkan Pembulatan Jumlah'
b'DocType: Employee Loan Application',b'Repayment Info',b'Info pembayaran'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448',"b""'Entries' cannot be empty""","b""'Entries' tidak boleh kosong"""
b'DocType: Maintenance Team Member',b'Maintenance Role',b'Peran Pemeliharaan'
b'apps/erpnext/erpnext/utilities/transaction_base.py +92',b'Duplicate row {0} with same {1}',b'Baris duplikat {0} dengan sama {1}'
,b'Trial Balance',b'Trial Balance'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +443',b'Fiscal Year {0} not found',b'Tahun fiskal {0} tidak ditemukan'
b'apps/erpnext/erpnext/config/hr.py +309',b'Setting up Employees',b'Persiapan Karyawan'
b'DocType: Sales Order',b'SO-',b'BEGITU-'
b'DocType: Hotel Room Reservation',b'Hotel Reservation User',b'Pengguna Reservasi Hotel'
b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +158',b'Please select prefix first',b'Silakan pilih awalan terlebih dahulu'
b'DocType: Student',b'O-',b'HAI-'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189',b'Research',b'Penelitian'
b'DocType: Maintenance Visit Purpose',b'Work Done',b'Pekerjaan Selesai'
b'apps/erpnext/erpnext/controllers/item_variant.py +35',b'Please specify at least one attribute in the Attributes table',b'Silakan tentukan setidaknya satu atribut dalam tabel Atribut'
b'DocType: Announcement',b'All Students',b'Semua murid'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +45',b'Item {0} must be a non-stock item',b'Barang {0} harus barang non-persediaan'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +18',b'View Ledger',b'Lihat Buku Besar'
b'DocType: Grading Scale',b'Intervals',b'interval'
b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41',b'Earliest',b'Paling Awal'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +526',"b'An Item Group exists with same name, please change the item name or rename the item group'","b'Item Grup ada dengan nama yang sama, ubah nama item atau mengubah nama kelompok Stok Barang'"
b'DocType: Crop Cycle',b'Less than a year',b'Kurang dari setahun'
b'apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52',b'Student Mobile No.',b'Mahasiswa Nomor Ponsel'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +105',b'Rest Of The World',b'Rest of The World'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81',b'The Item {0} cannot have Batch',b'Item {0} tidak dapat memiliki Batch'
b'DocType: Crop',b'Yield UOM',b'Hasil UOM'
,b'Budget Variance Report',b'Laporan Perbedaan Anggaran'
b'DocType: Salary Slip',b'Gross Pay',b'Nilai Gross Bayar'
b'DocType: Item',b'Is Item from Hub',b'Adalah Item dari Hub'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +118',b'Row {0}: Activity Type is mandatory.',b'Row {0}: Jenis Kegiatan adalah wajib.'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166',b'Dividends Paid',b'Dividen Dibagi'
b'apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36',b'Accounting Ledger',b'Buku Besar Akuntansi'
b'DocType: Stock Reconciliation',b'Difference Amount',b'Jumlah Perbedaan'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +107',b'Dr {0} on Leave on {1}',b'Dr {0} di Tinggalkan pada {1}'
b'DocType: Purchase Invoice',b'Reverse Charge',b'Biaya terbalik'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +172',b'Retained Earnings',b'Laba Ditahan'
b'DocType: Purchase Invoice',b'05-Change in POS',b'05-Ubah POS'
b'DocType: Vehicle Log',b'Service Detail',b'layanan Detil'
b'DocType: BOM',b'Item Description',b'Deskripsi Barang'
b'DocType: Student Sibling',b'Student Sibling',b'Mahasiswa Sibling'
b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +18',b'Payment Mode',b'Mode Pembayaran'
b'DocType: Purchase Invoice',b'Supplied Items',b'Produk Disupply'
b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +85',b'Please set an active menu for Restaurant {0}',b'Harap atur menu aktif untuk Restoran {0}'
b'DocType: Student',b'STUD.',b'STUD.'
b'DocType: Work Order',b'Qty To Manufacture',b'Kuantitas untuk diproduksi'
b'DocType: Email Digest',b'New Income',b'Penghasilan baru'
b'DocType: Buying Settings',b'Maintain same rate throughout purchase cycle',b'Pertahankan tarif yang sama sepanjang siklus pembelian'
b'DocType: Opportunity Item',b'Opportunity Item',b'Peluang Stok Barang'
,b'Student and Guardian Contact Details',b'Mahasiswa dan Wali Detail Kontak'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +53',b'Row {0}: For supplier {0} Email Address is required to send email',b'Baris {0}: Untuk pemasok {0} Alamat Email diperlukan untuk mengirim email'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72',b'Temporary Opening',b'Akun Pembukaan Sementara'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +10',b'View Hub',b'Lihat Hub'
,b'Employee Leave Balance',b'Nilai Cuti Karyawan'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147',b'Balance for Account {0} must always be {1}',b'Saldo Rekening {0} harus selalu {1}'
b'DocType: Patient Appointment',b'More Info',b'Info Selengkapnya'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +180',b'Valuation Rate required for Item in row {0}',b'Penilaian Tingkat diperlukan untuk Item berturut-turut {0}'
b'DocType: Supplier Scorecard',b'Scorecard Actions',b'Tindakan Scorecard'
b'apps/erpnext/erpnext/utilities/user_progress.py +169',b'Example: Masters in Computer Science',b'Contoh: Magister Ilmu Komputer'
b'DocType: Purchase Invoice',b'Rejected Warehouse',b'Gudang Reject'
b'DocType: GL Entry',b'Against Voucher',b'Terhadap Voucher'
b'DocType: Item',b'Default Buying Cost Center',b'Standar Biaya Pusat Pembelian'
b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +6',"b'To get the best out of ERPNext, we recommend that you take some time and watch these help videos.'","b'Untuk mendapatkan yang terbaik dari ERPNext, kami menyarankan Anda mengambil beberapa waktu dan menonton video ini membantu.'"
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +76',b' to ',b'untuk'
b'DocType: Supplier Quotation Item',b'Lead Time in days',b'Masa Tenggang dalam hari'
b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +70',b'Accounts Payable Summary',b'Ringkasan Buku Besar Hutang'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +326',b'Payment of salary from {0} to {1}',b'Pembayaran gaji dari {0} ke {1}'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213',b'Not authorized to edit frozen Account {0}',b'Tidak berwenang untuk mengedit Akun frozen {0}'
b'DocType: Journal Entry',b'Get Outstanding Invoices',b'Dapatkan Faktur Berjalan'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +84',b'Sales Order {0} is not valid',b'Order Penjualan {0} tidak valid'
b'DocType: Supplier Scorecard',b'Warn for new Request for Quotations',b'Peringatkan untuk Permintaan Kuotasi baru'
b'apps/erpnext/erpnext/utilities/activation.py +91',b'Purchase orders help you plan and follow up on your purchases',b'pesanan pembelian membantu Anda merencanakan dan menindaklanjuti pembelian Anda'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151',b'Lab Test Prescriptions',b'Resep Uji Lab'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +166',b'The total Issue / Transfer quantity {0} in Material Request {1}  \\\n\t\t\t\t\t\t\tcannot be greater than requested quantity {2} for Item {3}',b'Total Issue / transfer kuantitas {0} Material Permintaan {1} \\ tidak dapat lebih besar dari yang diminta kuantitas {2} untuk Item {3}'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197',b'Small',b'Kecil'
b'DocType: Opening Invoice Creation Tool Item',b'Opening Invoice Creation Tool Item',b'Membuka Item Alat Pembuatan Faktur'
b'DocType: Education Settings',b'Employee Number',b'Jumlah Karyawan'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67',b'Case No(s) already in use. Try from Case No {0}',b'Kasus ada (s) sudah digunakan. Coba dari Case ada {0}'
b'DocType: Project',b'% Completed',b'Selesai %'
,b'Invoiced Amount (Exculsive Tax)',b'Faktur Jumlah (Pajak exculsive)'
b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14',b'Item 2',b'Item 2'
b'DocType: Supplier',b'SUPP-',b'SUPP-'
b'DocType: Training Event',b'Training Event',b'pelatihan Kegiatan'
b'DocType: Item',b'Auto re-order',b'Auto re-order'
b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59',b'Total Achieved',b'Total Dicapai'
b'DocType: Employee',b'Place of Issue',b'Tempat Issue'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101',b'Contract',b'Kontrak'
b'DocType: Plant Analysis',b'Laboratory Testing Datetime',b'Uji Laboratorium Datetime'
b'DocType: Email Digest',b'Add Quote',b'Tambahkan Kutipan'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +987',b'UOM coversion factor required for UOM: {0} in Item: {1}',b'Faktor coversion UOM diperlukan untuk UOM: {0} di Item: {1}'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92',b'Indirect Expenses',b'Biaya tidak langsung'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +98',b'Row {0}: Qty is mandatory',b'Row {0}: Qty adalah wajib'
b'DocType: Agriculture Analysis Criteria',b'Agriculture',b'Pertanian'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +794',b'Sync Master Data',b'Sync Master Data'
b'DocType: Asset Repair',b'Repair Cost',b'Biaya perbaikan'
b'apps/erpnext/erpnext/utilities/user_progress.py +138',b'Your Products or Services',b'Produk atau Jasa Anda'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15',b'Failed to login',b'Gagal untuk masuk'
b'DocType: Special Test Items',b'Special Test Items',b'Item Uji Khusus'
b'DocType: Mode of Payment',b'Mode of Payment',b'Mode Pembayaran'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +202',b'Website Image should be a public file or website URL',b'Website Image harus file umum atau URL situs'
b'DocType: Student Applicant',b'AP',b'AP'
b'DocType: Purchase Invoice Item',b'BOM',b'BOM'
b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37',b'This is a root item group and cannot be edited.',b'Ini adalah kelompok Stok Barang akar dan tidak dapat diedit.'
b'DocType: Journal Entry Account',b'Purchase Order',b'Purchase Order'
b'DocType: Vehicle',b'Fuel UOM',b'BBM UOM'
b'DocType: Warehouse',b'Warehouse Contact Info',b'Info Kontak Gudang'
b'DocType: Payment Entry',b'Write Off Difference Amount',b'Menulis Off Perbedaan Jumlah'
b'DocType: Volunteer',b'Volunteer Name',b'Nama Relawan'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +434',"b'{0}: Employee email not found, hence email not sent'","b'{0}: email Karyawan tidak ditemukan, maka email tidak dikirim'"
b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85',b'Shipping rule not applicable for country {0}',b'Aturan pengiriman tidak berlaku untuk negara {0}'
b'DocType: Item',b'Foreign Trade Details',b'Rincian Perdagangan Luar Negeri'
,b'Assessment Plan Status',b'Status Rencana Penilaian'
b'DocType: Email Digest',b'Annual Income',b'Pendapatan tahunan'
b'DocType: Serial No',b'Serial No Details',b'Nomor Detail Serial'
b'DocType: Purchase Invoice Item',b'Item Tax Rate',b'Tarif Pajak Stok Barang'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +89',b'Please select Physician and Date',b'Silakan pilih Dokter dan Tanggal'
b'DocType: Student Group Student',b'Group Roll Number',b'Nomor roll grup'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145',"b'For {0}, only credit accounts can be linked against another debit entry'","b'Untuk {0}, hanya rekening kredit dapat dihubungkan dengan entri debit lain'"
b'apps/erpnext/erpnext/projects/doctype/project/project.py +84',b'Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly',b'Total semua bobot tugas harus 1. Sesuaikan bobot dari semua tugas Proyek sesuai'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +588',b'Delivery Note {0} is not submitted',b'Nota pengiriman {0} tidak Terkirim'
b'apps/erpnext/erpnext/stock/get_item_details.py +148',b'Item {0} must be a Sub-contracted Item',b'Item {0} harus Item Sub-kontrak'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43',b'Capital Equipments',b'Perlengkapan Modal'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33',"b""Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.""","b""Rule harga terlebih dahulu dipilih berdasarkan 'Terapkan On' lapangan, yang dapat Stok Barang, Stok Barang Grup atau Merek."""
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +246',b'Please set the Item Code first',b'Harap set Kode Item terlebih dahulu'
b'DocType: Item',b'ITEM-',b'BARANG-'
b'apps/erpnext/erpnext/controllers/selling_controller.py +123',b'Total allocated percentage for sales team should be 100',b'Persentase total yang dialokasikan untuk tim penjualan harus 100'
b'DocType: Sales Invoice Item',b'Edit Description',b'Edit Keterangan'
b'DocType: Antibiotic',b'Antibiotic',b'Antibiotika'
,b'Team Updates',b'Pembaruan Tim'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +912',b'For Supplier',b'Untuk Supplier'
b'DocType: Account',b'Setting Account Type helps in selecting this Account in transactions.',b'Mengatur Tipe Akun membantu dalam memilih Akun ini dalam transaksi.'
b'DocType: Purchase Invoice',b'Grand Total (Company Currency)',b'Jumlah Nilai Total (Mata Uang Perusahaan)'
b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9',b'Create Print Format',b'Buat Print Format'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5',b'Fee Created',b'Biaya Dibuat'
b'apps/erpnext/erpnext/utilities/bot.py +39',b'Did not find any item called {0}',b'Tidak menemukan item yang disebut {0}'
b'DocType: Supplier Scorecard Criteria',b'Criteria Formula',b'Formula Kriteria'
b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41',b'Total Outgoing',b'Total Outgoing'
b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +39',"b'There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""'","b'Hanya ada satu Peraturan Pengiriman Kondisi dengan nilai kosong atau 0 untuk ""To Nilai""'"
b'DocType: Authorization Rule',b'Transaction',b'Transaksi'
b'DocType: Patient Appointment',b'Duration',b'Lamanya'
b'apps/erpnext/erpnext/controllers/status_updater.py +160',"b'For an item {0}, quantity must be positive number'","b'Untuk item {0}, kuantitas harus berupa bilangan positif'"
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27',b'Note: This Cost Center is a Group. Cannot make accounting entries against groups.',b'Catatan: Biaya Pusat ini adalah Group. Tidak bisa membuat entri akuntansi terhadap kelompok-kelompok.'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +53',b'Child warehouse exists for this warehouse. You can not delete this warehouse.',b'gudang anak ada untuk gudang ini. Anda tidak dapat menghapus gudang ini.'
b'DocType: Item',b'Website Item Groups',b'Situs Grup Stok Barang'
b'DocType: Purchase Invoice',b'Total (Company Currency)',b'Total (Perusahaan Mata Uang)'
b'DocType: Daily Work Summary Group',b'Reminder',b'Peringatan'
b'apps/erpnext/erpnext/stock/utils.py +207',b'Serial number {0} entered more than once',b'Serial number {0} masuk lebih dari sekali'
b'DocType: Journal Entry',b'Journal Entry',b'Jurnal Entri'
b'DocType: Expense Claim Advance',b'Unclaimed amount',b'Jumlah yang tidak diklaim'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +148',b'{0} items in progress',b'{0} item berlangsung'
b'DocType: Workstation',b'Workstation Name',b'Nama Workstation'
b'DocType: Grading Scale Interval',b'Grade Code',b'Kode kelas'
b'DocType: POS Item Group',b'POS Item Group',b'POS Barang Grup'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17',b'Email Digest:',b'Surel Ringkasan:'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +613',b'BOM {0} does not belong to Item {1}',b'BOM {0} bukan milik Barang {1}'
b'DocType: Sales Partner',b'Target Distribution',b'Target Distribusi'
b'DocType: Purchase Invoice',b'06-Finalization of Provisional assessment',b'06-Finalisasi penilaian sementara'
b'DocType: Salary Slip',b'Bank Account No.',b'No Rekening Bank'
b'DocType: Naming Series',b'This is the number of the last created transaction with this prefix',b'Ini adalah jumlah transaksi yang diciptakan terakhir dengan awalan ini'
b'DocType: Supplier Scorecard',"b'Scorecard variables can be used, as well as:\n{total_score} (the total score from that period),\n{period_number} (the number of periods to present day)\n'","b'Variabel Scorecard dapat digunakan, dan juga: {total_score} (skor total dari periode tersebut), {period_number} (jumlah periode sampai sekarang)'"
b'DocType: Quality Inspection Reading',b'Reading 8',b'Membaca 8'
b'DocType: Sales Partner',b'Agent',b'Agen'
b'DocType: Purchase Invoice',b'Taxes and Charges Calculation',b'Pajak dan Biaya Dihitung'
b'DocType: Accounts Settings',b'Book Asset Depreciation Entry Automatically',b'Rekam Depresiasi Asset Entri Otomatis'
b'DocType: BOM Operation',b'Workstation',b'Workstation'
b'DocType: Request for Quotation Supplier',b'Request for Quotation Supplier',b'Permintaan Quotation Pemasok'
b'DocType: Healthcare Settings',b'Registration Message',b'Pesan Pendaftaran'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154',b'Hardware',b'Perangkat keras'
b'DocType: Prescription Dosage',b'Prescription Dosage',b'Dosis Resep'
b'DocType: Attendance',b'HR Manager',b'HR Manager'
b'apps/erpnext/erpnext/accounts/party.py +175',b'Please select a Company',b'Silakan pilih sebuah Perusahaan'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92',b'Privilege Leave',b'Privilege Cuti'
b'DocType: Purchase Invoice',b'Supplier Invoice Date',b'Tanggal Faktur Supplier'
b'DocType: Asset Settings',b'This value is used for pro-rata temporis calculation',b'Nilai ini digunakan untuk perhitungan temporer pro-rata'
b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90',b'You need to enable Shopping Cart',b'Anda harus mengaktifkan Keranjang Belanja'
b'DocType: Payment Entry',b'Writeoff',b'writeoff'
b'DocType: Stock Settings',b'Naming Series Prefix',b'Awalan Seri Penamaan'
b'DocType: Appraisal Template Goal',b'Appraisal Template Goal',b'Template Target Penilaian Pencapaian'
b'DocType: Salary Component',b'Earning',b'Pendapatan'
b'DocType: Supplier Scorecard',b'Scoring Criteria',b'Kriteria penilaian'
b'DocType: Purchase Invoice',b'Party Account Currency',b'Akun Mata Uang per Party'
,b'BOM Browser',b'BOM Browser'
b'apps/erpnext/erpnext/templates/emails/training_event.html +13',b'Please update your status for this training event',b'Harap perbarui status anda untuk acara pelatihan ini'
b'DocType: Item Barcode',b'EAN',b'EAN'
b'DocType: Purchase Taxes and Charges',b'Add or Deduct',b'Penambahan atau Pengurangan'
b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148',b'Overlapping conditions found between:',b'Kondisi Tumpang Tindih ditemukan antara:'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187',b'Against Journal Entry {0} is already adjusted against some other voucher',b'Atas Catatan Jurnal {0} sudah dilakukan penyesuaian terhadap beberapa dokumen lain.'
b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68',b'Total Order Value',b'Nilai Total Order'
b'apps/erpnext/erpnext/demo/setup/setup_data.py +328',b'Food',b'Makanan'
b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +57',b'Ageing Range 3',b'Rentang Ageing 3'
b'DocType: Maintenance Schedule Item',b'No of Visits',b'Tidak ada Kunjungan'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165',b'Maintenance Schedule {0} exists against {1}',b'Jadwal Pemeliharaan {0} ada terhadap {1}'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36',b'Enrolling student',b'mahasiswa Mendaftarkan'
b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33',b'Currency of the Closing Account must be {0}',b'Mata uang dari Rekening Penutupan harus {0}'
b'apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21',b'Sum of points for all goals should be 100. It is {0}',b'Jumlah poin untuk semua tujuan harus 100. Ini adalah {0}'
b'DocType: Project',b'Start and End Dates',b'Mulai dan Akhir Tanggal'
,b'Delivered Items To Be Billed',b'Produk Terkirim untuk Ditagih'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16',b'Open BOM {0}',b'Terbuka BOM {0}'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60',b'Warehouse cannot be changed for Serial No.',b'Gudang tidak dapat diubah untuk Serial Number'
b'DocType: Authorization Rule',b'Average Discount',b'Rata-rata Diskon'
b'DocType: Project Update',b'Great/Quickly',b'Hebat / Cepat'
b'DocType: Purchase Invoice Item',b'UOM',b'UOM'
b'DocType: Rename Tool',b'Utilities',b'Utilitas'
b'DocType: POS Profile',b'Accounting',b'Akuntansi'
b'DocType: Employee',b'EMP/',b'EMP /'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133',b'Please select batches for batched item ',b'Silakan pilih batch untuk item batched'
b'DocType: Asset',b'Depreciation Schedules',b'Jadwal penyusutan'
b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +192',b'Following accounts might be selected in GST Settings:',b'Akun berikut mungkin dipilih di Setelan GST:'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +70',b'Application period cannot be outside leave allocation period',b'Periode aplikasi tidak bisa periode alokasi cuti di luar'
b'DocType: Activity Cost',b'Projects',b'Proyek'
b'DocType: Payment Request',b'Transaction Currency',b'Mata uang transaksi'
b'apps/erpnext/erpnext/controllers/buying_controller.py +30',b'From {0} | {1} {2}',b'Dari {0} | {1} {2}'
b'DocType: Work Order Operation',b'Operation Description',b'Deskripsi Operasi'
b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34',b'Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.',b'Tidak dapat mengubah Tahun Anggaran Tanggal Mulai dan Tanggal Akhir Tahun Anggaran setelah Tahun Anggaran disimpan.'
b'DocType: Quotation',b'Shopping Cart',b'Daftar Belanja'
b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41',b'Avg Daily Outgoing',b'Rata-rata Harian Outgoing'
b'DocType: POS Profile',b'Campaign',b'Promosi'
b'DocType: Supplier',b'Name and Type',b'Nama dan Jenis'
b'DocType: Physician',b'Contacts and Address',b'Kontak dan Alamat'
b'DocType: Purchase Invoice',b'Contact Person',b'Contact Person'
b'apps/erpnext/erpnext/projects/doctype/task/task.py +38',"b""'Expected Start Date' can not be greater than 'Expected End Date'""","b'""Jadwal Tanggal Mulai\' tidak dapat lebih besar dari \'Jadwal Tanggal Selesai\''"
b'DocType: Course Scheduling Tool',b'Course End Date',b'Tentu saja Tanggal Akhir'
b'DocType: Holiday List',b'Holidays',b'Hari Libur'
b'DocType: Sales Order Item',b'Planned Quantity',b'Direncanakan Kuantitas'
b'DocType: Purchase Invoice Item',b'Item Tax Amount',b'Jumlah Pajak Stok Barang'
b'DocType: Water Analysis',b'Water Analysis Criteria',b'Kriteria Analisis Air'
b'DocType: Item',b'Maintain Stock',b'Jaga Persediaan'
b'DocType: Employee',b'Prefered Email',b'Email Utama'
b'DocType: Student Admission',b'Eligibility and Details',b'Kelayakan dan Detail'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +38',b'Net Change in Fixed Asset',b'Perubahan bersih dalam Aset Tetap'
b'DocType: Leave Control Panel',b'Leave blank if considered for all designations',b'Biarkan kosong jika dipertimbangkan untuk semua sebutan'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +806',"b""Charge of type 'Actual' in row {0} cannot be included in Item Rate""","b""Mengisi tipe 'sebenarnya' berturut-turut {0} tidak dapat dimasukkan dalam Butir Tingkat"""
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +382',b'Max: {0}',b'Max: {0}'
b'apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24',b'From Datetime',b'Dari Datetime'
b'DocType: Email Digest',b'For Company',b'Untuk Perusahaan'
b'apps/erpnext/erpnext/config/support.py +17',b'Communication log.',b'Log komunikasi.'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +195',"b'Request for Quotation is disabled to access from portal, for more check portal settings.'","b'Permintaan Quotation dinonaktifkan untuk akses dari portal, untuk pengaturan Portal cek lagi.'"
b'DocType: Supplier Scorecard Scoring Variable',b'Supplier Scorecard Scoring Variable',b'Variabel Scorecard Supplier Variabel'
b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72',b'Buying Amount',b'Jumlah Pembelian'
b'DocType: Sales Invoice',b'Shipping Address Name',b'Alamat Pengiriman'
b'DocType: Material Request',b'Terms and Conditions Content',b'Syarat dan Ketentuan Konten'
b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18',b'There were errors creating Course Schedule',b'Ada kesalahan dalam membuat Jadwal Kursus'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +581',b'cannot be greater than 100',b'tidak dapat lebih besar dari 100'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +752',b'Item {0} is not a stock Item',b'Barang {0} bukan merupakan Barang persediaan'
b'DocType: Maintenance Visit',b'Unscheduled',b'Tidak Terjadwal'
b'DocType: Employee',b'Owned',b'Dimiliki'
b'DocType: Salary Detail',b'Depends on Leave Without Pay',b'Tergantung pada Cuti Tanpa Bayar'
b'DocType: Pricing Rule',"b'Higher the number, higher the priority'","b'Semakin tinggi angkanya, semakin tinggi prioritas'"
,b'Purchase Invoice Trends',b'Pembelian Faktur Trends'
b'DocType: Employee',b'Better Prospects',b'Prospek yang Lebih Baik'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +217',"b'Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches'","b'Baris # {0}: Kumpulan {1} hanya memiliki {2} qty. Silakan pilih batch lain yang memiliki {3} qty available atau membagi baris menjadi beberapa baris, untuk mengirimkan / mengeluarkan dari beberapa batch'"
b'DocType: Vehicle',b'License Plate',b'Pelat'
b'DocType: Appraisal',b'Goals',b'tujuan'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +353',b'Select POS Profile',b'Pilih Profil POS'
b'DocType: Warranty Claim',b'Warranty / AMC Status',b'Garansi / Status AMC'
,b'Accounts Browser',b'Browser Nama Akun'
b'DocType: Payment Entry Reference',b'Payment Entry Reference',b'Pembayaran Referensi Masuk'
b'DocType: GL Entry',b'GL Entry',b'GL Entri'
b'DocType: HR Settings',b'Employee Settings',b'Pengaturan Karyawan'
,b'Batch-Wise Balance History',b'Rekap Saldo menurut Kumpulan'
b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73',b'Print settings updated in respective print format',b'Pengaturan cetak diperbarui dalam format cetak terkait'
b'DocType: Package Code',b'Package Code',b'Kode paket'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105',b'Apprentice',b'Magang'
b'DocType: Purchase Invoice',b'Company GSTIN',b'Perusahaan GSTIN'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +105',b'Negative Quantity is not allowed',b'Jumlah negatif tidak diperbolehkan'
b'DocType: Purchase Invoice Item',b'Tax detail table fetched from item master as a string and stored in this field.\nUsed for Taxes and Charges',b'Rinci tabel pajak diambil dari master Stok Barang sebagai string dan disimpan dalam bidang ini.\n Digunakan untuk Pajak dan Biaya'
b'DocType: Supplier Scorecard Period',b'SSC-',b'SSC-'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +159',b'Employee cannot report to himself.',b'Karyawan tidak bisa melaporkan kepada dirinya sendiri.'
b'DocType: Account',"b'If the account is frozen, entries are allowed to restricted users.'","b'Jika account beku, entri yang diizinkan untuk pengguna terbatas.'"
b'DocType: Email Digest',b'Bank Balance',b'Saldo bank'
b'apps/erpnext/erpnext/accounts/party.py +240',b'Accounting Entry for {0}: {1} can only be made in currency: {2}',b'Entri Akuntansi untuk {0}: {1} hanya dapat dilakukan dalam mata uang: {2}'
b'DocType: Job Opening',"b'Job profile, qualifications required etc.'","b'Profil pekerjaan, kualifikasi yang dibutuhkan dll'"
b'DocType: Journal Entry Account',b'Account Balance',b'Saldo Akun Rekening'
b'apps/erpnext/erpnext/config/accounts.py +183',b'Tax Rule for transactions.',b'Aturan pajak untuk transaksi.'
b'DocType: Rename Tool',b'Type of document to rename.',b'Jenis dokumen untuk mengubah nama.'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53',b'{0} {1}: Customer is required against Receivable account {2}',b'{0} {1}: Pelanggan diperlukan untuk akun Piutang {2}'
b'DocType: Purchase Invoice',b'Total Taxes and Charges (Company Currency)',b'Jumlah Pajak dan Biaya (Perusahaan Mata Uang)'
b'DocType: Weather',b'Weather Parameter',b'Parameter Cuaca'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60',"b""Show unclosed fiscal year's P&L balances""",b'Tampilkan P &amp; saldo L tahun fiskal tertutup ini'
b'DocType: Lab Test Template',b'Collection Details',b'Detail Koleksi'
b'DocType: POS Profile',b'Allow Print Before Pay',b'Izinkan Cetak Sebelum Bayar'
b'DocType: Land Unit',b'Linked Soil Texture',b'Tekstur Tanah Tertib'
b'DocType: Shipping Rule',b'Shipping Account',b'Account Pengiriman'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92',b'{0} {1}: Account {2} is inactive',b'{0} {1}: Akun {2} tidak aktif'
b'apps/erpnext/erpnext/utilities/activation.py +82',b'Make Sales Orders to help you plan your work and deliver on-time',b'Membuat Penjualan Pesanan untuk membantu Anda merencanakan pekerjaan Anda dan memberikan tepat waktu'
b'DocType: Quality Inspection',b'Readings',b'Bacaan'
b'DocType: Stock Entry',b'Total Additional Costs',b'Total Biaya Tambahan'
b'DocType: Course Schedule',b'SH',b'SH'
b'DocType: BOM',b'Scrap Material Cost(Company Currency)',b'Scrap Material Cost (Perusahaan Mata Uang)'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66',b'Sub Assemblies',b'Sub Assemblies'
b'DocType: Asset',b'Asset Name',b'Aset Nama'
b'DocType: Project',b'Task Weight',b'tugas Berat'
b'DocType: Shipping Rule Condition',b'To Value',b'Untuk Dinilai'
b'DocType: Asset Movement',b'Stock Manager',b'Pengelola Persediaan'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +171',b'Source warehouse is mandatory for row {0}',b'Sumber gudang adalah wajib untuk baris {0}'
b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38',b'The Payment Term at row {0} is possibly a duplicate.',b'Syarat Pembayaran di baris {0} mungkin merupakan duplikat.'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +30',b'Agriculture (beta)',b'Pertanian (beta)'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +863',b'Packing Slip',b'Slip Packing'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110',b'Office Rent',b'Sewa Kantor'
b'apps/erpnext/erpnext/config/setup.py +111',b'Setup SMS gateway settings',b'Pengaturan gerbang Pengaturan SMS'
b'DocType: Disease',b'Common Name',b'Nama yang umum'
b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61',b'Import Failed!',b'Impor Gagal!'
b'apps/erpnext/erpnext/public/js/templates/address_list.html +20',b'No address added yet.',b'Belum ditambahkan alamat'
b'DocType: Workstation Working Hour',b'Workstation Working Hour',b'Jam Kerja Workstation'
b'DocType: Vital Signs',b'Blood Pressure',b'Tekanan darah'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125',b'Analyst',b'Analis'
b'DocType: Item',b'Inventory',b'Inventarisasi'
b'DocType: Item',b'Sales Details',b'Detail Penjualan'
b'DocType: Quality Inspection',b'QI-',b'QI-'
b'DocType: Opportunity',b'With Items',b'Dengan Produk'
b'DocType: Asset Maintenance',b'Maintenance Team',b'Tim Pemeliharaan'
b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'In Qty',b'Dalam Qty'
b'DocType: Education Settings',b'Validate Enrolled Course for Students in Student Group',b'Validasi Kursus Terdaftar untuk Siswa di Kelompok Pelajar'
b'DocType: Notification Control',b'Expense Claim Rejected',b'Beban Klaim Ditolak'
b'DocType: Item',b'Item Attribute',b'Item Atribut'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147',b'Government',b'pemerintahan'
b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40',b'Expense Claim {0} already exists for the Vehicle Log',b'Beban Klaim {0} sudah ada untuk Kendaraan Log'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +64',b'Institute Name',b'nama institusi'
b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117',b'Please enter repayment Amount',b'Masukkan pembayaran Jumlah'
b'apps/erpnext/erpnext/config/stock.py +309',b'Item Variants',b'Item Varian'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +29',b'Services',b'Jasa'
b'DocType: HR Settings',b'Email Salary Slip to Employee',b'Email Slip Gaji ke Karyawan'
b'DocType: Cost Center',b'Parent Cost Center',b'Parent Biaya Pusat'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1041',b'Select Possible Supplier',b'Pilih Kemungkinan Pemasok'
b'DocType: Sales Invoice',b'Source',b'Sumber'
b'DocType: Customer',"b'Select, to make the customer searchable with these fields'","b'Pilih, untuk membuat pelanggan dapat ditelusuri dengan bidang ini'"
b'apps/erpnext/erpnext/templates/pages/projects.html +31',b'Show closed',b'Tampilkan ditutup'
b'DocType: Leave Type',b'Is Leave Without Pay',b'Apakah Cuti Tanpa Bayar'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +261',b'Asset Category is mandatory for Fixed Asset item',b'Aset Kategori adalah wajib untuk item aset tetap'
b'DocType: Fee Validity',b'Fee Validity',b'Validitas biaya'
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +146',b'No records found in the Payment table',b'Tidak ada catatan yang ditemukan dalam tabel Pembayaran'
b'apps/erpnext/erpnext/education/utils.py +19',b'This {0} conflicts with {1} for {2} {3}',b'Ini {0} konflik dengan {1} untuk {2} {3}'
b'DocType: Student Attendance Tool',b'Students HTML',b'siswa HTML'
b'DocType: POS Profile',b'Apply Discount',b'Terapkan Diskon'
b'DocType: GST HSN Code',b'GST HSN Code',b'Kode HSN GST'
b'DocType: Employee External Work History',b'Total Experience',b'Jumlah Pengalaman'
b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70',b'Open Projects',b'terbuka Proyek'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +295',b'Packing Slip(s) cancelled',b'Packing slip (s) dibatalkan'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +36',b'Cash Flow from Investing',b'Arus Kas dari Investasi'
b'DocType: Program Course',b'Program Course',b'Kursus Program'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99',b'Freight and Forwarding Charges',b'Pengangkutan dan Forwarding Biaya'
b'DocType: Homepage',b'Company Tagline for website homepage',b'Perusahaan Tagline untuk homepage website'
b'DocType: Item Group',b'Item Group Name',b'Nama Item Grup'
b'apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27',b'Taken',b'Diambil'
b'DocType: Student',b'Date of Leaving',b'Tanggal Meninggalkan'
b'DocType: Pricing Rule',b'For Price List',b'Untuk Daftar Harga'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27',b'Executive Search',b'Pencarian eksekutif'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55',b'Setting defaults',b'Pengaturan default'
b'apps/erpnext/erpnext/utilities/activation.py +63',b'Create Leads',b'Buat Prospek'
b'DocType: Maintenance Schedule',b'Schedules',b'Jadwal'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +468',b'POS Profile is required to use Point-of-Sale',b'Profil POS diharuskan menggunakan Point of Sale'
b'DocType: Purchase Invoice Item',b'Net Amount',b'Nilai Bersih'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +141',b'{0} {1} has not been submitted so the action cannot be completed',b'{0} {1} belum dikirim sehingga tindakan tidak dapat diselesaikan'
b'DocType: Purchase Order Item Supplied',b'BOM Detail No',b'No. Rincian BOM'
b'DocType: Landed Cost Voucher',b'Additional Charges',b'Pungutan-pungutan tambahan'
b'DocType: Purchase Invoice',b'Additional Discount Amount (Company Currency)',b'Jumlah Diskon Tambahan (dalam Mata Uang Perusahaan)'
b'DocType: Supplier Scorecard',b'Supplier Scorecard',b'Supplier Scorecard'
b'DocType: Plant Analysis',b'Result Datetime',b'Hasil Datetime'
b'apps/erpnext/erpnext/accounts/doctype/account/account.js +21',b'Please create new account from Chart of Accounts.',b'Silahkan buat akun baru dari Bagan Akun.'
,b'Support Hour Distribution',b'Distribusi Jam Dukungan'
b'DocType: Maintenance Visit',b'Maintenance Visit',b'Kunjungan Pemeliharaan'
b'DocType: Student',b'Leaving Certificate Number',b'Meninggalkan Sertifikat Nomor'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +58',"b'Appointment cancelled, Please review and cancel the invoice {0}'","b'Penunjukan dibatalkan, Harap tinjau dan batalkan faktur {0}'"
b'DocType: Sales Invoice Item',b'Available Batch Qty at Warehouse',b'Tersedia Batch Qty di Gudang'
b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9',b'Update Print Format',b'Perbarui Format Cetak'
b'DocType: Landed Cost Voucher',b'Landed Cost Help',b'Bantuan Biaya Landed'
b'DocType: Purchase Invoice',b'Select Shipping Address',b'Pilih Alamat Pengiriman'
b'apps/erpnext/erpnext/config/non_profit.py +28',b'Memebership Details',b'Rincian Memebership'
b'DocType: Leave Block List',b'Block Holidays on important days.',b'Blok Hari Libur pada hari-hari penting.'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +220',b'Please input all required Result Value(s)',b'Harap masukan semua Nilai Hasil yang dibutuhkan'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +106',b'Accounts Receivable Summary',b'Ringkasan Buku Piutang'
b'DocType: Employee Loan',b'Monthly Repayment Amount',b'Bulanan Pembayaran Jumlah'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9',b'Opening Invoices',b'Membuka Faktur'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +195',b'Please set User ID field in an Employee record to set Employee Role',b'Silakan set ID lapangan Pengguna dalam catatan Karyawan untuk mengatur Peran Karyawan'
b'DocType: UOM',b'UOM Name',b'Nama UOM'
b'DocType: GST HSN Code',b'HSN Code',b'Kode HSN'
b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +39',b'Contribution Amount',b'Jumlah kontribusi'
b'DocType: Purchase Invoice',b'Shipping Address',b'Alamat Pengiriman'
b'DocType: Stock Reconciliation',b'This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.',b'Alat ini membantu Anda memperbarui atau memperbaiki kuantitas dan valuasi persediaan di sistem. Biasanya digunakan untuk menyelaraskan sistem dengan aktual barang yang ada di gudang.'
b'DocType: Delivery Note',b'In Words will be visible once you save the Delivery Note.',b'Dalam Kata-kata akan terlihat sekali Anda menyimpan Delivery Note.'
b'DocType: Expense Claim',b'EXP',b'EXP'
b'DocType: Water Analysis',b'Container',b'Wadah'
b'apps/erpnext/erpnext/education/utils.py +50',b'Student {0} - {1} appears Multiple times in row {2} & {3}',b'Mahasiswa {0} - {1} muncul Beberapa kali berturut-turut {2} &amp; {3}'
b'DocType: Project',b'Day to Send',b'Hari ke Kirim'
b'DocType: Healthcare Settings',b'Manage Sample Collection',b'Mengelola Sampel Koleksi'
b'DocType: Production Plan',b'Ignore Existing Ordered Quantity',b'Abaikan Kuantitas Pemesanan yang Ada'
b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +66',b'Please set the series to be used.',b'Silakan mengatur seri yang akan digunakan.'
b'DocType: Patient',b'Tobacco Past Use',b'Tobacco Past Use'
b'DocType: Sales Invoice Item',b'Brand Name',b'Nama Merek'
b'DocType: Purchase Receipt',b'Transporter Details',b'Detail transporter'
b'apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +55',b'User {0} is already assigned to Physician {1}',b'Pengguna {0} sudah ditugaskan ke Dokter {1}'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2700',b'Default warehouse is required for selected item',b'gudang standar diperlukan untuk item yang dipilih'
b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Box',b'Kotak'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1038',b'Possible Supplier',b'mungkin Pemasok'
b'DocType: Budget',b'Monthly Distribution',b'Distribusi bulanan'
b'apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68',b'Receiver List is empty. Please create Receiver List',b'Receiver List kosong. Silakan membuat Receiver List'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +31',b'Healthcare (beta)',b'Kesehatan (beta)'
b'DocType: Production Plan Sales Order',b'Production Plan Sales Order',b'Rencana Produksi berdasar Order Penjualan'
b'DocType: Sales Partner',b'Sales Partner Target',b'Sasaran Mitra Penjualan'
b'DocType: Loan Type',b'Maximum Loan Amount',b'Maksimum Jumlah Pinjaman'
b'DocType: Pricing Rule',b'Pricing Rule',b'Aturan Harga'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58',b'Duplicate roll number for student {0}',b'Nomor pengguliran duplikat untuk siswa {0}'
b'DocType: Budget',b'Action if Annual Budget Exceeded',b'Tindakan jika Anggaran Tahunan Melebihi'
b'apps/erpnext/erpnext/config/learn.py +197',b'Material Request to Purchase Order',b'Permintaan Material untuk Order Pembelian'
b'DocType: Shopping Cart Settings',b'Payment Success URL',b'Pembayaran Sukses URL'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +81',b'Row # {0}: Returned Item {1} does not exists in {2} {3}',b'Baris # {0}: Barang Retur {1} tidak ada dalam {2} {3}'
b'DocType: Purchase Receipt',b'PREC-',b'PREC-'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16',b'Bank Accounts',b'Rekening Bank'
,b'Bank Reconciliation Statement',b'Laporan Rekonsiliasi Bank'
b'DocType: Consultation',b'Medical Coding',b'Pengkodean medis'
b'DocType: Healthcare Settings',b'Reminder Message',b'Pesan pengingat'
,b'Lead Name',b'Nama Prospek'
,b'POS',b'POS'
b'DocType: C-Form',b'III',b'AKU AKU AKU'
b'apps/erpnext/erpnext/config/stock.py +314',b'Opening Stock Balance',b'Saldo Persediaan Pembukaan'
b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58',b'{0} must appear only once',b'{0} harus muncul hanya sekali'
b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59',b'Leaves Allocated Successfully for {0}',b'cuti Dialokasikan Berhasil untuk {0}'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42',b'No Items to pack',b'Tidak ada item untuk dikemas'
b'DocType: Shipping Rule Condition',b'From Value',b'Dari Nilai'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +606',b'Manufacturing Quantity is mandatory',b'Qty Manufaktur  wajib diisi'
b'DocType: Employee Loan',b'Repayment Method',b'Metode pembayaran'
b'DocType: Products Settings',"b'If checked, the Home page will be the default Item Group for the website'","b'Jika diperiksa, Home page akan menjadi default Barang Group untuk website'"
b'DocType: Quality Inspection Reading',b'Reading 4',b'Membaca 4'
b'apps/erpnext/erpnext/config/hr.py +132',b'Claims for company expense.',b'Klaim untuk biaya perusahaan.'
b'apps/erpnext/erpnext/utilities/activation.py +118',"b'Students are at the heart of the system, add all your students'","b'Siswa di jantung dari sistem, menambahkan semua siswa Anda'"
b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97',b'Row #{0}: Clearance date {1} cannot be before Cheque Date {2}',b'Row # {0}: tanggal Jarak {1} tidak bisa sebelum Cek Tanggal {2}'
b'DocType: Asset Maintenance Task',b'Certificate Required',b'Sertifikat yang dibutuhkan'
b'DocType: Company',b'Default Holiday List',b'Standar Daftar Hari Libur'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +196',b'Row {0}: From Time and To Time of {1} is overlapping with {2}',b'Row {0}: Dari Waktu dan Untuk Waktu {1} adalah tumpang tindih dengan {2}'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145',b'Stock Liabilities',b'Hutang Persediaan'
b'DocType: Purchase Invoice',b'Supplier Warehouse',b'Gudang Supplier'
b'DocType: Opportunity',b'Contact Mobile No',b'Kontak Mobile No'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +399',b'Select Company',b'Pilih Perusahaan'
,b'Material Requests for which Supplier Quotations are not created',b'Permintaan Material yang Supplier Quotation tidak diciptakan'
b'DocType: Student Report Generation Tool',b'Print Section',b'Bagian Cetak'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34',"b""User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.""",b'Pengguna {0} tidak memiliki Profil POS default. Cek Default di Baris {1} untuk Pengguna ini.'
b'DocType: Student Group',b'Set 0 for no limit',b'Set 0 untuk tidak ada batas'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +122',b'The day(s) on which you are applying for leave are holidays. You need not apply for leave.',b'Hari (s) yang Anda lamar cuti adalah hari libur. Anda tidak perlu mengajukan cuti.'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64',b'Row {idx}: {field} is required to create the Opening {invoice_type} Invoices',b'Baris {idx}: {field} diperlukan untuk membuat Pembukaan {invoice_type} Faktur'
b'DocType: Customer',b'Primary Address and Contact Detail',b'Alamat Utama dan Detail Kontak'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20',b'Resend Payment Email',b'Kirim ulang Email Pembayaran'
b'apps/erpnext/erpnext/templates/pages/projects.html +27',b'New task',b'tugas baru'
b'DocType: Consultation',b'Appointment',b'Janji'
b'apps/erpnext/erpnext/utilities/activation.py +74',b'Make Quotation',b'Membuat Quotation'
b'apps/erpnext/erpnext/config/education.py +230',b'Other Reports',b'Laporan lainnya'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +39',b'Please select at least one domain.',b'Pilih setidaknya satu domain.'
b'DocType: Dependent Task',b'Dependent Task',b'Tugas Dependent'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +444',b'Conversion factor for default Unit of Measure must be 1 in row {0}',b'Faktor konversi untuk Unit default Ukur harus 1 berturut-turut {0}'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +188',b'Leave of type {0} cannot be longer than {1}',b'Cuti jenis {0} tidak boleh lebih dari {1}'
b'DocType: Manufacturing Settings',b'Try planning operations for X days in advance.',b'Coba operasi untuk hari X perencanaan di muka.'
b'DocType: HR Settings',b'Stop Birthday Reminders',b'Stop Pengingat Ulang Tahun'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +235',b'Please set Default Payroll Payable Account in Company {0}',b'Silahkan mengatur default Payroll Hutang Akun di Perusahaan {0}'
b'DocType: SMS Center',b'Receiver List',b'Daftar Penerima'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1094',b'Search Item',b'Cari Barang'
b'DocType: Payment Schedule',b'Payment Amount',b'Jumlah pembayaran'
b'DocType: Patient Appointment',b'Referring Physician',b'Merujuk Dokter'
b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46',b'Consumed Amount',b'Dikonsumsi Jumlah'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +100',b'Net Change in Cash',b'Perubahan bersih dalam kas'
b'DocType: Assessment Plan',b'Grading Scale',b'Skala penilaian'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +438',b'Unit of Measure {0} has been entered more than once in Conversion Factor Table',b'Satuan Ukur {0} telah dimasukkan lebih dari sekali dalam Faktor Konversi Tabel'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +639',b'Already completed',b'Sudah lengkap'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33',b'Stock In Hand',b'Persediaan Di Tangan'
b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64',b'Import Successful!',b'Impor Sukses!'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29',b'Payment Request already exists {0}',b'Permintaan pembayaran sudah ada {0}'
b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27',b'Cost of Issued Items',b'Biaya Produk Dikeluarkan'
b'DocType: Physician',b'Hospital',b'RSUD'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +385',b'Quantity must not be more than {0}',b'Kuantitas tidak boleh lebih dari {0}'
b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117',b'Previous Financial Year is not closed',b'Sebelumnya Keuangan Tahun tidak tertutup'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46',b'Age (Days)',b'Umur (Hari)'
b'DocType: Quotation Item',b'Quotation Item',b'Produk/Barang Penawaran'
b'DocType: Customer',b'Customer POS Id',b'Id POS Pelanggan'
b'DocType: Account',b'Account Name',b'Nama Akun'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40',b'From Date cannot be greater than To Date',b'Dari Tanggal tidak dapat lebih besar dari To Date'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198',b'Serial No {0} quantity {1} cannot be a fraction',b'Serial ada {0} kuantitas {1} tak bisa menjadi pecahan'
b'apps/erpnext/erpnext/config/buying.py +43',b'Supplier Type master.',b'Supplier Type induk.'
b'DocType: Purchase Order Item',b'Supplier Part Number',b'Supplier Part Number'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108',b'Conversion rate cannot be 0 or 1',b'Tingkat konversi tidak bisa 0 atau 1'
b'DocType: Share Balance',b'To No',b'Ke no'
b'DocType: Subscription',b'Reference Document',b'Dokumen referensi'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +229',b'{0} {1} is cancelled or stopped',b'{0} {1} dibatalkan atau dihentikan'
b'DocType: Accounts Settings',b'Credit Controller',b'Kredit Kontroller'
b'DocType: Grant Application',b'Applicant Type',b'Jenis Pemohon'
b'DocType: Purchase Invoice',b'03-Deficiency in services',b'03-Kekurangan layanan'
b'DocType: Delivery Note',b'Vehicle Dispatch Date',b'Kendaraan Dikirim Tanggal'
b'DocType: Healthcare Settings',b'Default Medical Code Standard',b'Standar Kode Standar Medis'
b'DocType: Purchase Invoice Item',b'HSN/SAC',b'HSN / SAC'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237',b'Purchase Receipt {0} is not submitted',b'Nota Penerimaan {0} tidak Terkirim'
b'DocType: Company',b'Default Payable Account',b'Standar Akun Hutang'
b'apps/erpnext/erpnext/config/website.py +17',"b'Settings for online shopping cart such as shipping rules, price list etc.'","b'Pengaturan untuk keranjang belanja online seperti aturan pengiriman, daftar harga dll'"
b'apps/erpnext/erpnext/controllers/website_list_for_contact.py +113',b'{0}% Billed',b'{0}% Ditagih'
b'apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18',b'Reserved Qty',b'Reserved Qty'
b'DocType: Party Account',b'Party Account',b'Akun Party'
b'apps/erpnext/erpnext/config/setup.py +122',b'Human Resources',b'Sumber Daya Manusia'
b'DocType: Lead',b'Upper Income',b'Penghasilan Atas'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17',b'Reject',b'Menolak'
b'DocType: Journal Entry Account',b'Debit in Company Currency',b'Debit di Mata Uang Perusahaan'
b'DocType: BOM Item',b'BOM Item',b'Komponen BOM'
b'DocType: Appraisal',b'For Employee',b'Untuk Karyawan'
b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49',b'Make Disbursement Entry',b'Membuat Pencairan Masuk'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138',b'Row {0}: Advance against Supplier must be debit',b'Row {0}: Muka melawan Supplier harus mendebet'
b'DocType: Company',b'Default Values',b'Nilai Default'
b'DocType: Membership',b'INR',b'INR'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60',b'{frequency} Digest',b'{Frekuensi} Digest'
b'DocType: Expense Claim',b'Total Amount Reimbursed',b'Jumlah Total diganti'
b'apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5',b'This is based on logs against this Vehicle. See timeline below for details',b'Hal ini didasarkan pada log terhadap kendaraan ini. Lihat timeline di bawah untuk rincian'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90',b'Against Supplier Invoice {0} dated {1}',b'Terhadap Faktur Supplier {0} di tanggal {1}'
b'DocType: Customer',b'Default Price List',b'Standar List Harga'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +322',b'Asset Movement record {0} created',b'Gerakan aset catatan {0} dibuat'
b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51',b'You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings',b'Anda tidak dapat menghapus Tahun Anggaran {0}. Tahun Fiskal {0} diatur sebagai default di Pengaturan Global'
b'apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20',b'A customer with the same name already exists',b'Pelanggan dengan nama yang sama sudah ada'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +185',b'This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?',b'Ini akan mengirimkan Slip Gaji dan membuat Entri Jurnal akrual. Apakah kamu ingin melanjutkan?'
b'DocType: Purchase Invoice',b'Total Net Weight',b'Total Berat Bersih'
b'DocType: Purchase Invoice',b'Eligibility For ITC',b'Kelayakan Untuk ITC'
b'DocType: Journal Entry',b'Entry Type',b'Entri Type'
,b'Customer Credit Balance',b'Saldo Kredit Pelanggan'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +28',b'Net Change in Accounts Payable',b'Perubahan bersih Hutang'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48',b'EcritureLet',b'EcritureLet'
b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +209',b'Credit limit has been crossed for customer {0} ({1}/{2})',b'Batas kredit telah disilangkan untuk pelanggan {0} ({1} / {2})'
b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42',"b""Customer required for 'Customerwise Discount'""","b""Pelanggan diperlukan untuk 'Diskon Pelanggan'"""
b'apps/erpnext/erpnext/config/accounts.py +140',b'Update bank payment dates with journals.',b'Perbarui tanggal pembayaran bank dengan jurnal.'
b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21',b'Pricing',b'harga'
b'DocType: Quotation',b'Term Details',b'Rincian Term'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30',b'Cannot enroll more than {0} students for this student group.',b'tidak bisa mendaftar lebih dari {0} siswa untuk kelompok siswa ini.'
b'apps/erpnext/erpnext/templates/print_formats/includes/total.html +4',b'Total (Without Tax)',b'Total (Tanpa Pajak)'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17',b'Lead Count',b'Jumlah Prospek'
b'apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15',b'{0} must be greater than 0',b'{0} harus lebih besar dari 0'
b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +30',b'Stock Available',b'Stok Tersedia'
b'DocType: Manufacturing Settings',b'Capacity Planning For (Days)',b'Perencanaan Kapasitas Untuk (Hari)'
b'apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10',b'Procurement',b'Pembelian'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +66',b'None of the items have any change in quantity or value.',b'Tak satu pun dari item memiliki perubahan kuantitas atau nilai.'
b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17',b'Mandatory field - Program',b'Bidang wajib - Program'
b'DocType: Special Test Template',b'Result Component',b'Komponen Hasil'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46',b'Warranty Claim',b'Garansi Klaim'
,b'Lead Details',b'Rincian Prospek'
b'DocType: Volunteer',b'Availability and Skills',b'Ketersediaan dan Keterampilan'
b'DocType: Salary Slip',b'Loan repayment',b'Pembayaran pinjaman'
b'DocType: Purchase Invoice',"b""End date of current invoice's period""",b'Tanggal akhir periode faktur saat ini'
b'DocType: Pricing Rule',b'Applicable For',b'Berlaku Untuk'
b'DocType: Lab Test',b'Technician Name',b'Nama teknisi'
b'DocType: Accounts Settings',b'Unlink Payment on Cancellation of Invoice',b'Membatalkan tautan Pembayaran pada Pembatalan Faktur'
b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16',b'Current Odometer reading entered should be greater than initial Vehicle Odometer {0}',b'Odometer membaca saat masuk harus lebih besar dari awal Kendaraan Odometer {0}'
b'DocType: Restaurant Reservation',b'No Show',b'Tidak menunjukkan'
b'DocType: Shipping Rule Country',b'Shipping Rule Country',b'Aturan Pengiriman \xe2\x80\x93 Negara'
b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10',b'Leave and Attendance',b'Tinggalkan dan Kehadiran'
b'DocType: Maintenance Visit',b'Partially Completed',b'Selesai Sebagian'
b'apps/erpnext/erpnext/healthcare/setup.py +257',b'Moderate Sensitivity',b'Sensitivitas sedang'
b'DocType: Leave Type',b'Include holidays within leaves as leaves',b'Sertakan libur dalam cuti cuti'
b'DocType: Sales Invoice',b'Packed Items',b'Produk Kemasan'
b'apps/erpnext/erpnext/config/support.py +27',b'Warranty Claim against Serial No.',b'Garansi Klaim terhadap Serial No.'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +197',"b""'Total'""",b'&#39;Total&#39;'
b'DocType: Shopping Cart Settings',b'Enable Shopping Cart',b'Aktifkan Keranjang Belanja'
b'DocType: Employee',b'Permanent Address',b'Alamat Tetap'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +260',b'Advance paid against {0} {1} cannot be greater \\\n\t\t\t\t\t\tthan Grand Total {2}',b'Uang muka yang dibayar terhadap {0} {1} tidak dapat lebih besar \\ dari Grand Total {2}'
b'DocType: Consultation',b'Medication',b'Obat'
b'DocType: Production Plan',b'Include Non Stock Items',b'Sertakan Item Non Stok'
b'DocType: Project Update',b'Challenging/Slow',b'Menantang / Lambat'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147',b'Please select item code',b'Silahkan pilih kode Stok Barang'
b'DocType: Student Sibling',b'Studying in Same Institute',b'Belajar di Same Institute'
b'DocType: Territory',b'Territory Manager',b'Manager Wilayah'
b'DocType: Packed Item',b'To Warehouse (Optional)',b'Untuk Gudang (pilihan)'
b'DocType: GST Settings',b'GST Accounts',b'Akun GST'
b'DocType: Payment Entry',b'Paid Amount (Company Currency)',b'Dibayar Jumlah (Perusahaan Mata Uang)'
b'DocType: Purchase Invoice',b'Additional Discount',b'Potongan Tambahan'
b'DocType: Selling Settings',b'Selling Settings',b'Pengaturan Penjualan'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +83',b'Confirm Action',b'Konfirmasi Tindakan'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39',b'Online Auctions',b'Lelang Online'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +100',b'Please specify either Quantity or Valuation Rate or both',b'Silakan tentukan baik Quantity atau Tingkat Penilaian atau keduanya'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18',b'Fulfillment',b'Pemenuhan'
b'apps/erpnext/erpnext/templates/generators/item.html +82',b'View in Cart',b'Lihat Troli'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103',b'Marketing Expenses',b'Beban Pemasaran'
,b'Item Shortage Report',b'Laporan Kekurangan Barang / Item'
b'apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py +15',"b""Can't create standard criteria. Please rename the criteria""",b'Tidak dapat membuat kriteria standar. Mohon ganti nama kriteria'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +311',"b'Weight is mentioned,\\nPlease mention ""Weight UOM"" too'","b'Berat disebutkan, \\n Sebutkan ""Berat UOM"" terlalu'"
b'DocType: Stock Entry Detail',b'Material Request used to make this Stock Entry',b'Permintaan Material yang digunakan untuk membuat Entri Persediaan ini'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +68',b'Next Depreciation Date is mandatory for new asset',b'Berikutnya Penyusutan Tanggal wajib untuk aset baru'
b'DocType: Student Group Creation Tool',b'Separate course based Group for every Batch',b'Kelompok terpisah berdasarkan Kelompok untuk setiap Batch'
b'apps/erpnext/erpnext/config/support.py +32',b'Single unit of an Item.',b'Unit tunggal Item.'
b'DocType: Fee Category',b'Fee Category',b'biaya Kategori'
b'DocType: Agriculture Task',b'Next Business Day',b'Hari bisnis selanjutnya'
b'DocType: Drug Prescription',b'Dosage by time interval',b'Dosis berdasarkan interval waktu'
b'DocType: Cash Flow Mapper',b'Section Header',b'Bagian Header'
,b'Student Fee Collection',b'Mahasiswa Koleksi Fee'
b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +24',b'Appointment Duration (mins)',b'Durasi Penunjukan (menit)'
b'DocType: Accounts Settings',b'Make Accounting Entry For Every Stock Movement',b'Membuat Entri Akuntansi Untuk Setiap Perpindahan Persediaan'
b'DocType: Leave Allocation',b'Total Leaves Allocated',b'Jumlah cuti Dialokasikan'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163',b'Warehouse required at Row No {0}',b'Gudang diperlukan pada Row nomor {0}'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +145',b'Please enter valid Financial Year Start and End Dates',b'Entrikan Tahun Mulai berlaku Keuangan dan Tanggal Akhir'
b'DocType: Employee',b'Date Of Retirement',b'Tanggal Pensiun'
b'DocType: Upload Attendance',b'Get Template',b'Dapatkan Template'
b'DocType: Material Request',b'Transferred',b'Ditransfer'
b'DocType: Vehicle',b'Doors',b'pintu'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +117',b'ERPNext Setup Complete!',b'ERPNext Pengaturan Selesai!'
b'DocType: Healthcare Settings',b'Collect Fee for Patient Registration',b'Kumpulkan Biaya untuk Registrasi Pasien'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +678',b'Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item',b'Tidak dapat mengubah Atribut setelah transaksi saham. Buat Item baru dan transfer saham ke Item baru'
b'DocType: Course Assessment Criteria',b'Weightage',b'Weightage'
b'DocType: Purchase Invoice',b'Tax Breakup',b'Rincian pajak'
b'DocType: Packing Slip',b'PS-',b'PS'
b'DocType: Member',b'Non Profit Member',b'Anggota nirlaba'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67',"b""{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.""","b""{0} {1}: Pusat Biaya diperlukan untuk akun 'Rugi Laba' {2}. Silakan membuat Pusat Biaya default untuk Perusahaan."""
b'DocType: Payment Schedule',b'Payment Term',b'Jangka waktu pembayaran'
b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +160',b'A Customer Group exists with same name please change the Customer name or rename the Customer Group',"b'Sudah ada Kelompok Pelanggan dengan nama yang sama, silakan ganti Nama Pelanggan atau ubah nama Kelompok Pelanggan'"
b'DocType: Land Unit',b'Area',b'Daerah'
b'apps/erpnext/erpnext/public/js/templates/contact_list.html +37',b'New Contact',b'Kontak baru'
b'DocType: Territory',b'Parent Territory',b'Wilayah Induk'
b'DocType: Purchase Invoice',b'Place of Supply',b'Tempat Pasokan'
b'DocType: Quality Inspection Reading',b'Reading 2',b'Membaca 2'
b'DocType: Stock Entry',b'Material Receipt',b'Nota Penerimaan Barang'
b'DocType: Homepage',b'Products',b'Produk'
b'DocType: Announcement',b'Instructor',b'Pengajar'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +61',b'Select Item (optional)',b'Pilih Item (opsional)'
b'DocType: Fee Schedule Student Group',b'Fee Schedule Student Group',b'Jadwal Biaya Kelompok Pelajar'
b'DocType: Student',b'AB+',b'AB +'
b'DocType: Item',"b'If this item has variants, then it cannot be selected in sales orders etc.'","b'Jika item ini memiliki varian, maka tidak dapat dipilih dalam order penjualan dll'"
b'DocType: Lead',b'Next Contact By',b'Kontak Selanjutnya Oleh'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +325',b'Quantity required for Item {0} in row {1}',b'Kuantitas yang dibutuhkan untuk Item {0} di baris {1}'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +45',b'Warehouse {0} can not be deleted as quantity exists for Item {1}',b'Gudang {0} tidak dapat dihapus karena ada kuantitas untuk Item {1}'
b'DocType: Quotation',b'Order Type',b'Tipe Order'
,b'Item-wise Sales Register',b'Item-wise Daftar Penjualan'
b'DocType: Asset',b'Gross Purchase Amount',b'Jumlah Pembelian Gross'
b'apps/erpnext/erpnext/utilities/user_progress.py +39',b'Opening Balances',b'Saldo awal'
b'DocType: Asset',b'Depreciation Method',b'Metode penyusutan'
b'DocType: Purchase Taxes and Charges',b'Is this Tax included in Basic Rate?',b'Apakah Pajak ini termasuk dalam Basic Rate?'
b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56',b'Total Target',b'Total Jumlah Target'
b'DocType: Soil Texture',b'Sand Composition (%)',b'Komposisi Pasir (%)'
b'DocType: Job Applicant',b'Applicant for a Job',b'Pemohon untuk Lowongan Kerja'
b'DocType: Production Plan Material Request',b'Production Plan Material Request',b'Produksi Permintaan Rencana Material'
b'DocType: Stock Reconciliation',b'Reconciliation JSON',b'Rekonsiliasi JSON'
b'apps/erpnext/erpnext/accounts/report/financial_statements.html +3',b'Too many columns. Export the report and print it using a spreadsheet application.',b'Terlalu banyak kolom. Mengekspor laporan dan mencetaknya menggunakan aplikasi spreadsheet.'
b'DocType: Purchase Invoice Item',b'Batch No',b'No. Batch'
b'DocType: Selling Settings',"b""Allow multiple Sales Orders against a Customer's Purchase Order""",b'Memungkinkan beberapa Order Penjualan terhadap Order Pembelian dari Pelanggan'
b'DocType: Student Group Instructor',b'Student Group Instructor',b'Instruktur Kelompok Mahasiswa'
b'DocType: Grant Application',b'Assessment  Mark (Out of 10)',b'Tanda Penilaian (Dari 10)'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61',b'Guardian2 Mobile No',b'Guardian2 Ponsel Tidak'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +218',b'Main',b'Utama'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +72',b'Variant',b'Varian'
b'DocType: Naming Series',b'Set prefix for numbering series on your transactions',b'Mengatur awalan untuk penomoran seri pada transaksi Anda'
b'DocType: Employee Attendance Tool',b'Employees HTML',b'Karyawan HTML'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +458',b'Default BOM ({0}) must be active for this item or its template',b'Standar BOM ({0}) harus aktif untuk item ini atau template-nya'
b'DocType: Employee',b'Leave Encashed?',b'Cuti dicairkan?'
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32',b'Opportunity From field is mandatory',b'Peluang Dari Bidang Usaha Wajib Diisi'
b'DocType: Email Digest',b'Annual Expenses',b'Beban tahunan'
b'DocType: Item',b'Variants',b'Varian'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1148',b'Make Purchase Order',b'Buat Order Pembelian'
b'DocType: SMS Center',b'Send To',b'Kirim Ke'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133',b'There is not enough leave balance for Leave Type {0}',b'Tidak ada saldo cuti cukup bagi Leave Type {0}'
b'DocType: Payment Reconciliation Payment',b'Allocated amount',b'Jumlah yang dialokasikan'
b'DocType: Sales Team',b'Contribution to Net Total',b'Kontribusi terhadap Net Jumlah'
b'DocType: Sales Invoice Item',"b""Customer's Item Code""",b'Kode Barang Pelanggan'
b'DocType: Stock Reconciliation',b'Stock Reconciliation',b'Rekonsiliasi Persediaan'
b'DocType: Territory',b'Territory Name',b'Nama Wilayah'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +204',b'Work-in-Progress Warehouse is required before Submit',b'Kerja-in-Progress Gudang diperlukan sebelum Submit'
b'apps/erpnext/erpnext/config/hr.py +40',b'Applicant for a Job.',b'Pemohon untuk Lowongan Pekerjaan'
b'DocType: Purchase Order Item',b'Warehouse and Reference',b'Gudang dan Referensi'
b'DocType: Supplier',b'Statutory info and other general information about your Supplier',b'Info Statutory dan informasi umum lainnya tentang Supplier Anda'
b'DocType: Item',b'Serial Nos and Batches',b'Nomor Seri dan Partai'
b'apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42',b'Student Group Strength',b'Kekuatan Kelompok Mahasiswa'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +261',b'Against Journal Entry {0} does not have any unmatched {1} entry',b'Catatan Jurnal {0} tidak memiliki {1} catatan yang belum dicocokan.'
b'apps/erpnext/erpnext/config/hr.py +142',b'Appraisals',b'Penilaian'
b'apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8',b'Training Events',b'Acara Pelatihan'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205',b'Duplicate Serial No entered for Item {0}',b'Gandakan Serial ada dimasukkan untuk Item {0}'
b'apps/erpnext/erpnext/config/selling.py +179',b'Track Leads by Lead Source.',b'Lacak Memimpin oleh Sumber Utama.'
b'DocType: Shipping Rule Condition',b'A condition for a Shipping Rule',b'Sebuah kondisi untuk Aturan Pengiriman'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +167',b'Please enter ',b'masukkan'
b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43',b'Maintenance Log',b'Log Pemeliharaan'
b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +236',b'Please set filter based on Item or Warehouse',b'Silahkan mengatur filter berdasarkan Barang atau Gudang'
b'DocType: Packing Slip',b'The net weight of this package. (calculated automatically as sum of net weight of items)',b'Berat bersih package ini. (Dihitung secara otomatis sebagai jumlah berat bersih item)'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +802',b'Discount amount cannot be greater than 100%',b'Jumlah diskon tidak boleh lebih dari 100%'
b'DocType: Sales Order',b'To Deliver and Bill',b'Untuk Dikirim dan Ditagih'
b'DocType: Student Group',b'Instructors',b'instruktur'
b'DocType: GL Entry',b'Credit Amount in Account Currency',b'Jumlah kredit di Akun Mata Uang'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +603',b'BOM {0} must be submitted',b'BOM {0} harus dikirimkan'
b'apps/erpnext/erpnext/config/accounts.py +460',b'Share Management',b'Manajemen saham'
b'DocType: Authorization Control',b'Authorization Control',b'Pengendali Otorisasi'
b'apps/erpnext/erpnext/controllers/buying_controller.py +317',b'Row #{0}: Rejected Warehouse is mandatory against rejected Item {1}',b'Row # {0}: Ditolak Gudang adalah wajib terhadap ditolak Stok Barang {1}'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810',b'Payment',b'Pembayaran'
b'apps/erpnext/erpnext/controllers/stock_controller.py +92',"b'Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.'","b'Gudang {0} tidak ditautkan ke akun apa pun, sebutkan akun di catatan gudang atau tetapkan akun persediaan baku di perusahaan {1}.'"
b'apps/erpnext/erpnext/utilities/activation.py +81',b'Manage your orders',b'Mengelola pesanan Anda'
b'DocType: Work Order Operation',b'Actual Time and Cost',b'Waktu dan Biaya Aktual'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +56',b'Material Request of maximum {0} can be made for Item {1} against Sales Order {2}',b'Permintaan Bahan maksimal {0} dapat dibuat untuk Item {1} terhadap Sales Order {2}'
b'DocType: Crop',b'Crop Spacing',b'Jarak tanam'
b'DocType: Course',b'Course Abbreviation',b'Singkatan saja'
b'DocType: Student Leave Application',b'Student Leave Application',b'Mahasiswa Cuti Aplikasi'
b'DocType: Item',b'Will also apply for variants',b'Juga akan berlaku untuk varian'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +217',"b'Asset cannot be cancelled, as it is already {0}'","b'Aset tidak dapat dibatalkan, karena sudah {0}'"
b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29',b'Employee {0} on Half day on {1}',b'Karyawan {0} tentang Half hari {1}'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42',b'Total working hours should not be greater than max working hours {0}',b'Jumlah jam kerja tidak boleh lebih besar dari max jam kerja {0}'
b'apps/erpnext/erpnext/templates/pages/task_info.html +90',b'On',b'Nyala'
b'apps/erpnext/erpnext/config/selling.py +62',b'Bundle items at time of sale.',b'Bundel item pada saat penjualan.'
b'DocType: Material Request Plan Item',b'Actual Qty',b'Jumlah Aktual'
b'DocType: Sales Invoice Item',b'References',b'Referensi'
b'DocType: Quality Inspection Reading',b'Reading 10',b'Membaca 10'
b'DocType: Item',b'Barcodes',b'Barcode'
b'DocType: Hub Category',b'Hub Node',b'Hub Node'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78',b'You have entered duplicate items. Please rectify and try again.',b'Anda telah memasukan item duplikat. Harap perbaiki dan coba lagi.'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129',b'Associate',b'Rekan'
b'DocType: Asset Movement',b'Asset Movement',b'Gerakan aset'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +508',b'Work Order {0} must be submitted',b'Perintah Kerja {0} harus diserahkan'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2214',b'New Cart',b'Cart baru'
b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44',b'Item {0} is not a serialized Item',b'Item {0} bukan merupakan Stok Barang serial'
b'DocType: SMS Center',b'Create Receiver List',b'Buat Daftar Penerima'
b'DocType: Vehicle',b'Wheels',b'roda'
b'DocType: Packing Slip',b'To Package No.',b'Untuk Paket No'
b'DocType: Patient Relation',b'Family',b'Keluarga'
b'DocType: Production Plan',b'Material Requests',b'Permintaan bahan'
b'DocType: Warranty Claim',b'Issue Date',b'Tanggal dibuat'
b'DocType: Activity Cost',b'Activity Cost',b'Biaya Aktivitas'
b'DocType: Sales Invoice Timesheet',b'Timesheet Detail',b'Detil absen'
b'DocType: Purchase Receipt Item Supplied',b'Consumed Qty',b'Qty Dikonsumsi'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52',b'Telecommunications',b'Telekomunikasi'
b'apps/erpnext/erpnext/accounts/party.py +263',"b""Billing currency must be equal to either default company's currency or party account currency""",b'Mata uang penagihan harus sama dengan mata uang perusahaan atau mata uang akun tertagih'
b'DocType: Packing Slip',b'Indicates that the package is a part of this delivery (Only Draft)',b'Menunjukkan bahwa paket tersebut merupakan bagian dari pengiriman ini (Hanya Draft)'
b'DocType: Soil Texture',b'Loam',b'Lempung'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +705',b'Row {0}: Due Date cannot be before posting date',b'Baris {0}: Tanggal Jatuh Tempo tidak boleh sebelum tanggal posting'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36',b'Make Payment Entry',b'Buat Entri Pembayaran'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129',b'Quantity for Item {0} must be less than {1}',b'Kuantitas untuk Item {0} harus kurang dari {1}'
,b'Sales Invoice Trends',b'Trend Faktur Penjualan'
b'DocType: Leave Application',b'Apply / Approve Leaves',b'Mohon / Approve Cuti'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3',b'For',b'Untuk'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +167',"b""Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total'""","b""Dapat merujuk baris hanya jika jenis biaya adalah 'On Sebelumnya Row Jumlah' atau 'Sebelumnya Row Jumlah'"""
b'DocType: Sales Order Item',b'Delivery Warehouse',b'Gudang Pengiriman'
b'apps/erpnext/erpnext/config/accounts.py +241',b'Tree of financial Cost Centers.',b'Pohon Pusat Biaya keuangan.'
b'DocType: Serial No',b'Delivery Document No',b'Nomor Dokumen Pengiriman'
b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191',"b""Please set 'Gain/Loss Account on Asset Disposal' in Company {0}""",b'Silahkan mengatur &#39;Gain / Loss Account pada Asset Disposal&#39; di Perusahaan {0}'
b'DocType: Landed Cost Voucher',b'Get Items From Purchase Receipts',b'Dapatkan Produk Dari Pembelian Penerimaan'
b'DocType: Serial No',b'Creation Date',b'Tanggal Pembuatan'
b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33',b'Item {0} appears multiple times in Price List {1}',b'Item {0} muncul beberapa kali dalam Daftar Harga {1}'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41',"b'Selling must be checked, if Applicable For is selected as {0}'","b'Jual harus diperiksa, jika Berlaku Untuk dipilih sebagai {0}'"
b'DocType: Production Plan Material Request',b'Material Request Date',b'Bahan Permintaan Tanggal'
b'DocType: Purchase Order Item',b'Supplier Quotation Item',b'Quotation Stok Barang Supplier'
b'DocType: Student',b'Student Mobile Number',b'Mahasiswa Nomor Ponsel'
b'DocType: Item',b'Has Variants',b'Memiliki Varian'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +488',"b'Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings'","b'Tidak dapat membebani Item {0} pada baris {1} lebih dari {2}. Untuk mengizinkan over-billing, silahkan atur di Stock Settings'"
b'apps/erpnext/erpnext/templates/emails/training_event.html +11',b'Update Response',b'Perbarui Tanggapan'
b'apps/erpnext/erpnext/public/js/utils.js +232',b'You have already selected items from {0} {1}',b'Anda sudah memilih item dari {0} {1}'
b'DocType: Monthly Distribution',b'Name of the Monthly Distribution',b'Nama Distribusi Bulanan'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +95',b'Batch ID is mandatory',b'Batch ID adalah wajib'
b'DocType: Sales Person',b'Parent Sales Person',b'Induk Sales Person'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +100',b'The seller and the buyer cannot be the same',b'Penjual dan pembeli tidak bisa sama'
b'DocType: Project',b'Collect Progress',b'Kumpulkan Kemajuan'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24',b'Select the program first',b'Pilih programnya dulu'
b'DocType: Patient Appointment',b'Patient Age',b'Usia pasien'
b'apps/erpnext/erpnext/config/learn.py +253',b'Managing Projects',b'Pengelolaan Proyek'
b'DocType: Supplier',b'Supplier of Goods or Services.',b'Supplier Stok Barang atau Jasa.'
b'DocType: Budget',b'Fiscal Year',b'Tahun Fiskal'
b'DocType: Asset Maintenance Log',b'Planned',b'Berencana'
b'DocType: Healthcare Settings',b'Default receivable accounts to be used if not set in Patient to book Consultation charges.',b'Rekening piutang bawaan yang akan digunakan jika tidak diatur oleh Pasien untuk memesan biaya Konsultasi.'
b'DocType: Vehicle Log',b'Fuel Price',b'Harga BBM'
b'DocType: Budget',b'Budget',b'Anggaran belanja'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +65',b'Set Open',b'Setel Buka'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +258',b'Fixed Asset Item must be a non-stock item.',b'Fixed Asset Item harus barang non-persediaan.'
b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50',"b""Budget cannot be assigned against {0}, as it's not an Income or Expense account""","b'Anggaran tidak dapat ditugaskan terhadap {0}, karena itu bukan Penghasilan atau Beban akun'"
b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51',b'Achieved',b'Tercapai'
b'DocType: Student Admission',b'Application Form Route',b'Form aplikasi Route'
b'apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66',b'Territory / Customer',b'Wilayah / Pelanggan'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +44',b'Leave Type {0} cannot be allocated since it is leave without pay',b'Tinggalkan Jenis {0} tidak dapat dialokasikan karena itu pergi tanpa membayar'
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +167',b'Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2}',b'Baris {0}: Alokasi jumlah {1} harus kurang dari atau sama dengan faktur jumlah yang luar biasa {2}'
b'DocType: Sales Invoice',b'In Words will be visible once you save the Sales Invoice.',b'Dalam Kata-kata akan terlihat setelah Anda menyimpan Faktur Penjualan.'
b'DocType: Lead',b'Follow Up',b'Mengikuti'
b'DocType: Item',b'Is Sales Item',b'Barang Jualan'
b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21',b'Item Group Tree',b'Tree Item Grup'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69',b'Item {0} is not setup for Serial Nos. Check Item master',b'Stok Barang {0} tidak setup untuk Nomor Seri. Periksa Induk Barang'
b'DocType: Maintenance Visit',b'Maintenance Time',b'Waktu Pemeliharaan'
,b'Amount to Deliver',b'Jumlah untuk Dikirim'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +335',b'Same item has been entered multiple times. {0}',b'Item yang sama telah beberapa kali dimasukkan. {0}'
b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +30',b'The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.',b'Jangka Tanggal Mulai tidak dapat lebih awal dari Tahun Tanggal Mulai Tahun Akademik yang istilah terkait (Tahun Akademik {}). Perbaiki tanggal dan coba lagi.'
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +190',b'There were errors.',b'Ada kesalahan.'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +166',b'Employee {0} has already applied for {1} between {2} and {3} : ',b'Karyawan {0} telah mengajukan permohonan untuk {1} antara {2} dan {3}:'
b'DocType: Guardian',b'Guardian Interests',b'wali Minat'
b'DocType: Naming Series',b'Current Value',b'Nilai saat ini'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +273',b'Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year',b'Beberapa tahun fiskal ada untuk tanggal {0}. Silakan set perusahaan di Tahun Anggaran'
b'DocType: Education Settings',b'Instructor Records to be created by',b'Catatan Instruktur yang akan dibuat oleh'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229',b'{0} created',b'{0} dibuat'
b'DocType: GST Account',b'GST Account',b'Akun GST'
b'DocType: Delivery Note Item',b'Against Sales Order',b'Berdasarkan Order Penjualan'
,b'Serial No Status',b'Status Nomor Serial'
b'DocType: Payment Entry Reference',b'Outstanding',b'terkemuka'
b'DocType: Supplier',b'Warn POs',b'Peringatkan untuk POs'
,b'Daily Timesheet Summary',b'Timesheet Ringkasan Harian'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +137',"b'Row {0}: To set {1} periodicity, difference between from and to date \\\n\t\t\t\t\t\tmust be greater than or equal to {2}'","b'Baris {0}: Untuk mengatur {1} periodisitas, perbedaan antara dari dan sampai saat ini \\\n harus lebih besar dari atau sama dengan {2}'"
b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6',b'This is based on stock movement. See {0} for details',b'Hal ini didasarkan pada pergerakan persediaan. Lihat {0} untuk rincian'
b'DocType: Pricing Rule',b'Selling',b'Penjualan'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +392',b'Amount {0} {1} deducted against {2}',b'Jumlah {0} {1} dipotong terhadap {2}'
b'DocType: Employee',b'Salary Information',b'Informasi Gaji'
b'DocType: Sales Person',b'Name and Employee ID',b'Nama dan ID Karyawan'
b'apps/erpnext/erpnext/accounts/party.py +308',b'Due Date cannot be before Posting Date',b'Tanggal jatuh tempo tidak bisa sebelum Tanggal Posting'
b'DocType: Website Item Group',b'Website Item Group',b'Situs Stok Barang Grup'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +463',b'No salary slip found to submit for the above selected criteria OR salary slip already submitted',b'Tidak ada slip gaji yang ditemukan untuk memenuhi kriteria yang dipilih di atas ATAU slip gaji yang telah diajukan'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150',b'Duties and Taxes',b'Tarif dan Pajak'
b'DocType: Projects Settings',b'Projects Settings',b'Pengaturan Proyek'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356',b'Please enter Reference date',b'Harap masukkan tanggal Referensi'
b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +44',b'{0} payment entries can not be filtered by {1}',b'{0} entri pembayaran tidak dapat disaring oleh {1}'
b'DocType: Item Website Specification',b'Table for Item that will be shown in Web Site',b'Tabel untuk Item yang akan ditampilkan di Situs Web'
b'DocType: Purchase Order Item Supplied',b'Supplied Qty',b'Qty Disupply'
b'DocType: Purchase Order Item',b'Material Request Item',b'Item Permintaan Material'
b'apps/erpnext/erpnext/config/selling.py +75',b'Tree of Item Groups.',b'Tree Item Grup.'
b'DocType: Production Plan',b'Total Produced Qty',b'Total Diproduksi Qty'
b'DocType: Payroll Entry',b'Get Employee Details',b'Dapatkan Rincian Karyawan'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +177',b'Cannot refer row number greater than or equal to current row number for this Charge type',b'Tidak dapat merujuk nomor baris yang lebih besar dari atau sama dengan nomor baris saat ini untuk jenis Biaya ini'
b'DocType: Asset',b'Sold',b'Terjual'
,b'Item-wise Purchase History',b'Laporan Riwayat Pembelian berdasarkan Stok Barang/Item'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230',"b""Please click on 'Generate Schedule' to fetch Serial No added for Item {0}""","b""Silahkan klik 'Menghasilkan Jadwal' untuk mengambil Serial yang ditambahkan untuk Item {0}"""
b'DocType: Account',b'Frozen',b'Beku'
b'DocType: Sales Invoice Payment',b'Base Amount (Company Currency)',b'Dasar Penilaian (Mata Uang Perusahaan)'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +928',b'Raw Materials',b'Bahan baku'
b'DocType: Payment Reconciliation Payment',b'Reference Row',b'referensi Row'
b'DocType: Installation Note',b'Installation Time',b'Waktu Installasi'
b'DocType: Sales Invoice',b'Accounting Details',b'Rincian Akuntansi'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +113',b'Delete all the Transactions for this Company',b'Hapus semua Transaksi untuk Perusahaan ini'
b'DocType: Patient',b'O Positive',b'O Positif'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68',b'Investments',b'Investasi'
b'DocType: Issue',b'Resolution Details',b'Detail Resolusi'
b'apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3',b'Allocations',b'Alokasi'
b'DocType: Item Quality Inspection Parameter',b'Acceptance Criteria',b'Kriteria Penerimaan'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +159',b'Please enter Material Requests in the above table',b'Cukup masukkan Permintaan Bahan dalam tabel di atas'
b'DocType: Item Attribute',b'Attribute Name',b'Nama Atribut'
b'DocType: BOM',b'Show In Website',b'Tampilkan Di Website'
b'DocType: Shopping Cart Settings',b'Show Quantity in Website',b'Tampilkan Kuantitas Website'
b'DocType: Employee Loan Application',b'Total Payable Amount',b'Jumlah Total Hutang'
b'DocType: Task',b'Expected Time (in hours)',b'Waktu yang diharapkan (dalam jam)'
b'DocType: Item Reorder',b'Check in (group)',b'Check in (kelompok)'
b'DocType: Soil Texture',b'Silt',b'Lanau'
,b'Qty to Order',b'Kuantitas untuk diorder'
b'DocType: Period Closing Voucher',"b'The account head under Liability or Equity, in which Profit/Loss will be booked'","b'Account kepala di bawah Kewajiban atau Ekuitas, di mana Laba / Rugi akan dipesan'"
b'apps/erpnext/erpnext/config/projects.py +36',b'Gantt chart of all tasks.',b'Gantt chart dari semua tugas.'
b'DocType: Opportunity',b'Mins to First Response',b'Menit untuk Respon Pertama'
b'DocType: Pricing Rule',b'Margin Type',b'Margin Jenis'
b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15',b'{0} hours',b'{0} jam'
b'DocType: Course',b'Default Grading Scale',b'Skala Grading bawaan'
b'DocType: Appraisal',b'For Employee Name',b'Untuk Nama Karyawan'
b'DocType: Holiday List',b'Clear Table',b'Bersihkan Table'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +119',b'Available slots',b'Slot yang tersedia'
b'DocType: C-Form Invoice Detail',b'Invoice No',b'Nomor Faktur'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +363',b'Make Payment',b'Melakukan pembayaran'
b'DocType: Room',b'Room Name',b'Nama ruangan'
b'DocType: Prescription Duration',b'Prescription Duration',b'Durasi Resep'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +81',"b'Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}'","b'Cuti tidak dapat diterapkan / dibatalkan sebelum {0}, saldo cuti sudah pernah membawa-diteruskan dalam catatan alokasi cuti masa depan {1}'"
b'DocType: Activity Cost',b'Costing Rate',b'Tingkat Biaya'
b'apps/erpnext/erpnext/config/selling.py +234',b'Customer Addresses And Contacts',b'Alamat dan Kontak Pelanggan'
,b'Campaign Efficiency',b'Efisiensi Promosi'
b'DocType: Discussion',b'Discussion',b'Diskusi'
b'DocType: Payment Entry',b'Transaction ID',b'ID transaksi'
b'DocType: Volunteer',b'Anytime',b'Kapan saja'
b'DocType: Patient',b'Surgical History',b'Sejarah Bedah'
b'DocType: Employee',b'Resignation Letter Date',b'Tanggal Surat Pengunduran Diri'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39',b'Pricing Rules are further filtered based on quantity.',b'Aturan harga selanjutnya disaring berdasarkan kuantitas.'
b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +127',b'Not Set',b'Tidak Diatur'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335',b'Please set the Date Of Joining for employee {0}',b'Harap atur tanggal bergabung untuk karyawan {0}'
b'DocType: Task',b'Total Billing Amount (via Time Sheet)',b'Jumlah Total Penagihan (via Waktu Lembar)'
b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61',b'Repeat Customer Revenue',b'Pendapatan Pelanggan Rutin'
b'DocType: Soil Texture',b'Silty Clay Loam',b'Silty Clay Loam'
b'DocType: Chapter',b'Chapter',b'Bab'
b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Pair',b'Pasangan'
b'DocType: Mode of Payment Account',b'Default account will be automatically updated in POS Invoice when this mode is selected.',b'Akun default akan diperbarui secara otomatis di Faktur POS saat mode ini dipilih.'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +970',b'Select BOM and Qty for Production',b'Pilih BOM dan Qty untuk Produksi'
b'DocType: Asset',b'Depreciation Schedule',b'Jadwal penyusutan'
b'apps/erpnext/erpnext/config/selling.py +124',b'Sales Partner Addresses And Contacts',b'Alamat Mitra Penjualan Dan Kontak'
b'DocType: Bank Reconciliation Detail',b'Against Account',b'Terhadap Akun'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52',b'Half Day Date should be between From Date and To Date',b'Tanggal Setengah Hari harus di antara Tanggal Mulai dan Tanggal Akhir'
b'DocType: Maintenance Schedule Detail',b'Actual Date',b'Tanggal Aktual'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +139',b'Please set the Default Cost Center in {0} company.',b'Harap atur Default Cost Center di {0} perusahaan.'
b'DocType: Item',b'Has Batch No',b'Bernomor Batch'
b'apps/erpnext/erpnext/public/js/utils.js +106',b'Annual Billing: {0}',b'Penagihan tahunan: {0}'
b'apps/erpnext/erpnext/config/accounts.py +200',b'Goods and Services Tax (GST India)',b'Pajak Barang dan Jasa (GST India)'
b'DocType: Delivery Note',b'Excise Page Number',b'Jumlah Halaman Excise'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +227',"b'Company, From Date and To Date is mandatory'","b'Perusahaan, Dari Tanggal dan To Date adalah wajib'"
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33',b'Get from Consultation',b'Dapatkan Konsultasi'
b'DocType: Asset',b'Purchase Date',b'Tanggal Pembelian'
b'DocType: Volunteer',b'Volunteer Type',b'Jenis Relawan'
b'DocType: Student',b'Personal Details',b'Data Pribadi'
b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193',"b""Please set 'Asset Depreciation Cost Center' in Company {0}""",b'Silahkan mengatur &#39;Biaya Penyusutan Asset Center di Perusahaan {0}'
,b'Maintenance Schedules',b'Jadwal pemeliharaan'
b'DocType: Task',b'Actual End Date (via Time Sheet)',b'Tanggal Akhir Aktual (dari Lembar Waktu)'
b'DocType: Soil Texture',b'Soil Type',b'Jenis tanah'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +387',b'Amount {0} {1} against {2} {3}',b'Jumlah {0} {1} terhadap {2} {3}'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +277',b'New Message',b'Pesan baru'
,b'Quotation Trends',b'Trend Penawaran'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +160',b'Item Group not mentioned in item master for item {0}',b'Item Grup tidak disebutkan dalam master Stok Barang untuk item {0}'
b'DocType: GoCardless Mandate',b'GoCardless Mandate',b'Mandat GoCardless'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +368',b'Debit To account must be a Receivable account',b'Debit Untuk akun harus rekening Piutang'
b'DocType: Shipping Rule',b'Shipping Amount',b'Jumlah Pengiriman'
b'DocType: Supplier Scorecard Period',b'Period Score',b'Skor Periode'
b'apps/erpnext/erpnext/utilities/user_progress.py +66',b'Add Customers',b'Tambahkan Pelanggan'
b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20',b'Pending Amount',b'Jumlah Pending'
b'DocType: Lab Test Template',b'Special',b'Khusus'
b'DocType: Purchase Order Item Supplied',b'Conversion Factor',b'Faktor konversi'
b'DocType: Purchase Order',b'Delivered',b'Dikirim'
,b'Vehicle Expenses',b'Beban kendaraan'
b'DocType: Serial No',b'Invoice Details',b'Detail faktur'
b'DocType: Grant Application',b'Show on Website',b'Tampilkan di Website'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +212',b'Expected value after useful life must be greater than or equal to {0}',b'nilai yang diharapkan setelah masa manfaat harus lebih besar dari atau sama dengan {0}'
b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29',b'Start on',b'Mulai dari'
b'DocType: Hub Category',b'Hub Category',b'Kategori Hub'
b'DocType: Purchase Invoice',b'SEZ',b'SEZ'
b'DocType: Purchase Receipt',b'Vehicle Number',b'Nomor Kendaraan'
b'DocType: Employee Loan',b'Loan Amount',b'Jumlah pinjaman'
b'DocType: Student Report Generation Tool',b'Add Letterhead',b'Tambahkan kop surat'
b'DocType: Program Enrollment',b'Self-Driving Vehicle',b'Kendaraan Mengemudi Sendiri'
b'DocType: Supplier Scorecard Standing',b'Supplier Scorecard Standing',b'Supplier Scorecard Berdiri'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +443',b'Row {0}: Bill of Materials not found for the Item {1}',b'Row {0}: Bill of Material tidak ditemukan Item {1}'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +98',b'Total allocated leaves {0} cannot be less than already approved leaves {1} for the period',b'Jumlah cuti dialokasikan {0} tidak bisa kurang dari cuti yang telah disetujui {1} untuk periode'
b'DocType: Journal Entry',b'Accounts Receivable',b'Piutang'
,b'Supplier-Wise Sales Analytics',b'Sales Analitikal berdasarkan Supplier'
b'DocType: Purchase Invoice',b'Availed ITC Central Tax',b'Mengakses Pajak Pusat ITC'
b'DocType: Salary Structure',b'Select employees for current Salary Structure',b'Pilih karyawan untuk Struktur Gaji saat ini'
b'DocType: Sales Invoice',b'Company Address Name',b'Nama alamat perusahaan'
b'DocType: Work Order',b'Use Multi-Level BOM',b'Gunakan Multi-Level BOM'
b'DocType: Bank Reconciliation',b'Include Reconciled Entries',b'Termasuk Entri Rekonsiliasi'
b'DocType: Course',"b""Parent Course (Leave blank, if this isn't part of Parent Course)""","b'Kursus Orang Tua (Biarkan kosong, jika ini bukan bagian dari Kursus Orang Tua)'"
b'DocType: Leave Control Panel',b'Leave blank if considered for all employee types',b'Biarkan kosong jika dipertimbangkan untuk semua jenis karyawan'
b'DocType: Landed Cost Voucher',b'Distribute Charges Based On',b'Distribusi Biaya Berdasarkan'
b'DocType: Projects Settings',b'Timesheets',b'timesheets'
b'DocType: HR Settings',b'HR Settings',b'Pengaturan Sumber Daya Manusia'
b'DocType: Salary Slip',b'net pay info',b'net Info pay'
b'DocType: Lab Test Template',b'This value is updated in the Default Sales Price List.',b'Nilai ini diperbarui dalam Daftar Harga Penjualan Standar.'
b'DocType: Email Digest',b'New Expenses',b'Beban baru'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +79',b'PDC/LC Amount',b'Jumlah PDC / LC'
b'DocType: Shareholder',b'Shareholder',b'Pemegang saham'
b'DocType: Purchase Invoice',b'Additional Discount Amount',b'Jumlah Potongan Tambahan'
b'DocType: Cash Flow Mapper',b'Position',b'Posisi'
b'DocType: Patient',b'Patient Details',b'Rincian pasien'
b'DocType: Patient',b'B Positive',b'B Positif'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +596',"b'Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.'","b'Row # {0}: Qty harus 1, sebagai item aset tetap. Silakan gunakan baris terpisah untuk beberapa qty.'"
b'DocType: Leave Block List Allow',b'Leave Block List Allow',b'Cuti Block List Izinkan'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +317',b'Abbr can not be blank or space',b'Singkatan tidak boleh kosong atau spasi'
b'DocType: Patient Medical Record',b'Patient Medical Record',b'Catatan Medis Pasien'
b'apps/erpnext/erpnext/accounts/doctype/account/account.js +68',b'Group to Non-Group',b'Kelompok Non-kelompok'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50',b'Sports',b'Olahraga'
b'DocType: Loan Type',b'Loan Name',b'pinjaman Nama'
b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56',b'Total Actual',b'Total Aktual'
b'DocType: Lab Test UOM',b'Test UOM',b'Uji UOM'
b'DocType: Student Siblings',b'Student Siblings',b'Saudara mahasiswa'
b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Unit',b'Satuan'
b'apps/erpnext/erpnext/stock/get_item_details.py +138',b'Please specify Company',b'Silakan tentukan Perusahaan'
,b'Customer Acquisition and Loyalty',b'Akuisisi dan Loyalitas Pelanggan'
b'DocType: Asset Maintenance Task',b'Maintenance Task',b'Tugas pemeliharaan'
b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +118',b'Please set B2C Limit in GST Settings.',b'Harap atur Batas B2C di Setelan GST.'
b'DocType: Purchase Invoice',b'Warehouse where you are maintaining stock of rejected items',b'Gudang di mana Anda menyimpan barang-barang yang ditolak/reject'
b'DocType: Work Order',b'Skip Material Transfer',b'Lewati Transfer Material'
b'apps/erpnext/erpnext/setup/utils.py +109',b'Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually',b'Tidak dapat menemukan nilai tukar untuk {0} sampai {1} untuk tanggal kunci {2}. Buat catatan Currency Exchange secara manual'
b'DocType: POS Profile',b'Price List',b'Daftar Harga'
b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +22',b'{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.',b'{0} adalah Tahun Anggaran bawaan. Silahkan memuat kembali browser Anda agar perubahan dapat terwujud.'
b'apps/erpnext/erpnext/projects/doctype/task/task.js +45',b'Expense Claims',b'Beban Klaim'
b'DocType: Issue',b'Support',b'Support'
,b'BOM Search',b'Pencarian BOM'
b'DocType: Project',b'Total Consumed Material Cost  (via Stock Entry)',b'Total Biaya Bahan yang Dikonsumsi (melalui Entri Stok)'
b'DocType: Item',"b'Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.'",b'Publish &quot;In Stock&quot; atau &quot;Not in Stock&quot; di Hub berdasarkan stok yang ada di gudang ini.'
b'DocType: Vehicle',b'Fuel Type',b'Jenis bahan bakar'
b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27',b'Please specify currency in Company',b'Silakan tentukan mata uang di Perusahaan'
b'DocType: Workstation',b'Wages per hour',b'Upah per jam'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47',b'Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3}',b'Saldo Persediaan di Batch {0} akan menjadi negatif {1} untuk Barang {2} di Gudang {3}'
b'apps/erpnext/erpnext/templates/emails/reorder_item.html +1',"b""Following Material Requests have been raised automatically based on Item's re-order level""",b'Berikut Permintaan Bahan telah dibesarkan secara otomatis berdasarkan tingkat re-order Item'
b'DocType: Email Digest',b'Pending Sales Orders',b'Pending Order Penjualan'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +312',b'Account {0} is invalid. Account Currency must be {1}',b'Akun {0} tidak berlaku. Mata Uang Akun harus {1}'
b'DocType: Healthcare Settings',b'Remind Before',b'Ingatkan sebelumnya'
b'apps/erpnext/erpnext/buying/utils.py +34',b'UOM Conversion factor is required in row {0}',b'Faktor UOM Konversi diperlukan berturut-turut {0}'
b'DocType: Production Plan Item',b'material_request_item',b'material_request_item'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1087',"b'Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry'","b'Row # {0}: Dokumen Referensi Type harus menjadi salah satu Sales Order, Faktur Penjualan atau Journal Entri'"
b'DocType: Salary Component',b'Deduction',b'Deduksi'
b'DocType: Item',b'Retain Sample',b'Simpan sampel'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115',b'Row {0}: From Time and To Time is mandatory.',b'Row {0}: Dari Waktu dan To Waktu adalah wajib.'
b'DocType: Stock Reconciliation Item',b'Amount Difference',b'jumlah Perbedaan'
b'apps/erpnext/erpnext/stock/get_item_details.py +356',b'Item Price added for {0} in Price List {1}',b'Item Harga ditambahkan untuk {0} di Daftar Harga {1}'
b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8',b'Please enter Employee Id of this sales person',b'Cukup masukkan Id Karyawan Sales Person ini'
b'DocType: Territory',b'Classification of Customers by region',b'Klasifikasi Pelanggan menurut wilayah'
b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +71',b'In Production',b'Dalam produksi'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +65',b'Difference Amount must be zero',b'Perbedaan Jumlah harus nol'
b'DocType: Project',b'Gross Margin',b'Margin kotor'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +61',b'Please enter Production Item first',b'Entrikan Produksi Stok Barang terlebih dahulu'
b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45',b'Calculated Bank Statement balance',b'Dihitung keseimbangan Laporan Bank'
b'DocType: Normal Test Template',b'Normal Test Template',b'Template Uji Normal'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64',b'disabled user',b'Pengguna Non-aktif'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +919',b'Quotation',b'Penawaran'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +984',b'Cannot set a received RFQ to No Quote',b'Tidak dapat mengatur RFQ yang diterima ke No Quote'
b'DocType: Quotation',b'QTN-',b'QTN-'
b'DocType: Salary Slip',b'Total Deduction',b'Jumlah Deduksi'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +18',b'Select an account to print in account currency',b'Pilih akun yang akan dicetak dalam mata uang akun'
,b'Production Analytics',b'Analytics produksi'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6',b'This is based on transactions against this Patient. See timeline below for details',b'Hal ini didasarkan pada transaksi melawan Pasien ini. Lihat garis waktu di bawah untuk rinciannya'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +204',b'Cost Updated',b'Biaya Diperbarui'
b'DocType: Patient',b'Date of Birth',b'Tanggal Lahir'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +133',b'Item {0} has already been returned',b'Item {0} telah dikembalikan'
b'DocType: Fiscal Year',b'**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.',b'** Tahun Anggaran ** mewakili Tahun Keuangan. Semua entri akuntansi dan transaksi besar lainnya dilacak terhadap Tahun Anggaran ** **.'
b'DocType: Opportunity',b'Customer / Lead Address',b'Alamat Pelanggan / Prospek'
b'DocType: Supplier Scorecard Period',b'Supplier Scorecard Setup',b'Penyiapan Scorecard Pemasok'
b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133',b'Assessment Plan Name',b'Nama Rencana Penilaian'
b'DocType: Work Order Operation',b'Work Order Operation',b'Operasi Orde Kerja'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +233',b'Warning: Invalid SSL certificate on attachment {0}',b'Peringatan: Sertifikat SSL tidak valid pada lampiran {0}'
b'apps/erpnext/erpnext/utilities/activation.py +64',"b'Leads help you get business, add all your contacts and more as your leads'","b'Prospek membantu Anda mendapatkan bisnis, tambahkan semua kontak Anda sebagai prospek Anda'"
b'DocType: Work Order Operation',b'Actual Operation Time',b'Waktu Operasi Aktual'
b'DocType: Authorization Rule',b'Applicable To (User)',b'Berlaku Untuk (User)'
b'DocType: Purchase Taxes and Charges',b'Deduct',b'Pengurangan'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238',b'Job Description',b'Deskripsi Bidang Kerja'
b'DocType: Student Applicant',b'Applied',b'Terapan'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874',b'Re-open',b'Re-terbuka'
b'DocType: Sales Invoice Item',b'Qty as per Stock UOM',b'Kuantitas sesuai UOM Persediaan'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59',b'Guardian2 Name',b'Nama Guardian2'
b'DocType: Purchase Invoice',b'02-Post Sale Discount',b'Diskon Pasca Penjualan 02-Post'
b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +132',"b'Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series'","b'Karakter khusus kecuali ""-"" ""."", ""#"", dan ""/"" tidak diperbolehkan dalam penamaan seri'"
b'DocType: Campaign',"b'Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.'","b'Pantau Kampanye Penjualan. Pantau Prospek, Penawaran, Perintah Penjualan dll dari Kampanye untuk mengukur Return on Investment.'"
,b'SO Qty',b'SO Qty'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +91',b'The field To Shareholder cannot be blank',b'Bidang Ke Pemegang Saham tidak boleh kosong'
b'DocType: Guardian',b'Work Address',b'kerja Alamat'
b'DocType: Appraisal',b'Calculate Total Score',b'Hitung Total Skor'
b'DocType: Health Insurance',b'Health Insurance',b'Asuransi Kesehatan'
b'DocType: Asset Repair',b'Manufacturing Manager',b'Manajer Manufaktur'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191',b'Serial No {0} is under warranty upto {1}',b'Serial ada {0} masih dalam garansi upto {1}'
b'DocType: Plant Analysis Criteria',b'Minimum Permissible Value',b'Nilai Diijinkan Minimal'
b'apps/erpnext/erpnext/education/doctype/guardian/guardian.py +41',b'User {0} already exists',b'Pengguna {0} sudah ada'
b'apps/erpnext/erpnext/hooks.py +109',b'Shipments',b'Pengiriman'
b'DocType: Payment Entry',b'Total Allocated Amount (Company Currency)',b'Total Dialokasikan Jumlah (Perusahaan Mata Uang)'
b'DocType: Purchase Order Item',b'To be delivered to customer',b'Akan dikirimkan ke pelanggan'
b'DocType: BOM',b'Scrap Material Cost',b'Scrap Material Biaya'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227',b'Serial No {0} does not belong to any Warehouse',b'Serial ada {0} bukan milik Gudang setiap'
b'DocType: Grant Application',b'Email Notification Sent',b'Notifikasi Email Terkirim'
b'DocType: Purchase Invoice',b'In Words (Company Currency)',b'Dalam Kata-kata (Perusahaan Mata Uang)'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1018',"b'Item Code, warehouse, quantity are required on row'","b'Kode Barang, gudang, jumlah diminta pada baris'"
b'DocType: Pricing Rule',b'Supplier',b'Supplier'
b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41',b'Show Payment Details',b'Tampilkan Rincian Pembayaran'
b'DocType: Consultation',b'Consultation Time',b'Waktu Konsultasi'
b'DocType: C-Form',b'Quarter',b'Seperempat'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106',b'Miscellaneous Expenses',b'Beban lain-lain'
b'DocType: Global Defaults',b'Default Company',b'Standar Perusahaan'
b'apps/erpnext/erpnext/controllers/stock_controller.py +227',b'Expense or Difference account is mandatory for Item {0} as it impacts overall stock value',b'Akun Beban atau Selisih adalah wajib untuk Barang {0} karena berdampak pada keseluruhan nilai persediaan'
b'DocType: Payment Request',b'PR',b'PR'
b'DocType: Cheque Print Template',b'Bank Name',b'Nama Bank'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +30',b'-Above',b'-Di Atas'
b'DocType: Employee Loan',b'Employee Loan Account',b'Rekening Pinjaman karyawan'
b'DocType: Leave Application',b'Total Leave Days',b'Jumlah Cuti Hari'
b'DocType: Email Digest',b'Note: Email will not be sent to disabled users',b'Catatan: Surel tidak akan dikirim ke pengguna non-aktif'
b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14',b'Number of Interaction',b'Jumlah Interaksi'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +105',b'Item Variant Settings',b'Pengaturan Variasi Item'
b'apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +37',b'Select Company...',b'Pilih Perusahaan ...'
b'DocType: Leave Control Panel',b'Leave blank if considered for all departments',b'Biarkan kosong jika dianggap untuk semua departemen'
b'apps/erpnext/erpnext/config/hr.py +228',"b'Types of employment (permanent, contract, intern etc.).'","b'Jenis pekerjaan (permanen, kontrak, magang dll).'"
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434',b'{0} is mandatory for Item {1}',b'{0} adalah wajib untuk Item {1}'
b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +136',"b'Item {0}: {1} qty produced, '","b'Item {0}: {1} qty diproduksi,'"
b'DocType: Payroll Entry',b'Fortnightly',b'sekali dua minggu'
b'DocType: Currency Exchange',b'From Currency',b'Dari mata uang'
b'DocType: Vital Signs',b'Weight (In Kilogram)',b'Berat (dalam Kilogram)'
b'DocType: Chapter',b'chapters/chapter_name\nleave blank automatically set after saving chapter.',b'bab / chapter_name kosongkan secara otomatis setelah bab save.'
b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +202',b'Please set GST Accounts in GST Settings',b'Harap setel akun GST di GST Settings'
b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js +31',b'Type of Business',b'Jenis bisnis'
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +171',"b'Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row'","b'Silakan pilih Jumlah Alokasi, Faktur Jenis dan Faktur Nomor di minimal satu baris'"
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +128',b'Cost of New Purchase',b'Biaya Pembelian New'
b'apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py +35',b'All tasks for the detected diseases were imported',b'Semua tugas untuk penyakit yang terdeteksi diimpor'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97',b'Sales Order required for Item {0}',b'Sales Order yang diperlukan untuk Item {0}'
b'DocType: Grant Application',b'Grant Description',b'Deskripsi Hibah'
b'DocType: Purchase Invoice Item',b'Rate (Company Currency)',b'Rate (Perusahaan Mata Uang)'
b'DocType: Student Guardian',b'Others',b'Lainnya'
b'DocType: Payment Entry',b'Unallocated Amount',b'Jumlah yang tidak terisi'
b'apps/erpnext/erpnext/templates/includes/product_page.js +91',b'Cannot find a matching Item. Please select some other value for {0}.',b'Tidak dapat menemukan yang cocok Item. Silakan pilih beberapa nilai lain untuk {0}.'
b'DocType: POS Profile',b'Taxes and Charges',b'Pajak dan Biaya'
b'DocType: Item',"b'A Product or a Service that is bought, sold or kept in stock.'","b'Produk atau Jasa yang dibeli, dijual atau disimpan dalam persediaan.'"
b'apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44',b'No more updates',b'Tidak ada perbaruan lagi'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171',"b""Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row""","b""Tidak dapat memilih jenis biaya sebagai 'Pada Row Sebelumnya Jumlah' atau 'On Sebelumnya Row Jumlah' untuk baris terlebih dahulu"""
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6',b'This covers all scorecards tied to this Setup',b'Ini mencakup semua scorecard yang terkait dengan Setup ini'
b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29',b'Child Item should not be a Product Bundle. Please remove item `{0}` and save',b'Barang Turunan tidak boleh berupa sebuah Bundel Produk. Silahkan hapus barang `{0}` dan simpan'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12',b'Banking',b'Perbankan'
b'apps/erpnext/erpnext/utilities/activation.py +108',b'Add Timesheets',b'menambahkan Timesheets'
b'DocType: Vehicle Service',b'Service Item',b'layanan Barang'
b'DocType: Bank Guarantee',b'Bank Guarantee',b'Bank Garansi'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39',"b""Please click on 'Generate Schedule' to get schedule""","b""Silahkan klik 'Menghasilkan Jadwal' untuk mendapatkan jadwal"""
b'DocType: Bin',b'Ordered Quantity',b'Qty Terpesan/Terorder'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +118',"b'e.g. ""Build tools for builders""'","b'misalnya ""Membangun alat untuk pembangun ""'"
b'DocType: Grading Scale',b'Grading Scale Intervals',b'Grading Scale Interval'
b'apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39',b'Profit for the year',b'keuntungan untuk tahun ini'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125',b'{0} {1}: Accounting Entry for {2} can only be made in currency: {3}',b'{0} {1}: Entri Akuntansi untuk {2} hanya dapat dilakukan dalam bentuk mata uang: {3}'
b'DocType: Fee Schedule',b'In Process',b'Dalam Proses'
b'DocType: Authorization Rule',b'Itemwise Discount',b'Diskon berdasarkan Item/Stok'
b'apps/erpnext/erpnext/config/accounts.py +75',b'Tree of financial accounts.',b'Pohon rekening keuangan.'
b'DocType: Cash Flow Mapping',b'Cash Flow Mapping',b'Pemetaan Arus Kas'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364',b'{0} against Sales Order {1}',b'{0} terhadap Order Penjualan {1}'
b'DocType: Account',b'Fixed Asset',b'Asset Tetap'
b'apps/erpnext/erpnext/config/stock.py +324',b'Serialized Inventory',b'Persediaan memiliki serial'
b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74',b'Email not found in default contact',b'Email tidak ditemukan dalam kontak default'
b'DocType: Employee Loan',b'Account Info',b'Info akun'
b'DocType: Activity Type',b'Default Billing Rate',b'Standar Tingkat Penagihan'
b'DocType: Fees',b'Include Payment',b'Sertakan Pembayaran'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77',b'{0} Student Groups created.',b'{0} Kelompok Siswa dibuat.'
b'DocType: Sales Invoice',b'Total Billing Amount',b'Jumlah Total Tagihan'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50',b'Program in the Fee Structure and Student Group {0} are different.',b'Program di Struktur Biaya dan Kelompok Pelajar {0} berbeda.'
b'DocType: Fee Schedule',b'Receivable Account',b'Akun Piutang'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +618',b'Row #{0}: Asset {1} is already {2}',b'Row # {0}: Aset {1} sudah {2}'
b'DocType: Quotation Item',b'Stock Balance',b'Saldo Persediaan'
b'apps/erpnext/erpnext/config/selling.py +321',b'Sales Order to Payment',b'Nota Penjualan untuk Pembayaran'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123',b'CEO',b'CEO'
b'DocType: Purchase Invoice',b'With Payment of Tax',b'Dengan pembayaran pajak'
b'DocType: Expense Claim Detail',b'Expense Claim Detail',b'Detail Klaim Biaya'
b'DocType: Purchase Invoice',b'TRIPLICATE FOR SUPPLIER',b'TRIPLICATE UNTUK PEMASOK'
b'DocType: Land Unit',b'Is Container',b'Adalah kontainer'
b'DocType: Crop Cycle',b'This will be day 1 of the crop cycle',b'Ini akan menjadi hari 1 dari siklus panen'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +871',b'Please select correct account',b'Silakan pilih akun yang benar'
b'DocType: Purchase Invoice Item',b'Weight UOM',b'Berat UOM'
b'apps/erpnext/erpnext/config/accounts.py +466',b'List of available Shareholders with folio numbers',b'Daftar Pemegang Saham yang tersedia dengan nomor folio'
b'DocType: Salary Structure Employee',b'Salary Structure Employee',b'Struktur Gaji Karyawan'
b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45',b'Show Variant Attributes',b'Tampilkan Variant Attributes'
b'DocType: Student',b'Blood Group',b'Golongan Darah'
b'DocType: Course',b'Course Name',b'Nama kursus'
b'DocType: Employee Leave Approver',"b""Users who can approve a specific employee's leave applications""",b'Pengguna yang dapat menyetujui aplikasi cuti karyawan tertentu yang'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52',b'Office Equipments',b'Peralatan Kantor'
b'DocType: Purchase Invoice Item',b'Qty',b'Kuantitas'
b'DocType: Fiscal Year',b'Companies',b'Perusahaan'
b'DocType: Supplier Scorecard',b'Scoring Setup',b'Setup Scoring'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24',b'Electronics',b'Elektronik'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +326',b'Debit ({0})',b'Debit ({0})'
b'DocType: Stock Settings',b'Raise Material Request when stock reaches re-order level',b'Munculkan Permintaan Material ketika persediaan mencapai tingkat pesan ulang'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98',b'Full-time',b'Full-time'
b'DocType: Payroll Entry',b'Employees',b'Para karyawan'
b'DocType: Employee',b'Contact Details',b'Kontak Detail'
b'DocType: C-Form',b'Received Date',b'Diterima Tanggal'
b'DocType: Delivery Note',"b'If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.'","b'Jika Anda telah membuat template standar dalam Penjualan Pajak dan Biaya Template, pilih salah satu dan klik pada tombol di bawah ini.'"
b'DocType: BOM Scrap Item',b'Basic Amount (Company Currency)',b'Nilai Dasar (Mata Uang Perusahaan)'
b'DocType: Student',b'Guardians',b'Penjaga'
b'apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html +13',b'Payment Confirmation',b'Konfirmasi pembayaran'
b'DocType: Shopping Cart Settings',b'Prices will not be shown if Price List is not set',b'Harga tidak akan ditampilkan jika Harga Daftar tidak diatur'
b'DocType: Stock Entry',b'Total Incoming Value',b'Total nilai masuk'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +362',b'Debit To is required',b'Debit Untuk diperlukan'
b'apps/erpnext/erpnext/utilities/activation.py +109',"b'Timesheets help keep track of time, cost and billing for activites done by your team'","b'Timesheets membantu melacak waktu, biaya dan penagihan untuk kegiatan yang dilakukan oleh tim Anda'"
b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39',b'Purchase Price List',b'Pembelian Daftar Harga'
b'apps/erpnext/erpnext/config/buying.py +155',b'Templates of supplier scorecard variables.',b'Template dari variabel scorecard pemasok.'
b'DocType: Job Offer Term',b'Offer Term',b'Penawaran Term'
b'DocType: Asset',b'Quality Manager',b'Manajer Mutu'
b'DocType: Job Applicant',b'Job Opening',b'Lowongan Pekerjaan'
b'DocType: Payment Reconciliation',b'Payment Reconciliation',b'Rekonsiliasi Pembayaran'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153',"b""Please select Incharge Person's name""",b'Silahkan Pilih Pihak penanggung jawab'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51',b'Technology',b'Teknologi'
b'DocType: Hub Settings',b'Unregister from Hub',b'Unregister dari Hub'
b'apps/erpnext/erpnext/public/js/utils.js +108',b'Total Unpaid: {0}',b'Total Tunggakan: {0}'
b'DocType: BOM Website Operation',b'BOM Website Operation',b'BOM Operasi Situs'
b'DocType: Supplier Scorecard',b'Supplier Score',b'Skor Pemasok'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +213',b'Total Invoiced Amt',b'Jumlah Nilai Tagihan'
b'DocType: Supplier',b'Warn RFQs',b'Peringatkan untuk RFQs'
b'DocType: BOM',b'Conversion Rate',b'Tingkat konversi'
b'apps/erpnext/erpnext/templates/pages/product_search.html +3',b'Product Search',b'Cari produk'
b'DocType: Assessment Plan',b'To Time',b'Untuk Waktu'
b'DocType: Authorization Rule',b'Approving Role (above authorized value)',b'Menyetujui Peran (di atas nilai yang berwenang)'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118',b'Credit To account must be a Payable account',b'Kredit Untuk akun harus rekening Hutang'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43',b'Please select Student Admission which is mandatory for the paid student applicant',b'Silakan pilih Student Admission yang wajib diisi pemohon uang pelajar'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +355',b'BOM recursion: {0} cannot be parent or child of {2}',b'BOM recursion: {0} tidak bisa menjadi induk atau cabang dari {2}'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +21',b'Please select a Price List to publish pricing',b'Silakan pilih Daftar Harga untuk menerbitkan harga'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38',b'Budget List',b'Daftar anggaran'
b'DocType: Work Order Operation',b'Completed Qty',b'Qty Selesai'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148',"b'For {0}, only debit accounts can be linked against another credit entry'","b'Untuk {0}, hanya rekening debit dapat dihubungkan dengan entri kredit lain'"
b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27',b'Price List {0} is disabled',b'Daftar Harga {0} dinonaktifkan'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127',b'Row {0}: Completed Qty cannot be more than {1} for operation {2}',b'Row {0}: Selesai Qty tidak bisa lebih dari {1} untuk operasi {2}'
b'DocType: Manufacturing Settings',b'Allow Overtime',b'Izinkan Lembur'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148',"b'Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry'","b'Serial Barang {0} tidak dapat diperbarui menggunakan Rekonsiliasi Persediaan, gunakan Entri Persediaan'"
b'DocType: Training Event Employee',b'Training Event Employee',b'Acara Pelatihan Karyawan'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1031',b'Maximum Samples - {0} can be retained for Batch {1} and Item {2}.',b'Sampel Maksimum - {0} dapat disimpan untuk Batch {1} dan Item {2}.'
b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +7',b'Add Time Slots',b'Tambahkan Slot Waktu'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201',b'{0} Serial Numbers required for Item {1}. You have provided {2}.',b'{0} Nomer Seri diperlukan untuk Item {1}. Anda menyediakan {2}.'
b'DocType: Stock Reconciliation Item',b'Current Valuation Rate',b'Nilai Tingkat Penilaian Saat ini'
b'DocType: Training Event',b'Advance',b'Muka'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'for making recurring again.',b'untuk membuat berulang lagi.'
b'apps/erpnext/erpnext/config/erpnext_integrations.py +13',b'GoCardless payment gateway settings',b'Pengaturan gateway pembayaran GoCardless'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +122',b'Exchange Gain/Loss',b'Efek Gain / Loss'
b'DocType: Opportunity',b'Lost Reason',b'Alasan Kehilangan'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +265',b'Row #{0}: Account {1} does not belong to company {2}',b'Baris # {0}: Akun {1} bukan milik perusahaan {2}'
b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +30',b'Unable to find DocType {0}',b'Tidak dapat menemukan DocType {0}'
b'apps/erpnext/erpnext/public/js/templates/address_list.html +22',b'New Address',b'Alamat baru'
b'DocType: Quality Inspection',b'Sample Size',b'Ukuran Sampel'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47',b'Please enter Receipt Document',b'Masukkan Dokumen Penerimaan'
b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +369',b'All items have already been invoiced',b'Semua Stok Barang telah tertagih'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49',"b""Please specify a valid 'From Case No.'""","b""Silakan tentukan valid 'Dari Kasus No'"""
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +24',b'Further cost centers can be made under Groups but entries can be made against non-Groups',b'Pusat biaya lebih lanjut dapat dibuat di bawah Grup tetapi entri dapat dilakukan terhadap non-Grup'
b'apps/erpnext/erpnext/config/setup.py +66',b'Users and Permissions',b'Pengguna dan Perizinan'
b'DocType: Vehicle Log',b'VLOG.',b'VLOG.'
b'DocType: Branch',b'Branch',b'Cabang'
b'DocType: Soil Analysis',b'Ca/(K+Ca+Mg)',b'Ca / (K + Ca + Mg)'
b'DocType: Delivery Trip',b'Fulfillment User',b'Pengguna Pemenuhan'
b'apps/erpnext/erpnext/config/setup.py +61',b'Printing and Branding',b'Percetakan dan Branding'
b'DocType: Company',b'Total Monthly Sales',b'Total Penjualan Bulanan'
b'DocType: Agriculture Analysis Criteria',b'Weather',b'Cuaca'
b'DocType: Bin',b'Actual Quantity',b'Kuantitas Aktual'
b'DocType: Shipping Rule',b'example: Next Day Shipping',b'Contoh: Hari Berikutnya Pengiriman'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187',b'Serial No {0} not found',b'Serial No {0} tidak ditemukan'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +291',b'Subscription has been {0}',b'Langganan telah {0}'
b'DocType: Fee Schedule Program',b'Fee Schedule Program',b'Program Jadwal Biaya'
b'DocType: Fee Schedule Program',b'Student Batch',b'Mahasiswa Batch'
b'apps/erpnext/erpnext/utilities/activation.py +119',b'Make Student',b'membuat Siswa'
b'DocType: Supplier Scorecard Scoring Standing',b'Min Grade',b'Min Grade'
b'apps/erpnext/erpnext/projects/doctype/project/project.py +218',b'You have been invited to collaborate on the project: {0}',b'Anda telah diundang untuk berkolaborasi pada proyek: {0}'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +157',b'Physician not available on {0}',b'Dokter tidak tersedia di {0}'
b'DocType: Leave Block List Date',b'Block Date',b'Blok Tanggal'
b'DocType: Crop',b'Crop',b'Tanaman'
b'DocType: Purchase Receipt',b'Supplier Delivery Note',b'Catatan Pengiriman Supplier'
b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70',b'Apply Now',b'Terapkan Sekarang'
b'apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25',b'Actual Qty {0} / Waiting Qty {1}',b'Sebenarnya Qty {0} / Menunggu Qty {1}'
b'DocType: Purchase Invoice',b'E-commerce GSTIN',b'E-commerce GSTIN'
b'DocType: Sales Order',b'Not Delivered',b'Tidak Terkirim'
,b'Bank Clearance Summary',b'Ringkasan Kliring Bank'
b'apps/erpnext/erpnext/config/setup.py +106',"b'Create and manage daily, weekly and monthly email digests.'","b'Buat dan kelola surel ringkasan harian, mingguan dan bulanan.'"
b'DocType: Appraisal Goal',b'Appraisal Goal',b'Penilaian Pencapaian'
b'DocType: Stock Reconciliation Item',b'Current Amount',b'Jumlah saat ini'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +58',b'Buildings',b'Bangunan'
b'DocType: Fee Schedule',b'Fee Structure',b'Struktur biaya'
b'DocType: Timesheet Detail',b'Costing Amount',b'Nilai Jumlah Biaya'
b'DocType: Student Admission Program',b'Application Fee',b'Biaya aplikasi'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +52',b'Submit Salary Slip',b'Kirim Slip Gaji'
b'apps/erpnext/erpnext/controllers/selling_controller.py +137',b'Maxiumm discount for Item {0} is {1}%',b'Diskon Maxiumm untuk Item {0} adalah {1}%'
b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16',b'Import in Bulk',b'Impor Secara massal'
b'DocType: Sales Partner',b'Address & Contacts',b'Alamat & Kontak'
b'DocType: SMS Log',b'Sender Name',b'Nama Pengirim'
b'DocType: Agriculture Analysis Criteria',b'Agriculture Analysis Criteria',b'Kriteria Analisis Pertanian'
b'DocType: POS Profile',b'[Select]',b'[Pilih]'
b'DocType: Vital Signs',b'Blood Pressure (diastolic)',b'Tekanan Darah (diastolik)'
b'DocType: SMS Log',b'Sent To',b'Dikirim Ke'
b'DocType: Agriculture Task',b'Holiday Management',b'Manajemen liburan'
b'DocType: Payment Request',b'Make Sales Invoice',b'Buat Faktur Penjualan'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61',b'Softwares',b'software'
b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +53',b'Next Contact Date cannot be in the past',b'Berikutnya Hubungi Tanggal tidak dapat di masa lalu'
b'DocType: Company',b'For Reference Only.',b'Untuk referensi saja.'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +112',b'Physician {0} not available on {1}',b'Dokter {0} tidak tersedia di {1}'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2581',b'Select Batch No',b'Pilih Batch No'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +61',b'Invalid {0}: {1}',b'Valid {0}: {1}'
,b'GSTR-1',b'GSTR-1'
b'DocType: Purchase Invoice',b'PINV-RET-',b'PINV-RET-'
b'DocType: Fee Validity',b'Reference Inv',b'Referensi Inv'
b'DocType: Sales Invoice Advance',b'Advance Amount',b'Jumlah Uang Muka'
b'DocType: Manufacturing Settings',b'Capacity Planning',b'Perencanaan Kapasitas'
b'DocType: Supplier Quotation',b'Rounding Adjustment (Company Currency',b'Penyesuaian Pembulatan (Mata Uang Perusahaan'
b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43',"b""'From Date' is required""","b""'Dari Tanggal' diperlukan"""
b'DocType: Journal Entry',b'Reference Number',b'Nomor Referensi'
b'DocType: Employee',b'Employment Details',b'Rincian Pekerjaan'
b'DocType: Employee',b'New Workplace',b'Tempat Kerja Baru'
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17',b'Set as Closed',b'Tetapkan untuk ditutup'
b'apps/erpnext/erpnext/stock/get_item_details.py +127',b'No Item with Barcode {0}',b'Ada Stok Barang dengan Barcode {0}'
b'DocType: Normal Test Items',b'Require Result Value',b'Mengharuskan Nilai Hasil'
b'DocType: Item',b'Show a slideshow at the top of the page',b'Tampilkan slideshow di bagian atas halaman'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +532',b'Boms',b'BOMS'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +162',b'Stores',b'Toko'
b'DocType: Project Type',b'Projects Manager',b'Manajer Proyek'
b'DocType: Serial No',b'Delivery Time',b'Waktu Pengiriman'
b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +33',b'Ageing Based On',b'Umur Berdasarkan'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +61',b'Appointment cancelled',b'Penunjukan dibatalkan'
b'DocType: Item',b'End of Life',b'Akhir Riwayat'
b'apps/erpnext/erpnext/demo/setup/setup_data.py +331',b'Travel',b'Perjalanan'
b'DocType: Student Report Generation Tool',b'Include All Assessment Group',b'Termasuk Semua Kelompok Penilaian'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183',b'No active or default Salary Structure found for employee {0} for the given dates',b'Tidak ada yang aktif atau gaji standar Struktur ditemukan untuk karyawan {0} untuk tanggal tertentu'
b'DocType: Leave Block List',b'Allow Users',b'Izinkan Pengguna'
b'DocType: Purchase Order',b'Customer Mobile No',b'Nomor Seluler Pelanggan'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +1',b'Recurring',b'Pengulangan'
b'DocType: Cash Flow Mapping Template Details',b'Cash Flow Mapping Template Details',b'Detail Rincian Pemetaan Arus Kas'
b'DocType: Cost Center',b'Track separate Income and Expense for product verticals or divisions.',b'Melacak Penghasilan terpisah dan Beban untuk vertikal produk atau divisi.'
b'DocType: Rename Tool',b'Rename Tool',b'Alat Perubahan Nama'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +72',b'Update Cost',b'Perbarui Biaya'
b'DocType: Item Reorder',b'Item Reorder',b'Item Reorder'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463',b'Show Salary Slip',b'Slip acara Gaji'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +849',b'Transfer Material',b'Transfer Material/Stok Barang'
b'DocType: Fees',b'Send Payment Request',b'Kirim Permintaan Pembayaran'
b'DocType: BOM',"b'Specify the operations, operating cost and give a unique Operation no to your operations.'","b'Tentukan operasi, biaya operasi dan memberikan Operation unik ada pada operasi Anda.'"
b'DocType: Water Analysis',b'Origin',b'Asal'
b'apps/erpnext/erpnext/controllers/status_updater.py +204',b'This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?',b'Dokumen ini adalah lebih dari batas oleh {0} {1} untuk item {4}. Apakah Anda membuat yang lain {3} terhadap yang sama {2}?'
b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1154',b'Please set recurring after saving',b'Silahkan mengatur berulang setelah menyimpan'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +769',b'Select change amount account',b'Pilih akun berubah jumlah'
b'DocType: Purchase Invoice',b'Price List Currency',b'Daftar Harga Mata uang'
b'DocType: Naming Series',b'User must always select',b'Pengguna harus selalu pilih'
b'DocType: Stock Settings',b'Allow Negative Stock',b'Izinkan persediaan negatif'
b'DocType: Installation Note',b'Installation Note',b'Nota Installasi'
b'DocType: Soil Texture',b'Clay',b'Tanah liat'
b'DocType: Topic',b'Topic',b'Tema'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +45',b'Cash Flow from Financing',b'Arus Kas dari Pendanaan'
b'DocType: Budget Account',b'Budget Account',b'Akun anggaran'
b'DocType: Quality Inspection',b'Verified By',b'Diverifikasi oleh'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +78',"b""Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.""","b'Tidak dapat mengubah mata uang default perusahaan, karena ada transaksi yang ada. Transaksi harus dibatalkan untuk mengubah mata uang default.'"
b'DocType: Cash Flow Mapping',b'Is Income Tax Liability',b'Apakah Kewajiban Pajak Penghasilan'
b'DocType: Grading Scale Interval',b'Grade Description',b'kelas Keterangan'
b'DocType: Stock Entry',b'Purchase Receipt No',b'No Nota Penerimaan'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30',b'Earnest Money',b'Uang Earnest'
b'DocType: Sales Invoice',b' Shipping Bill Number',b'Nomor Tagihan Pengiriman'
b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34',b'Traceability',b'Lacak'
b'DocType: Asset Maintenance Log',b'Actions performed',b'Tindakan dilakukan'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51',b'Customer &gt; Customer Group &gt; Territory',b'Pelanggan&gt; Grup Pelanggan&gt; Wilayah'
b'DocType: Cash Flow Mapper',b'Section Leader',b'Pemimpin Seksi'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137',b'Source of Funds (Liabilities)',b'Sumber Dana (Kewajiban)'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +431',b'Quantity in row {0} ({1}) must be same as manufactured quantity {2}',b'Kuantitas di baris {0} ({1}) harus sama dengan jumlah yang diproduksi {2}'
b'DocType: Supplier Scorecard Scoring Standing',b'Employee',b'Karyawan'
b'DocType: Asset Repair',b'Failure Date',b'Tanggal Kegagalan'
b'DocType: Sample Collection',b'Collected Time',b'Waktu yang Dikumpulkan'
b'DocType: Company',b'Sales Monthly History',b'Riwayat Bulanan Penjualan'
b'DocType: Asset Maintenance Task',b'Next Due Date',b'Tanggal Jatuh Tempo Berikutnya'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214',b'Select Batch',b'Pilih Batch'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244',b'{0} {1} is fully billed',b'{0} {1} telah ditagih sepenuhnya'
b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +31',b'Vital Signs',b'Tanda-tanda vital'
b'DocType: Training Event',b'End Time',b'Waktu Akhir'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63',b'Active Salary Structure {0} found for employee {1} for the given dates',b'Struktur Gaji aktif {0} ditemukan untuk karyawan {1} untuk tanggal yang diberikan'
b'DocType: Payment Entry',b'Payment Deductions or Loss',b'Pengurangan pembayaran atau Rugi'
b'DocType: Soil Analysis',b'Soil Analysis Criterias',b'Kriteria Analisis Tanah'
b'apps/erpnext/erpnext/config/setup.py +42',b'Standard contract terms for Sales or Purchase.',b'Ketentuan kontrak standar untuk Penjualan atau Pembelian.'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +112',b'Group by Voucher',b'Group by Voucher'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +233',b'Are you sure you want to cancel this appointment?',b'Yakin ingin membatalkan janji temu ini?'
b'DocType: Hotel Room Pricing Package',b'Hotel Room Pricing Package',b'Paket Harga Kamar Hotel'
b'apps/erpnext/erpnext/config/crm.py +6',b'Sales Pipeline',b'Pipeline penjualan'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201',b'Please set default account in Salary Component {0}',b'Silakan set account default di Komponen Gaji {0}'
b'apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7',b'Required On',b'Diperlukan pada'
b'DocType: Rename Tool',b'File to Rename',b'Nama File untuk Diganti'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200',b'Please select BOM for Item in Row {0}',b'Silakan pilih BOM untuk Item di Row {0}'
b'apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28',b'Account {0} does not match with Company {1} in Mode of Account: {2}',b'Akun {0} tidak sesuai Perusahaan {1} dalam Mode Akun: {2}'
b'apps/erpnext/erpnext/controllers/buying_controller.py +464',b'Specified BOM {0} does not exist for Item {1}',b'Ditentukan BOM {0} tidak ada untuk Item {1}'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +301',b'Course: ',b'Kursus:'
b'DocType: Soil Texture',b'Sandy Loam',b'Sandy Loam'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232',b'Maintenance Schedule {0} must be cancelled before cancelling this Sales Order',b'Jadwal pemeliharaan {0} harus dibatalkan sebelum membatalkan Sales Order ini'
b'DocType: POS Profile',b'Applicable for Users',b'Berlaku untuk Pengguna'
b'DocType: Notification Control',b'Expense Claim Approved',b'Klaim Biaya Disetujui'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231',b'No Work Orders created',b'Tidak ada Perintah Kerja yang dibuat'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +321',b'Salary Slip of employee {0} already created for this period',b'Slip Gaji karyawan {0} sudah dibuat untuk periode ini'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155',b'Pharmaceutical',b'Farmasi'
b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26',b'Cost of Purchased Items',b'Biaya Produk Dibeli'
b'DocType: Selling Settings',b'Sales Order Required',b'Nota Penjualan Diperlukan'
b'DocType: Purchase Invoice',b'Credit To',b'Kredit Untuk'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46',b'PieceDate',b'PieceDate'
b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31',b'Active Leads / Customers',b'Prospek / Pelanggan Aktif'
b'DocType: Employee Education',b'Post Graduate',b'Pasca Sarjana'
b'DocType: Maintenance Schedule Detail',b'Maintenance Schedule Detail',b'Jadwal pemeliharaan Detil'
b'DocType: Supplier Scorecard',b'Warn for new Purchase Orders',b'Peringatkan untuk Pesanan Pembelian baru'
b'DocType: Quality Inspection Reading',b'Reading 9',b'Membaca 9'
b'DocType: Supplier',b'Is Frozen',b'Dibekukan'
b'apps/erpnext/erpnext/stock/utils.py +224',b'Group node warehouse is not allowed to select for transactions',b'gudang kelompok simpul tidak diperbolehkan untuk memilih untuk transaksi'
b'DocType: Buying Settings',b'Buying Settings',b'Setting Pembelian'
b'DocType: Stock Entry Detail',b'BOM No. for a Finished Good Item',b'No. BOM untuk Barang Jadi'
b'DocType: Upload Attendance',b'Attendance To Date',b'Kehadiran Sampai Tanggal'
b'DocType: Request for Quotation Supplier',b'No Quote',b'Tidak ada kutipan'
b'DocType: Warranty Claim',b'Raised By',b'Diangkat Oleh'
b'DocType: Payment Gateway Account',b'Payment Account',b'Akun Pembayaran'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +909',b'Please specify Company to proceed',b'Silahkan tentukan Perusahaan untuk melanjutkan'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +27',b'Net Change in Accounts Receivable',b'Perubahan bersih Piutang'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88',b'Compensatory Off',b'Kompensasi Off'
b'DocType: Job Offer',b'Accepted',b'Diterima'
b'DocType: Grant Application',b'Organization',b'Organisasi'
b'DocType: BOM Update Tool',b'BOM Update Tool',b'Alat Pembaruan BOM'
b'DocType: SG Creation Tool Course',b'Student Group Name',b'Nama Kelompok Mahasiswa'
b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js +17',b'Show exploded view',b'Tampilkan tampilan yang meledak'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7',b'Creating Fees',b'Menciptakan Biaya'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +91',b'Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.',b'Pastikan Anda benar-benar ingin menghapus semua transaksi untuk perusahaan ini. Data master Anda akan tetap seperti itu. Tindakan ini tidak bisa dibatalkan.'
b'apps/erpnext/erpnext/templates/pages/product_search.html +21',b'Search Results',b'Hasil Pencarian'
b'DocType: Room',b'Room Number',b'Nomor kamar'
b'apps/erpnext/erpnext/utilities/transaction_base.py +107',b'Invalid reference {0} {1}',b'Referensi yang tidak valid {0} {1}'
b'DocType: Shipping Rule',b'Shipping Rule Label',b'Peraturan Pengiriman Label'
b'DocType: Journal Entry Account',b'Payroll Entry',b'Entri Penggajian'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +75',b'View Fees Records',b'Lihat Catatan Biaya'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +35',b'Make Tax Template',b'Buat Template Pajak'
b'apps/erpnext/erpnext/public/js/conf.js +28',b'User Forum',b'Forum pengguna'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +319',b'Raw Materials cannot be blank.',b'Bahan baku tidak boleh kosong.'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +498',"b'Could not update stock, invoice contains drop shipping item.'","b'Tidak bisa memperbarui persediaan, faktur berisi barang titipan.'"
b'DocType: Lab Test Sample',b'Lab Test Sample',b'Sampel Uji Lab'
b'DocType: Item Variant Settings',b'Allow Rename Attribute Value',b'Izinkan Ganti Nama Nilai Atribut'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +491',b'Quick Journal Entry',b'Jurnal Entry Cepat'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200',b'You can not change rate if BOM mentioned agianst any item',b'Anda tidak dapat mengubah kurs jika BOM disebutkan atas tiap barang'
b'DocType: Restaurant',b'Invoice Series Prefix',b'Awalan Seri Faktur'
b'DocType: Employee',b'Previous Work Experience',b'Pengalaman Kerja Sebelumnya'
b'DocType: Stock Entry',b'For Quantity',b'Untuk Kuantitas'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205',b'Please enter Planned Qty for Item {0} at row {1}',b'Entrikan Planned Qty untuk Item {0} pada baris {1}'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +93',b'Google Maps integration is not enabled',b'Integrasi Google Maps tidak diaktifkan'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241',b'{0} {1} is not submitted',b'{0} {1} belum dikirim'
b'DocType: Member',b'Membership Expiry Date',b'Tanggal Kedaluwarsa Keanggotaan'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +131',b'{0} must be negative in return document',b'{0} harus negatif dalam dokumen retur'
,b'Minutes to First Response for Issues',b'Menit ke Response Pertama untuk Masalah'
b'DocType: Purchase Invoice',b'Terms and Conditions1',b'Syarat dan Conditions1'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +109',b'The name of the institute for which you are setting up this system.',b'Nama lembaga yang Anda menyiapkan sistem ini.'
b'DocType: Accounts Settings',"b'Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.'","b'Pencatatan Akuntansi telah dibekukan sampai tanggal ini, tidak seorang pun yang bisa melakukan / memodifikasi pencatatan kecuali peran yang telah ditentukan di bawah ini.'"
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116',b'Please save the document before generating maintenance schedule',b'Harap menyimpan dokumen sebelum menghasilkan jadwal pemeliharaan'
b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30',b'Latest price updated in all BOMs',b'Harga terbaru diperbarui di semua BOM'
b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28',b'Project Status',b'Status proyek'
b'DocType: UOM',b'Check this to disallow fractions. (for Nos)',b'Centang untuk melarang fraksi. (Untuk Nos)'
b'DocType: Student Admission Program',b'Naming Series (for Student Applicant)',b'Penamaan Series (untuk Mahasiswa Pemohon)'
b'DocType: Delivery Note',b'Transporter Name',b'Transporter Nama'
b'DocType: Authorization Rule',b'Authorized Value',b'Nilai Disetujui'
b'DocType: BOM',b'Show Operations',b'Tampilkan Operasi'
,b'Minutes to First Response for Opportunity',b'Menit ke Response Pertama untuk Peluang'
b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Absent',b'Jumlah Absen'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +862',b'Item or Warehouse for row {0} does not match Material Request',b'Item atau Gudang untuk baris {0} Material tidak cocok Permintaan'
b'apps/erpnext/erpnext/config/stock.py +191',b'Unit of Measure',b'Satuan Ukur'
b'DocType: Fiscal Year',b'Year End Date',b'Tanggal Akhir Tahun'
b'DocType: Task Depends On',b'Task Depends On',b'Tugas Tergantung Pada'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1026',b'Opportunity',b'Peluang'
b'DocType: Operation',b'Default Workstation',b'Standar Workstation'
b'DocType: Notification Control',b'Expense Claim Approved Message',b'Beban Klaim Disetujui Pesan'
b'DocType: Payment Entry',b'Deductions or Loss',b'Pemotongan atau Rugi'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +247',b'{0} {1} is closed',b'{0} {1} tertutup'
b'DocType: Email Digest',b'How frequently?',b'Seberapa sering?'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +55',b'Total Collected: {0}',b'Total Dikumpulkan: {0}'
b'DocType: Purchase Receipt',b'Get Current Stock',b'Dapatkan Persediaan saat ini'
b'DocType: Purchase Invoice',b'ineligible',b'tidak memenuhi syarat'
b'apps/erpnext/erpnext/config/manufacturing.py +46',b'Tree of Bill of Materials',b'Tree Bill of Material'
b'DocType: Student',b'Joining Date',b'Tanggal Bergabung'
,b'Employees working on a holiday',b'Karyawan yang bekerja pada hari libur'
b'DocType: Share Balance',b'Current State',b'Kondisi saat ini'
b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152',b'Mark Present',b'Mark Hadir'
b'DocType: Share Transfer',b'From Shareholder',b'Dari Pemegang Saham'
b'DocType: Project',b'% Complete Method',b'% Metode Lengkap'
b'apps/erpnext/erpnext/healthcare/setup.py +181',b'Drug',b'Obat'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200',b'Maintenance start date can not be before delivery date for Serial No {0}',b'Tanggal mulai pemeliharaan tidak bisa sebelum tanggal pengiriman untuk Serial No {0}'
b'DocType: Work Order',b'Actual End Date',b'Tanggal Akhir Aktual'
b'DocType: Cash Flow Mapping',b'Is Finance Cost Adjustment',b'Apakah Penyesuaian Biaya Keuangan'
b'DocType: BOM',b'Operating Cost (Company Currency)',b'Biaya operasi (Perusahaan Mata Uang)'
b'DocType: Purchase Invoice',b'PINV-',b'PINV-'
b'DocType: Authorization Rule',b'Applicable To (Role)',b'Berlaku Untuk (Peran)'
b'DocType: BOM Update Tool',b'Replace BOM',b'Ganti BOM'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110',b'Code {0} already exist',b'Kode {0} sudah ada'
b'DocType: Employee Advance',b'Purpose',b'Tujuan'
b'DocType: Company',b'Fixed Asset Depreciation Settings',b'Pengaturan Penyusutan Aset Tetap'
b'DocType: Item',b'Will also apply for variants unless overrridden',b'Juga akan berlaku untuk varian kecuali tertimpa'
b'DocType: Purchase Invoice',b'Advances',b'Advances'
b'DocType: Work Order',b'Manufacture against Material Request',b'Memproduksi terhadap Permintaan Bahan'
b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +14',b'Assessment Group: ',b'Kelompok Penilaian:'
b'DocType: Item Reorder',b'Request for',b'Meminta'
b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32',b'Approving User cannot be same as user the rule is Applicable To',b'Menyetujui Pengguna tidak bisa sama dengan pengguna aturan yang Berlaku Untuk'
b'DocType: Stock Entry Detail',b'Basic Rate (as per Stock UOM)',b'Tarif Dasar (sesuai UOM Persediaan)'
b'DocType: SMS Log',b'No of Requested SMS',b'Tidak ada dari Diminta SMS'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +246',b'Leave Without Pay does not match with approved Leave Application records',b'Tinggalkan Tanpa Bayar tidak sesuai dengan catatan Cuti Aplikasi disetujui'
b'DocType: Campaign',b'Campaign-.####',b'Promosi-.####'
b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21',b'Next Steps',b'Langkah selanjutnya'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +796',b'Please supply the specified items at the best possible rates',b'Silakan memasok barang-barang tertentu dengan tarif terbaik'
b'DocType: Membership',b'USD',b'USD'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28',b'Make Invoice',b'Membuat Invoice'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +80',b'Remaining Balance',b'Saldo yang tersisa'
b'DocType: Selling Settings',b'Auto close Opportunity after 15 days',b'Auto Peluang dekat setelah 15 hari'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +86',b'Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.',b'Pesanan Pembelian tidak diizinkan untuk {0} karena kartu skor berdiri {1}.'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +498',b'Barcode {0} is not a valid {1} code',b'Kode batang {0} bukan kode {1} yang valid'
b'apps/erpnext/erpnext/public/js/financial_statements.js +83',b'End Year',b'akhir Tahun'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23',b'Quot/Lead %',b'Penawaran/Prospek %'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +124',b'Contract End Date must be greater than Date of Joining',b'Kontrak Tanggal Akhir harus lebih besar dari Tanggal Bergabung'
b'DocType: Driver',b'Driver',b'Sopir'
b'DocType: Vital Signs',b'Nutrition Values',b'Nilai gizi'
b'DocType: Lab Test Template',b'Is billable',b'Apakah bisa ditagih'
b'DocType: Delivery Note',b'DN-',b'DN-'
b'DocType: Sales Partner',b'A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.',b'Seorang distributor pihak ketiga / agen / komisi agen / affiliate / reseller yang menjual produk-produk perusahaan untuk komisi.'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +376',b'{0} against Purchase Order {1}',b'{0} terhadap Purchase Order {1}'
b'DocType: Patient',b'Patient Demographics',b'Demografi pasien'
b'DocType: Task',b'Actual Start Date (via Time Sheet)',b'Aktual Mulai Tanggal (via Waktu Lembar)'
b'apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15',b'This is an example website auto-generated from ERPNext',b'Ini adalah situs contoh auto-dihasilkan dari ERPNext'
b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +43',b'Ageing Range 1',b'Rentang Ageing 1'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +212',b'Total advance amount cannot be greater than total claimed amount',b'Jumlah uang muka total tidak boleh lebih besar dari jumlah total yang diklaim'
b'DocType: Purchase Taxes and Charges Template',"b'Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.\n10. Add or Deduct: Whether you want to add or deduct the tax.'","b'Pajak standar template yang dapat diterapkan untuk semua Transaksi Pembelian. Template ini dapat berisi daftar kepala pajak dan juga kepala biaya lain seperti ""Pengiriman"", ""Asuransi"", ""Penanganan"" dll \n\n #### Catatan \n\n Tarif pajak Anda mendefinisikan sini akan menjadi tarif pajak standar untuk semua item ** **. Jika ada Item ** ** yang memiliki tarif yang berbeda, mereka harus ditambahkan dalam ** Pajak Stok Barang ** meja di ** Stok Barang ** menguasai.\n\n #### Deskripsi Kolom \n\n 1. Perhitungan Type: \n - Ini bisa berada di ** Net Jumlah ** (yang adalah jumlah dari jumlah dasar).\n - ** Pada Row Sebelumnya Jumlah / Amount ** (untuk pajak kumulatif atau biaya). Jika Anda memilih opsi ini, pajak akan diterapkan sebagai persentase dari baris sebelumnya (dalam tabel pajak) jumlah atau total.\n - ** Aktual ** (seperti yang disebutkan).\n 2. Akun Kepala: Account buku di mana pajak ini akan dipesan \n 3. Biaya Center: Jika pajak / biaya adalah penghasilan (seperti pengiriman) atau beban perlu dipesan terhadap Cost Center.\n 4. Keterangan: Deskripsi pajak (yang akan dicetak dalam faktur / tanda kutip).\n 5. Tarif: Tarif Pajak.\n 6. Jumlah: Jumlah Pajak.\n 7. Total: Total kumulatif ke titik ini.\n 8. Entrikan Row: Jika berdasarkan ""Sebelumnya Row Jumlah"" Anda dapat memilih nomor baris yang akan diambil sebagai dasar untuk perhitungan ini (default adalah baris sebelumnya).\n 9. Pertimbangkan Pajak atau Biaya untuk: Pada bagian ini Anda dapat menentukan apakah pajak / biaya hanya untuk penilaian (bukan bagian dari total) atau hanya total (tidak menambah nilai Stok Barang) atau keduanya.\n 10. Menambah atau Dikurangi: Apakah Anda ingin menambah atau mengurangi pajak.'"
b'DocType: Homepage',b'Homepage',b'Homepage'
b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +68',b'Select Physician...',b'Pilih Dokter ...'
b'DocType: Grant Application',b'Grant Application Details ',b'Berikan Rincian Aplikasi'
b'DocType: Purchase Receipt Item',b'Recd Quantity',b'Qty Diterima'
b'apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +65',b'Fee Records Created - {0}',b'Biaya Rekaman Dibuat - {0}'
b'DocType: Asset Category Account',b'Asset Category Account',b'Aset Kategori Akun'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +913',b'Row #{0} (Payment Table): Amount must be positive',b'Baris # {0} (Tabel Pembayaran): Jumlah harus positif'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44',b'CompteNum',b'CompteNum'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +137',b'Cannot produce more Item {0} than Sales Order quantity {1}',b'Tidak dapat menghasilkan lebih Stok Barang {0} daripada kuantitas Sales Order {1}'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +391',b'Select Attribute Values',b'Pilih Nilai Atribut'
b'DocType: Purchase Invoice',b'Reason For Issuing document',b'Alasan untuk menerbitkan dokumen'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +539',b'Stock Entry {0} is not submitted',b'Entri Persediaan {0} tidak terkirim'
b'DocType: Payment Reconciliation',b'Bank / Cash Account',b'Bank / Rekening Kas'
b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +47',b'Next Contact By cannot be same as the Lead Email Address',b'Dikontak Oleh berikut tidak bisa sama dengan Alamat Email Prospek'
b'DocType: Tax Rule',b'Billing City',b'Kota Penagihan'
b'DocType: Asset',b'Manual',b'panduan'
b'DocType: Salary Component Account',b'Salary Component Account',b'Akun Komponen Gaji'
b'DocType: Global Defaults',b'Hide Currency Symbol',b'Sembunyikan Mata Uang'
b'apps/erpnext/erpnext/config/non_profit.py +58',b'Donor information.',b'Informasi donor'
b'apps/erpnext/erpnext/config/accounts.py +330',"b'e.g. Bank, Cash, Credit Card'","b'misalnya Bank, Kas, Kartu Kredit'"
b'DocType: Lead Source',b'Source Name',b'sumber Nama'
b'DocType: Vital Signs',"b'Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""'","b'Tekanan darah istirahat normal pada orang dewasa sekitar 120 mmHg sistolik, dan diastolik 80 mmHg, disingkat &quot;120/80 mmHg&quot;'"
b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +119',"b'Set items shelf life in days, to set expiry based on manufacturing_date plus self life'","b'Setel umur simpan barang dalam hitungan hari, untuk menetapkan kadaluwarsa berdasarkan manufacturing_date plus self life'"
b'DocType: Journal Entry',b'Credit Note',b'Nota Kredit'
b'DocType: Projects Settings',b'Ignore Employee Time Overlap',b'Abaikan Waktu Karyawan Tumpang Tindih'
b'DocType: Warranty Claim',b'Service Address',b'Alamat Layanan'
b'DocType: Asset Maintenance Task',b'Calibration',b'Kalibrasi'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +97',b'{0} is a company holiday',b'{0} adalah hari libur perusahaan'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49',b'Furnitures and Fixtures',b'Mebel dan perlengkapan'
b'DocType: Item',b'Manufacture',b'Pembuatan'
b'apps/erpnext/erpnext/utilities/user_progress.py +27',b'Setup Company',b'Penyiapan Perusahaan'
,b'Lab Test Report',b'Laporan Uji Lab'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13',b'Please Delivery Note first',b'Silakan Pengiriman Catatan terlebih dahulu'
b'DocType: Student Applicant',b'Application Date',b'Tanggal Aplikasi'
b'DocType: Salary Detail',b'Amount based on formula',b'Jumlah berdasarkan formula'
b'DocType: Purchase Invoice',b'Currency and Price List',b'Mata Uang dan Daftar Harga'
b'DocType: Opportunity',b'Customer / Lead Name',b'Nama Pelanggan / Prospek'
b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +115',b'Clearance Date not mentioned',b'Izin Tanggal tidak disebutkan'
b'apps/erpnext/erpnext/config/manufacturing.py +7',b'Production',b'Produksi'
b'DocType: Guardian',b'Occupation',b'Pendudukan'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74',b'Row {0}:Start Date must be before End Date',b'Row {0}: Tanggal awal harus sebelum Tanggal Akhir'
b'DocType: Crop',b'Planting Area',b'Luas Tanam'
b'apps/erpnext/erpnext/controllers/trends.py +19',b'Total(Qty)',b'Total (Qty)'
b'DocType: Installation Note Item',b'Installed Qty',b'Terpasang Qty'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4',b'This could be because of some invalid Email Addresses in the',b'Ini bisa jadi karena beberapa Alamat Email yang salah di'
b'apps/erpnext/erpnext/utilities/user_progress.py +31',b'You added ',b'Anda menambahkan'
b'DocType: Purchase Taxes and Charges',b'Parenttype',b'Parenttype'
b'apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +10',b'Training Result',b'pelatihan Hasil'
b'DocType: Purchase Invoice',b'Is Paid',b'Telah dibayar'
b'DocType: Salary Structure',b'Total Earning',b'Total Penghasilan'
b'DocType: Purchase Receipt',b'Time at which materials were received',b'Waktu di mana bahan yang diterima'
b'DocType: Products Settings',b'Products per Page',b'Produk per Halaman'
b'DocType: Stock Ledger Entry',b'Outgoing Rate',b'Tingkat keluar'
b'apps/erpnext/erpnext/config/hr.py +233',b'Organization branch master.',b'Cabang master organisasi.'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +313',b' or ',b'atau'
b'DocType: Sales Order',b'Billing Status',b'Status Penagihan'
b'apps/erpnext/erpnext/public/js/conf.js +32',b'Report an Issue',b'Laporkan Masalah'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120',b'Utility Expenses',b'Beban utilitas'
b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64',b'90-Above',b'90-ke atas'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +252',b'Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher',b'Row # {0}: Journal Entri {1} tidak memiliki akun {2} atau sudah cocok dengan voucher lain'
b'DocType: Supplier Scorecard Criteria',b'Criteria Weight',b'Kriteria Berat'
b'DocType: Buying Settings',b'Default Buying Price List',b'Standar Membeli Daftar Harga'
b'DocType: Payroll Entry',b'Salary Slip Based on Timesheet',b'Slip Gaji Berdasarkan Daftar Absen'
b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +43',b'Buying Rate',b'Tingkat pembelian'
b'DocType: Notification Control',b'Sales Order Message',b'Pesan Nota Penjualan'
b'apps/erpnext/erpnext/config/setup.py +15',"b'Set Default Values like Company, Currency, Current Fiscal Year, etc.'","b'Set Nilai Default seperti Perusahaan, Mata Uang, Tahun Anggaran Current, dll'"
b'DocType: Payment Entry',b'Payment Type',b'Jenis Pembayaran'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +240',b'Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement',b'Silakan pilih Batch for Item {0}. Tidak dapat menemukan satu bets yang memenuhi persyaratan ini'
b'DocType: Hub Category',b'Parent Category',b'Kategori Induk'
b'DocType: Payroll Entry',b'Select Employees',b'Pilih Karyawan'
b'DocType: Opportunity',b'Potential Sales Deal',b'Kesepakatan potensial Penjualan'
b'DocType: Complaint',b'Complaints',b'Keluhan'
b'DocType: Payment Entry',b'Cheque/Reference Date',b'Cek / Tanggal Referensi'
b'DocType: Purchase Invoice',b'Total Taxes and Charges',b'Jumlah Pajak dan Biaya'
b'DocType: Employee',b'Emergency Contact',b'Darurat Kontak'
b'DocType: Bank Reconciliation Detail',b'Payment Entry',b'Masuk pembayaran'
,b'sales-browser',b'penjualan-browser'
b'apps/erpnext/erpnext/accounts/doctype/account/account.js +79',b'Ledger',b'Buku besar'
b'DocType: Patient Medical Record',b'PMR-',b'PMR-'
b'DocType: Drug Prescription',b'Drug Code',b'Kode obat'
b'DocType: Target Detail',b'Target  Amount',b'Target Jumlah'
b'DocType: POS Profile',b'Print Format for Online',b'Format Cetak untuk Online'
b'DocType: Shopping Cart Settings',b'Shopping Cart Settings',b'Pengaturan Keranjang Belanja'
b'DocType: Journal Entry',b'Accounting Entries',b'Entri Akuntansi'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17',"b""If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.""","b'Jika dipilih Pricing Rule dibuat untuk &#39;Rate&#39;, maka akan menimpa Daftar Harga. Tarif tarif adalah tingkat akhir, sehingga tidak ada diskon lebih lanjut yang harus diterapkan. Oleh karena itu, dalam transaksi seperti Order Penjualan, Pesanan Pembelian dll, akan diambil di bidang &#39;Rate&#39;, bukan bidang &#39;Price List Rate&#39;.'"
b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24',b'Duplicate Entry. Please check Authorization Rule {0}',b'Gandakan entri. Silakan periksa Peraturan Otorisasi {0}'
b'DocType: Journal Entry Account',b'Reference Due Date',b'Tanggal Jatuh Tempo Referensi'
b'DocType: Purchase Order',b'Ref SQ',b'Ref SQ'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55',b'Receipt document must be submitted',b'dokumen tanda terima harus diserahkan'
b'DocType: Purchase Invoice Item',b'Received Qty',b'Qty Diterima'
b'DocType: Stock Entry Detail',b'Serial No / Batch',b'Serial No / Batch'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340',b'Not Paid and Not Delivered',b'Tidak Dibayar dan tidak Terkirim'
b'DocType: Product Bundle',b'Parent Item',b'Induk Stok Barang'
b'DocType: Account',b'Account Type',b'Jenis Account'
b'DocType: Delivery Note',b'DN-RET-',b'DN-RET-'
b'apps/erpnext/erpnext/templates/pages/projects.html +58',b'No time sheets',b'Tidak ada lembar waktu'
b'DocType: GoCardless Mandate',b'GoCardless Customer',b'Pelanggan GoCardless'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +123',b'Leave Type {0} cannot be carry-forwarded',b'Cuti Jenis {0} tidak dapat membawa-diteruskan'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215',"b""Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule'""","b""Jadwal pemeliharaan tidak dihasilkan untuk semua item. Silahkan klik 'Menghasilkan Jadwal'"""
,b'To Produce',b'Untuk Menghasilkan'
b'apps/erpnext/erpnext/config/hr.py +93',b'Payroll',b'Daftar gaji'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +196',"b'For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included'","b'Untuk baris {0} di {1}. Untuk menyertakan {2} di tingkat Item, baris {3} juga harus disertakan'"
b'DocType: Patient Service Unit',b'Parent Service Unit',b'Unit Layanan Orang Tua'
b'apps/erpnext/erpnext/utilities/activation.py +101',b'Make User',b'membuat Pengguna'
b'DocType: Packing Slip',b'Identification of the package for the delivery (for print)',b'Identifikasi paket untuk pengiriman (untuk mencetak)'
b'DocType: Bin',b'Reserved Quantity',b'Reserved Kuantitas'
b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34',b'Please enter valid email address',b'Harap masukkan alamat email yang benar'
b'DocType: Volunteer Skill',b'Volunteer Skill',b'Keterampilan Relawan'
b'DocType: Bank Reconciliation',b'Include POS Transactions',b'Sertakan Transaksi POS'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +784',b'Please select an item in the cart',b'Harap pilih item di keranjang'
b'DocType: Landed Cost Voucher',b'Purchase Receipt Items',b'Nota Penerimaan Produk'
b'apps/erpnext/erpnext/config/learn.py +21',b'Customizing Forms',b'Menyesuaikan Bentuk'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +74',b'Arrear',b'tunggakan'
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158',b'Depreciation Amount during the period',b'Penyusutan Jumlah selama periode tersebut'
b'apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +43',b'Disabled template must not be default template',b'Template cacat tidak harus template default'
b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +314',b'For row {0}: Enter planned qty',b'Untuk baris {0}: Masuki rencana qty'
b'DocType: Shareholder',b'SH-',b'SH-'
b'DocType: Account',b'Income Account',b'Akun Penghasilan'
b'DocType: Payment Request',"b""Amount in customer's currency""",b'Jumlah dalam mata uang pelanggan'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +825',b'Delivery',b'Pengiriman'
b'DocType: Volunteer',b'Weekdays',b'Hari kerja'
b'DocType: Stock Reconciliation Item',b'Current Qty',b'Jumlah saat ini'
b'DocType: Restaurant Menu',b'Restaurant Menu',b'Menu Restoran'
b'apps/erpnext/erpnext/templates/generators/item_group.html +36',b'Prev',b'Sebelumnya'
b'DocType: Appraisal Goal',b'Key Responsibility Area',b'Key Responsibility area'
b'apps/erpnext/erpnext/utilities/activation.py +127',"b'Student Batches help you track attendance, assessments and fees for students'","b'Batch Student membantu Anda melacak kehadiran, penilaian dan biaya untuk siswa'"
b'DocType: Payment Entry',b'Total Allocated Amount',b'Jumlah Total Dialokasikan'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +151',b'Set default inventory account for perpetual inventory',b'Tetapkan akun inventaris default untuk persediaan perpetual'
b'DocType: Item Reorder',b'Material Request Type',b'Permintaan Jenis Bahan'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252',b'Accural Journal Entry for salaries from {0} to {1}',b'Accural Journal masuk untuk gaji dari {0} ke {1}'
b'apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17',b'Send Grant Review Email',b'Kirim Email Peninjauan Hibah'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +848',"b'LocalStorage is full, did not save'","b'LocalStorage penuh, tidak menyimpan'"
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +100',b'Row {0}: UOM Conversion Factor is mandatory',b'Row {0}: UOM Faktor Konversi adalah wajib'
b'apps/erpnext/erpnext/utilities/user_progress.py +235',b'Room Capacity',b'Kapasitas Kamar'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +95',b'Ref',b'Ref'
b'DocType: Lab Test',b'LP-',b'LP-'
b'DocType: Healthcare Settings',b'Registration Fee',b'Biaya pendaftaran'
b'DocType: Budget',b'Cost Center',b'Biaya Pusat'
b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +45',b'Voucher #',b'Voucher #'
b'DocType: Notification Control',b'Purchase Order Message',b'Pesan Purchase Order'
b'DocType: Tax Rule',b'Shipping Country',b'Pengiriman Negara'
b'DocType: Selling Settings',"b""Hide Customer's Tax Id from Sales Transactions""",b'Menyembunyikan Id Pajak Nasabah Transaksi Penjualan'
b'DocType: Upload Attendance',b'Upload HTML',b'Unggah HTML'
b'DocType: Employee',b'Relieving Date',b'Menghilangkan Tanggal'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14',"b'Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.'","b'Rule harga dibuat untuk menimpa Daftar Harga / mendefinisikan persentase diskon, berdasarkan beberapa kriteria.'"
b'DocType: Serial No',b'Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt',b'Gudang hanya dapat diubah melalui Entri Persediaan / Nota Pengiriman / Nota Pembelian'
b'DocType: Employee Education',b'Class / Percentage',b'Kelas / Persentase'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134',b'Head of Marketing and Sales',b'Kepala Pemasaran dan Penjualan'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72',b'Income Tax',b'Pajak Penghasilan'
b'apps/erpnext/erpnext/config/selling.py +174',b'Track Leads by Industry Type.',b'Lacak Prospek menurut Jenis Industri.'
b'apps/erpnext/erpnext/utilities/user_progress.py +101',b'Go to Letterheads',b'Pergi ke kop surat'
b'DocType: Item Supplier',b'Item Supplier',b'Item Supplier'
b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1255',b'Please enter Item Code to get batch no',b'Entrikan Item Code untuk mendapatkan bets tidak'
b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +880',b'Please select a value for {0} quotation_to {1}',b'Silakan pilih nilai untuk {0} quotation_to {1}'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +419',b'No Items selected for transfer',b'Tidak ada item yang dipilih untuk transfer'
b'apps/erpnext/erpnext/config/selling.py +46',b'All Addresses.',b'Semua Alamat'
b'DocType: Company',b'Stock Settings',b'Pengaturan Persediaan'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +183',"b'Merging is only possible if following properties are same in both records. Is Group, Root Type, Company'","b'Penggabungan ini hanya mungkin jika sifat berikut yang sama di kedua catatan. Apakah Group, Akar Jenis, Perusahaan'"
b'DocType: Vehicle',b'Electric',b'listrik'
b'DocType: Task',b'% Progress',b'% Selesai'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123',b'Gain/Loss on Asset Disposal',b'Laba / Rugi Asset Disposal'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +117',b'Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.',b'Nomor akun untuk akun {0} tidak tersedia. <br> Harap atur bagan akun Anda dengan benar.'
b'DocType: Task',b'Depends on Tasks',b'Tergantung pada Tugas'
b'apps/erpnext/erpnext/config/selling.py +36',b'Manage Customer Group Tree.',b'Kelola Pohon Kelompok Pelanggan.'
b'DocType: Shopping Cart Settings',b'Attachments can be shown without enabling the shopping cart',b'Lampiran dapat ditunjukkan tanpa mengaktifkan keranjang belanja'
b'DocType: Normal Test Items',b'Result Value',b'Nilai hasil'
b'DocType: Hotel Room',b'Hotels',b'Hotel'
b'DocType: Supplier Quotation',b'SQTN-',b'SQTN-'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22',b'New Cost Center Name',b'Baru Nama Biaya Pusat'
b'DocType: Leave Control Panel',b'Leave Control Panel',b'Cuti Control Panel'
b'DocType: Project',b'Task Completion',b'tugas Penyelesaian'
b'apps/erpnext/erpnext/templates/includes/product_page.js +22',b'Not in Stock',b'Tidak tersedia'
b'DocType: Volunteer',b'Volunteer Skills',b'Keterampilan Relawan'
b'DocType: Appraisal',b'HR User',b'HR Pengguna'
b'DocType: Purchase Invoice',b'Taxes and Charges Deducted',b'Pajak dan Biaya Dikurangi'
b'apps/erpnext/erpnext/hooks.py +142',b'Issues',b'Isu'
b'apps/erpnext/erpnext/controllers/status_updater.py +12',b'Status must be one of {0}',b'Status harus menjadi salah satu {0}'
b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +64',b'Reminder to update GSTIN Sent',b'Pengingat untuk memperbarui GSTIN Terkirim'
b'DocType: Sales Invoice',b'Debit To',b'Debit Untuk'
b'DocType: Restaurant Menu Item',b'Restaurant Menu Item',b'Item Menu Restoran'
b'DocType: Delivery Note',b'Required only for sample item.',b'Diperlukan hanya untuk item sampel.'
b'DocType: Stock Ledger Entry',b'Actual Qty After Transaction',b'Jumlah Aktual Setelah Transaksi'
,b'Pending SO Items For Purchase Request',b'Pending SO Items Untuk Pembelian Permintaan'
b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35',b'Student Admissions',b'Penerimaan Mahasiswa'
b'apps/erpnext/erpnext/accounts/party.py +388',b'{0} {1} is disabled',b'{0} {1} dinonaktifkan'
b'DocType: Supplier',b'Billing Currency',b'Mata Uang Penagihan'
b'DocType: Sales Invoice',b'SINV-RET-',b'SINV-RET-'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200',b'Extra Large',b'Ekstra Besar'
b'DocType: Crop',b'Scientific Name',b'Nama ilmiah'
b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Leaves',b'Jumlah Daun'
b'DocType: Customer',"b'Reselect, if the chosen contact is edited after save'","b'Pilih ulang, jika kontak yang dipilih akan diedit setelah menyimpan'"
b'DocType: Consultation',b'In print',b'Di cetak'
,b'Profit and Loss Statement',b'Laba Rugi'
b'DocType: Bank Reconciliation Detail',b'Cheque Number',b'Nomor Cek'
,b'Sales Browser',b'Browser Penjualan'
b'DocType: Journal Entry',b'Total Credit',b'Jumlah Kredit'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542',b'Warning: Another {0} # {1} exists against stock entry {2}',b'Peringatan: Ada {0} # {1} lain terhadap entri persediaan {2}'
b'apps/erpnext/erpnext/utilities/user_progress_utils.py +66',b'Local',b'[Daerah'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26',b'Loans and Advances (Assets)',b'Pinjaman Uang Muka dan (Aset)'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12',b'Debtors',b'Debitur'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199',b'Large',b'Besar'
b'DocType: Homepage Featured Product',b'Homepage Featured Product',b'Homepage Produk Pilihan'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +248',b'All Assessment Groups',b'Semua Grup Assessment'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15',b'New Warehouse Name',b'Gudang baru Nama'
b'apps/erpnext/erpnext/accounts/report/financial_statements.py +259',b'Total {0} ({1})',b'Total {0} ({1})'
b'DocType: C-Form Invoice Detail',b'Territory',b'Wilayah'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151',b'Please mention no of visits required',b'Harap menyebutkan tidak ada kunjungan yang diperlukan'
b'DocType: Stock Settings',b'Default Valuation Method',b'Metode Perhitungan Standar'
b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26',b'Fee',b'Biaya'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +154',b'Update in progress. It might take a while.',b'Perbaruan sedang berlangsung. Mungkin perlu beberapa saat.'
b'DocType: Production Plan Item',b'Produced Qty',b'Diproduksi Qty'
b'DocType: Vehicle Log',b'Fuel Qty',b'BBM Qty'
b'DocType: Stock Entry',b'Target Warehouse Name',b'Target Nama Gudang'
b'DocType: Work Order Operation',b'Planned Start Time',b'Rencana Start Time'
b'DocType: Course',b'Assessment',b'Penilaian'
b'DocType: Payment Entry Reference',b'Allocated',b'Dialokasikan'
b'apps/erpnext/erpnext/config/accounts.py +267',b'Close Balance Sheet and book Profit or Loss.',b'Tutup Neraca dan Perhitungan Laba Rugi atau buku.'
b'DocType: Student Applicant',b'Application Status',b'Status aplikasi'
b'DocType: Sensitivity Test Items',b'Sensitivity Test Items',b'Item Uji Sensitivitas'
b'DocType: Project Update',b'Project Update',b'Pembaruan Proyek'
b'DocType: Fees',b'Fees',b'biaya'
b'DocType: Currency Exchange',b'Specify Exchange Rate to convert one currency into another',b'Tentukan Nilai Tukar untuk mengkonversi satu mata uang ke yang lain'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159',b'Quotation {0} is cancelled',b'Quotation {0} dibatalkan'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +119',b'Total Outstanding Amount',b'Jumlah Total Outstanding'
b'DocType: Sales Partner',b'Targets',b'Target'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js +54',b'Please register the SIREN number in the company information file',b'Silakan daftar nomor SIREN di file informasi perusahaan'
b'DocType: Price List',b'Price List Master',b'Daftar Harga Guru'
b'DocType: GST Account',b'CESS Account',b'Akun CESS'
b'DocType: Sales Person',b'All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.',b'Semua Transaksi Penjualan dapat ditandai terhadap beberapa ** Orang Penjualan ** sehingga Anda dapat mengatur dan memonitor target.'
,b'S.O. No.',b'SO No'
b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241',b'Please create Customer from Lead {0}',b'Silakan membuat Pelanggan dari Prospek {0}'
b'apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3',b'Select Patient',b'Pilih pasien'
b'DocType: Price List',b'Applicable for Countries',b'Berlaku untuk Negara'
b'DocType: Supplier Scorecard Scoring Variable',b'Parameter Name',b'Nama parameter'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52',b'Student Group Name is mandatory in row {0}',b'Mahasiswa Nama Group adalah wajib berturut-turut {0}'
b'DocType: Homepage',b'Products to be shown on website homepage',b'Produk yang akan ditampilkan pada homepage website'
b'apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13',b'This is a root customer group and cannot be edited.',b'Ini adalah kelompok pelanggan paling dasar dan tidak dapat diedit.'
b'DocType: Student',b'AB-',b'AB-'
b'DocType: POS Profile',b'Ignore Pricing Rule',b'Abaikan Aturan Harga'
b'DocType: Employee Education',b'Graduate',b'Lulusan'
b'DocType: Leave Block List',b'Block Days',b'Blok Hari'
b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83',"b'Shipping Address does not have country, which is required for this Shipping Rule'","b'Alamat Pengiriman tidak memiliki negara, yang diperlukan untuk Aturan Pengiriman ini'"
b'DocType: Journal Entry',b'Excise Entry',b'Cukai Entri'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65',"b""Warning: Sales Order {0} already exists against Customer's Purchase Order {1}""",b'Peringatan: Order Penjualan {0} sudah ada untuk Order Pembelian Pelanggan {1}'
b'DocType: Terms and Conditions',"b'Standard Terms and Conditions that can be added to Sales and Purchases.\n\nExamples:\n\n1. Validity of the offer.\n1. Payment Terms (In Advance, On Credit, part advance etc).\n1. What is extra (or payable by the Customer).\n1. Safety / usage warning.\n1. Warranty if any.\n1. Returns Policy.\n1. Terms of shipping, if applicable.\n1. Ways of addressing disputes, indemnity, liability, etc.\n1. Address and Contact of your Company.'","b'Syarat dan Ketentuan Standar yang dapat ditambahkan ke Penjualan dan Pembelian. Contoh : 1. Validitas tawaran. 1. Termin Pembayaran (Pembayaran Dimuka, Secara Kredit, pembayaran dimuka sebagian, dll). 1. Apa yang ekstra (atau dibayar oleh Pelanggan). 1. Peringatan keamanan / penggunaan. 1. Garansi jika ada. 1. Kebijakan Retur. 1. Syarat pengiriman, jika berlaku. 1. Cara menangani sengketa, ganti rugi, kewajiban, dll. 1. Alamat dan Kontak Perusahaan Anda.'"
b'DocType: Issue',b'Issue Type',b'Jenis Isu'
b'DocType: Attendance',b'Leave Type',b'Cuti Type'
b'DocType: Purchase Invoice',b'Supplier Invoice Details',b'Pemasok Rincian Faktur'
b'DocType: Agriculture Task',b'Ignore holidays',b'Abaikan hari libur'
b'apps/erpnext/erpnext/controllers/stock_controller.py +233',"b""Expense / Difference account ({0}) must be a 'Profit or Loss' account""","b""Beban akun / Difference ({0}) harus akun 'Laba atau Rugi'"""
b'DocType: Project',b'Copied From',b'Disalin dari'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +340',b'Invoice already created for all billing hours',b'Faktur sudah dibuat untuk semua jam penagihan'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96',b'Name error: {0}',b'Nama error: {0}'
b'DocType: Cash Flow Mapping',b'Is Finance Cost',b'Apakah Biaya Keuangan?'
b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18',b'Attendance for employee {0} is already marked',b'Kehadiran bagi karyawan {0} sudah ditandai'
b'DocType: Packing Slip',b'If more than one package of the same type (for print)',b'Jika lebih dari satu paket dari jenis yang sama (untuk mencetak)'
b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27',b'Please set default customer in Restaurant Settings',b'Harap tetapkan pelanggan default di Pengaturan Restoran'
,b'Salary Register',b'Register Gaji'
b'DocType: Warehouse',b'Parent Warehouse',b'Gudang tua'
b'DocType: C-Form Invoice Detail',b'Net Total',b'Jumlah Bersih'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +546',b'Default BOM not found for Item {0} and Project {1}',b'Default BOM tidak ditemukan untuk Item {0} dan Project {1}'
b'apps/erpnext/erpnext/config/hr.py +168',b'Define various loan types',b'Mendefinisikan berbagai jenis pinjaman'
b'DocType: Bin',b'FCFS Rate',b'FCFS Tingkat'
b'DocType: Opening Invoice Creation Tool Item',b'Outstanding Amount',b'Jumlah belum terbayar'
b'apps/erpnext/erpnext/templates/generators/bom.html +71',b'Time(in mins)',b'Waktu (dalam menit)'
b'DocType: Project Task',b'Working',b'Kerja'
b'DocType: Stock Ledger Entry',b'Stock Queue (FIFO)',b'Antrian Persediaan (FIFO)'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +127',b'Financial Year',b'Tahun Keuangan'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46',b'{0} does not belong to Company {1}',b'{0} bukan milik Perusahaan {1}'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66',b'Could not solve criteria score function for {0}. Make sure the formula is valid.',b'Tidak dapat memecahkan kriteria fungsi skor untuk {0}. Pastikan rumusnya benar.'
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122',b'Cost as on',b'Biaya seperti pada'
b'DocType: Healthcare Settings',b'Out Patient Settings',b'Keluar Pengaturan Pasien'
b'DocType: Account',b'Round Off',b'Membulatkan'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +259',b'Quantity must be positive',b'Kuantitas harus positif'
b'DocType: Material Request Plan Item',b'Requested Qty',b'Diminta Qty'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +96',b'The fields From Shareholder and To Shareholder cannot be blank',b'Bidang Dari Pemegang Saham dan Pemegang Saham tidak boleh kosong'
b'DocType: Tax Rule',b'Use for Shopping Cart',b'Gunakan untuk Keranjang Belanja'
b'apps/erpnext/erpnext/controllers/item_variant.py +101',b'Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2}',b'Nilai {0} untuk Atribut {1} tidak ada dalam daftar Barang valid Atribut Nilai untuk Item {2}'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79',b'Select Serial Numbers',b'Pilih Nomor Seri'
b'DocType: BOM Item',b'Scrap %',b'Scrap%'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46',"b'Charges will be distributed proportionately based on item qty or amount, as per your selection'","b'Biaya akan didistribusikan secara proporsional berdasarkan pada item qty atau jumlah, sesuai pilihan Anda'"
b'DocType: Maintenance Visit',b'Purposes',b'Tujuan'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +112',b'Atleast one item should be entered with negative quantity in return document',b'Atleast satu item harus dimasukkan dengan kuantitas negatif dalam dokumen kembali'
b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +71',"b'Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations'","b'Operasi {0} lebih lama daripada jam kerja yang tersedia di workstation {1}, memecah operasi menjadi beberapa operasi'"
b'DocType: Membership',b'Membership Status',b'Status Keanggotaan'
,b'Requested',b'Diminta'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93',b'No Remarks',b'Tidak ada Keterangan'
b'DocType: Asset',b'In Maintenance',b'Dalam perawatan'
b'DocType: Purchase Invoice',b'Overdue',b'Terlambat'
b'DocType: Account',b'Stock Received But Not Billed',b'Persediaan Diterima Tapi Tidak Ditagih'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +84',b'Root Account must be a group',b'Akar Rekening harus kelompok'
b'DocType: Drug Prescription',b'Drug Prescription',b'Resep obat'
b'DocType: Fees',b'FEE.',b'BIAYA.'
b'DocType: Employee Loan',b'Repaid/Closed',b'Dilunasi / Ditutup'
b'DocType: Item',b'Total Projected Qty',b'Total Proyeksi Jumlah'
b'DocType: Monthly Distribution',b'Distribution Name',b'Nama Distribusi'
b'apps/erpnext/erpnext/stock/stock_ledger.py +477',"b'Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry'","b'Angka penilaian tidak ditemukan untuk Item {0}, yang diperlukan untuk melakukan entri akuntansi untuk {1} {2}. Jika item tersebut bertransaksi sebagai item angka penilaian nol di {1}, mohon sebutkan di tabel Item {1}. Jika tidak, buat transaksi saham masuk untuk item tersebut atau beri nilai valuasi dalam catatan Item, lalu coba kirimkan / batalkan entri ini.'"
b'DocType: Course',b'Course Code',b'Kode Course'
b'apps/erpnext/erpnext/controllers/stock_controller.py +337',b'Quality Inspection required for Item {0}',b'Inspeksi Mutu diperlukan untuk Item {0}'
b'DocType: POS Settings',b'Use POS in Offline Mode',b'Gunakan POS dalam Mode Offline'
b'DocType: Supplier Scorecard',b'Supplier Variables',b'Variabel pemasok'
b'DocType: Quotation',"b""Rate at which customer's currency is converted to company's base currency""",b'Tingkat di mana mata uang pelanggan dikonversi ke mata uang dasar perusahaan'
b'DocType: Purchase Invoice Item',b'Net Rate (Company Currency)',b'Tingkat Net (Perusahaan Mata Uang)'
b'DocType: Salary Detail',b'Condition and Formula Help',b'Kondisi dan Formula Bantuan'
b'apps/erpnext/erpnext/config/selling.py +105',b'Manage Territory Tree.',b'Kelola Wilayah Tree.'
b'DocType: Patient Service Unit',b'Patient Service Unit',b'Unit Layanan Pasien'
b'DocType: Journal Entry Account',b'Sales Invoice',b'Faktur Penjualan'
b'DocType: Journal Entry Account',b'Party Balance',b'Saldo Partai'
b'DocType: Cash Flow Mapper',b'Section Subtotal',b'Bagian Subtotal'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +498',b'Please select Apply Discount On',b'Silakan pilih Terapkan Diskon Pada'
b'DocType: Stock Settings',b'Sample Retention Warehouse',b'Contoh Retensi Gudang'
b'DocType: Company',b'Default Receivable Account',b'Standar Piutang Rekening'
b'DocType: Physician Schedule',b'Physician Schedule',b'Jadwal dokter'
b'DocType: Purchase Invoice',b'Deemed Export',b'Dianggap ekspor'
b'DocType: Stock Entry',b'Material Transfer for Manufacture',b'Alih Material untuk Produksi'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20',b'Discount Percentage can be applied either against a Price List or for all Price List.',b'Persentase Diskon dapat diterapkan baik terhadap Daftar Harga atau untuk semua List Price.'
b'DocType: Subscription',b'Half-yearly',b'Setengah tahun sekali'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +407',b'Accounting Entry for Stock',b'Entri Akuntansi untuk Persediaan'
b'DocType: Lab Test',b'LabTest Approver',b'Pendekatan LabTest'
b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +61',b'You have already assessed for the assessment criteria {}.',b'Anda telah memberikan penilaian terhadap kriteria penilaian {}.'
b'DocType: Vehicle Service',b'Engine Oil',b'Oli mesin'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1005',b'Work Orders Created: {0}',b'Pesanan Pekerjaan Dibuat: {0}'
b'DocType: Sales Invoice',b'Sales Team1',b'Penjualan team1'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +547',b'Item {0} does not exist',b'Item {0} tidak ada'
b'DocType: Sales Invoice',b'Customer Address',b'Alamat Pelanggan'
b'DocType: Employee Loan',b'Loan Details',b'Detail pinjaman'
b'DocType: Company',b'Default Inventory Account',b'Akun Inventaris Default'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +192',b'The folio numbers are not matching',b'Nomor folio tidak sesuai'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124',b'Row {0}: Completed Qty must be greater than zero.',b'Row {0}: Selesai Qty harus lebih besar dari nol.'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +262',b'Payment Request for {0}',b'Permintaan Pembayaran untuk {0}'
b'DocType: Item Barcode',b'Barcode Type',b'Jenis Barcode'
b'DocType: Antibiotic',b'Antibiotic Name',b'Nama Antibiotik'
b'DocType: Purchase Invoice',b'Apply Additional Discount On',b'Terapkan tambahan Diskon Pada'
b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +66',b'Select Type...',b'Pilih Jenis ...'
b'DocType: Crop Cycle',b'A link to all the Land Units in which the Crop is growing',b'Tautan ke semua Unit Tanah tempat Tanaman tumbuh'
b'DocType: Account',b'Root Type',b'Akar Type'
b'DocType: Item',b'FIFO',b'FIFO'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +136',b'Row # {0}: Cannot return more than {1} for Item {2}',b'Baris # {0}: Tidak dapat mengembalikan lebih dari {1} untuk Barang {2}'
b'DocType: Item Group',b'Show this slideshow at the top of the page',b'Tampilkan slide ini di bagian atas halaman'
b'DocType: BOM',b'Item UOM',b'Stok Barang UOM'
b'DocType: Sales Taxes and Charges',b'Tax Amount After Discount Amount (Company Currency)',b'Jumlah pajak Setelah Diskon Jumlah (Perusahaan Mata Uang)'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +177',b'Target warehouse is mandatory for row {0}',b'Target gudang adalah wajib untuk baris {0}'
b'DocType: Cheque Print Template',b'Primary Settings',b'Pengaturan utama'
b'DocType: Purchase Invoice',b'Select Supplier Address',b'Pilih Pemasok Alamat'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397',b'Add Employees',b'Tambahkan Karyawan'
b'DocType: Purchase Invoice Item',b'Quality Inspection',b'Inspeksi Mutu'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196',b'Extra Small',b'Ekstra Kecil'
b'DocType: Company',b'Standard Template',b'Template standar'
b'DocType: Training Event',b'Theory',b'Teori'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +806',b'Warning: Material Requested Qty is less than Minimum Order Qty',b'Peringatan: Material Diminta Qty kurang dari Minimum Order Qty'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211',b'Account {0} is frozen',b'Akun {0} dibekukan'
b'DocType: Company',b'Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.',b'Badan Hukum / Anak dengan Bagan terpisah Account milik Organisasi.'
b'DocType: Payment Request',b'Mute Email',b'Diamkan Surel'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29',"b'Food, Beverage & Tobacco'","b'Makanan, Minuman dan Tembakau'"
b'DocType: Account',b'Account Number',b'Nomor Akun'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +752',b'Can only make payment against unbilled {0}',b'Hanya dapat melakukan pembayaran terhadap yang belum ditagihkan {0}'
b'apps/erpnext/erpnext/controllers/selling_controller.py +102',b'Commission rate cannot be greater than 100',b'Tingkat komisi tidak dapat lebih besar dari 100'
b'DocType: Volunteer',b'Volunteer',b'Sukarelawan'
b'DocType: Stock Entry',b'Subcontract',b'Kontrak tambahan'
b'apps/erpnext/erpnext/public/js/utils/party.js +166',b'Please enter {0} first',b'Entrikan {0} terlebih dahulu'
b'apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +104',b'No replies from',b'Tidak ada balasan dari'
b'DocType: Work Order Operation',b'Actual End Time',b'Waktu Akhir Aktual'
b'DocType: Item',b'Manufacturer Part Number',b'Produsen Part Number'
b'DocType: Work Order Operation',b'Estimated Time and Cost',b'Perkiraan Waktu dan Biaya'
b'DocType: Bin',b'Bin',b'Tong Sampah'
b'DocType: Crop',b'Crop Name',b'Nama tanaman'
b'DocType: SMS Log',b'No of Sent SMS',b'Tidak ada dari Sent SMS'
b'DocType: Antibiotic',b'Healthcare Administrator',b'Administrator Kesehatan'
b'apps/erpnext/erpnext/utilities/user_progress.py +47',b'Set a Target',b'Tetapkan Target'
b'DocType: Dosage Strength',b'Dosage Strength',b'Kekuatan Dosis'
b'DocType: Account',b'Expense Account',b'Beban Akun'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49',b'Software',b'Perangkat lunak'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203',b'Colour',b'Warna'
b'DocType: Assessment Plan Criteria',b'Assessment Plan Criteria',b'Kriteria Rencana Penilaian'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +118',b'Expiry date is mandatory for selected item',b'Tanggal kedaluwarsa wajib untuk item yang dipilih'
b'DocType: Supplier Scorecard Scoring Standing',b'Prevent Purchase Orders',b'Cegah Pesanan Pembelian'
b'apps/erpnext/erpnext/healthcare/setup.py +258',b'Susceptible',b'Rentan'
b'DocType: Patient Appointment',b'Scheduled',b'Dijadwalkan'
b'apps/erpnext/erpnext/config/buying.py +18',b'Request for quotation.',b'Meminta kutipan.'
b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js +13',"b'Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle'","b'Silahkan pilih barang yang ""Barang Stok"" nya  ""Tidak"" dan ""Barang Jualan"" nya ""Ya"", serta tidak ada Bundel Produk lainnya'"
b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148',b'Select Customer',b'Pilih pelanggan'
b'DocType: Student Log',b'Academic',b'Akademis'
b'DocType: Patient',b'Personal and Social History',b'Sejarah Pribadi dan Sosial'
b'apps/erpnext/erpnext/education/doctype/guardian/guardian.py +51',b'User {0} created',b'Pengguna {0} dibuat'
b'DocType: Fee Schedule',b'Fee Breakup for each student',b'Fee Breakup untuk setiap siswa'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +541',b'Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2})',b'Total muka ({0}) terhadap Orde {1} tidak dapat lebih besar dari Grand Total ({2})'
b'DocType: Sales Partner',b'Select Monthly Distribution to unevenly distribute targets across months.',b'Pilih Distribusi bulanan untuk merata mendistribusikan target di bulan.'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78',b'Change Code',b'Ubah Kode'
b'DocType: Purchase Invoice Item',b'Valuation Rate',b'Tingkat Penilaian'
b'DocType: Stock Reconciliation',b'SR/',b'SR /'
b'DocType: Vehicle',b'Diesel',b'disel'
b'apps/erpnext/erpnext/stock/get_item_details.py +388',b'Price List Currency not selected',b'Daftar Harga Mata uang tidak dipilih'
b'DocType: Purchase Invoice',b'Availed ITC Cess',b'Dilengkapi ITC Cess'
,b'Student Monthly Attendance Sheet',b'Mahasiswa Lembar Kehadiran Bulanan'
b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96',b'Shipping rule only applicable for Selling',b'Aturan pengiriman hanya berlaku untuk penjualan'
b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30',b'Project Start Date',b'Tanggal Project Mulai'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +23',b'Until',b'Sampai'
b'DocType: Rename Tool',b'Rename Log',b'Log Riwayat Ganti Nama'
b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27',b'Student Group or Course Schedule is mandatory',b'Student Group atau Jadwal Kursus adalah wajib'
b'DocType: HR Settings',b'Maintain Billing Hours and Working Hours Same on Timesheet',b'Samakan Jam Penagihan dan Jam Kerja di Daftar Absen'
b'DocType: Maintenance Visit Purpose',b'Against Document No',b'Terhadap No. Dokumen'
b'DocType: BOM',b'Scrap',b'Membatalkan'
b'apps/erpnext/erpnext/utilities/user_progress.py +217',b'Go to Instructors',b'Pergi ke instruktur'
b'apps/erpnext/erpnext/config/selling.py +110',b'Manage Sales Partners.',b'Kelola Partner Penjualan'
b'DocType: Quality Inspection',b'Inspection Type',b'Tipe Inspeksi'
b'DocType: Fee Validity',b'Visited yet',b'Dikunjungi belum'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +134',b'Warehouses with existing transaction can not be converted to group.',b'Gudang dengan transaksi yang ada tidak dapat dikonversi ke grup.'
b'DocType: Assessment Result Tool',b'Result HTML',b'hasil HTML'
b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35',b'Expires On',b'Kadaluarsa pada'
b'apps/erpnext/erpnext/utilities/activation.py +117',b'Add Students',b'Tambahkan Siswa'
b'apps/erpnext/erpnext/public/js/utils.js +270',b'Please select {0}',b'Silahkan pilih {0}'
b'DocType: C-Form',b'C-Form No',b'C-Form ada'
b'DocType: BOM',b'Exploded_items',b'Pembesaran Item'
b'apps/erpnext/erpnext/utilities/user_progress.py +139',b'List your products or services that you buy or sell.',b'Cantumkan produk atau layanan yang Anda beli atau jual.'
b'DocType: Water Analysis',b'Storage Temperature',b'Suhu Penyimpanan'
b'DocType: Employee Attendance Tool',b'Unmarked Attendance',b'Kehadiran non-absen'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137',b'Researcher',b'Peneliti'
b'DocType: Program Enrollment Tool Student',b'Program Enrollment Tool Student',b'Program Pendaftaran Alat Mahasiswa'
b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16',b'Start date should be less than end date for task {0}',b'Tanggal mulai harus kurang dari tanggal akhir untuk tugas {0}'
b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25',b'Name or Email is mandatory',b'Nama atau Email adalah wajib'
b'DocType: Member',b'MEM-',b'MEM-'
b'DocType: Instructor',b'Instructor Log',b'Log Instruktur'
b'DocType: Purchase Order Item',b'Returned Qty',b'Qty Retur'
b'DocType: Student',b'Exit',b'Keluar'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +156',b'Root Type is mandatory',b'Tipe Dasar adalah wajib'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29',b'Failed to install presets',b'Gagal memasang prasetel'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +44',"b'{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.'","b'{0} saat ini memiliki {1} posisi Supplier Scorecard, dan RFQs ke pemasok ini harus dikeluarkan dengan hati-hati.'"
b'DocType: Chapter',b'Non Profit Manager',b'Manajer Non Profit'
b'DocType: BOM',b'Total Cost(Company Currency)',b'Total Biaya (Perusahaan Mata Uang)'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315',b'Serial No {0} created',b'Serial ada {0} dibuat'
b'DocType: Homepage',b'Company Description for website homepage',b'Deskripsi Perusahaan untuk homepage website'
b'DocType: Item Customer Detail',"b'For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes'","b'Untuk kenyamanan pelanggan, kode ini dapat digunakan dalam format cetak seperti Faktur dan Nota Pengiriman'"
b'apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18',b'Suplier Name',b'Nama suplier'
b'apps/erpnext/erpnext/accounts/report/financial_statements.py +174',b'Could not retrieve information for {0}.',b'Tidak dapat mengambil informasi untuk {0}.'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +134',b'Opening Entry Journal',b'Membuka Entri Jurnal'
b'DocType: Sales Invoice',b'Time Sheet List',b'Waktu Daftar Lembar'
b'DocType: Employee',b'You can enter any date manually',b'Anda dapat memasukkan tanggal apapun secara manual'
b'DocType: Healthcare Settings',b'Result Printed',b'Hasil cetak'
b'DocType: Asset Category Account',b'Depreciation Expense Account',b'Akun Beban Penyusutan'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +233',b'Probationary Period',b'Masa percobaan'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32',b'View {0}',b'Lihat {0}'
b'DocType: Customer Group',b'Only leaf nodes are allowed in transaction',b'Hanya node cuti yang diperbolehkan dalam transaksi'
b'DocType: Project',b'Total Costing Amount (via Timesheets)',b'Total Costing Amount (melalui Timesheets)'
b'DocType: Employee Advance',b'Expense Approver',b'Approver Klaim Biaya'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136',b'Row {0}: Advance against Customer must be credit',b'Baris {0}: Uang muka dari Pelanggan harus kredit'
b'DocType: Project',b'Hourly',b'Per jam'
b'apps/erpnext/erpnext/accounts/doctype/account/account.js +89',b'Non-Group to Group',b'Non-Group untuk Grup'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58',b'Batch is mandatory in row {0}',b'Batch wajib di baris {0}'
b'DocType: Purchase Receipt Item Supplied',b'Purchase Receipt Item Supplied',b'Nota Penerimaan Stok Barang Disediakan'
b'apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24',b'To Datetime',b'Untuk Datetime'
b'apps/erpnext/erpnext/config/selling.py +302',b'Logs for maintaining sms delivery status',b'Log untuk mempertahankan status pengiriman sms'
b'DocType: Accounts Settings',b'Make Payment via Journal Entry',b'Lakukan Pembayaran via Journal Entri'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +223',b'Printed On',b'Printed On'
b'DocType: Item',b'Inspection Required before Delivery',b'Inspeksi Diperlukan sebelum Pengiriman'
b'DocType: Item',b'Inspection Required before Purchase',b'Inspeksi Diperlukan sebelum Pembelian'
b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93',b'Pending Activities',b'Kegiatan Tertunda'
b'DocType: Patient Appointment',b'Reminded',b'Mengingatkan'
b'DocType: Patient',b'PID-',b'PID-'
b'DocType: Chapter Member',b'Chapter Member',b'Bab Anggota'
b'DocType: Material Request Plan Item',b'Minimum Order Quantity',b'Jumlah Pesanan Minimum'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +106',b'Your Organization',b'Organisasi Anda'
b'DocType: Fee Component',b'Fees Category',b'biaya Kategori'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +134',b'Please enter relieving date.',b'Silahkan masukkan menghilangkan date.'
b'apps/erpnext/erpnext/controllers/trends.py +149',b'Amt',b'Amt'
b'DocType: Supplier Scorecard',b'Notify Employee',b'Beritahu Karyawan'
b'DocType: Opportunity',b'Enter name of campaign if source of enquiry is campaign',b'Entrikan nama kampanye jika sumber penyelidikan adalah kampanye'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38',b'Newspaper Publishers',b'Penerbit Koran'
b'apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30',b'Select Fiscal Year',b'Pilih Tahun Fiskal'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115',b'Expected Delivery Date should be after Sales Order Date',b'Tanggal Pengiriman yang Diharapkan harus setelah Tanggal Pesanan Penjualan'
b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42',b'Reorder Level',b'Tingkat Re-Order'
b'DocType: Company',b'Chart Of Accounts Template',b'Grafik Of Account Template'
b'DocType: Attendance',b'Attendance Date',b'Tanggal Kehadiran'
b'apps/erpnext/erpnext/stock/get_item_details.py +352',b'Item Price updated for {0} in Price List {1}',b'Harga Barang diperbarui untuk {0} di Daftar Harga {1}'
b'DocType: Salary Structure',b'Salary breakup based on Earning and Deduction.',b'Gaji perpisahan berdasarkan Produktif dan Pengurangan.'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +128',b'Account with child nodes cannot be converted to ledger',b'Akun dengan node anak tidak dapat dikonversi ke buku besar'
b'DocType: Purchase Invoice Item',b'Accepted Warehouse',b'Gudang Barang Diterima'
b'DocType: Bank Reconciliation Detail',b'Posting Date',b'Tanggal Posting'
b'DocType: Item',b'Valuation Method',b'Metode Perhitungan'
b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203',b'Mark Half Day',b'Mark Half Day'
b'DocType: Sales Invoice',b'Sales Team',b'Tim Penjualan'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +87',b'Duplicate entry',b'Entri Ganda/Duplikat'
b'DocType: Program Enrollment Tool',b'Get Students',b'Dapatkan Siswa'
b'DocType: Serial No',b'Under Warranty',b'Masih Garansi'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +516',b'[Error]',b'[Kesalahan]'
b'DocType: Sales Order',b'In Words will be visible once you save the Sales Order.',b'Dalam Kata-kata akan terlihat setelah Anda menyimpan Sales Order.'
,b'Employee Birthday',b'Ulang Tahun Karyawan'
b'apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14',b'Please select Completion Date for Completed Repair',b'Silakan pilih Tanggal Penyelesaian untuk Perbaikan Selesai'
b'DocType: Student Batch Attendance Tool',b'Student Batch Attendance Tool',b'Alat Batch Kehadiran mahasiswa'
b'apps/erpnext/erpnext/controllers/status_updater.py +213',b'Limit Crossed',b'batas Dilalui'
b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22',b'Scheduled Upto',b'Terjadwal Upto'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55',b'Venture Capital',b'Modal Ventura'
b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +40',"b""An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.""",b'Istilah akademik dengan ini &#39;Tahun Akademik&#39; {0} dan &#39;Nama Term&#39; {1} sudah ada. Harap memodifikasi entri ini dan coba lagi.'
b'DocType: UOM',b'Must be Whole Number',b'Harus Nomor Utuh'
b'DocType: Leave Control Panel',b'New Leaves Allocated (In Days)',b'cuti baru Dialokasikan (Dalam Hari)'
b'DocType: Purchase Invoice',b'Invoice Copy',b'Salinan faktur'
b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49',b'Serial No {0} does not exist',b'Serial ada {0} tidak ada'
b'DocType: Sales Invoice Item',b'Customer Warehouse (Optional)',b'Gudang Customer (pilihan)'
b'DocType: Pricing Rule',b'Discount Percentage',b'Persentase Diskon'
b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51',b'Reserved for sub contracting',b'Dicadangkan untuk sub kontrak'
b'DocType: Payment Reconciliation Invoice',b'Invoice Number',b'Nomor Faktur'
b'DocType: Shopping Cart Settings',b'Orders',b'Order'
b'DocType: Employee Leave Approver',b'Leave Approver',b'Approver Cuti'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +285',b'Please select a batch',b'Silakan pilih satu batch'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42',b'JournalLib',b'JournalLib'
b'DocType: Assessment Group',b'Assessment Group Name',b'Nama penilaian Grup'
b'DocType: Manufacturing Settings',b'Material Transferred for Manufacture',b'Bahan Ditransfer untuk Produksi'
b'DocType: Landed Cost Item',b'Receipt Document Type',b'Dokumen penerimaan Type'
b'DocType: Daily Work Summary Settings',b'Select Companies',b'Pilih perusahaan'
b'DocType: Antibiotic',b'Healthcare',b'Kesehatan'
b'DocType: Target Detail',b'Target Detail',b'Sasaran Detil'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +65',b'Single Variant',b'Varian tunggal'
b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24',b'All Jobs',b'Semua Jobs'
b'DocType: Sales Order',b'% of materials billed against this Sales Order',b'% Bahan ditagih terhadap Sales Order ini'
b'DocType: Program Enrollment',b'Mode of Transportation',b'Cara Transportasi'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49',b'Period Closing Entry',b'Periode Penutupan Entri'
b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +72',b'Select Department...',b'Pilih Departemen ...'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38',b'Cost Center with existing transactions can not be converted to group',b'Biaya Center dengan transaksi yang ada tidak dapat dikonversi ke grup'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374',b'Amount {0} {1} {2} {3}',b'Jumlah {0} {1} {2} {3}'
b'DocType: Account',b'Depreciation',b'Penyusutan'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +102',b'The number of shares and the share numbers are inconsistent',b'Jumlah saham dan jumlah saham tidak konsisten'
b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49',b'Supplier(s)',b'Supplier (s)'
b'DocType: Employee Attendance Tool',b'Employee Attendance Tool',b'Alat Absensi Karyawan'
b'DocType: Guardian Student',b'Guardian Student',b'wali Mahasiswa'
b'DocType: Supplier',b'Credit Limit',b'Batas Kredit'
b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70',b'Avg. Selling Price List Rate',b'Rata-rata Tarif Daftar Harga Jual'
b'DocType: Salary Component',b'Salary Component',b'Komponen gaji'
b'apps/erpnext/erpnext/accounts/utils.py +495',b'Payment Entries {0} are un-linked',b'Entries pembayaran {0} adalah un-linked'
b'DocType: GL Entry',b'Voucher No',b'Voucher Tidak ada'
,b'Lead Owner Efficiency',b'Efisiensi Pemilik Prospek'
b'DocType: Leave Allocation',b'Leave Allocation',b'Alokasi Cuti'
b'DocType: Payment Request',b'Recipient Message And Payment Details',b'Penerima Pesan Dan Rincian Pembayaran'
b'DocType: Training Event',b'Trainer Email',b'Email Pelatih'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550',b'Material Requests {0} created',b'Permintaan Material {0} dibuat'
b'DocType: Restaurant Reservation',b'No of People',b'Tidak ada orang'
b'apps/erpnext/erpnext/config/selling.py +164',b'Template of terms or contract.',b'Template istilah atau kontrak.'
b'DocType: Purchase Invoice',b'Address and Contact',b'Alamat dan Kontak'
b'DocType: Cheque Print Template',b'Is Account Payable',b'Apakah Account Payable'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276',b'Stock cannot be updated against Purchase Receipt {0}',b'Persediaan tidak dapat diperbarui terhadap Nota Pembelian {0}'
b'DocType: Support Settings',b'Auto close Issue after 7 days',b'Auto Issue dekat setelah 7 hari'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +71',"b'Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}'","b'Cuti tidak dapat dialokasikan sebelum {0}, saldo cuti sudah pernah membawa-diteruskan dalam catatan alokasi cuti masa depan {1}'"
b'apps/erpnext/erpnext/accounts/party.py +317',b'Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s)',b'Catatan: Tanggal Jatuh Tempo / Referensi melebihi {0} hari dari yang diperbolehkan untuk kredit pelanggan'
b'apps/erpnext/erpnext/education/doctype/program/program.js +8',b'Student Applicant',b'Mahasiswa Pemohon'
b'DocType: Purchase Invoice',b'ORIGINAL FOR RECIPIENT',b'ORIGINAL UNTUK RECIPIENT'
b'DocType: Asset Category Account',b'Accumulated Depreciation Account',b'Akun Penyusutan Akumulasi'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11',b'This email is autogenerated',b'Email ini otomatis terkirim'
b'DocType: Stock Settings',b'Freeze Stock Entries',b'Bekukan Entri Persediaan'
b'DocType: Program Enrollment',b'Boarding Student',b'Siswa Asrama'
b'DocType: Asset',b'Expected Value After Useful Life',b'Nilai diharapkan Setelah Hidup Berguna'
b'DocType: Item',b'Reorder level based on Warehouse',b'Tingkat Re-Order berdasarkan Gudang'
b'DocType: Activity Cost',b'Billing Rate',b'Tarip penagihan'
,b'Qty to Deliver',b'Kuantitas Pengiriman'
,b'Stock Analytics',b'Analisis Persediaan'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +523',b'Operations cannot be left blank',b'Operasi tidak dapat dibiarkan kosong'
b'DocType: Maintenance Visit Purpose',b'Against Document Detail No',b'Terhadap Detail Dokumen No.'
b'apps/erpnext/erpnext/regional/__init__.py +11',b'Deletion is not permitted for country {0}',b'Penghapusan tidak diizinkan untuk negara {0}'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +110',b'Party Type is mandatory',b'Partai Type adalah wajib'
b'DocType: Quality Inspection',b'Outgoing',b'Keluaran'
b'DocType: Material Request',b'Requested For',b'Diminta Untuk'
b'DocType: Quotation Item',b'Against Doctype',b'Terhadap Doctype'
b'apps/erpnext/erpnext/controllers/buying_controller.py +404',b'{0} {1} is cancelled or closed',b'{0} {1} dibatalkan atau ditutup'
b'DocType: Asset',b'Calculate Depreciation',b'Hitung Depresiasi'
b'DocType: Delivery Note',b'Track this Delivery Note against any Project',b'Lacak Pengiriman ini Catatan terhadap Proyek manapun'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +35',b'Net Cash from Investing',b'Kas Bersih dari Investasi'
b'DocType: Work Order',b'Work-in-Progress Warehouse',b'Gudang Work In Progress'
b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111',b'Asset {0} must be submitted',b'Aset {0} harus diserahkan'
b'DocType: Fee Schedule Program',b'Total Students',b'Jumlah Siswa'
b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56',b'Attendance Record {0} exists against Student {1}',b'Kehadiran Rekam {0} ada terhadap Mahasiswa {1}'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354',b'Reference #{0} dated {1}',b'Referensi # {0} tanggal {1}'
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164',b'Depreciation Eliminated due to disposal of assets',b'Penyusutan Dieliminasi karena pelepasan aset'
b'DocType: Member',b'Member',b'Anggota'
b'apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15',b'Manage Addresses',b'Pengelolaan Alamat'
b'DocType: Work Order Item',b'Work Order Item',b'Item Pesanan Kerja'
b'DocType: Pricing Rule',b'Item Code',b'Kode Item'
b'DocType: Serial No',b'Warranty / AMC Details',b'Garansi / Detail AMC'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116',b'Select students manually for the Activity based Group',b'Pilih siswa secara manual untuk Activity based Group'
b'DocType: Journal Entry',b'User Remark',b'Keterangan Pengguna'
b'DocType: Lead',b'Market Segment',b'Segmen Pasar'
b'DocType: Agriculture Analysis Criteria',b'Agriculture Manager',b'Manajer Pertanian'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +966',b'Paid Amount cannot be greater than total negative outstanding amount {0}',b'Dibayar Jumlah tidak dapat lebih besar dari jumlah total outstanding negatif {0}'
b'DocType: Supplier Scorecard Period',b'Variables',b'Variabel'
b'DocType: Employee Internal Work History',b'Employee Internal Work History',b'Riwayat Kerja Karyawan Internal'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +249',b'Closing (Dr)',b'Penutup (Dr)'
b'DocType: Cheque Print Template',b'Cheque Size',b'Cek Ukuran'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232',b'Serial No {0} not in stock',b'No. Seri {0} tidak tersedia'
b'apps/erpnext/erpnext/config/selling.py +169',b'Tax template for selling transactions.',b'Template Pajak transaksi penjualan'
b'DocType: Sales Invoice',b'Write Off Outstanding Amount',b'Write Off Jumlah Outstanding'
b'apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27',b'Account {0} does not match with Company {1}',b'Akun {0} tidak sesuai Perusahaan {1}'
b'DocType: Education Settings',b'Current Academic Year',b'Tahun Akademik Saat Ini'
b'DocType: Stock Settings',b'Default Stock UOM',b'UOM Persediaan Standar'
b'DocType: Asset',b'Number of Depreciations Booked',b'Jumlah Penyusutan Dipesan'
b'apps/erpnext/erpnext/public/js/pos/pos.html +71',b'Qty Total',b'Jumlah Qty'
b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32',b'Against Employee Loan: {0}',b'Terhadap Pinjaman Karyawan: {0}'
b'DocType: Landed Cost Item',b'Receipt Document',b'Dokumen penerimaan'
b'DocType: Employee Education',b'School/University',b'Sekolah / Universitas'
b'DocType: Payment Request',b'Reference Details',b'Detail referensi'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +56',b'Expected Value After Useful Life must be less than Gross Purchase Amount',b'Nilai diharapkan Setelah Hidup Berguna harus kurang dari Gross Jumlah Pembelian'
b'DocType: Sales Invoice Item',b'Available Qty at Warehouse',b'Jumlah Tersedia di Gudang'
b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20',b'Billed Amount',b'Nilai Tagihan'
b'DocType: Share Transfer',b'(including)',b'(termasuk)'
b'DocType: Asset',b'Double Declining Balance',b'Ganda Saldo Menurun'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180',b'Closed order cannot be cancelled. Unclose to cancel.',b'Agar tertutup tidak dapat dibatalkan. Unclose untuk membatalkan.'
b'DocType: Student Guardian',b'Father',b'Ayah'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +627',"b""'Update Stock' cannot be checked for fixed asset sale""","b""'Pembaruan Persediaan\xe2\x80\x99 tidak dapat ditandai untuk penjualan aset tetap"""
b'DocType: Bank Reconciliation',b'Bank Reconciliation',b'Rekonsiliasi Bank'
b'DocType: Attendance',b'On Leave',b'Sedang cuti'
b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7',b'Get Updates',b'Dapatkan Perbaruan'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96',b'{0} {1}: Account {2} does not belong to Company {3}',b'{0} {1}: Akun {2} bukan milik Perusahaan {3}'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +397',b'Select at least one value from each of the attributes.',b'Pilih setidaknya satu nilai dari masing-masing atribut.'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +166',b'Material Request {0} is cancelled or stopped',b'Permintaan Material {0} dibatalkan atau dihentikan'
b'apps/erpnext/erpnext/config/hr.py +314',b'Leave Management',b'Manajemen Cuti'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +118',b'Group by Account',b'Group by Akun'
b'apps/erpnext/erpnext/education/doctype/instructor/instructor.py +21',b'Please select Employee',b'Silahkan pilih Karyawan'
b'DocType: Sales Order',b'Fully Delivered',b'Sepenuhnya Terkirim'
b'DocType: Lead',b'Lower Income',b'Penghasilan rendah'
b'DocType: Restaurant Order Entry',b'Current Order',b'Pesanan saat ini'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +196',b'Source and target warehouse cannot be same for row {0}',b'Sumber dan target gudang tidak bisa sama untuk baris {0}'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +243',"b'Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry'","b'Akun Perbedaan harus jenis rekening Aset / Kewajiban, karena Rekonsiliasi Persediaan adalah Entri Pembukaan'"
b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107',b'Disbursed Amount cannot be greater than Loan Amount {0}',b'Dicairkan Jumlah tidak dapat lebih besar dari Jumlah Pinjaman {0}'
b'apps/erpnext/erpnext/utilities/user_progress.py +176',b'Go to Programs',b'Buka Program'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +205',b'Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2}',b'Baris {0} # Jumlah alokasi {1} tidak boleh lebih besar dari jumlah yang tidak diklaim {2}'
b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89',b'Purchase Order number required for Item {0}',b'Nomor Purchase Order yang diperlukan untuk Item {0}'
b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18',"b""'From Date' must be after 'To Date'""","b""'Tanggal Mulai' harus sebelum 'Tanggal Akhir'"""
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39',b'Cannot change status as student {0} is linked with student application {1}',b'tidak dapat mengubah status sebagai mahasiswa {0} terkait dengan aplikasi mahasiswa {1}'
b'DocType: Asset',b'Fully Depreciated',b'sepenuhnya disusutkan'
b'DocType: Item Barcode',b'UPC-A',b'UPC-A'
,b'Stock Projected Qty',b'Proyeksi Jumlah Persediaan'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +444',b'Customer {0} does not belong to project {1}',b'Pelanggan {0} tidak termasuk proyek {1}'
b'DocType: Employee Attendance Tool',b'Marked Attendance HTML',b'Kehadiran ditandai HTML'
b'apps/erpnext/erpnext/utilities/activation.py +73',"b'Quotations are proposals, bids you have sent to your customers'","b'Penawaran adalah proposal, tawaran yang anda kirim kepada pelanggan'"
b'DocType: Sales Invoice',"b""Customer's Purchase Order""",b'Order Pembelian Pelanggan'
b'DocType: Consultation',b'Patient',b'Sabar'
b'apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47',b'Bypass credit check at Sales Order ',b'Cek kredit bypass di Sales Order'
b'DocType: Land Unit',b'Check if it is a hydroponic unit',b'Periksa apakah itu unit hidroponik'
b'apps/erpnext/erpnext/config/stock.py +109',b'Serial No and Batch',b'Serial dan Batch'
b'DocType: Warranty Claim',b'From Company',b'Dari Perusahaan'
b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +52',b'Sum of Scores of Assessment Criteria needs to be {0}.',b'Jumlah Skor Kriteria Penilaian perlu {0}.'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +77',b'Please set Number of Depreciations Booked',b'Silakan mengatur Jumlah Penyusutan Dipesan'
b'DocType: Supplier Scorecard Period',b'Calculations',b'Perhitungan'
b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +86',b'Value or Qty',b'Nilai atau Qty'
b'DocType: Payment Terms Template',b'Payment Terms',b'Syarat pembayaran'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +449',b'Productions Orders cannot be raised for:',b'Produksi Pesanan tidak dapat diangkat untuk:'
b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Minute',b'Menit'
b'DocType: Purchase Invoice',b'Purchase Taxes and Charges',b'Pajak Pembelian dan Biaya'
b'DocType: Chapter',b'Meetup Embed HTML',b'Meetup Embed HTML'
b'apps/erpnext/erpnext/utilities/user_progress.py +121',b'Go to Suppliers',b'Pergi ke Pemasok'
,b'Qty to Receive',b'Kuantitas untuk diterima'
b'DocType: Leave Block List',b'Leave Block List Allowed',b'Cuti Block List Diizinkan'
b'DocType: Grading Scale Interval',b'Grading Scale Interval',b'Grading Scale Interval'
b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49',b'Expense Claim for Vehicle Log {0}',b'Beban Klaim untuk Kendaraan Log {0}'
b'DocType: Sales Invoice Item',b'Discount (%) on Price List Rate with Margin',b'Discount (%) pada Price List Rate dengan Margin'
b'apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59',b'All Warehouses',b'semua Gudang'
b'DocType: Sales Partner',b'Retailer',b'Pengecer'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115',b'Credit To account must be a Balance Sheet account',b'Kredit Untuk akun harus rekening Neraca'
b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +118',b'All Supplier Types',b'Semua Jenis Supplier'
b'DocType: Donor',b'Donor',b'Penyumbang'
b'DocType: Global Defaults',b'Disable In Words',b'Nonaktifkan Dalam Kata-kata'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +60',b'Item Code is mandatory because Item is not automatically numbered',b'Item Code adalah wajib karena Item tidak secara otomatis nomor'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +98',b'Quotation {0} not of type {1}',b'Penawaran {0} bukan jenis {1}'
b'DocType: Maintenance Schedule Item',b'Maintenance Schedule Item',b'Jadwal pemeliharaan Stok Barang'
b'DocType: Sales Order',b'%  Delivered',b'% Terkirim'
b'apps/erpnext/erpnext/education/doctype/fees/fees.js +105',b'Please set the Email ID for the Student to send the Payment Request',b'Harap atur ID Email untuk Siswa untuk mengirim Permintaan Pembayaran'
b'DocType: Patient',b'Medical History',b'Riwayat kesehatan'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157',b'Bank Overdraft Account',b'Akun Overdraft Bank'
b'DocType: Patient',b'Patient ID',b'ID pasien'
b'DocType: Physician Schedule',b'Schedule Name',b'Nama Jadwal'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48',b'Make Salary Slip',b'Membuat Slip Gaji'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +840',b'Add All Suppliers',b'Tambahkan Semua Pemasok'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +94',b'Row #{0}: Allocated Amount cannot be greater than outstanding amount.',b'Baris # {0}: Alokasi Jumlah tidak boleh lebih besar dari jumlah yang terutang.'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75',b'Browse BOM',b'Telusuri BOM'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155',b'Secured Loans',b'Pinjaman Aman'
b'DocType: Purchase Invoice',b'Edit Posting Date and Time',b'Mengedit Posting Tanggal dan Waktu'
b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +101',b'Please set Depreciation related Accounts in Asset Category {0} or Company {1}',b'Silahkan mengatur Penyusutan Akun terkait Aset Kategori {0} atau Perusahaan {1}'
b'DocType: Lab Test Groups',b'Normal Range',b'Jarak normal'
b'DocType: Academic Term',b'Academic Year',b'Tahun akademik'
b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72',b'Available Selling',b'Jual Beli'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169',b'Opening Balance Equity',b'Saldo Pembukaan Ekuitas'
b'DocType: Lead',b'CRM',b'CRM'
b'DocType: Purchase Invoice',b'N',b'N'
b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175',b'Remaining',b'sisa'
b'DocType: Appraisal',b'Appraisal',b'Penilaian'
b'DocType: Purchase Invoice',b'GST Details',b'Rincian GST'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +156',b'Email sent to supplier {0}',b'Email dikirim ke pemasok {0}'
b'DocType: Item',b'Default Sales Unit of Measure',b'Unit Penjualan Default Ukur'
b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9',b'Academic Year: ',b'Tahun akademik:'
b'DocType: Opportunity',b'OPTY-',b'OPTY-'
b'apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19',b'Date is repeated',b'Tanggal diulang'
b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27',b'Authorized Signatory',b'Penandatangan yang Sah'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +64',b'Create Fees',b'Buat Biaya'
b'DocType: Project',b'Total Purchase Cost (via Purchase Invoice)',b'Total Biaya Pembelian (Purchase Invoice via)'
b'DocType: Training Event',b'Start Time',b'Waktu Mulai'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +400',b'Select Quantity',b'Pilih Kuantitas'
b'DocType: Customs Tariff Number',b'Customs Tariff Number',b'Tarif Bea Nomor'
b'DocType: Patient Appointment',b'Patient Appointment',b'Penunjukan Pasien'
b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34',b'Approving Role cannot be same as role the rule is Applicable To',b'Menyetujui Peran tidak bisa sama dengan peran aturan yang Berlaku Untuk'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +64',b'Unsubscribe from this Email Digest',b'Berhenti berlangganan dari Email Ringkasan ini'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +830',b'Get Suppliers By',b'Dapatkan Pemasok Dengan'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +173',b'{0} not found for Item {1}',b'{0} tidak ditemukan untuk Barang {1}'
b'apps/erpnext/erpnext/utilities/user_progress.py +197',b'Go to Courses',b'Pergi ke kursus'
b'DocType: Accounts Settings',b'Show Inclusive Tax In Print',b'Menunjukkan Pajak Inklusif Dalam Cetak'
b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +17',"b'Bank Account, From Date and To Date are Mandatory'","b'Rekening Bank, Dari Tanggal dan Tanggal Wajib'"
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28',b'Message Sent',b'Pesan Terkirim'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +98',b'Account with child nodes cannot be set as ledger',b'Akun dengan sub-akun tidak dapat digunakan sebagai akun buku besar'
b'DocType: C-Form',b'II',b'II'
b'DocType: Sales Invoice',"b""Rate at which Price list currency is converted to customer's base currency""",b'Tingkat di mana mata uang Daftar Harga dikonversi ke mata uang dasar pelanggan'
b'DocType: Purchase Invoice Item',b'Net Amount (Company Currency)',b'Jumlah Bersih (Perusahaan Mata Uang)'
b'DocType: Physician',b'Physician Schedules',b'Jadwal Dokter'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +215',b'Total advance amount cannot be greater than total sanctioned amount',b'Jumlah uang muka tidak boleh lebih besar dari jumlah sanksi'
b'DocType: Salary Slip',b'Hour Rate',b'Nilai per Jam'
b'DocType: Stock Settings',b'Item Naming By',b'Item Penamaan Dengan'
b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46',b'Another Period Closing Entry {0} has been made after {1}',b'Lain Periode Pendaftaran penutupan {0} telah dibuat setelah {1}'
b'DocType: Work Order',b'Material Transferred for Manufacturing',b'Bahan Ditransfer untuk Manufaktur'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +41',b'Account {0} does not exists',b'Akun {0} tidak ada'
b'DocType: Project',b'Project Type',b'Jenis proyek'
b'apps/erpnext/erpnext/projects/doctype/task/task.py +153',b'Child Task exists for this Task. You can not delete this Task.',b'Tugas Anak ada untuk Tugas ini. Anda tidak dapat menghapus tugas ini.'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48',b'DateLet',b'DateLet'
b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16',b'Either target qty or target amount is mandatory.',b'Entah Target qty atau jumlah target adalah wajib.'
b'apps/erpnext/erpnext/config/projects.py +56',b'Cost of various activities',b'Biaya berbagai kegiatan'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +60',"b'Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}'","b'Mengatur Acara untuk {0}, karena karyawan yang melekat di bawah Penjualan Orang tidak memiliki User ID {1}'"
b'DocType: Timesheet',b'Billing Details',b'Detail penagihan'
b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +163',b'Source and target warehouse must be different',b'Sumber dan gudang target harus berbeda'
b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +140',b'Payment Failed. Please check your GoCardless Account for more details',b'Pembayaran gagal. Silakan periksa Akun GoCardless Anda untuk lebih jelasnya'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101',b'Not allowed to update stock transactions older than {0}',b'Tidak diizinkan memperbarui transaksi persediaan lebih lama dari {0}'
b'DocType: BOM',b'Inspection Required',b'Inspeksi Diperlukan'
b'DocType: Purchase Invoice Item',b'PR Detail',b'PR Detil'
b'DocType: Driving License Category',b'Class',b'Kelas'
b'DocType: Sales Order',b'Fully Billed',b'Sepenuhnya Ditagih'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +426',b'Work Order cannot be raised against a Item Template',b'Work Order tidak dapat dimunculkan dengan Template Item'
b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101',b'Shipping rule only applicable for Buying',b'Aturan pengiriman hanya berlaku untuk pembelian'
b'DocType: Vital Signs',b'BMI',b'BMI'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20',b'Cash In Hand',b'Cash In Hand'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137',b'Delivery warehouse required for stock item {0}',b'Gudang pengiriman diperlukan untuk persediaan barang {0}'
b'DocType: Packing Slip',b'The gross weight of the package. Usually net weight + packaging material weight. (for print)',b'Berat kotor paket. Berat + kemasan biasanya net berat bahan. (Untuk mencetak)'
b'DocType: Assessment Plan',b'Program',b'Program'
b'DocType: Accounts Settings',b'Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts',b'Pengguna dengan peran ini diperbolehkan untuk mengatur account beku dan membuat / memodifikasi entri akuntansi terhadap rekening beku'
b'DocType: Serial No',b'Is Cancelled',b'Apakah Dibatalkan'
b'DocType: Student Group',b'Group Based On',b'Grup Berdasarkan'
b'DocType: Journal Entry',b'Bill Date',b'Tanggal Penagihan'
b'DocType: Healthcare Settings',b'Laboratory SMS Alerts',b'SMS Pemberitahuan Laboratorium'
b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20',"b'Service Item,Type,frequency and expense amount are required'","b'Layanan Item, Jenis, frekuensi dan jumlah beban yang diperlukan'"
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +45',"b'Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:'","b'Bahkan jika ada beberapa Aturan Harga dengan prioritas tertinggi, kemudian mengikuti prioritas internal diterapkan:'"
b'DocType: Plant Analysis Criteria',b'Plant Analysis Criteria',b'Kriteria Analisis Tanaman'
b'DocType: Cheque Print Template',b'Cheque Height',b'Cek Tinggi'
b'DocType: Supplier',b'Supplier Details',b'Rincian Supplier'
b'DocType: Setup Progress',b'Setup Progress',b'Setup Progress'
b'DocType: Hub Settings',b'Publish Items to Hub',b'Publikasikan Produk untuk Hub'
b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35',b'From value must be less than to value in row {0}',b'Dari nilai harus kurang dari nilai dalam baris {0}'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182',b'Wire Transfer',b'Transfer Kliring'
b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92',b'Check all',b'Periksa Semua'
,b'Issued Items Against Work Order',b'Item yang Diterbitkan Melawan Perintah Kerja'
b'DocType: Vehicle Log',b'Invoice Ref',b'faktur Ref'
b'DocType: Company',b'Default Income Account',b'Akun Pendapatan standar'
b'apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32',b'Customer Group / Customer',b'Kelompok Pelanggan / Pelanggan'
b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37',b'Unclosed Fiscal Years Profit / Loss (Credit)',b'Tertutup Fiskal Tahun Laba / Rugi (Kredit)'
b'DocType: Sales Invoice',b'Time Sheets',b'waktu Lembar'
b'DocType: Lab Test Template',b'Change In Item',b'Ubah Item'
b'DocType: Payment Gateway Account',b'Default Payment Request Message',b'Standar Pesan Permintaan Pembayaran'
b'DocType: Item Group',b'Check this if you want to show in website',b'Periksa ini jika Anda ingin menunjukkan di website'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +338',b'Balance ({0})',b'Saldo ({0})'
b'apps/erpnext/erpnext/config/accounts.py +134',b'Banking and Payments',b'Perbankan dan Pembayaran'
,b'Welcome to ERPNext',b'Selamat Datang di ERPNext'
b'apps/erpnext/erpnext/config/learn.py +102',b'Lead to Quotation',b'Prospek menuju Penawaran'
b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +34',b'Email Reminders will be sent to all parties with email contacts',b'Pengingat Email akan dikirim ke semua pihak dengan kontak email'
b'DocType: Project',b'Twice Daily',b'Dua kali sehari'
b'DocType: Patient',b'A Negative',b'Negatif'
b'apps/erpnext/erpnext/templates/includes/product_list.js +45',b'Nothing more to show.',b'Tidak lebih untuk ditampilkan.'
b'DocType: Lead',b'From Customer',b'Dari Pelanggan'
b'apps/erpnext/erpnext/demo/setup/setup_data.py +327',b'Calls',b'Panggilan'
b'apps/erpnext/erpnext/utilities/user_progress.py +143',b'A Product',b'Produk'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +207',b'Batches',b'Batches'
b'apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34',b'Make Fee Schedule',b'Jadikan Jadwal Biaya'
b'DocType: Purchase Order Item Supplied',b'Stock UOM',b'UOM Persediaan'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233',b'Purchase Order {0} is not submitted',b'Order Pembelian {0} tidak terkirim'
b'DocType: Vital Signs',b'Normal reference range for an adult is 16\xe2\x80\x9320 breaths/minute (RCP 2012)',b'Rentang referensi normal untuk orang dewasa adalah 16-20 napas / menit (RCP 2012)'
b'DocType: Customs Tariff Number',b'Tariff Number',b'tarif Nomor'
b'DocType: Work Order Item',b'Available Qty at WIP Warehouse',b'Tersedia Qty di WIP Warehouse'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +39',b'Projected',b'Proyeksi'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222',b'Serial No {0} does not belong to Warehouse {1}',b'Serial ada {0} bukan milik Gudang {1}'
b'apps/erpnext/erpnext/controllers/status_updater.py +177',b'Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0',b'Catatan: Sistem tidak akan memeriksa over-pengiriman dan over-booking untuk Item {0} kuantitas atau jumlah 0'
b'DocType: Notification Control',b'Quotation Message',b'Pesan Penawaran'
b'DocType: Employee Loan',b'Employee Loan Application',b'Karyawan Aplikasi Kredit'
b'DocType: Issue',b'Opening Date',b'Tanggal Pembukaan'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +86',b'Please save the patient first',b'Tolong simpan pasien dulu'
b'apps/erpnext/erpnext/education/api.py +80',b'Attendance has been marked successfully.',b'Kehadiran telah ditandai berhasil.'
b'DocType: Program Enrollment',b'Public Transport',b'Transportasi umum'
b'DocType: Soil Texture',b'Silt Composition (%)',b'Komposisi Silt (%)'
b'DocType: Journal Entry',b'Remark',b'Komentar'
b'DocType: Healthcare Settings',b'Avoid Confirmation',b'Hindari Konfirmasi'
b'DocType: Purchase Receipt Item',b'Rate and Amount',b'Rate dan Jumlah'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +176',b'Account Type for {0} must be {1}',b'Jenis Akun untuk {0} harus {1}'
b'DocType: Healthcare Settings',b'Default income accounts to be used if not set in Physician to book Consultation charges.',b'Akun pendapatan default yang akan digunakan jika tidak ditetapkan dalam Dokter untuk memesan biaya Konsultasi.'
b'apps/erpnext/erpnext/config/hr.py +55',b'Leaves and Holiday',b'Daun dan Liburan'
b'DocType: Education Settings',b'Current Academic Term',b'Istilah Akademik Saat Ini'
b'DocType: Sales Order',b'Not Billed',b'Tidak Ditagih'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +76',b'Both Warehouse must belong to same Company',b'Kedua Gudang harus merupakan gudang dari Perusahaan yang sama'
b'apps/erpnext/erpnext/public/js/templates/contact_list.html +34',b'No contacts added yet.',b'Tidak ada kontak belum ditambahkan.'
b'DocType: Purchase Invoice Item',b'Landed Cost Voucher Amount',b'Jumlah Nilai Voucher Landing Cost'
,b'Item Balance (Simple)',b'Item Balance (Sederhana)'
b'apps/erpnext/erpnext/config/accounts.py +17',b'Bills raised by Suppliers.',b'Tagihan diajukan oleh Pemasok.'
b'DocType: POS Profile',b'Write Off Account',b'Akun Write Off'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +215',b'Debit Note Amt',b'Catatan Debet Amt'
b'apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5',b'Discount Amount',b'Jumlah Diskon'
b'DocType: Purchase Invoice',b'Return Against Purchase Invoice',b'Retur Terhadap Faktur Pembelian'
b'DocType: Item',b'Warranty Period (in days)',b'Masa Garansi (dalam hari)'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61',b'Failed to set defaults',b'Gagal menetapkan default'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56',b'Relation with Guardian1',b'Hubungan dengan Guardian1'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +786',b'Please select BOM against item {0}',b'Silahkan pilih BOM terhadap item {0}'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18',b'Make Invoices',b'Buat Faktur'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23',b'Net Cash from Operations',b'Kas Bersih dari Operasi'
b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26',b'Item 4',b'Item 4'
b'DocType: Student Admission',b'Admission End Date',b'Pendaftaran Tanggal Akhir'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30',b'Sub-contracting',b'Sub-kontraktor'
b'DocType: Journal Entry Account',b'Journal Entry Account',b'Akun Jurnal Entri'
b'apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3',b'Student Group',b'Kelompok mahasiswa'
b'DocType: Shopping Cart Settings',b'Quotation Series',b'Seri Penawaran'
b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +57',"b'An item exists with same name ({0}), please change the item group name or rename the item'","b'Sebuah item yang ada dengan nama yang sama ({0}), silakan mengubah nama kelompok Stok Barang atau mengubah nama item'"
b'DocType: Soil Analysis Criteria',b'Soil Analysis Criteria',b'Kriteria Analisis Tanah'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2041',b'Please select customer',b'Silakan pilih pelanggan'
b'DocType: C-Form',b'I',b'saya'
b'DocType: Company',b'Asset Depreciation Cost Center',b'Asset Pusat Penyusutan Biaya'
b'DocType: Production Plan Sales Order',b'Sales Order Date',b'Tanggal Nota Penjualan'
b'DocType: Sales Invoice Item',b'Delivered Qty',b'Qty Terkirim'
b'DocType: Assessment Plan',b'Assessment Plan',b'Rencana penilaian'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +90',b'Customer {0} is created.',b'Pelanggan {0} dibuat'
b'DocType: Stock Settings',b'Limit Percent',b'batas Persen'
b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82',b' Currently no stock available in any warehouse',b'Saat ini tidak ada persediaan di gudang manapun'
,b'Payment Period Based On Invoice Date',b'Masa Pembayaran Berdasarkan Faktur Tanggal'
b'DocType: Sample Collection',b'No. of print',b'Jumlah cetak'
b'DocType: Hotel Room Reservation Item',b'Hotel Room Reservation Item',b'Item Pemesanan Kamar Hotel'
b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58',b'Missing Currency Exchange Rates for {0}',b'Hilang Kurs mata uang Tarif untuk {0}'
b'DocType: Health Insurance',b'Health Insurance Name',b'Nama Asuransi Kesehatan'
b'DocType: Assessment Plan',b'Examiner',b'Pemeriksa'
b'DocType: Student',b'Siblings',b'saudara'
b'DocType: Journal Entry',b'Stock Entry',b'Entri Persediaan'
b'DocType: Payment Entry',b'Payment References',b'Referensi pembayaran'
b'DocType: C-Form',b'C-FORM-',b'C-bentuk-'
b'DocType: Vehicle',b'Insurance Details',b'Detail asuransi'
b'DocType: Account',b'Payable',b'Hutang'
b'DocType: Share Balance',b'Share Type',b'Jenis saham'
b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113',b'Please enter Repayment Periods',b'Masukkan Periode Pembayaran'
b'apps/erpnext/erpnext/shopping_cart/cart.py +378',b'Debtors ({0})',b'Debitur ({0})'
b'DocType: Pricing Rule',b'Margin',b'Margin'
b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57',b'New Customers',b'Pelanggan baru'
b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74',b'Gross Profit %',b'Laba Kotor%'
b'DocType: Appraisal Goal',b'Weightage (%)',b'Weightage (%)'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +503',b'Change POS Profile',b'Ubah Profil POS'
b'DocType: Bank Reconciliation Detail',b'Clearance Date',b'Izin Tanggal'
b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7',b'Assessment Report',b'Laporan Penilaian'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +59',b'Gross Purchase Amount is mandatory',b'Jumlah Pembelian kotor adalah wajib'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +95',b'Company name not same',b'Nama perusahaan tidak sama'
b'DocType: Lead',b'Address Desc',b'Deskripsi Alamat'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +113',b'Party is mandatory',b'Partai adalah wajib'
b'DocType: Journal Entry',b'JV-',b'JV-'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +712',b'Rows with duplicate due dates in other rows were found: {list}',b'Baris dengan tanggal jatuh tempo duplikat pada baris lainnya ditemukan: {list}'
b'DocType: Topic',b'Topic Name',b'topik Nama'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +37',b'Atleast one of the Selling or Buying must be selected',"b'Setidaknya salah satu, Jual atau Beli harus dipilih'"
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +290',b'Select an employee to get the employee advance.',b'Pilih karyawan untuk mendapatkan uang muka karyawan.'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +56',b'Please select a valid Date',b'Silakan pilih tanggal yang valid'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +36',b'Select the nature of your business.',b'Pilih jenis bisnis anda.'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +24',b'Please setup Employee Naming System in Human Resource &gt; HR Settings',b'Silakan mengatur Sistem Penamaan Karyawan di Sumber Daya Manusia&gt; Pengaturan SDM'
b'DocType: Lab Test Template',"b'Single for results which require only a single input, result UOM and normal value \n<br>\nCompound for results which require multiple input fields with corresponding event names, result UOMs and normal values\n<br>\nDescriptive for tests which have multiple result components and corresponding result entry fields. \n<br>\nGrouped for test templates which are a group of other test templates.\n<br>\nNo Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.'","b'Single untuk hasil yang hanya memerlukan satu input saja, hasil UOM dan nilai normal <br> Senyawa untuk hasil yang membutuhkan banyak field masukan dengan nama acara yang sesuai, hasil UOM dan nilai normal <br> Deskriptif untuk tes yang memiliki beberapa komponen hasil dan bidang entri hasil yang sesuai. <br> Dikelompokkan untuk template uji yang merupakan kelompok dari template uji lainnya. <br> Tidak ada hasil untuk tes tanpa hasil. Juga, tidak ada Lab Test yang dibuat. misalnya. Sub Tes untuk hasil yang dikelompokkan.'"
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +86',b'Row #{0}: Duplicate entry in References {1} {2}',b'Baris # {0}: Entri duplikat di Referensi {1} {2}'
b'apps/erpnext/erpnext/config/manufacturing.py +57',b'Where manufacturing operations are carried.',b'Dimana operasi manufaktur dilakukan.'
b'apps/erpnext/erpnext/education/doctype/instructor/instructor.js +18',b'As Examiner',b'Sebagai pemeriksa'
b'DocType: Appointment Type',b'Default Duration',b'Durasi Default'
b'DocType: Asset Movement',b'Source Warehouse',b'Sumber Gudang'
b'DocType: Installation Note',b'Installation Date',b'Instalasi Tanggal'
b'apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js +30',b'Share Ledger',b'Berbagi Ledger'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +606',b'Row #{0}: Asset {1} does not belong to company {2}',b'Row # {0}: Aset {1} bukan milik perusahaan {2}'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206',b'Sales Invoice {0} created',b'Faktur Penjualan {0} dibuat'
b'DocType: Employee',b'Confirmation Date',b'Konfirmasi Tanggal'
b'DocType: C-Form',b'Total Invoiced Amount',b'Jumlah Total Tagihan'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +50',b'Min Qty can not be greater than Max Qty',b'Min Qty tidak dapat lebih besar dari Max Qty'
b'DocType: Soil Texture',b'Silty Clay',b'Silty Clay'
b'DocType: Account',b'Accumulated Depreciation',b'Akumulasi penyusutan'
b'DocType: Supplier Scorecard Scoring Standing',b'Standing Name',b'Nama berdiri'
b'DocType: Stock Entry',b'Customer or Supplier Details',b'Rincian Pelanggan atau Pemasok'
b'DocType: Employee Loan Application',b'Required by Date',b'Dibutuhkan oleh Tanggal'
b'DocType: Lead',b'Lead Owner',b'Pemilik Prospek'
b'DocType: Production Plan',b'Sales Orders Detail',b'Detail Pesanan Penjualan'
b'DocType: Bin',b'Requested Quantity',b'diminta Kuantitas'
b'DocType: Patient',b'Marital Status',b'Status Perkawinan'
b'DocType: Stock Settings',b'Auto Material Request',b'Permintaan Material Otomatis'
b'DocType: Delivery Note Item',b'Available Batch Qty at From Warehouse',b'Tersedia Batch Qty di Gudang Dari'
b'DocType: Customer',b'CUST-',b'CUST-'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50',b'Idevise',b'Idevise'
b'DocType: Salary Slip',b'Gross Pay - Total Deduction - Loan Repayment',b'Pay Gross - Jumlah Pengurangan - Pelunasan Pinjaman'
b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +29',b'Current BOM and New BOM can not be same',b'BOM Lancar dan New BOM tidak bisa sama'
b'apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +47',b'Salary Slip ID',b'Slip Gaji ID'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +118',b'Date Of Retirement must be greater than Date of Joining',b'Tanggal Of Pensiun harus lebih besar dari Tanggal Bergabung'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +68',b'Multiple Variants',b'Beberapa varian'
b'DocType: Sales Invoice',b'Against Income Account',b'Terhadap Akun Pendapatan'
b'apps/erpnext/erpnext/controllers/website_list_for_contact.py +117',b'{0}% Delivered',b'{0}% Terkirim'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +107',b'Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).',b'Item {0}: qty Memerintahkan {1} tidak bisa kurang dari qty minimum order {2} (didefinisikan dalam Butir).'
b'DocType: Monthly Distribution Percentage',b'Monthly Distribution Percentage',b'Bulanan Persentase Distribusi'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +49',b'Please login as another user.',b'Silahkan login sebagai pengguna lain.'
b'DocType: Daily Work Summary Group User',b'Daily Work Summary Group User',b'Pengguna Grup Ringkasan Pekerjaan Harian'
b'DocType: Territory',b'Territory Targets',b'Target Wilayah'
b'DocType: Soil Analysis',b'Ca/Mg',b'Ca / Mg'
b'DocType: Delivery Note',b'Transporter Info',b'Info Transporter'
b'apps/erpnext/erpnext/accounts/utils.py +502',b'Please set default {0} in Company {1}',b'Silahkan mengatur default {0} di Perusahaan {1}'
b'DocType: Cheque Print Template',b'Starting position from top edge',b'Mulai posisi dari tepi atas'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +33',b'Same supplier has been entered multiple times',b'pemasok yang sama telah dimasukkan beberapa kali'
b'apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152',b'Gross Profit / Loss',b'Laba Kotor / Rugi'
,b'Warehouse wise Item Balance Age and Value',b'Gudang Item yang bijak Saldo Umur dan Nilai'
b'DocType: Purchase Order Item Supplied',b'Purchase Order Item Supplied',b'Purchase Order Stok Barang Disediakan'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +94',b'Company Name cannot be Company',b'Nama perusahaan tidak dapat perusahaan'
b'apps/erpnext/erpnext/config/setup.py +27',b'Letter Heads for print templates.',b'Surat Kepala untuk mencetak template.'
b'apps/erpnext/erpnext/config/setup.py +32',b'Titles for print templates e.g. Proforma Invoice.',b'Judul untuk mencetak template misalnya Proforma Invoice.'
b'DocType: Program Enrollment',b'Walking',b'Berjalan'
b'DocType: Student Guardian',b'Student Guardian',b'Wali murid'
b'DocType: Member',b'Member Name',b'Nama anggota'
b'DocType: Stock Settings',b'Use Naming Series',b'Gunakan Seri Penamaan'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218',b'Valuation type charges can not marked as Inclusive',b'Jenis penilaian biaya tidak dapat ditandai sebagai Inklusif'
b'DocType: POS Profile',b'Update Stock',b'Perbarui Persediaan'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10',b'in the subscription',b'dalam berlangganan'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100',b'Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.',b'UOM berbeda akan menyebabkan kesalahan Berat Bersih (Total). Pastikan Berat Bersih untuk setiap barang memakai UOM yang sama.'
b'DocType: Membership',b'Payment Details',b'Rincian Pembayaran'
b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39',b'BOM Rate',b'Tingkat BOM'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +225',"b'Stopped Work Order cannot be cancelled, Unstop it first to cancel'","b'Pesanan Kerja yang Berhenti tidak dapat dibatalkan, Hapus terlebih dahulu untuk membatalkan'"
b'DocType: Asset',b'Journal Entry for Scrap',b'Jurnal masuk untuk Scrap'
b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83',b'Please pull items from Delivery Note',b'Silakan tarik item dari Pengiriman Note'
b'apps/erpnext/erpnext/accounts/utils.py +472',b'Journal Entries {0} are un-linked',b'Entri jurnal {0} un-linked'
b'apps/erpnext/erpnext/config/crm.py +92',"b'Record of all communications of type email, phone, chat, visit, etc.'","b'Catatan dari semua komunikasi email, telepon, chatting, kunjungan, dll'"
b'DocType: Supplier Scorecard Scoring Standing',b'Supplier Scorecard Scoring Standing',b'Penilai Scorecard Penilai Berdiri'
b'DocType: Manufacturer',b'Manufacturers used in Items',b'Produsen yang digunakan dalam Produk'
b'apps/erpnext/erpnext/accounts/general_ledger.py +170',b'Please mention Round Off Cost Center in Company',b'Sebutkan Putaran Off Biaya Pusat di Perusahaan'
b'DocType: Purchase Invoice',b'Terms',b'Istilah'
b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +10',b'Select Days',b'Pilih Hari'
b'DocType: Academic Term',b'Term Name',b'istilah Nama'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +332',b'Credit ({0})',b'Kredit ({0})'
b'DocType: Buying Settings',b'Purchase Order Required',b'Order Pembelian Diperlukan'
,b'Item-wise Sales History',b'Item-wise Penjualan Sejarah'
b'DocType: Expense Claim',b'Total Sanctioned Amount',b'Jumlah Total Disahkan'
b'DocType: Land Unit',b'Land Unit',b'Unit tanah'
,b'Purchase Analytics',b'Pembelian Analytics'
b'DocType: Sales Invoice Item',b'Delivery Note Item',b'Pengiriman Stok Barang Note'
b'DocType: Asset Maintenance Log',b'Task',b'Tugas'
b'DocType: Purchase Taxes and Charges',b'Reference Row #',b'Referensi Row #'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76',b'Batch number is mandatory for Item {0}',b'Nomor kumpulan adalah wajib untuk Barang {0}'
b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13',b'This is a root sales person and cannot be edited.',b'Ini adalah orang penjualan akar dan tidak dapat diedit.'
b'DocType: Salary Detail',"b""If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ""","b'Jika dipilih, nilai yang ditentukan atau dihitung dalam komponen ini tidak akan berkontribusi pada pendapatan atau deduksi. Namun, nilai itu bisa direferensikan oleh komponen lain yang bisa ditambah atau dikurangkan.'"
b'DocType: Asset Settings',b'Number of Days in Fiscal Year',b'Jumlah Hari di Tahun Anggaran'
,b'Stock Ledger',b'Buku Persediaan'
b'apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29',b'Rate: {0}',b'Tingkat: {0}'
b'DocType: Company',b'Exchange Gain / Loss Account',b'Efek Gain / Loss Akun'
b'apps/erpnext/erpnext/config/hr.py +7',b'Employee and Attendance',b'Karyawan dan Kehadiran'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +93',b'Purpose must be one of {0}',b'Tujuan harus menjadi salah satu {0}'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +100',b'Fill the form and save it',b'Isi formulir dan menyimpannya'
b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26',b'Community Forum',b'Forum Komunitas'
b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52',b'Actual qty in stock',b'Jumlah persediaan aktual'
b'DocType: Homepage',"b'URL for ""All Products""'",b'URL untuk &quot;Semua Produk&quot;'
b'DocType: Leave Application',b'Leave Balance Before Application',b'Cuti Saldo Sebelum Aplikasi'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +46',b'Send SMS',b'Kirim SMS'
b'DocType: Supplier Scorecard Criteria',b'Max Score',b'Skor Maks'
b'DocType: Cheque Print Template',b'Width of amount in word',b'Lebar jumlah dalam kata'
b'DocType: Company',b'Default Letter Head',b'Standar Surat Kepala'
b'DocType: Purchase Order',b'Get Items from Open Material Requests',b'Dapatkan Produk dari Permintaan Buka Material'
b'DocType: Hotel Room Amenity',b'Billable',b'Dapat ditagih'
b'DocType: Lab Test Template',b'Standard Selling Rate',b'Standard Jual Tingkat'
b'DocType: Account',b'Rate at which this tax is applied',b'Tingkat di mana pajak ini diterapkan'
b'DocType: Cash Flow Mapper',b'Section Name',b'nama bagian'
b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +77',b'Reorder Qty',b'Susun ulang Qty'
b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28',b'Current Job Openings',b'Job Openings saat'
b'DocType: Company',b'Stock Adjustment Account',b'Penyesuaian Akun Persediaan'
b'apps/erpnext/erpnext/public/js/payment/pos_payment.html +17',b'Write Off',b'Mencoret'
b'DocType: Patient Service Unit',b'Allow Overlap',b'Izinkan Tumpang Tindih'
b'DocType: Timesheet Detail',b'Operation ID',b'ID Operasi'
b'DocType: Employee',"b'System User (login) ID. If set, it will become default for all HR forms.'","b'Pengguna Sistem (login) ID. Jika diset, itu akan menjadi default untuk semua bentuk HR.'"
b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16',b'{0}: From {1}',b'{0}: Dari {1}'
b'DocType: Task',b'depends_on',b'tergantung pada'
b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +60',b'Queued for updating latest price in all Bill of Materials. It may take a few minutes.',"b'Diantrikan untuk memperbaharui harga terakhir di ""Bill of Material"". Akan memakan waktu beberapa menit.'"
b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26',"b""Name of new Account. Note: Please don't create accounts for Customers and Suppliers""",b'Nama Akun baru. Catatan: Jangan membuat akun untuk Pelanggan dan Pemasok'
b'apps/erpnext/erpnext/config/setup.py +37',b'Country wise default Address Templates',b'Negara bijaksana Alamat bawaan Template'
b'DocType: Water Analysis',b'Appearance',b'Penampilan'
b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70',b'Avg. Buying Price List Rate',b'Rata-rata Tarif Daftar Harga Beli'
b'DocType: Sales Order Item',b'Supplier delivers to Customer',b'Pemasok mengirim ke Pelanggan'
b'apps/erpnext/erpnext/config/non_profit.py +23',b'Member information.',b'Informasi anggota'
b'apps/erpnext/erpnext/utilities/bot.py +34',b'[{0}](#Form/Item/{0}) is out of stock',b'[{0}] (#Formulir/Barang/{0}) tidak tersedia'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +58',b'Asset Maintenance',b'Pemeliharaan Aset'
,b'Sales Payment Summary',b'Ringkasan Pembayaran Penjualan'
b'DocType: Restaurant',b'Restaurant',b'Restoran'
b'apps/erpnext/erpnext/accounts/party.py +320',b'Due / Reference Date cannot be after {0}',b'Karena / Referensi Tanggal tidak boleh setelah {0}'
b'apps/erpnext/erpnext/config/setup.py +51',b'Data Import and Export',b'Data Impor dan Ekspor'
b'DocType: Patient',b'Account Details',b'Rincian Account'
b'DocType: Crop',b'Materials Required',b'Bahan yang dibutuhkan'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76',b'No students Found',b'Tidak ada siswa Ditemukan'
b'DocType: Medical Department',b'Medical Department',b'Departemen Kesehatan'
b'DocType: Supplier Scorecard Scoring Criteria',b'Supplier Scorecard Scoring Criteria',b'Kriteria penilaian scorecard pemasok'
b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55',b'Invoice Posting Date',b'Faktur Posting Tanggal'
b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25',b'Sell',b'Menjual'
b'DocType: Purchase Invoice',b'Rounded Total',b'Rounded Jumlah'
b'DocType: Product Bundle',b'List items that form the package.',b'Daftar item yang membentuk paket.'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +39',b'Not permitted. Please disable the Test Template',b'Tidak diperbolehkan. Nonaktifkan Template Uji'
b'apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26',b'Percentage Allocation should be equal to 100%',b'Persentase Alokasi harus sama dengan 100%'
b'DocType: Crop Cycle',b'Linked Land Unit',b'Linked Land Unit'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584',b'Please select Posting Date before selecting Party',b'Silakan pilih Posting Tanggal sebelum memilih Partai'
b'DocType: Program Enrollment',b'School House',b'Asrama Sekolah'
b'DocType: Serial No',b'Out of AMC',b'Dari AMC'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +82',b'Number of Depreciations Booked cannot be greater than Total Number of Depreciations',b'Jumlah Penyusutan Memesan tidak dapat lebih besar dari total jumlah Penyusutan'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47',b'Make Maintenance Visit',b'Membuat Maintenance Visit'
b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +215',b'Please contact to the user who have Sales Master Manager {0} role',b'Silahkan hubungi untuk pengguna yang memiliki penjualan Guru Manajer {0} peran'
b'DocType: Company',b'Default Cash Account',b'Standar Rekening Kas'
b'apps/erpnext/erpnext/config/accounts.py +62',b'Company (not Customer or Supplier) master.',b'Perusahaan (bukan Pelanggan atau Pemasok) Utama.'
b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6',b'This is based on the attendance of this Student',b'Hal ini didasarkan pada kehadiran mahasiswa ini'
b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +178',b'No Students in',b'Tidak ada siswa'
b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +179',b'Add more items or open full form',b'Menambahkan item atau buka formulir selengkapnya'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212',b'Delivery Notes {0} must be cancelled before cancelling this Sales Order',b'Catatan pengiriman {0} harus dibatalkan sebelum membatalkan Sales Order ini'
b'apps/erpnext/erpnext/utilities/user_progress.py +259',b'Go to Users',b'Buka Pengguna'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85',b'Paid amount + Write Off Amount can not be greater than Grand Total',b'Jumlah yang dibayarkan + Write Off Jumlah tidak bisa lebih besar dari Grand Total'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78',b'{0} is not a valid Batch Number for Item {1}',b'{0} tidak Nomor Batch berlaku untuk Stok Barang {1}'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +130',b'Note: There is not enough leave balance for Leave Type {0}',b'Catatan: Tidak ada saldo cuti cukup bagi Leave Type {0}'
b'apps/erpnext/erpnext/regional/india/utils.py +16',b'Invalid GSTIN or Enter NA for Unregistered',b'GSTIN tidak valid atau Enter NA untuk tidak terdaftar'
b'DocType: Training Event',b'Seminar',b'Seminar'
b'DocType: Program Enrollment Fee',b'Program Enrollment Fee',b'Program Pendaftaran Biaya'
b'DocType: Item',b'Supplier Items',b'Supplier Produk'
b'DocType: Opportunity',b'Opportunity Type',b'Peluang Type'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16',b'New Company',b'Perusahaan Baru'
b'apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17',b'Transactions can only be deleted by the creator of the Company',b'Transaksi hanya dapat dihapus oleh pencipta Perusahaan'
b'apps/erpnext/erpnext/accounts/general_ledger.py +21',b'Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.',b'Jumlah yang salah dari General Ledger Entries ditemukan. Anda mungkin telah memilih Account salah dalam transaksi.'
b'DocType: Employee',b'Prefered Contact Email',b'Email Kontak Utama'
b'DocType: Cheque Print Template',b'Cheque Width',b'Lebar Cek'
b'DocType: Selling Settings',b'Validate Selling Price for Item against Purchase Rate or Valuation Rate',b'Memvalidasi Harga Jual untuk Item terhadap Purchase Rate atau Tingkat Penilaian'
b'DocType: Fee Schedule',b'Fee Schedule',b'Jadwal biaya'
b'DocType: Hub Settings',b'Publish Availability',b'Publikasikan Ketersediaan'
b'DocType: Company',b'Create Chart Of Accounts Based On',b'Buat Bagan Of Account Berbasis Pada'
b'apps/erpnext/erpnext/projects/doctype/task/task.js +91',b'Cannot convert it to non-group. Child Tasks exist.',b'Tidak dapat mengubahnya menjadi non-grup. Tugas Anak ada.'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +112',b'Date of Birth cannot be greater than today.',b'Tanggal Lahir tidak dapat lebih besar dari saat ini.'
,b'Stock Ageing',b'Usia Persediaan'
b'apps/erpnext/erpnext/education/doctype/student/student.py +40',b'Student {0} exist against student applicant {1}',b'Mahasiswa {0} ada terhadap pemohon mahasiswa {1}'
b'DocType: Purchase Invoice',b'Rounding Adjustment (Company Currency)',b'Penyesuaian Pembulatan (Mata Uang Perusahaan)'
b'apps/erpnext/erpnext/projects/doctype/task/task.js +39',b'Timesheet',b'Timesheet'
b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +243',b'Batch: ',b'Batch:'
b'DocType: Volunteer',b'Afternoon',b'Sore'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +258',"b""{0} '{1}' is disabled""","b""{0} '{1}' dinonaktifkan"""
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13',b'Set as Open',b'Ditetapkan sebagai Terbuka'
b'DocType: Cheque Print Template',b'Scanned Cheque',b'Cek Terpindai'
b'DocType: Notification Control',b'Send automatic emails to Contacts on Submitting transactions.',b'Kirim email otomatis ke Kontak untuk Pengiriman transaksi.'
b'DocType: Timesheet',b'Total Billable Amount',b'Jumlah Total Ditagih'
b'DocType: Customer',b'Credit Limit and Payment Terms',b'Batas Kredit dan Persyaratan Pembayaran'
b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20',b'Item 3',b'Butir 3'
b'apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6',b'Order Entry',b'Pesanan masuk'
b'DocType: Purchase Order',b'Customer Contact Email',b'Email Kontak Pelanggan'
b'DocType: Warranty Claim',b'Item and Warranty Details',b'Item dan Garansi Detail'
b'DocType: Chapter',b'Chapter Members',b'Anggota Bab'
b'DocType: Sales Team',b'Contribution (%)',b'Kontribusi (%)'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +102',"b""Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified""","b""Catatan: Entry Pembayaran tidak akan dibuat karena 'Cash atau Rekening Bank tidak ditentukan"""
b'apps/erpnext/erpnext/projects/doctype/project/project.py +70',b'Project {0} already exists',b'Project {0} sudah ada'
b'DocType: Medical Department',b'Nursing User',b'Pengguna perawatan'
b'DocType: Plant Analysis',b'Plant Analysis Criterias',b'Kriteria Analisis Tanaman'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239',b'Responsibilities',b'Tanggung Jawab'
b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125',b'Validity period of this quotation has ended.',b'Masa berlaku dari kutipan ini telah berakhir.'
b'DocType: Expense Claim Account',b'Expense Claim Account',b'Akun Beban Klaim'
b'DocType: Accounts Settings',b'Allow Stale Exchange Rates',b'Biarkan nilai tukar basi'
b'DocType: Sales Person',b'Sales Person Name',b'Penjualan Person Nama'
b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54',b'Please enter atleast 1 invoice in the table',b'Entrikan minimal 1 faktur dalam tabel'
b'apps/erpnext/erpnext/utilities/user_progress.py +247',b'Add Users',b'Tambah Pengguna'
b'DocType: POS Item Group',b'Item Group',b'Item Grup'
b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +16',b'Student Group: ',b'Kelompok Mahasiswa:'
b'DocType: Item',b'Safety Stock',b'Persediaan Aman'
b'DocType: Healthcare Settings',b'Healthcare Settings',b'Pengaturan Kesehatan'
b'apps/erpnext/erpnext/projects/doctype/task/task.py +54',b'Progress % for a task cannot be more than 100.',b'Kemajuan% untuk tugas tidak bisa lebih dari 100.'
b'DocType: Stock Reconciliation Item',b'Before reconciliation',b'Sebelum rekonsiliasi'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12',b'To {0}',b'Untuk {0}'
b'DocType: Purchase Invoice',b'Taxes and Charges Added (Company Currency)',b'Pajak dan Biaya Ditambahkan (Perusahaan Mata Uang)'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +476',b'Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable',b'Item Pajak Row {0} harus memiliki akun Pajak jenis atau Penghasilan atau Beban atau Dibebankan'
b'DocType: Sales Order',b'Partly Billed',b'Sebagian Ditagih'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +43',b'Item {0} must be a Fixed Asset Item',b'Item {0} harus menjadi Asset barang Tetap'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +372',b'Make Variants',b'Buatlah Varian'
b'DocType: Item',b'Default BOM',b'BOM Standar'
b'DocType: Project',b'Total Billed Amount (via Sales Invoices)',b'Total Jumlah Bills (via Faktur Penjualan)'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +118',b'Debit Note Amount',b'Jumlah Catatan Debet'
b'DocType: Project Update',b'Not Updated',b'Tidak diperbarui'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +106',"b'There are inconsistencies between the rate, no of shares and the amount calculated'","b'Ada ketidakkonsistenan antara tingkat, tidak ada saham dan jumlah yang dihitung'"
b'apps/erpnext/erpnext/setup/doctype/company/company.js +89',b'Please re-type company name to confirm',b'Mohon tipe nama perusahaan untuk mengkonfirmasi'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +216',b'Total Outstanding Amt',b'Jumlah Posisi Amt'
b'DocType: Journal Entry',b'Printing Settings',b'Pengaturan pencetakan'
b'DocType: Employee Advance',b'Advance Account',b'Uang muka'
b'DocType: Job Offer',b'Job Offer Terms',b'Persyaratan Penawaran Pekerjaan'
b'DocType: Sales Invoice',b'Include Payment (POS)',b'Sertakan Pembayaran (POS)'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292',b'Total Debit must be equal to Total Credit. The difference is {0}',b'Jumlah Debit harus sama dengan total kredit. Perbedaannya adalah {0}'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11',b'Automotive',b'Otomotif'
b'DocType: Vehicle',b'Insurance Company',b'Perusahaan asuransi'
b'DocType: Asset Category Account',b'Fixed Asset Account',b'Akun Aset Tetap'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +414',b'Variable',b'Variabel'
b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47',b'From Delivery Note',b'Dari Delivery Note'
b'DocType: Chapter',b'Members',b'Anggota'
b'DocType: Student',b'Student Email Address',b'Alamat Email Siswa'
b'DocType: Item',b'Hub Warehouse',b'Gudang Hub'
b'DocType: Assessment Plan',b'From Time',b'Dari Waktu'
b'DocType: Hotel Settings',b'Hotel Settings',b'Pengaturan Hotel'
b'apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12',b'In Stock: ',b'Persediaan:'
b'DocType: Notification Control',b'Custom Message',b'Custom Pesan'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33',b'Investment Banking',b'Perbankan Investasi'
b'DocType: Purchase Invoice',b'input',b'memasukkan'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79',b'Cash or Bank Account is mandatory for making payment entry',b'Kas atau Rekening Bank wajib untuk membuat entri pembayaran'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54',b'Student Address',b'Alamat siswa'
b'DocType: Purchase Invoice',b'Price List Exchange Rate',b'Daftar Harga Tukar'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +251',b'Account Number {0} already used in account {1}',b'Nomor Akun {0} sudah digunakan di akun {1}'
b'DocType: GoCardless Mandate',b'Mandate',b'Mandat'
b'DocType: POS Profile',b'POS Profile Name',b'Nama Profil POS'
b'DocType: Hotel Room Reservation',b'Booked',b'Memesan'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45',b'CompAuxLib',b'CompAuxLib'
b'DocType: Purchase Invoice Item',b'Rate',b'Harga'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104',b'Intern',b'Menginternir'
b'DocType: Delivery Stop',b'Address Name',b'Nama alamat'
b'DocType: Stock Entry',b'From BOM',b'Dari BOM'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +639',b'Splitting {0} units of {1}',b'Memisahkan {0} unit dari {1}'
b'DocType: Assessment Code',b'Assessment Code',b'Kode penilaian'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73',b'Basic',b'Dasar'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94',b'Stock transactions before {0} are frozen',b'Transaksi persediaan sebelum {0} dibekukan'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219',"b""Please click on 'Generate Schedule'""","b""Silahkan klik 'Menghasilkan Jadwal'"""
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122',b'Reference No is mandatory if you entered Reference Date',b'Referensi ada adalah wajib jika Anda memasukkan Referensi Tanggal'
b'DocType: Bank Reconciliation Detail',b'Payment Document',b'Dokumen pembayaran'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37',b'Error evaluating the criteria formula',b'Kesalahan dalam mengevaluasi rumus kriteria'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +115',b'Date of Joining must be greater than Date of Birth',b'Tanggal Bergabung harus lebih besar dari Tanggal Lahir'
b'DocType: Salary Slip',b'Salary Structure',b'Struktur Gaji'
b'DocType: Account',b'Bank',b'Bank'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9',b'Airline',b'Maskapai Penerbangan'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +853',b'Issue Material',b'Isu Material'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3',b'An error occured while creating recurring',b'Terjadi kesalahan saat membuat berulang'
b'DocType: Material Request Item',b'For Warehouse',b'Untuk Gudang'
b'DocType: Employee',b'Offer Date',b'Penawaran Tanggal'
b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33',b'Quotations',b'Penawaran'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +735',b'You are in offline mode. You will not be able to reload until you have network.',b'Anda berada dalam mode offline. Anda tidak akan dapat memuat sampai Anda memiliki jaringan.'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47',b'No Student Groups created.',b'Tidak Grup Pelajar dibuat.'
b'DocType: Purchase Invoice Item',b'Serial No',b'Serial ada'
b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119',b'Monthly Repayment Amount cannot be greater than Loan Amount',b'Bulanan Pembayaran Jumlah tidak dapat lebih besar dari Jumlah Pinjaman'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143',b'Please enter Maintaince Details first',b'Cukup masukkan Maintaince Detail terlebih dahulu'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56',b'Row #{0}: Expected Delivery Date cannot be before Purchase Order Date',b'Baris # {0}: Tanggal Pengiriman yang Diharapkan tidak boleh sebelum Tanggal Pemesanan Pembelian'
b'DocType: Purchase Invoice',b'Print Language',b'cetak Bahasa'
b'DocType: Salary Slip',b'Total Working Hours',b'Jumlah Jam Kerja'
b'DocType: Sales Invoice',b'Customer PO Details',b'Rincian PO Pelanggan'
b'DocType: Subscription',b'Next Schedule Date',b'Jadwal Jadwal Berikutnya'
b'DocType: Stock Entry',b'Including items for sub assemblies',b'Termasuk item untuk sub rakitan'
b'DocType: Opening Invoice Creation Tool Item',b'Temporary Opening Account',b'Rekening Pembukaan Sementara'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1964',b'Enter value must be positive',b'Masukkan nilai harus positif'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +446',b'All Territories',b'Semua Wilayah'
b'apps/erpnext/erpnext/projects/doctype/task/task_tree.js +49',b'Add Multiple Tasks',b'Tambahkan Beberapa Tugas'
b'DocType: Purchase Invoice',b'Items',b'Items'
b'apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +34',b'Student is already enrolled.',b'Mahasiswa sudah terdaftar.'
b'DocType: Fiscal Year',b'Year Name',b'Nama Tahun'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +241',b'There are more holidays than working days this month.',b'Ada lebih dari hari kerja libur bulan ini.'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +78',b'PDC/LC Ref',b'PDC / LC Ref'
b'DocType: Product Bundle Item',b'Product Bundle Item',b'Barang Bundel Produk'
b'DocType: Sales Partner',b'Sales Partner Name',b'Penjualan Mitra Nama'
b'apps/erpnext/erpnext/hooks.py +136',b'Request for Quotations',b'Permintaan Kutipan'
b'DocType: Payment Reconciliation',b'Maximum Invoice Amount',b'Maksimum Faktur Jumlah'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50',b'Montantdevise',b'Montantdevise'
b'apps/erpnext/erpnext/healthcare/setup.py +210',b'Haematology',b'Hematologi'
b'DocType: Normal Test Items',b'Normal Test Items',b'Item Uji Normal'
b'DocType: Student Language',b'Student Language',b'Bahasa siswa'
b'apps/erpnext/erpnext/config/selling.py +23',b'Customers',b'Pelanggan'
b'DocType: Cash Flow Mapping',b'Is Working Capital',b'Apakah Modal Kerja'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24',b'Order/Quot %',b'Order / Kuot%'
b'apps/erpnext/erpnext/config/healthcare.py +25',b'Record Patient Vitals',b'Catat Pasien Vitals'
b'DocType: Fee Schedule',b'Institution',b'Lembaga'
b'DocType: Asset',b'Partially Depreciated',b'sebagian disusutkan'
b'DocType: Issue',b'Opening Time',b'Membuka Waktu'
b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +89',b'From and To dates required',b'Dari dan Untuk tanggal yang Anda inginkan'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46',b'Securities & Commodity Exchanges',b'Efek & Bursa Komoditi'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +689',"b""Default Unit of Measure for Variant '{0}' must be same as in Template '{1}'""",b'Standar Satuan Ukur untuk Variant &#39;{0}&#39; harus sama seperti di Template &#39;{1}&#39;'
b'DocType: Shipping Rule',b'Calculate Based On',b'Hitung Berbasis On'
b'DocType: Delivery Note Item',b'From Warehouse',b'Dari Gudang'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59',b'No employees for the mentioned criteria',b'Tidak ada karyawan untuk kriteria tersebut'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +955',b'No Items with Bill of Materials to Manufacture',b'Tidak ada Item dengan Bill of Material untuk Industri'
b'DocType: Hotel Settings',b'Default Customer',b'Pelanggan default'
b'DocType: Assessment Plan',b'Supervisor Name',b'Nama pengawas'
b'DocType: Healthcare Settings',b'Do not confirm if appointment is created for the same day',b'Jangan mengkonfirmasi jika janji dibuat untuk hari yang sama'
b'DocType: Program Enrollment Course',b'Program Enrollment Course',b'Kursus Pendaftaran Program'
b'DocType: Purchase Taxes and Charges',b'Valuation and Total',b'Penilaian dan Total'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11',b'Scorecards',b'Scorecard'
b'DocType: Tax Rule',b'Shipping City',b'Pengiriman Kota'
b'DocType: Notification Control',b'Customize the Notification',b'Sesuaikan Pemberitahuan'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24',b'Cash Flow from Operations',b'Arus Kas dari Operasi'
b'DocType: Purchase Invoice',b'Shipping Rule',b'Aturan Pengiriman'
b'DocType: Patient Relation',b'Spouse',b'Pasangan'
b'DocType: Lab Test Groups',b'Add Test',b'Tambahkan Test'
b'DocType: Manufacturer',b'Limited to 12 characters',b'Terbatas untuk 12 karakter'
b'DocType: Journal Entry',b'Print Heading',b'Cetak Pos'
b'apps/erpnext/erpnext/config/stock.py +146',b'Delivery Trip service tours to customers.',b'Pengiriman Trip service tours ke pelanggan.'
b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57',b'Total cannot be zero',b'Jumlah tidak boleh nol'
b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16',"b""'Days Since Last Order' must be greater than or equal to zero""","b""'Hari Sejak Pesanan Terakhir' harus lebih besar dari atau sama dengan nol"""
b'DocType: Plant Analysis Criteria',b'Maximum Permissible Value',b'Nilai Maksimum yang Diijinkan'
b'DocType: Journal Entry Account',b'Employee Advance',b'Uang muka karyawan'
b'DocType: Payroll Entry',b'Payroll Frequency',b'Payroll Frekuensi'
b'DocType: Lab Test Template',b'Sensitivity',b'Kepekaan'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +941',b'Raw Material',b'Bahan Baku'
b'DocType: Leave Application',b'Follow via Email',b'Ikuti via Email'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55',b'Plants and Machineries',b'Tanaman dan Mesin'
b'DocType: Purchase Taxes and Charges',b'Tax Amount After Discount Amount',b'Jumlah pajak Setelah Diskon Jumlah'
b'DocType: Daily Work Summary Settings',b'Daily Work Summary Settings',b'Pengaturan Kerja Ringkasan Harian'
b'apps/erpnext/erpnext/controllers/buying_controller.py +447',b'Please enter Reqd by Date',b'Masukkan Reqd menurut Tanggal'
b'DocType: Payment Entry',b'Internal Transfer',b'internal transfer'
b'DocType: Asset Maintenance',b'Maintenance Tasks',b'Tugas pemeliharaan'
b'apps/erpnext/erpnext/setup/doctype/territory/territory.py +19',b'Either target qty or target amount is mandatory',b'Entah sasaran qty atau jumlah target adalah wajib'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366',b'Please select Posting Date first',b'Silakan pilih Posting Tanggal terlebih dahulu'
b'apps/erpnext/erpnext/public/js/account_tree_grid.js +209',b'Opening Date should be before Closing Date',b'Tanggal Pembukaan harus sebelum Tanggal Penutupan'
b'DocType: Leave Control Panel',b'Carry Forward',b'Carry Teruskan'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30',b'Cost Center with existing transactions can not be converted to ledger',b'Biaya Center dengan transaksi yang ada tidak dapat dikonversi ke buku'
b'DocType: Department',b'Days for which Holidays are blocked for this department.',b'Hari yang Holidays diblokir untuk departemen ini.'
b'DocType: GoCardless Mandate',b'ERPNext Integrations',b'ERPNext Integrasi'
b'DocType: Crop Cycle',b'Detected Disease',b'Penyakit Terdeteksi'
,b'Produced',b'Diproduksi'
b'DocType: Item',b'Item Code for Suppliers',b'Item Code untuk Supplier'
b'DocType: Issue',b'Raised By (Email)',b'Dimunculkan Oleh (Email)'
b'DocType: Training Event',b'Trainer Name',b'Nama pelatih'
b'DocType: Mode of Payment',b'General',b'Umum'
b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28',b'Last Communication',b'Komunikasi terakhir'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +372',"b""Cannot deduct when category is for 'Valuation' or 'Valuation and Total'""","b""Tidak bisa mengurangi ketika kategori adalah untuk 'Penilaian' atau 'Penilaian dan Total'"""
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +234',b'Serial Nos Required for Serialized Item {0}',b'Nomor Seri Diperlukan untuk Barang Bernomor Seri {0}'
b'apps/erpnext/erpnext/config/accounts.py +144',b'Match Payments with Invoices',b'Pembayaran pertandingan dengan Faktur'
b'DocType: Journal Entry',b'Bank Entry',b'Entri Bank'
b'DocType: Authorization Rule',b'Applicable To (Designation)',b'Berlaku Untuk (Penunjukan)'
,b'Profitability Analysis',b'Analisis profitabilitas'
b'DocType: Fees',b'Student Email',b'Email Siswa'
b'DocType: Supplier',b'Prevent POs',b'Mencegah PO'
b'DocType: Patient',"b'Allergies, Medical and Surgical History'","b'Alergi, Riwayat Medis dan Bedah'"
b'apps/erpnext/erpnext/templates/generators/item.html +77',b'Add to Cart',b'Tambahkan ke Keranjang Belanja'
b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28',b'Group By',b'Kelompok Dengan'
b'DocType: Guardian',b'Interests',b'minat'
b'apps/erpnext/erpnext/config/accounts.py +298',b'Enable / disable currencies.',b'Mengaktifkan / menonaktifkan mata uang.'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +105',b'Dr {0} on Half day Leave on {1}',b'Dr {0} pada Setengah Hari di hari {1}'
b'DocType: Production Plan',b'Get Material Request',b'Dapatkan Material Permintaan'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111',b'Postal Expenses',b'Beban pos'
b'apps/erpnext/erpnext/controllers/trends.py +19',b'Total(Amt)',b'Total (Amt)'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26',b'Entertainment & Leisure',b'Hiburan & Kenyamanan'
,b'Item Variant Details',b'Rincian Item Variant'
b'DocType: Quality Inspection',b'Item Serial No',b'Item Serial No'
b'apps/erpnext/erpnext/utilities/activation.py +135',b'Create Employee Records',b'Buat Rekaman Karyawan'
b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Present',b'Total Hadir'
b'apps/erpnext/erpnext/config/accounts.py +105',b'Accounting Statements',b'Laporan akuntansi'
b'DocType: Drug Prescription',b'Hour',b'Jam'
b'DocType: Restaurant Order Entry',b'Last Sales Invoice',b'Faktur penjualan terakhir'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +788',b'Please select Qty against item {0}',b'Silakan pilih Qty terhadap item {0}'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29',b'New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt',b'No. Seri baru tidak dapat memiliki Gudang. Gudang harus diatur oleh Entri Persediaan atau Nota Pembelian'
b'DocType: Lead',b'Lead Type',b'Jenis Prospek'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +114',b'You are not authorized to approve leaves on Block Dates',b'Anda tidak berwenang untuk menyetujui cuti di Blok Tanggal'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +394',b'All these items have already been invoiced',b'Semua Stok Barang-Stok Barang tersebut telah ditagih'
b'DocType: Company',b'Monthly Sales Target',b'Target Penjualan Bulanan'
b'apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37',b'Can be approved by {0}',b'Dapat disetujui oleh {0}'
b'DocType: Hotel Room',b'Hotel Room Type',b'Tipe kamar hotel'
b'DocType: Item',b'Default Material Request Type',b'Default Bahan Jenis Permintaan'
b'DocType: Supplier Scorecard',b'Evaluation Period',b'Periode Evaluasi'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13',b'Unknown',b'tidak diketahui'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +954',b'Work Order not created',b'Perintah Kerja tidak dibuat'
b'DocType: Shipping Rule',b'Shipping Rule Conditions',b'Aturan Pengiriman Kondisi'
b'DocType: Purchase Invoice',b'Export Type',b'Jenis ekspor'
b'DocType: Salary Slip Loan',b'Salary Slip Loan',b'Pinjaman Saldo Gaji'
b'DocType: BOM Update Tool',b'The new BOM after replacement',b'The BOM baru setelah penggantian'
,b'Point of Sale',b'Point of Sale'
b'DocType: Payment Entry',b'Received Amount',b'menerima Jumlah'
b'DocType: Patient',b'Widow',b'Janda'
b'DocType: GST Settings',b'GSTIN Email Sent On',b'Email GSTIN Terkirim Pada'
b'DocType: Program Enrollment',b'Pick/Drop by Guardian',b'Pick / Drop oleh Guardian'
b'DocType: Crop',b'Planting UOM',b'Menanam UOM'
b'DocType: Account',b'Tax',b'PPN'
b'apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45',b'Not Marked',b'tidak Ditandai'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1',b'Opening Invoices Summary',b'Membuka Faktur Ringkasan'
b'DocType: Education Settings',b'Education Manager',b'Manajer Pendidikan'
b'DocType: Crop Cycle',b'The minimum length between each plant in the field for optimum growth',b'Panjang minimum antara masing-masing pabrik di lapangan untuk pertumbuhan optimum'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152',"b'Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry'","b'Kumpulan Barang {0} tidak dapat diperbarui menggunakan Rekonsiliasi Persediaan, gunakan Entri Persediaan'"
b'DocType: Quality Inspection',b'Report Date',b'Tanggal Laporan'
b'DocType: Student',b'Middle Name',b'Nama tengah'
b'DocType: C-Form',b'Invoices',b'Faktur'
b'DocType: Water Analysis',b'Type of Sample',b'Jenis Sampel'
b'DocType: Batch',b'Source Document Name',b'Nama dokumen sumber'
b'DocType: Production Plan',b'Get Raw Materials For Production',b'Dapatkan Bahan Baku untuk Produksi'
b'DocType: Job Opening',b'Job Title',b'Jabatan'
b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84',"b'{0} indicates that {1} will not provide a quotation, but all items \\\n\t\t\t\t\thave been quoted. Updating the RFQ quote status.'","b'{0} menunjukkan bahwa {1} tidak akan memberikan kutipan, namun semua item \\ telah dikutip. Memperbarui status kutipan RFQ.'"
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1026',b'Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.',b'Sampel Maksimum - {0} telah disimpan untuk Batch {1} dan Item {2} di Batch {3}.'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +125',b'Please Set Supplier Type in Buying Settings.',b'Harap Tetapkan Jenis Supplier di Setelan Pembelian.'
b'DocType: Manufacturing Settings',b'Update BOM Cost Automatically',b'Perbarui Biaya BOM secara otomatis'
b'DocType: Lab Test',b'Test Name',b'Nama uji'
b'apps/erpnext/erpnext/utilities/activation.py +99',b'Create Users',b'Buat Pengguna'
b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Gram',b'Gram'
b'DocType: Supplier Scorecard',b'Per Month',b'Per bulan'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +433',b'Quantity to Manufacture must be greater than 0.',b'Kuantitas untuk Produksi harus lebih besar dari 0.'
b'DocType: Asset Settings',b'Calculate Prorated Depreciation Schedule Based on Fiscal Year',b'Hitung Jadwal Depresiasi Prorata Berdasarkan Tahun Anggaran'
b'apps/erpnext/erpnext/config/maintenance.py +17',b'Visit report for maintenance call.',b'Kunjungi laporan untuk panggilan pemeliharaan.'
b'DocType: Stock Entry',b'Update Rate and Availability',b'Perbarui Hitungan dan Ketersediaan'
b'DocType: Stock Settings',b'Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.',b'Persentase Anda diijinkan untuk menerima atau memberikan lebih terhadap kuantitas memerintahkan. Misalnya: Jika Anda telah memesan 100 unit. dan Tunjangan Anda adalah 10% maka Anda diperbolehkan untuk menerima 110 unit.'
b'DocType: POS Customer Group',b'Customer Group',b'Kelompok Pelanggan'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +217',b'Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order # {3}. Please update operation status via Time Logs',b'Baris # {0}: Operasi {1} tidak selesai untuk {2} qty barang jadi di Perintah Kerja # {3}. Harap perbarui status operasi melalui Log Waktu'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +128',b'New Batch ID (Optional)',b'ID Batch Baru (Opsional)'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201',b'Expense account is mandatory for item {0}',b'Rekening pengeluaran adalah wajib untuk item {0}'
b'DocType: BOM',b'Website Description',b'Website Description'
b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +47',b'Net Change in Equity',b'Perubahan Bersih Ekuitas'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +220',b'Please cancel Purchase Invoice {0} first',b'Batalkan Purchase Invoice {0} pertama'
b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43',"b'Email Address must be unique, already exists for {0}'","b'Alamat Email harus unik, sudah ada untuk {0}'"
b'DocType: Serial No',b'AMC Expiry Date',b'Tanggal Kadaluarsa AMC'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +880',b'Receipt',b'Penerimaan'
,b'Sales Register',b'Daftar Penjualan'
b'DocType: Daily Work Summary Group',b'Send Emails At',b'Kirim Email pada'
b'DocType: Quotation',b'Quotation Lost Reason',b'Alasan Kalah Penawaran'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +381',b'Transaction reference no {0} dated {1}',b'referensi transaksi tidak ada {0} tertanggal {1}'
b'apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5',b'There is nothing to edit.',b'Tidak ada yang mengedit.'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116',b'Summary for this month and pending activities',b'Ringkasan untuk bulan ini dan kegiatan yang tertunda'
b'apps/erpnext/erpnext/utilities/user_progress.py +248',"b'Add users to your organization, other than yourself.'","b'Tambahkan pengguna ke organisasi Anda, selain dirimu sendiri.'"
b'DocType: Customer Group',b'Customer Group Name',b'Nama Kelompok Pelanggan'
b'apps/erpnext/erpnext/public/js/pos/pos.html +109',b'No Customers yet!',b'Belum ada pelanggan'
b'apps/erpnext/erpnext/public/js/financial_statements.js +56',b'Cash Flow Statement',b'Laporan arus kas'
b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +473',b'No material request created',b'Tidak ada permintaan material yang dibuat'
b'apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23',b'Loan Amount cannot exceed Maximum Loan Amount of {0}',b'Jumlah Pinjaman tidak dapat melebihi Jumlah pinjaman maksimum {0}'
b'apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22',b'License',b'Lisensi'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +491',b'Please remove this Invoice {0} from C-Form {1}',b'Hapus Invoice ini {0} dari C-Form {1}'
b'DocType: Leave Control Panel',"b""Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year""",b'Silakan pilih Carry Teruskan jika Anda juga ingin menyertakan keseimbangan fiskal tahun sebelumnya cuti tahun fiskal ini'
b'DocType: GL Entry',b'Against Voucher Type',b'Terhadap Tipe Voucher'
b'DocType: Physician',b'Phone (R)',b'Telepon (R)'
b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +56',b'Time slots added',b'Slot waktu ditambahkan'
b'DocType: Item',b'Attributes',b'Atribut'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31',b'Enable Template',b'Aktifkan Template'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226',b'Please enter Write Off Account',b'Cukup masukkan Write Off Akun'
b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71',b'Last Order Date',b'Order terakhir Tanggal'
b'DocType: Patient',b'B Negative',b'B Negatif'
b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25',b'Maintenance Status has to be Cancelled or Completed to Submit',b'Status Pemeliharaan harus Dibatalkan atau Selesai untuk Dikirim'
b'DocType: Hotel Room',b'Hotel Room',b'Ruang hotel'
b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47',b'Account {0} does not belongs to company {1}',b'Akun {0} bukan milik perusahaan {1}'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +884',b'Serial Numbers in row {0} does not match with Delivery Note',b'Nomor Seri di baris {0} tidak cocok dengan Catatan Pengiriman'
b'DocType: Student',b'Guardian Details',b'Detail wali'
b'DocType: C-Form',b'C-Form',b'C-Form'
b'apps/erpnext/erpnext/config/hr.py +18',b'Mark Attendance for multiple employees',b'Mark Kehadiran untuk beberapa karyawan'
b'DocType: Agriculture Task',b'Start Day',b'Mulai hari'
b'DocType: Vehicle',b'Chassis No',b'Nomor Rangka'
b'DocType: Payment Request',b'Initiated',b'Diprakarsai'
b'DocType: Production Plan Item',b'Planned Start Date',b'Direncanakan Tanggal Mulai'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +618',b'Please select a BOM',b'Silahkan pilih BOM'
b'DocType: Purchase Invoice',b'Availed ITC Integrated Tax',b'Mengakses Pajak Terpadu ITC'
b'DocType: Serial No',b'Creation Document Type',b'Pembuatan Dokumen Type'
b'DocType: Project Task',b'View Timesheet',b'Lihat Timesheet'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54',b'End date must be greater than start date',b'Tanggal akhir harus lebih besar dari tanggal mulai'
b'DocType: Leave Type',b'Is Encash',b'Apakah menjual'
b'DocType: Leave Allocation',b'New Leaves Allocated',b'cuti baru Dialokasikan'
b'apps/erpnext/erpnext/controllers/trends.py +269',b'Project-wise data is not available for Quotation',b'Data proyek-bijaksana tidak tersedia untuk Quotation'
b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30',b'End on',b'Akhiri'
b'DocType: Project',b'Expected End Date',b'Diharapkan Tanggal Akhir'
b'DocType: Budget Account',b'Budget Amount',b'Jumlah anggaran'
b'DocType: Donor',b'Donor Name',b'Nama Donor'
b'DocType: Appraisal Template',b'Appraisal Template Title',b'Judul Template Penilaian'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39',"b""From Date {0} for Employee {1} cannot be before employee's joining Date {2}""",b'Dari Tanggal {0} Karyawan {1} tidak boleh sebelum Tanggal bergabung karyawan {2}'
b'apps/erpnext/erpnext/utilities/user_progress_utils.py +29',b'Commercial',b'Komersial'
b'DocType: Patient',b'Alcohol Current Use',b'Penggunaan Alkohol saat ini'
b'DocType: Student Admission Program',b'Student Admission Program',b'Program Penerimaan Mahasiswa'
b'DocType: Payment Entry',b'Account Paid To',b'Akun Dibayar Kepada'
b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24',b'Parent Item {0} must not be a Stock Item',b'Induk Barang {0} tidak boleh merupakan Barang Persediaan'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +466',b'Could not submit any Salary Slip <br>\\\n\t\t\tPossible reasons: <br>\\\n\t\t\t1. Net pay is less than 0. <br>\\\n\t\t\t2. Company Email Address specified in employee master is not valid. <br>',b'Tidak bisa mengirimkan Slip Gaji <br> \\ Kemungkinan alasan: <br> \\ 1. Pembayaran bersih kurang dari 0. <br> \\ 2. Alamat Email Perusahaan yang ditentukan dalam master pegawai tidak sah. <br>'
b'apps/erpnext/erpnext/config/selling.py +57',b'All Products or Services.',b'Semua Produk atau Jasa.'
b'DocType: Expense Claim',b'More Details',b'Detail Lebih'
b'DocType: Supplier Quotation',b'Supplier Address',b'Supplier Alamat'
b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128',b'{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5}',b'{0} Anggaran untuk Akun {1} terhadap {2} {3} adalah {4}. Ini akan berlebih sebanyak {5}'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +695',"b""Row {0}# Account must be of type 'Fixed Asset'""",b'Row {0} # Akun harus bertipe &#39;Fixed Asset&#39;'
b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'Out Qty',b'Out Qty'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'and unchcked Disabled in the',b'dan Unchcked Disabled in'
b'apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +41',b'Series is mandatory',b'Series adalah wajib'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28',b'Financial Services',b'Jasa Keuangan'
b'DocType: Student Sibling',b'Student ID',b'Identitas Siswa'
b'apps/erpnext/erpnext/config/projects.py +51',b'Types of activities for Time Logs',b'Jenis kegiatan untuk Waktu Log'
b'DocType: Opening Invoice Creation Tool',b'Sales',b'Penjualan'
b'DocType: Stock Entry Detail',b'Basic Amount',b'Nilai Dasar'
b'DocType: Training Event',b'Exam',b'Ujian'
b'DocType: Complaint',b'Complaint',b'Keluhan'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +462',b'Warehouse required for stock Item {0}',b'Gudang diperlukan untuk Barang Persediaan{0}'
b'DocType: Leave Allocation',b'Unused leaves',b'cuti terpakai'
b'DocType: Patient',b'Alcohol Past Use',b'Penggunaan Alkohol yang Telah Lalu'
b'DocType: Fertilizer Content',b'Fertilizer Content',b'Isi pupuk'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +187',b'Cr',b'Cr'
b'DocType: Project Update',b'Problematic/Stuck',b'Bermasalah / Terjebak'
b'DocType: Tax Rule',b'Billing State',b'Negara penagihan'
b'DocType: Share Transfer',b'Transfer',b'Transfer'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252',b'Work Order {0} must be cancelled before cancelling this Sales Order',b'Perintah Kerja {0} harus dibatalkan sebelum membatalkan Sales Order ini'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +917',b'Fetch exploded BOM (including sub-assemblies)',b'Fetch meledak BOM (termasuk sub-rakitan)'
b'DocType: Authorization Rule',b'Applicable To (Employee)',b'Berlaku Untuk (Karyawan)'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +137',b'Due Date is mandatory',b'Due Date adalah wajib'
b'apps/erpnext/erpnext/controllers/item_variant.py +82',b'Increment for Attribute {0} cannot be 0',b'Kenaikan untuk Atribut {0} tidak dapat 0'
b'apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19',b'Rooms Booked',b'Kamar yang dipesan'
b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +57',b'Ends On date cannot be before Next Contact Date.',b'Berakhir Pada tanggal tidak boleh sebelum Tanggal Kontak Berikutnya.'
b'DocType: Journal Entry',b'Pay To / Recd From',b'Pay To / RECD Dari'
b'DocType: Naming Series',b'Setup Series',b'Pengaturan Series'
b'DocType: Payment Reconciliation',b'To Invoice Date',b'Untuk Faktur Tanggal'
b'DocType: Shareholder',b'Contact HTML',b'Hubungi HTML'
b'apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py +19',b'Registration fee can not be Zero',b'Biaya pendaftaran tidak bisa nol'
b'DocType: Disease',b'Treatment Period',b'Periode Pengobatan'
b'apps/erpnext/erpnext/education/api.py +338',b'Result already Submitted',b'Hasil sudah dikirim'
b'apps/erpnext/erpnext/controllers/buying_controller.py +169',b'Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied',b'Reserved Warehouse adalah wajib untuk Item {0} dalam Bahan Baku yang disediakan'
,b'Inactive Customers',b'Pelanggan tidak aktif'
b'DocType: Student Admission Program',b'Maximum Age',b'Usia Maksimum'
b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +28',b'Please wait 3 days before resending the reminder.',b'Tunggu 3 hari sebelum mengirim ulang pengingat.'
b'DocType: Landed Cost Voucher',b'LCV',b'LCV'
b'DocType: Landed Cost Voucher',b'Purchase Receipts',b'Nota Penerimaan'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29',b'How Pricing Rule is applied?',b'Bagaimana Aturan Harga diterapkan?'
b'DocType: Stock Entry',b'Delivery Note No',b'Pengiriman Note No'
b'DocType: Cheque Print Template',b'Message to show',b'Pesan untuk menunjukkan'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +28',b'Retail',b'Eceran'
b'DocType: Student Attendance',b'Absent',b'Absen'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591',b'Product Bundle',b'Bundel Produk'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38',b'Unable to find score starting at {0}. You need to have standing scores covering 0 to 100',b'Tidak dapat menemukan skor mulai dari {0}. Anda harus memiliki nilai berdiri yang mencakup 0 sampai 100'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +212',b'Row {0}: Invalid reference {1}',b'Row {0}: referensi tidak valid {1}'
b'DocType: Purchase Taxes and Charges Template',b'Purchase Taxes and Charges Template',b'Membeli Pajak dan Biaya Template'
b'DocType: Timesheet',b'TS-',b'TS-'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61',b'{0} {1}: Either debit or credit amount is required for {2}',b'{0} {1}: Salah satu dari jumlah debit atau kredit diperlukan untuk {2}'
b'DocType: GL Entry',b'Remarks',b'Keterangan'
b'DocType: Hotel Room Amenity',b'Hotel Room Amenity',b'Kamar Hotel Amenity'
b'DocType: Payment Entry',b'Account Paid From',b'Akun Dibayar Dari'
b'DocType: Purchase Order Item Supplied',b'Raw Material Item Code',b'Bahan Baku Item Code'
b'DocType: Task',b'Parent Task',b'Tugas orang tua'
b'DocType: Journal Entry',b'Write Off Based On',b'Menulis Off Berbasis On'
b'apps/erpnext/erpnext/utilities/activation.py +65',b'Make Lead',b'Membuat Prospek'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112',b'Print and Stationery',b'Cetak dan Alat Tulis'
b'DocType: Stock Settings',b'Show Barcode Field',b'Tampilkan Barcode Lapangan'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +809',b'Send Supplier Emails',b'Kirim Email Pemasok'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +96',"b'Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.'","b'Gaji sudah diproses untuk periode antara {0} dan {1}, Tinggalkan periode aplikasi tidak dapat antara rentang tanggal ini.'"
b'DocType: Chapter Member',b'Leave Reason',b'Tinggalkan Alasan'
b'DocType: Guardian Interest',b'Guardian Interest',b'wali Tujuan'
b'DocType: Volunteer',b'Availability',b'Tersedianya'
b'apps/erpnext/erpnext/config/accounts.py +319',b'Setup default values for POS Invoices',b'Tetapkan nilai default untuk Faktur POS'
b'apps/erpnext/erpnext/config/hr.py +182',b'Training',b'Latihan'
b'DocType: Project',b'Time to send',b'Saatnya mengirim'
b'DocType: Timesheet',b'Employee Detail',b'Detil karyawan'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58',b'Guardian1 Email ID',b'ID Email Guardian1'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68',"b""Next Date's day and Repeat on Day of Month must be equal""",b'Hari berikutnya Tanggal dan Ulangi pada Hari Bulan harus sama'
b'DocType: Lab Prescription',b'Test Code',b'Kode uji'
b'apps/erpnext/erpnext/config/website.py +11',b'Settings for website homepage',b'Pengaturan untuk homepage website'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +40',b'RFQs are not allowed for {0} due to a scorecard standing of {1}',b'RFQ tidak diizinkan untuk {0} karena kartu skor berdiri dari {1}'
b'DocType: Job Offer',b'Awaiting Response',b'Menunggu Respon'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60',b'Above',b'Di atas'
b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1466',b'Total Amount {0}',b'Jumlah Total {0}'
b'apps/erpnext/erpnext/controllers/item_variant.py +306',b'Invalid attribute {0} {1}',b'atribut tidak valid {0} {1}'
b'DocType: Supplier',b'Mention if non-standard payable account',b'Sebutkan jika akun hutang non-standar'
b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +25',"b""Please select the assessment group other than 'All Assessment Groups'""",b'Harap pilih kelompok penilaian selain &#39;Semua Kelompok Penilaian&#39;'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67',b'Row {0}: Cost center is required for an item {1}',b'Baris {0}: Pusat biaya diperlukan untuk item {1}'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43',b'EcritureDate',b'EcritureDate'
b'DocType: Training Event Employee',b'Optional',b'Pilihan'
b'DocType: Salary Slip',b'Earning & Deduction',b'Earning & Pengurangan'
b'DocType: Agriculture Analysis Criteria',b'Water Analysis',b'Analisis air'
b'DocType: Chapter',b'Region',b'Wilayah'
b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38',b'Optional. This setting will be used to filter in various transactions.',b'Opsional. Pengaturan ini akan digunakan untuk menyaring dalam berbagai transaksi.'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +110',b'Negative Valuation Rate is not allowed',b'Tingkat Penilaian negatif tidak diperbolehkan'
b'DocType: Holiday List',b'Weekly Off',b'Weekly Off'
b'apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7',b'Reload Linked Analysis',b'Reload Linked Analysis'
b'DocType: Fiscal Year',"b'For e.g. 2012, 2012-13'","b'Untuk misalnya 2012, 2012-13'"
b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96',b'Provisional Profit / Loss (Credit)',b'Laba Provisional / Rugi (Kredit)'
b'DocType: Sales Invoice',b'Return Against Sales Invoice',b'Retur Terhadap Faktur Penjualan'
b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32',b'Item 5',b'Butir 5'
b'DocType: Serial No',b'Creation Time',b'Waktu Pembuatan'
b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62',b'Total Revenue',b'Total Pendapatan'
b'DocType: Patient',b'Other Risk Factors',b'Faktor Risiko Lainnya'
b'DocType: Sales Invoice',b'Product Bundle Help',b'Bantuan Bundel Produk'
,b'Monthly Attendance Sheet',b'Lembar Kehadiran Bulanan'
b'apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py +15',b'No record found',b'Tidak ada catatan ditemukan'
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140',b'Cost of Scrapped Asset',b'Biaya Asset dibatalkan'
b'apps/erpnext/erpnext/controllers/stock_controller.py +236',b'{0} {1}: Cost Center is mandatory for Item {2}',"b'{0} {1}: ""Pusat Biaya"" adalah wajib untuk Item {2}'"
b'DocType: Vehicle',b'Policy No',b'Kebijakan Tidak ada'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +686',b'Get Items from Product Bundle',b'Dapatkan Barang-barang dari Bundel Produk'
b'DocType: Asset',b'Straight Line',b'Garis lurus'
b'DocType: Project User',b'Project User',b'proyek Pengguna'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +72',b'Split',b'Membagi'
b'DocType: GL Entry',b'Is Advance',b'Apakah Muka'
b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21',b'Attendance From Date and Attendance To Date is mandatory',b'Kehadiran Dari Tanggal dan Kehadiran Sampai Tanggal adalah wajib'
b'apps/erpnext/erpnext/controllers/buying_controller.py +156',"b""Please enter 'Is Subcontracted' as Yes or No""","b""Entrikan 'Apakah subkontrak' sebagai Ya atau Tidak"""
b'DocType: Item',b'Default Purchase Unit of Measure',b'Unit Pembelian Default'
b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29',b'Last Communication Date',b'Tanggal Komunikasi Terakhir'
b'DocType: Sales Team',b'Contact No.',b'Hubungi Nomor'
b'DocType: Bank Reconciliation',b'Payment Entries',b'Entries pembayaran'
b'DocType: Land Unit',b'Land Unit Details',b'Rincian Unit Tanah'
b'DocType: Land Unit',b'Latitude',b'Lintang'
b'DocType: Work Order',b'Scrap Warehouse',b'Gudang memo'
b'DocType: Work Order',b'Check if material transfer entry is not required',b'Periksa apakah entri pemindahan material tidak diperlukan'
b'DocType: Program Enrollment Tool',b'Get Students From',b'Dapatkan Siswa Dari'
b'apps/erpnext/erpnext/config/learn.py +263',b'Publish Items on Website',b'Publikasikan Produk di Website'
b'apps/erpnext/erpnext/utilities/activation.py +126',b'Group your students in batches',b'Kelompok siswa Anda dalam batch'
b'DocType: Authorization Rule',b'Authorization Rule',b'Regulasi Autorisasi'
b'DocType: POS Profile',b'Offline POS Section',b'Bagian POS Offline'
b'DocType: Sales Invoice',b'Terms and Conditions Details',b'Syarat dan Ketentuan Detail'
b'apps/erpnext/erpnext/templates/generators/item.html +100',b'Specifications',b'Spesifikasi'
b'DocType: Sales Taxes and Charges Template',b'Sales Taxes and Charges Template',b'Penjualan Pajak dan Biaya Template'
b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68',b'Total (Credit)',b'Total (Kredit)'
b'DocType: Repayment Schedule',b'Payment Date',b'Tanggal pembayaran'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +122',b'New Batch Qty',b'Baru Batch Qty'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10',b'Apparel & Accessories',b'Pakaian & Aksesoris'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91',b'Could not solve weighted score function. Make sure the formula is valid.',b'Tidak dapat memecahkan fungsi skor tertimbang. Pastikan rumusnya benar.'
b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67',b'Number of Order',b'Jumlah Order'
b'DocType: Item Group',b'HTML / Banner that will show on the top of product list.',b'HTML / Banner yang akan muncul di bagian atas daftar produk.'
b'DocType: Shipping Rule',b'Specify conditions to calculate shipping amount',b'Tentukan kondisi untuk menghitung jumlah pengiriman'
b'DocType: Program Enrollment',"b""Institute's Bus""",b'Bus Institut'
b'DocType: Accounts Settings',b'Role Allowed to Set Frozen Accounts & Edit Frozen Entries',b'Peran Diizinkan Set Beku Account & Edit Frozen Entri'
b'DocType: Supplier Scorecard Scoring Variable',b'Path',b'Jalan'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28',b'Cannot convert Cost Center to ledger as it has child nodes',b'Tidak dapat mengkonversi Pusat Biaya untuk buku karena memiliki node anak'
b'DocType: Production Plan',b'Total Planned Qty',b'Total Rencana Qty'
b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68',b'Opening Value',b'Nilai pembukaan'
b'DocType: Salary Detail',b'Formula',b'Rumus'
b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47',b'Serial #',b'Serial #'
b'DocType: Lab Test Template',b'Lab Test Template',b'Lab Test Template'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +181',b'Sales Account',b'Akun penjualan'
b'DocType: Purchase Invoice Item',b'Total Weight',b'Berat keseluruhan'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94',b'Commission on Sales',b'Komisi Penjualan'
b'DocType: Job Offer Term',b'Value / Description',b'Nilai / Keterangan'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +630',"b'Row #{0}: Asset {1} cannot be submitted, it is already {2}'","b'Row # {0}: Aset {1} tidak dapat disampaikan, itu sudah {2}'"
b'DocType: Tax Rule',b'Billing Country',b'Negara Penagihan'
b'DocType: Purchase Order Item',b'Expected Delivery Date',b'Diharapkan Pengiriman Tanggal'
b'DocType: Restaurant Order Entry',b'Restaurant Order Entry',b'Entri Pemesanan Restoran'
b'apps/erpnext/erpnext/accounts/general_ledger.py +134',b'Debit and Credit not equal for {0} #{1}. Difference is {2}.',b'Debit dan Kredit tidak sama untuk {0} # {1}. Perbedaan adalah {2}.'
b'DocType: Asset Maintenance Task',b'Assign To Name',b'Berikan nama'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98',b'Entertainment Expenses',b'Beban Hiburan'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +98',b'Make Material Request',b'Membuat Material Permintaan'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20',b'Open Item {0}',b'Terbuka Barang {0}'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222',b'Sales Invoice {0} must be cancelled before cancelling this Sales Order',b'Faktur Penjualan {0} harus dibatalkan sebelum membatalkan Sales Order ini'
b'DocType: Consultation',b'Age',b'Usia'
b'DocType: Sales Invoice Timesheet',b'Billing Amount',b'Jumlah Penagihan'
b'DocType: Cash Flow Mapping',b'Select Maximum Of 1',b'Pilih Maksimum 1'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84',b'Invalid quantity specified for item {0}. Quantity should be greater than 0.',b'Kuantitas tidak valid untuk item {0}. Jumlah harus lebih besar dari 0.'
b'DocType: Company',b'Default Employee Advance Account',b'Akun uang muka karyawan'
b'apps/erpnext/erpnext/config/hr.py +60',b'Applications for leave.',b'Aplikasi untuk cuti.'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +164',b'Account with existing transaction can not be deleted',b'Akun dengan transaksi yang ada tidak dapat dihapus'
b'DocType: Vehicle',b'Last Carbon Check',b'Terakhir Carbon Periksa'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102',b'Legal Expenses',b'Beban Legal'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140',b'Please select quantity on row ',b'Silakan pilih kuantitas pada baris'
b'apps/erpnext/erpnext/config/accounts.py +277',b'Make Opening Sales and Purchase Invoices',b'Lakukan Pembukaan Faktur Penjualan dan Pembelian'
b'DocType: Purchase Invoice',b'Posting Time',b'Posting Waktu'
b'DocType: Timesheet',b'% Amount Billed',b'% Jumlah Ditagih'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118',b'Telephone Expenses',b'Beban Telepon'
b'DocType: Sales Partner',b'Logo',b'Logo'
b'DocType: Naming Series',b'Check this if you want to force the user to select a series before saving. There will be no default if you check this.',b'Periksa ini jika Anda ingin untuk memaksa pengguna untuk memilih seri sebelum menyimpan. Tidak akan ada default jika Anda memeriksa ini.'
b'apps/erpnext/erpnext/stock/get_item_details.py +131',b'No Item with Serial No {0}',b'Tidak ada Stok Barang dengan Serial No {0}'
b'DocType: Email Digest',b'Open Notifications',b'Terbuka Pemberitahuan'
b'DocType: Payment Entry',b'Difference Amount (Company Currency)',b'Perbedaan Jumlah (Perusahaan Mata Uang)'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79',b'Direct Expenses',b'Beban Langsung'
b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60',b'New Customer Revenue',b'Pendapatan Pelanggan Baru'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119',b'Travel Expenses',b'Biaya Perjalanan'
b'DocType: Maintenance Visit',b'Breakdown',b'Rincian'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50',b'Add custom field Subscription in the doctype {0}',b'Tambahkan bidang kustom Langganan di doctype {0}'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +820',b'Account: {0} with currency: {1} can not be selected',b'Account: {0} dengan mata uang: {1} tidak dapat dipilih'
b'DocType: Purchase Receipt Item',b'Sample Quantity',b'Jumlah sampel'
b'DocType: Manufacturing Settings',"b'Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.'","b'Perbarui biaya BOM secara otomatis melalui Penjadwalan, berdasarkan hitungan penilaian / daftar harga / hitungan pembelian bahan baku terakhir.'"
b'DocType: Bank Reconciliation Detail',b'Cheque Date',b'Cek Tanggal'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +50',b'Account {0}: Parent account {1} does not belong to company: {2}',b'Akun {0}: akun Induk {1} bukan milik perusahaan: {2}'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +106',b'Successfully deleted all transactions related to this company!',b'Berhasil dihapus semua transaksi yang terkait dengan perusahaan ini!'
b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27',b'As on Date',b'Seperti pada Tanggal'
b'DocType: Appraisal',b'HR',b'HR'
b'DocType: Program Enrollment',b'Enrollment Date',b'tanggal pendaftaran'
b'DocType: Healthcare Settings',b'Out Patient SMS Alerts',b'SMS Pemberitahuan Pasien Luar'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100',b'Probation',b'Percobaan'
b'apps/erpnext/erpnext/config/hr.py +115',b'Salary Components',b'Komponen gaji'
b'DocType: Program Enrollment Tool',b'New Academic Year',b'Baru Tahun Akademik'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +811',b'Return / Credit Note',b'Nota Retur / Kredit'
b'DocType: Stock Settings',b'Auto insert Price List rate if missing',b'Insert auto tingkat Daftar Harga jika hilang'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +117',b'Total Paid Amount',b'Jumlah Total Dibayar'
b'DocType: GST Settings',b'B2C Limit',b'Batas B2C'
b'DocType: Work Order Item',b'Transferred Qty',b'Ditransfer Qty'
b'apps/erpnext/erpnext/config/learn.py +11',b'Navigating',b'Menjelajahi'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188',b'Planning',b'Perencanaan'
b'DocType: Share Balance',b'Issued',b'Diterbitkan'
b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14',b'Student Activity',b'Kegiatan Siswa'
b'apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80',b'Supplier Id',b'Supplier Id'
b'DocType: Payment Request',b'Payment Gateway Details',b'Pembayaran Detail Gateway'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +276',b'Quantity should be greater than 0',b'Kuantitas harus lebih besar dari 0'
b'DocType: Journal Entry',b'Cash Entry',b'Entri Kas'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17',"b""Child nodes can be only created under 'Group' type nodes""",b'node anak hanya dapat dibuat di bawah &#39;Grup&#39; Jenis node'
b'DocType: Leave Application',b'Half Day Date',b'Tanggal Setengah Hari'
b'DocType: Academic Year',b'Academic Year Name',b'Nama Tahun Akademis'
b'DocType: Sales Partner',b'Contact Desc',b'Contact Info'
b'apps/erpnext/erpnext/config/hr.py +65',"b'Type of leaves like casual, sick etc.'","b'Jenis cuti seperti kasual, dll sakit'"
b'DocType: Email Digest',b'Send regular summary reports via Email.',b'Mengirim laporan ringkasan berkala melalui Email.'
b'DocType: Payment Entry',b'PE-',b'PE-'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +282',b'Please set default account in Expense Claim Type {0}',b'Silakan set account default di Beban Klaim Jenis {0}'
b'DocType: Assessment Result',b'Student Name',b'Nama siswa'
b'DocType: Brand',b'Item Manager',b'Item Manajer'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143',b'Payroll Payable',b'Payroll Hutang'
b'DocType: Buying Settings',b'Default Supplier Type',b'Standar Supplier Type'
b'DocType: Plant Analysis',b'Collection Datetime',b'Koleksi Datetime'
b'DocType: Work Order',b'Total Operating Cost',b'Total Biaya Operasional'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171',b'Note: Item {0} entered multiple times',b'Catatan: Stok Barang {0} masuk beberapa kali'
b'apps/erpnext/erpnext/config/selling.py +41',b'All Contacts.',b'Semua Kontak.'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +71',b'Company Abbreviation',b'Singkatan Perusahaan'
b'apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +47',b'User {0} does not exist',b'Pengguna {0} tidak ada'
b'DocType: Payment Term',b'Day(s) after invoice date',b'Hari setelah tanggal faktur'
b'DocType: Payment Schedule',b'Payment Schedule',b'Jadwal pembayaran'
b'DocType: Subscription',b'SUB-',b'SUB-'
b'DocType: Item Attribute Value',b'Abbreviation',b'Singkatan'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +195',b'Payment Entry already exists',b'Masuk pembayaran sudah ada'
b'apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36',b'Not authroized since {0} exceeds limits',b'Tidak Authroized sejak {0} melebihi batas'
b'apps/erpnext/erpnext/config/hr.py +110',b'Salary template master.',b'Template master gaji.'
b'apps/erpnext/erpnext/healthcare/setup.py +241',b'Pathology',b'Patologi'
b'DocType: Restaurant Order Entry',b'Restaurant Table',b'Meja restoran'
b'DocType: Hotel Room',b'Hotel Manager',b'Manajer hotel'
b'DocType: Leave Type',b'Max Days Leave Allowed',b'Max Hari Cuti Diizinkan'
b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63',b'Set Tax Rule for shopping cart',b'Set Peraturan Pajak untuk keranjang belanja'
b'DocType: Purchase Invoice',b'Taxes and Charges Added',b'Pajak dan Biaya Ditambahkan'
,b'Sales Funnel',b'Penjualan Saluran'
b'apps/erpnext/erpnext/setup/doctype/company/company.py +49',b'Abbreviation is mandatory',b'Singkatan wajib diisi'
b'DocType: Project',b'Task Progress',b'tugas Kemajuan'
b'apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7',b'Cart',b'Troli'
,b'Qty to Transfer',b'Kuantitas untuk ditransfer'
b'apps/erpnext/erpnext/config/selling.py +13',b'Quotes to Leads or Customers.',b'Penawaran terhadap Prospek atau Pelanggan'
b'DocType: Stock Settings',b'Role Allowed to edit frozen stock',b'Peran diizinkan mengedit persediaan dibekukan'
,b'Territory Target Variance Item Group-Wise',b'Wilayah Sasaran Variance Stok Barang Group-Wise'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143',b'All Customer Groups',b'Semua Kelompok Pelanggan'
b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114',b'Accumulated Monthly',b'akumulasi Bulanan'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +781',b'{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.',b'{0} adalah wajib. Mungkin data Kurs Mata Uang tidak dibuat untuk {1} sampai {2}.'
b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +44',b'Tax Template is mandatory.',b'Template pajak adalah wajib.'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +44',b'Account {0}: Parent account {1} does not exist',b'Akun {0}: akun Induk {1} tidak ada'
b'DocType: Purchase Invoice Item',b'Price List Rate (Company Currency)',b'Daftar Harga Rate (Perusahaan Mata Uang)'
b'DocType: Products Settings',b'Products Settings',b'Pengaturan produk'
,b'Item Price Stock',b'Stok Harga Barang'
b'DocType: Lab Prescription',b'Test Created',b'Uji coba'
b'DocType: Healthcare Settings',b'Custom Signature in Print',b'Tanda Tangan Khusus di Cetak'
b'DocType: Account',b'Temporary',b'Sementara'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +107',b'Customer LPO No.',b'Nomor Pokok Pelanggan'
b'DocType: Program',b'Courses',b'Kursus'
b'DocType: Monthly Distribution Percentage',b'Percentage Allocation',b'Persentase Alokasi'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128',b'Secretary',b'Sekretaris'
b'DocType: Global Defaults',"b""If disable, 'In Words' field will not be visible in any transaction""","b'Jika menonaktifkan, &#39;Dalam Kata-kata&#39; bidang tidak akan terlihat di setiap transaksi'"
b'DocType: Serial No',b'Distinct unit of an Item',b'Unit berbeda Item'
b'DocType: Supplier Scorecard Criteria',b'Criteria Name',b'Nama kriteria'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1295',b'Please set Company',b'Harap set Perusahaan'
b'DocType: Pricing Rule',b'Buying',b'Pembelian'
b'apps/erpnext/erpnext/config/agriculture.py +24',b'Diseases & Fertilizers',b'Penyakit &amp; Pupuk'
b'DocType: HR Settings',b'Employee Records to be created by',b'Rekaman Karyawan yang akan dibuat oleh'
b'DocType: Patient',b'AB Negative',b'AB Negatif'
b'DocType: Sample Collection',b'SMPL-',b'SMPL-'
b'DocType: POS Profile',b'Apply Discount On',b'Terapkan Diskon Pada'
b'DocType: Member',b'Membership Type',b'jenis keanggotaan'
,b'Reqd By Date',b'Reqd By Date'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140',b'Creditors',b'Kreditor'
b'DocType: Assessment Plan',b'Assessment Name',b'penilaian Nama'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +94',b'Show PDC in Print',b'Tampilkan PDC di Print'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +97',b'Row # {0}: Serial No is mandatory',b'Row # {0}: Serial ada adalah wajib'
b'DocType: Purchase Taxes and Charges',b'Item Wise Tax Detail',b'Stok Barang Wise Detil Pajak'
b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13',b'Job Offer',b'Tawaran pekerjaan'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +71',b'Institute Abbreviation',b'Singkatan Institute'
,b'Item-wise Price List Rate',b'Stok Barang-bijaksana Daftar Harga Tingkat'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1082',b'Supplier Quotation',b'Supplier Quotation'
b'DocType: Quotation',b'In Words will be visible once you save the Quotation.',b'Dalam Kata-kata akan terlihat sekali Anda menyimpan Quotation tersebut.'
b'apps/erpnext/erpnext/utilities/transaction_base.py +164',b'Quantity ({0}) cannot be a fraction in row {1}',b'Kuantitas ({0}) tidak boleh menjadi pecahan dalam baris {1}'
b'DocType: Consultation',b'C-',b'C-'
b'DocType: Attendance',b'ATT-',b'ATT-'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +492',b'Barcode {0} already used in Item {1}',b'Barcode {0} sudah digunakan dalam Produk {1}'
b'apps/erpnext/erpnext/config/selling.py +86',b'Rules for adding shipping costs.',b'Aturan untuk menambahkan biaya pengiriman.'
b'DocType: Hotel Room',b'Extra Bed Capacity',b'Kapasitas Tempat Tidur Tambahan'
b'DocType: Item',b'Opening Stock',b'Persediaan pembukaan'
b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20',b'Customer is required',b'Pelanggan diwajibkan'
b'DocType: Lab Test',b'Result Date',b'Tanggal hasil'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +77',b'PDC/LC Date',b'Tanggal PDC / LC'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20',b'{0} is mandatory for Return',b'{0} adalah wajib untuk Retur'
b'DocType: Purchase Order',b'To Receive',b'Menerima'
b'apps/erpnext/erpnext/utilities/user_progress.py +252',b'user@example.com',b'user@example.com'
b'DocType: Asset',b'Asset Owner',b'Pemilik aset'
b'DocType: Employee',b'Personal Email',b'Email Pribadi'
b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57',b'Total Variance',b'Total Variance'
b'DocType: Accounts Settings',"b'If enabled, the system will post accounting entries for inventory automatically.'","b'Jika diaktifkan, sistem akan posting entri akuntansi untuk persediaan otomatis.'"
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15',b'Brokerage',b'Memperantarai'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +195',b'Attendance for employee {0} is already marked for this day',b'Kehadiran bagi karyawan {0} sudah ditandai untuk hari ini'
b'DocType: Work Order Operation',"b""in Minutes\nUpdated via 'Time Log'""","b""di Menit Diperbarui melalui 'Log Waktu'"""
b'DocType: Customer',b'From Lead',b'Dari Prospek'
b'apps/erpnext/erpnext/config/manufacturing.py +13',b'Orders released for production.',b'Order dirilis untuk produksi.'
b'apps/erpnext/erpnext/public/js/account_tree_grid.js +65',b'Select Fiscal Year...',b'Pilih Tahun Anggaran ...'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +567',b'POS Profile required to make POS Entry',b'POS Profil diperlukan untuk membuat POS Entri'
b'DocType: Program Enrollment Tool',b'Enroll Students',b'Daftarkan Siswa'
b'DocType: Lab Test',b'Approved Date',b'Tanggal yang Disetujui'
b'apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21',b'Standard Selling',b'Standard Jual'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +165',b'Atleast one warehouse is mandatory',b'Setidaknya satu gudang adalah wajib'
b'DocType: Serial No',b'Out of Warranty',b'Out of Garansi'
b'DocType: BOM Update Tool',b'Replace',b'Mengganti'
b'apps/erpnext/erpnext/templates/includes/product_list.js +42',b'No products found.',b'Tidak ditemukan produk.'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360',b'{0} against Sales Invoice {1}',b'{0} terhadap Faktur Penjualan {1}'
b'DocType: Antibiotic',b'Laboratory User',b'Pengguna Laboratorium'
b'DocType: Sales Invoice',b'SINV-',b'SINV-'
b'DocType: Request for Quotation Item',b'Project Name',b'Nama Proyek'
b'DocType: Customer',b'Mention if non-standard receivable account',b'Menyebutkan jika non-standar piutang'
b'DocType: Journal Entry Account',b'If Income or Expense',b'Jika Penghasilan atau Beban'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +288',b'Select interest income account in employee loan {0}',b'Pilih akun pendapatan bunga dalam pinjaman karyawan {0}'
b'DocType: Work Order',b'Required Items',b'Produk yang dibutuhkan'
b'DocType: Stock Ledger Entry',b'Stock Value Difference',b'Perbedaan Nilai Persediaan'
b'apps/erpnext/erpnext/config/learn.py +229',b'Human Resource',b'Sumber Daya Manusia'
b'DocType: Payment Reconciliation Payment',b'Payment Reconciliation Payment',b'Rekonsiliasi Pembayaran Pembayaran'
b'DocType: Disease',b'Treatment Task',b'Tugas Pengobatan'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38',b'Tax Assets',b'Aset pajak'
b'DocType: BOM Item',b'BOM No',b'No. BOM'
b'DocType: Instructor',b'INS/',b'INS /'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +160',b'Journal Entry {0} does not have account {1} or already matched against other voucher',b'Jurnal Entri {0} tidak memiliki akun {1} atau sudah dicocokkan voucher lainnya'
b'DocType: Item',b'Moving Average',b'Moving Average'
b'DocType: BOM Update Tool',b'The BOM which will be replaced',b'BOM yang akan diganti'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46',b'Electronic Equipments',b'Peralatan elektronik'
b'DocType: Asset',b'Maintenance Required',b'Pemeliharaan Diperlukan'
b'DocType: Account',b'Debit',b'Debet'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49',b'Leaves must be allocated in multiples of 0.5',"b'cuti harus dialokasikan dalam kelipatan 0,5'"
b'DocType: Work Order',b'Operation Cost',b'Biaya Operasi'
b'apps/erpnext/erpnext/config/hr.py +29',b'Upload attendance from a .csv file',b'Unggah kehadiran dari file csv.'
b'apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45',b'Outstanding Amt',b'Posisi Amt'
b'DocType: Sales Person',b'Set targets Item Group-wise for this Sales Person.',b'Target Set Stok Barang Group-bijaksana untuk Sales Person ini.'
b'DocType: Stock Settings',b'Freeze Stocks Older Than [Days]',b'Bekukan Persediaan Lebih Lama Dari [Hari]'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +600',b'Row #{0}: Asset is mandatory for fixed asset purchase/sale',b'Row # {0}: Aset adalah wajib untuk aktiva tetap pembelian / penjualan'
b'DocType: Asset Maintenance Team',b'Maintenance Team Name',b'Nama Tim Pemeliharaan'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42',"b'If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.'","b'Jika dua atau lebih Aturan Harga yang ditemukan berdasarkan kondisi di atas, Prioritas diterapkan. Prioritas adalah angka antara 0 sampai 20, sementara nilai default adalah nol (kosong). Jumlah yang lebih tinggi berarti akan diutamakan jika ada beberapa Aturan Harga dengan kondisi yang sama.'"
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +197',"b""Customer is mandatory if 'Opportunity From' is selected as Customer""",b'Pelanggan diwajibkan jika &#39;Opportunity From&#39; dipilih sebagai Customer'
b'apps/erpnext/erpnext/controllers/trends.py +36',b'Fiscal Year: {0} does not exists',b'Tahun Anggaran: {0} tidak ada'
b'DocType: Currency Exchange',b'To Currency',b'Untuk Mata'
b'DocType: Leave Block List',b'Allow the following users to approve Leave Applications for block days.',b'Izinkan pengguna ini untuk menyetujui aplikasi izin cuti untuk hari yang terpilih(blocked).'
b'apps/erpnext/erpnext/config/hr.py +137',b'Types of Expense Claim.',b'Jenis Beban Klaim.'
b'apps/erpnext/erpnext/controllers/selling_controller.py +148',b'Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2}',b'Tingkat penjualan untuk item {0} lebih rendah dari {1} nya. Tingkat penjualan harus atleast {2}'
b'DocType: Item',b'Taxes',b'PPN'
b'DocType: Purchase Invoice',b'capital goods',b'barang modal'
b'DocType: Purchase Invoice Item',b'Weight Per Unit',b'Berat Per Unit'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344',b'Paid and Not Delivered',b'Dibayar dan Tidak Terkirim'
b'DocType: Project',b'Default Cost Center',b'Standar Biaya Pusat'
b'DocType: Bank Guarantee',b'End Date',b'Tanggal Berakhir'
b'apps/erpnext/erpnext/config/stock.py +7',b'Stock Transactions',b'Transaksi Persediaan'
b'DocType: Budget',b'Budget Accounts',b'Akun anggaran'
b'DocType: Employee',b'Internal Work History',b'Sejarah Kerja internal'
b'DocType: Depreciation Schedule',b'Accumulated Depreciation Amount',b'Akumulasi Penyusutan Jumlah'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42',b'Private Equity',b'Private Equity'
b'DocType: Supplier Scorecard Variable',b'Supplier Scorecard Variable',b'Supplier Scorecard Variabel'
b'DocType: Employee Loan',b'Fully Disbursed',b'sepenuhnya Dicairkan'
b'DocType: Employee Advance',b'Due Advance Amount',b'Jumlah Uang Muka Sebelumnya'
b'DocType: Maintenance Visit',b'Customer Feedback',b'Umpan balik Pelanggan'
b'DocType: Account',b'Expense',b'Biaya'
b'apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +54',b'Score cannot be greater than Maximum Score',b'Skor tidak dapat lebih besar dari skor maksimum'
b'apps/erpnext/erpnext/utilities/user_progress.py +129',b'Customers and Suppliers',b'Pelanggan dan Pemasok'
b'DocType: Item Attribute',b'From Range',b'Dari Rentang'
b'DocType: BOM',b'Set rate of sub-assembly item based on BOM',b'Tetapkan tarif barang sub-rakitan berdasarkan BOM'
b'DocType: Hotel Room Reservation',b'Invoiced',b'Faktur'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98',b'Syntax error in formula or condition: {0}',b'kesalahan sintaks dalam formula atau kondisi: {0}'
b'DocType: Daily Work Summary Settings Company',b'Daily Work Summary Settings Company',b'Kerja Harian Ringkasan Pengaturan Perusahaan'
b'apps/erpnext/erpnext/stock/utils.py +125',b'Item {0} ignored since it is not a stock item',b'Barang {0} diabaikan karena bukan barang persediaan'
b'DocType: Appraisal',b'APRSL',b'APRSL'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23',"b'To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.'","b'Untuk tidak berlaku Rule Harga dalam transaksi tertentu, semua Aturan Harga yang berlaku harus dinonaktifkan.'"
b'DocType: Payment Term',b'Day(s) after the end of the invoice month',b'Hari setelah akhir bulan faktur'
b'DocType: Assessment Group',b'Parent Assessment Group',b'Induk Penilaian Grup'
b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27',b'Jobs',b'Pekerjaan'
,b'Sales Order Trends',b'Sales Order Trends'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51',"b""The 'From Package No.' field must neither be empty nor it's value less than 1.""",b'&#39;Dari Paket No.&#39; lapangan tidak boleh kosong atau nilainya kurang dari 1.'
b'DocType: Employee',b'Held On',b'Diadakan Pada'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +36',b'Production Item',b'Produksi Stok Barang'
,b'Employee Information',b'Informasi Karyawan'
b'DocType: Stock Entry Detail',b'Additional Cost',b'Biaya tambahan'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +48',"b'Can not filter based on Voucher No, if grouped by Voucher'","b'Tidak dapat memfilter berdasarkan No. Voucher, jika dikelompokkan berdasarkan Voucher'"
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +918',b'Make Supplier Quotation',b'Membuat Pemasok Quotation'
b'DocType: Quality Inspection',b'Incoming',b'Incoming'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +70',b'Default tax templates for sales and purchase are created.',b'Template pajak default untuk penjualan dan pembelian telah dibuat.'
b'apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +57',b'Assessment Result record {0} already exists.',b'Catatan Hasil Penilaian {0} sudah ada.'
b'DocType: BOM',b'Materials Required (Exploded)',b'Bahan yang dibutuhkan (Meledak)'
b'apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60',"b""Please set Company filter blank if Group By is 'Company'""",b'Harap tentukan filter Perusahaan jika Group By &#39;Company&#39;'
b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66',b'Posting Date cannot be future date',b'Posting Tanggal tidak bisa tanggal di masa depan'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +102',b'Row # {0}: Serial No {1} does not match with {2} {3}',b'Row # {0}: Serial No {1} tidak sesuai dengan {2} {3}'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10',b'for generating the recurring',b'untuk menghasilkan berulang'
b'DocType: Stock Entry',b'Target Warehouse Address',b'Target Gudang Alamat'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86',b'Casual Leave',b'Santai Cuti'
b'DocType: Agriculture Task',b'End Day',b'Hari Akhir'
b'DocType: Batch',b'Batch ID',b'Batch ID'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380',b'Note: {0}',b'Catatan: {0}'
,b'Delivery Note Trends',b'Tren pengiriman Note'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112',"b""This Week's Summary""",b'Ringkasan minggu ini'
b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +22',b'In Stock Qty',b'Jumlah tersedia'
b'DocType: Delivery Trip',b'Calculate Estimated Arrival Times',b'Hitung Perkiraan Waktu Kedatangan'
b'apps/erpnext/erpnext/accounts/general_ledger.py +113',b'Account: {0} can only be updated via Stock Transactions',b'Akun: {0} hanya dapat diperbarui melalui Transaksi Persediaan'
b'DocType: Student Group Creation Tool',b'Get Courses',b'Dapatkan Program'
b'DocType: GL Entry',b'Party',b'Pihak'
b'DocType: Healthcare Settings',b'Patient Name',b'Nama pasien'
b'DocType: Variant Field',b'Variant Field',b'Bidang Varian'
b'DocType: Sales Order',b'Delivery Date',b'Tanggal Pengiriman'
b'DocType: Opportunity',b'Opportunity Date',b'Peluang Tanggal'
b'DocType: Employee',b'Health Insurance Provider',b'Penyedia Asuransi Kesehatan'
b'DocType: Purchase Receipt',b'Return Against Purchase Receipt',b'Retur Terhadap Nota Pembelian'
b'DocType: Water Analysis',b'Person Responsible',b'Orang yang bertanggung jawab'
b'DocType: Request for Quotation Item',b'Request for Quotation Item',b'Permintaan Quotation Barang'
b'DocType: Purchase Order',b'To Bill',b'Bill'
b'DocType: Material Request',b'% Ordered',b'% Tersusun'
b'DocType: Education Settings',"b'For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.'","b'Untuk Kelompok Siswa Berbasis Kursus, Kursus akan divalidasi untuk setiap Siswa dari Program Pendaftaran Pendaftaran Program yang terdaftar.'"
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103',b'Piecework',b'Pekerjaan yg dibayar menurut hasil yg dikerjakan'
b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70',b'Avg. Buying Rate',b'Harga Beli Rata-rata'
b'DocType: Share Balance',b'From No',b'Dari No'
b'DocType: Task',b'Actual Time (in Hours)',b'Waktu Aktual (dalam Jam)'
b'DocType: Employee',b'History In Company',b'Sejarah Dalam Perusahaan'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +270',b'New Message from {sender}',b'Pesan baru dari {sender}'
b'DocType: Customer',b'Customer Primary Address',b'Alamat utama pelanggan'
b'apps/erpnext/erpnext/config/learn.py +107',b'Newsletters',b'Surat edaran'
b'DocType: Drug Prescription',b'Description/Strength',b'Deskripsi / Kekuatan'
b'DocType: Share Balance',b'Is Company',b'Apakah perusahaan'
b'DocType: Stock Ledger Entry',b'Stock Ledger Entry',b'Entri Buku Persediaan'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83',b'Same item has been entered multiple times',b'item yang sama telah dimasukkan beberapa kali'
b'DocType: Department',b'Leave Block List',b'Cuti Block List'
b'DocType: Purchase Invoice',b'Tax ID',b'Id pajak'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192',b'Item {0} is not setup for Serial Nos. Column must be blank',b'Stok Barang {0} tidak diatur untuk Nomor Seri. Kolom harus kosong'
b'DocType: Accounts Settings',b'Accounts Settings',b'Pengaturan Akun'
b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11',b'Approve',b'Menyetujui'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +69',"b'Malformatted address for {0}, please fix to continue.'","b'Alamat berformat salah untuk {0}, tolong perbaiki untuk melanjutkan.'"
b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28',"b'Number of new Account, it will be included in the account name as a prefix'","b'Jumlah Akun baru, akan disertakan dalam nama akun sebagai awalan'"
b'DocType: Maintenance Team Member',b'Team Member',b'Anggota tim'
b'apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151',b'No Result to submit',b'Tidak ada hasil untuk disampaikan'
b'DocType: Customer',b'Sales Partner and Commission',b'Penjualan Mitra dan Komisi'
b'DocType: Employee Loan',b'Rate of Interest (%) / Year',b'Tingkat bunga (%) / Tahun'
,b'Project Quantity',b'proyek Kuantitas'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +79',"b""Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'""","b'Total {0} untuk semua item adalah nol, mungkin Anda harus mengubah &#39;Distribusikan Biaya Berdasarkan&#39;'"
b'DocType: Opportunity',b'To Discuss',b'Untuk Diskusikan'
b'apps/erpnext/erpnext/stock/stock_ledger.py +377',b'{0} units of {1} needed in {2} to complete this transaction.',b'{0} unit {1} dibutuhkan dalam {2} untuk menyelesaikan transaksi ini.'
b'DocType: Loan Type',b'Rate of Interest (%) Yearly',b'Tingkat bunga (%) Tahunan'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71',b'Temporary Accounts',b'Akun sementara'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207',b'Black',b'Hitam'
b'DocType: BOM Explosion Item',b'BOM Explosion Item',b'Rincian Barang BOM'
b'DocType: Shareholder',b'Contact List',b'Daftar kontak'
b'DocType: Account',b'Auditor',b'Akuntan'
b'DocType: Project',b'Frequency To Collect Progress',b'Frekuensi Untuk Mengumpulkan Kemajuan'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +132',b'{0} items produced',b'{0} item diproduksi'
b'apps/erpnext/erpnext/utilities/user_progress.py +58',b'Learn More',b'Belajarlah lagi'
b'DocType: Cheque Print Template',b'Distance from top edge',b'Jarak dari tepi atas'
b'apps/erpnext/erpnext/stock/get_item_details.py +367',b'Price List {0} is disabled or does not exist',b'Daftar Harga {0} dinonaktifkan atau tidak ada'
b'DocType: Purchase Invoice',b'Return',b'Retur'
b'DocType: Pricing Rule',b'Disable',b'Nonaktifkan'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +180',b'Mode of payment is required to make a payment',b'Cara pembayaran yang diperlukan untuk melakukan pembayaran'
b'DocType: Project Task',b'Pending Review',b'Pending Ulasan'
b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14',"b'Edit in full page for more options like assets, serial nos, batches etc.'","b'Edit di halaman penuh untuk lebih banyak pilihan seperti aset, serial nos, batch dll.'"
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10',b'Appointments and Consultations',b'Janji dan Konsultasi'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41',b'{0} - {1} is not enrolled in the Batch {2}',b'{0} - {1} tidak terdaftar dalam Batch {2}'
b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113',"b'Asset {0} cannot be scrapped, as it is already {1}'","b'Aset {0} tidak dapat dihapus, karena sudah {1}'"
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +77',b'Cheques Required',b'Cek Diperlukan'
b'DocType: Task',b'Total Expense Claim (via Expense Claim)',b'Jumlah Klaim Beban (via Beban Klaim)'
b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177',b'Mark Absent',b'Mark Absen'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40',b'Failed to setup company',b'Gagal menata perusahaan'
b'DocType: Asset Repair',b'Asset Repair',b'Perbaikan Aset'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +143',b'Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2}',b'Row {0}: Mata dari BOM # {1} harus sama dengan mata uang yang dipilih {2}'
b'DocType: Journal Entry Account',b'Exchange Rate',b'Nilai Tukar'
b'DocType: Patient',b'Additional information regarding the patient',b'Informasi tambahan mengenai pasien'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +585',b'Sales Order {0} is not submitted',b'Order Penjualan {0} tidak Terkirim'
b'DocType: Homepage',b'Tag Line',b'klimaks'
b'DocType: Fee Component',b'Fee Component',b'biaya Komponen'
b'apps/erpnext/erpnext/config/hr.py +204',b'Fleet Management',b'Manajemen armada'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1080',b'Add items from',b'Menambahkan item dari'
b'apps/erpnext/erpnext/config/agriculture.py +7',b'Crops & Lands',b'Tanaman &amp; lahan'
b'DocType: Cheque Print Template',b'Regular',b'Reguler'
b'DocType: Fertilizer',b'Density (if liquid)',b'Densitas (jika cair)'
b'apps/erpnext/erpnext/education/doctype/course/course.py +20',b'Total Weightage of all Assessment Criteria must be 100%',b'Total weightage semua Kriteria Penilaian harus 100%'
b'DocType: Purchase Order Item',b'Last Purchase Rate',b'Tingkat Pembelian Terakhir'
b'DocType: Account',b'Asset',b'Aset'
b'DocType: Project Task',b'Task ID',b'Tugas ID'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84',b'Stock cannot exist for Item {0} since has variants',b'Persediaan tidak bisa muncul untuk Barang {0} karena memiliki varian'
b'DocType: Lab Test',b'Mobile',b'Mobile'
,b'Sales Person-wise Transaction Summary',b'Sales Person-bijaksana Rangkuman Transaksi'
b'DocType: Training Event',b'Contact Number',b'Nomor kontak'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +73',b'Warehouse {0} does not exist',b'Gudang {0} tidak ada'
b'DocType: Monthly Distribution',b'Monthly Distribution Percentages',b'Persentase Distribusi bulanan'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +110',b'The selected item cannot have Batch',b'Item yang dipilih tidak dapat memiliki Batch'
b'DocType: Delivery Note',b'% of materials delivered against this Delivery Note',b'% Dari materi yang Terkirim terhadap Pengiriman ini Note'
b'DocType: Asset Maintenance Log',b'Has Certificate',b'Memiliki sertifikat'
b'DocType: Project',b'Customer Details',b'Rincian Pelanggan'
b'DocType: Asset',b'Check if Asset requires Preventive Maintenance or Calibration',b'Periksa apakah Aset memerlukan Pemeliharaan atau Kalibrasi Pencegahan'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +87',b'Company Abbreviation cannot have more than 5 characters',b'Singkatan Perusahaan tidak boleh memiliki lebih dari 5 karakter'
b'DocType: Employee',b'Reports to',b'Laporan untuk'
,b'Unpaid Expense Claim',b'Tunggakan Beban Klaim'
b'DocType: Payment Entry',b'Paid Amount',b'Dibayar Jumlah'
b'apps/erpnext/erpnext/utilities/user_progress.py +158',b'Explore Sales Cycle',b'Jelajahi Siklus Penjualan'
b'DocType: Assessment Plan',b'Supervisor',b'Pengawas'
b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +869',b'Retention Stock Entry',b'Entri saham retensi'
,b'Available Stock for Packing Items',b'Tersedia untuk Barang Paket'
b'DocType: Item Variant',b'Item Variant',b'Item Variant'
,b'Work Order Stock Report',b'Laporan Stock Pesanan Kerja'
b'DocType: Assessment Result Tool',b'Assessment Result Tool',b'Alat Hasil penilaian'
b'apps/erpnext/erpnext/education/doctype/instructor/instructor.js +24',b'As Supervisor',b'Sebagai pengawas'
b'DocType: BOM Scrap Item',b'BOM Scrap Item',b'BOM Scrap Barang'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +895',b'Submitted orders can not be deleted',b'perintah yang disampaikan tidak dapat dihapus'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +114',"b""Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'""","b""Saldo rekening sudah berada di Debit, Anda tidak diizinkan untuk mengatur 'Balance Harus' sebagai 'Kredit'"""
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118',b'Quality Management',b'Manajemen Mutu'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +41',b'Item {0} has been disabled',b'Item {0} telah dinonaktifkan'
b'DocType: Project',b'Total Billable Amount (via Timesheets)',b'Total Jumlah yang Dapat Ditagih (via Timesheets)'
b'DocType: Agriculture Task',b'Previous Business Day',b'Hari Bisnis Sebelumnya'
b'DocType: Employee Loan',b'Repay Fixed Amount per Period',b'Membayar Jumlah Tetap per Periode'
b'DocType: Employee',b'Health Insurance No',b'Asuransi Kesehatan No'
b'apps/erpnext/erpnext/buying/utils.py +47',b'Please enter quantity for Item {0}',b'Mohon masukkan untuk Item {0}'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +215',b'Credit Note Amt',b'Catatan Kredit Amt'
b'DocType: Employee External Work History',b'Employee External Work History',b'Karyawan Eksternal Riwayat Pekerjaan'
b'DocType: Opening Invoice Creation Tool',b'Purchase',b'Pembelian'
b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'Balance Qty',b'Jumlah Saldo'
b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20',b'Goals cannot be empty',b'Tujuan tidak boleh kosong'
b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +15',b'Enrolling students',b'Mendaftar siswa'
b'DocType: Item Group',b'Parent Item Group',b'Induk Stok Barang Grup'
b'DocType: Appointment Type',b'Appointment Type',b'Jenis Pengangkatan'
b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21',b'{0} for {1}',b'{0} untuk {1}'
b'DocType: Healthcare Settings',b'Valid number of days',b'Jumlah hari yang valid'
b'apps/erpnext/erpnext/setup/doctype/company/company.js +39',b'Cost Centers',b'Pusat biaya'
b'DocType: Land Unit',b'Linked Plant Analysis',b'Analisis Tanaman Tertanam'
b'DocType: Purchase Receipt',"b""Rate at which supplier's currency is converted to company's base currency""",b'Tingkat di mana mata uang Supplier dikonversi ke mata uang dasar perusahaan'
b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36',b'Row #{0}: Timings conflicts with row {1}',b'Row # {0}: konflik Timing dengan baris {1}'
b'DocType: Purchase Invoice Item',b'Allow Zero Valuation Rate',b'Biarkan Zero Valuation Rate'
b'DocType: Training Event Employee',b'Invited',b'diundang'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +178',b'Multiple active Salary Structures found for employee {0} for the given dates',b'Beberapa Struktur Gaji aktif yang ditemukan untuk karyawan {0} untuk tanggal tertentu'
b'apps/erpnext/erpnext/config/accounts.py +308',b'Setup Gateway accounts.',b'Rekening Gateway setup.'
b'DocType: Employee',b'Employment Type',b'Jenis Pekerjaan'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42',b'Fixed Assets',b'Aktiva Tetap'
b'DocType: Payment Entry',b'Set Exchange Gain / Loss',b'Set Efek Gain / Loss'
,b'GST Purchase Register',b'Daftar Pembelian GST'
,b'Cash Flow',b'Arus kas'
b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25',b'Combined invoice portion must equal 100%',b'Bagian invoice gabungan harus sama dengan 100%'
b'DocType: Item Group',b'Default Expense Account',b'Beban standar Akun'
b'DocType: GST Account',b'CGST Account',b'Akun CGST'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53',b'Student Email ID',b'ID Email Siswa'
b'DocType: Employee',b'Notice (days)',b'Notice (hari)'
b'DocType: Tax Rule',b'Sales Tax Template',b'Template Pajak Penjualan'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2510',b'Select items to save the invoice',b'Pilih item untuk menyimpan faktur'
b'DocType: Employee',b'Encashment Date',b'Pencairan Tanggal'
b'DocType: Training Event',b'Internet',b'Internet'
b'DocType: Special Test Template',b'Special Test Template',b'Template Uji Khusus'
b'DocType: Account',b'Stock Adjustment',b'Penyesuaian Persediaan'
b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34',b'Default Activity Cost exists for Activity Type - {0}',b'Standar Kegiatan Biaya ada untuk Jenis Kegiatan - {0}'
b'DocType: Work Order',b'Planned Operating Cost',b'Direncanakan Biaya Operasi'
b'DocType: Academic Term',b'Term Start Date',b'Jangka Mulai Tanggal'
b'apps/erpnext/erpnext/config/accounts.py +471',b'List of all share transactions',b'Daftar semua transaksi saham'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18',b'Opp Count',b'Opp Count'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +244',b'Please find attached {0} #{1}',b'Silakan menemukan terlampir {0} # {1}'
b'apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py +52',b'Average Rate',b'Harga rata-rata'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +728',b'Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total',b'Jumlah Pembayaran Total dalam Jadwal Pembayaran harus sama dengan Grand / Rounded Total'
b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34',b'Bank Statement balance as per General Ledger',b'Saldo Laporan Bank sesuai Buku Besar'
b'DocType: Job Applicant',b'Applicant Name',b'Nama Pemohon'
b'DocType: Authorization Rule',b'Customer / Item Name',b'Nama Pelanggan / Barang'
b'DocType: Buying Settings',"b'If enabled, last purchase details of items will not be fetched from previous purchase order or purchase receipt'","b'Jika diaktifkan, rincian pembelian terakhir barang tidak akan diambil dari pesanan pembelian sebelumnya atau tanda terima pembelian'"
b'DocType: Product Bundle',"b'Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. \n\nThe package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".\n\nFor Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.\n\nNote: BOM = Bill of Materials'","b'Menggabungkan sekumpulan **Barang-barang** menjadi **Barang** lain. Hal ini berguna bila anda menyusun **Barang-barang** tertentu menjadi sebuah paket dan anda mengelola persediaan **Barang-barang** paket dan bukan sekumpulan **Barang**. **Barang** paket akan menampilkan ""Tidak"" pada ""Barang Stok"" dan ""Ya"" pada ""Barang Jualan"". Sebagai contoh: jika anda menjual Laptop dan Ransel secara terpisah namun memiliki harga khusus bila pelanggan membeli keduanya, maka Laptop + Backpack akan menjadi barang Bundel Produk baru. Catatan: BOM = Bill of Materials'"
b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42',b'Serial No is mandatory for Item {0}',b'Serial ada adalah wajib untuk Item {0}'
b'DocType: Item Variant Attribute',b'Attribute',b'Atribut'
b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43',b'Please specify from/to range',b'Silakan tentukan dari / ke berkisar'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28',b'Opening {0} Invoice created',b'Membuka {0} Faktur dibuat'
b'DocType: Serial No',b'Under AMC',b'Di bawah AMC'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55',b'Item valuation rate is recalculated considering landed cost voucher amount',b'Tingkat penilaian Item dihitung ulang mengingat mendarat biaya jumlah voucher'
b'apps/erpnext/erpnext/config/selling.py +153',b'Default settings for selling transactions.',b'Pengaturan default untuk menjual transaksi.'
b'DocType: Guardian',b'Guardian Of ',b'wali Of'
b'DocType: Grading Scale Interval',b'Threshold',b'Ambang'
b'DocType: BOM Update Tool',b'Current BOM',b'BOM saat ini'
b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +32',b'Balance (Dr - Cr)',b'Saldo (Dr - Cr)'
b'apps/erpnext/erpnext/public/js/utils.js +55',b'Add Serial No',b'Tambahkan Nomor Serial'
b'DocType: Work Order Item',b'Available Qty at Source Warehouse',b'Tersedia Qty di Gudang Sumber'
b'apps/erpnext/erpnext/config/support.py +22',b'Warranty',b'Jaminan'
b'DocType: Purchase Invoice',b'Debit Note Issued',b'Debit Note Ditempatkan'
b'DocType: Work Order',b'Warehouses',b'Gudang'
b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18',b'{0} asset cannot be transferred',b'{0} aset tidak dapat ditransfer'
b'DocType: Hotel Room Pricing',b'Hotel Room Pricing',b'Harga kamar hotel'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +80',b'This Item is a Variant of {0} (Template).',b'Item ini adalah Variant dari {0} (Template).'
b'DocType: Workstation',b'per hour',b'per jam'
b'apps/erpnext/erpnext/config/buying.py +7',b'Purchasing',b'pembelian'
b'DocType: Announcement',b'Announcement',b'Pengumuman'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +84',b'Customer LPO',b'LPO Pelanggan'
b'DocType: Education Settings',"b'For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.'","b'Untuk Kelompok Siswa berbasis Batch, Student Batch akan divalidasi untuk setiap Siswa dari Program Enrollment.'"
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +50',b'Warehouse can not be deleted as stock ledger entry exists for this warehouse.',b'Gudang tidak dapat dihapus karena ada entri buku persediaan untuk gudang ini.'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +25',b'Distribution',b'Distribusi'
b'DocType: Expense Claim Advance',b'Expense Claim Advance',b'Klaim Biaya Klaim'
b'DocType: Lab Test',b'Report Preference',b'Preferensi Laporan'
b'apps/erpnext/erpnext/config/non_profit.py +43',b'Volunteer information.',b'Informasi sukarela'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133',b'Project Manager',b'Manager Project'
,b'Quoted Item Comparison',b'Perbandingan Produk/Barang yang ditawarkan'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34',b'Overlap in scoring between {0} and {1}',b'Tumpang tindih dalam penilaian antara {0} dan {1}'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114',b'Dispatch',b'Pengiriman'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +74',b'Max discount allowed for item: {0} is {1}%',b'Diskon Max diperbolehkan untuk item: {0} {1}%'
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176',b'Net Asset value as on',b'Nilai Aktiva Bersih seperti pada'
b'DocType: Crop',b'Produce',b'Menghasilkan'
b'DocType: Hotel Settings',b'Default Taxes and Charges',b'Pajak default dan Biaya'
b'DocType: Account',b'Receivable',b'Piutang'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +308',b'Row #{0}: Not allowed to change Supplier as Purchase Order already exists',b'Row # {0}: Tidak diperbolehkan untuk mengubah Supplier sebagai Purchase Order sudah ada'
b'DocType: Accounts Settings',b'Role that is allowed to submit transactions that exceed credit limits set.',b'Peran yang diperbolehkan untuk mengirimkan transaksi yang melebihi batas kredit yang ditetapkan.'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +989',b'Select Items to Manufacture',b'Pilih Produk untuk Industri'
b'DocType: Delivery Stop',b'Delivery Stop',b'Berhenti pengiriman'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +963',"b'Master data syncing, it might take some time'","b'Data master sinkronisasi, itu mungkin memakan waktu'"
b'DocType: Item',b'Material Issue',b'Keluar Barang'
b'DocType: Employee Education',b'Qualification',b'Kualifikasi'
b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +42',b'View Salary Slips',b'Lihat Gaji Slip'
b'DocType: Item Price',b'Item Price',b'Item Price'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48',b'Soap & Detergent',b'Sabun & Deterjen'
b'DocType: BOM',b'Show Items',b'Tampilkan Produk'
b'apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30',b'From Time cannot be greater than To Time.',b'Dari waktu tidak dapat lebih besar dari Untuk Waktu.'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +92',b'Do you want to notify all the customers by email?',b'Apakah Anda ingin memberi tahu semua pelanggan melalui email?'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36',b'Motion Picture & Video',b'Motion Picture & Video'
b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5',b'Ordered',b'Ordered'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51',b'Resume',b'Lanjut'
b'DocType: Salary Detail',b'Component',b'Komponen'
b'DocType: Assessment Criteria',b'Assessment Criteria Group',b'Kriteria penilaian Grup'
b'DocType: Healthcare Settings',b'Patient Name By',b'Nama Pasien Oleh'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +72',b'Opening Accumulated Depreciation must be less than equal to {0}',b'Membuka Penyusutan Akumulasi harus kurang dari sama dengan {0}'
b'DocType: Warehouse',b'Warehouse Name',b'Nama Gudang'
b'DocType: Naming Series',b'Select Transaction',b'Pilih Transaksi'
b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30',b'Please enter Approving Role or Approving User',b'Entrikan Menyetujui Peran atau Menyetujui Pengguna'
b'DocType: Journal Entry',b'Write Off Entry',b'Menulis Off Entri'
b'DocType: BOM',b'Rate Of Materials Based On',b'Laju Bahan Berbasis On'
b'apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21',b'Support Analtyics',b'Dukungan Analtyics'
b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102',b'Uncheck all',b'Jangan tandai semua'
b'DocType: POS Profile',b'Terms and Conditions',b'Syarat dan Ketentuan'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49',b'To Date should be within the Fiscal Year. Assuming To Date = {0}',b'Untuk tanggal harus dalam Tahun Anggaran. Dengan asumsi To Date = {0}'
b'DocType: Employee',"b'Here you can maintain height, weight, allergies, medical concerns etc'","b'Di sini Anda dapat mempertahankan tinggi, berat, alergi, masalah medis dll'"
b'DocType: Leave Block List',b'Applies to Company',b'Berlaku untuk Perusahaan'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +231',b'Cannot cancel because submitted Stock Entry {0} exists',b'Tidak bisa membatalkan karena ada Entri Persediaan {0} terkirim'
b'DocType: Employee Loan',b'Disbursement Date',b'pencairan Tanggal'
b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80',"b""'Recipients' not specified""","b""'Penerima' belum ditentukan"""
b'DocType: BOM Update Tool',b'Update latest price in all BOMs',b'Perbarui harga terbaru di semua BOM'
b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +23',b'Medical Record',b'Rekam medis'
b'DocType: Vehicle',b'Vehicle',b'Kendaraan'
b'DocType: Purchase Invoice',b'In Words',b'Dalam Kata'
b'apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15',b'{0} must be submitted',b'{0} harus diserahkan'
b'DocType: POS Profile',b'Item Groups',b'Grup Item'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +221',"b""Today is {0}'s birthday!""","b""Hari ini adalah {0} 's birthday!"""
b'DocType: Sales Order Item',b'For Production',b'Untuk Produksi'
b'DocType: Payment Request',b'payment_url',b'payment_url'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +186',b'Please add a Temporary Opening account in Chart of Accounts',b'Harap tambahkan akun Pembukaan Sementara di Bagan Akun'
b'DocType: Customer',b'Customer Primary Contact',b'Kontak utama pelanggan'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +154',b'Period Closing Journal',b'Jurnal Penutupan Periode'
b'DocType: Project Task',b'View Task',b'Lihat Task'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22',b'Opp/Lead %',b'Peluang/Prospek %'
b'DocType: Material Request',b'MREQ-',b'MREQ-'
b'DocType: Payment Schedule',b'Invoice Portion',b'Bagian faktur'
,b'Asset Depreciations and Balances',b'Penyusutan aset dan Saldo'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +370',b'Amount {0} {1} transferred from {2} to {3}',b'Jumlah {0} {1} ditransfer dari {2} untuk {3}'
b'DocType: Sales Invoice',b'Get Advances Received',b'Dapatkan Uang Muka Diterima'
b'DocType: Email Digest',b'Add/Remove Recipients',b'Tambah / Hapus Penerima'
b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19',"b""To set this Fiscal Year as Default, click on 'Set as Default'""","b""Untuk mengatur Tahun Anggaran ini sebagai Default, klik 'Set as Default'"""
b'DocType: Production Plan',b'Include Subcontracted Items',b'Sertakan Subkontrak Items'
b'apps/erpnext/erpnext/projects/doctype/project/project.py +220',b'Join',b'Bergabung'
b'apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21',b'Shortage Qty',b'Kekurangan Jumlah'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +672',b'Cannot change Variant properties after stock transction. You will have to make a new Item to do this.',b'Tidak dapat mengubah sifat Variant setelah stock transction. Anda harus membuat Item baru untuk melakukan ini.'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +714',b'Item variant {0} exists with same attributes',b'Item varian {0} ada dengan atribut yang sama'
b'DocType: Employee Loan',b'Repay from Salary',b'Membayar dari Gaji'
b'DocType: Leave Application',b'LAP/',b'PUTARAN/'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +360',b'Requesting payment against {0} {1} for amount {2}',b'Meminta pembayaran terhadap {0} {1} untuk jumlah {2}'
b'DocType: Salary Slip',b'Salary Slip',b'Slip Gaji'
b'DocType: Lead',b'Lost Quotation',b'Quotation hilang'
b'apps/erpnext/erpnext/utilities/user_progress.py +221',b'Student Batches',b'Batch Siswa'
b'DocType: Pricing Rule',b'Margin Rate or Amount',b'Tingkat margin atau Jumlah'
b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48',"b""'To Date' is required""","b""'Tanggal Akhir' harus diisi"""
b'DocType: Packing Slip',"b'Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.'","b'Menghasilkan kemasan slip paket yang akan dikirimkan. Digunakan untuk memberitahu nomor paket, isi paket dan berat.'"
b'DocType: Sales Invoice Item',b'Sales Order Item',b'Stok barang Order Penjualan'
b'DocType: Salary Slip',b'Payment Days',b'Hari Jeda Pembayaran'
b'DocType: Stock Settings',b'Convert Item Description to Clean HTML',b'Mengkonversi Deskripsi Item untuk Bersihkan HTML'
b'DocType: Patient',b'Dormant',b'Terbengkalai'
b'DocType: Salary Slip',b'Total Interest Amount',b'Jumlah Bunga Total'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +124',b'Warehouses with child nodes cannot be converted to ledger',b'Gudang dengan node anak tidak dapat dikonversi ke buku besar'
b'DocType: BOM',b'Manage cost of operations',b'Kelola biaya operasional'
b'DocType: Accounts Settings',b'Stale Days',b'Hari basi'
b'DocType: Notification Control',"b'When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.'","b'Ketika salah satu transaksi yang dicentang ""Dikirim"", pop-up email secara otomatis terbuka untuk mengirim email ke ""Kontak"" terkait dalam transaksi itu, dengan transaksi sebagai lampiran. Pengguna bisa mengirim email tersebut atau tidak mengirim.'"
b'apps/erpnext/erpnext/config/setup.py +14',b'Global Settings',b'Pengaturan global'
b'DocType: Crop',b'Row Spacing UOM',b'Row Spacing UOM'
b'DocType: Assessment Result Detail',b'Assessment Result Detail',b'Penilaian Detil Hasil'
b'DocType: Employee Education',b'Employee Education',b'Pendidikan Karyawan'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53',b'Duplicate item group found in the item group table',b'Kelompok barang duplikat yang ditemukan dalam tabel grup item'
b'DocType: Land Unit',b'Parent Land Unit',b'Unit Induk Tanah'
b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1113',b'It is needed to fetch Item Details.',b'Hal ini diperlukan untuk mengambil Item detail.'
b'DocType: Fertilizer',b'Fertilizer Name',b'Nama pupuk'
b'DocType: Salary Slip',b'Net Pay',b'Nilai Bersih Terbayar'
b'DocType: Cash Flow Mapping Accounts',b'Account',b'Akun'
b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217',b'Serial No {0} has already been received',b'Serial ada {0} telah diterima'
,b'Requested Items To Be Transferred',b'Permintaan Produk Akan Ditransfer'
b'DocType: Expense Claim',b'Vehicle Log',b'kendaraan Log'
b'DocType: Vital Signs',b'Presence of a fever (temp &gt; 38.5 \xc2\xb0C/101.3 \xc2\xb0F or sustained temp &gt; 38 \xc2\xb0C/100.4 \xc2\xb0F)',"b'Adanya demam (suhu&gt; 38,5 \xc2\xb0 C / 101,3 \xc2\xb0 F atau suhu bertahan&gt; 38 \xc2\xb0 C / 100,4 \xc2\xb0 F)'"
b'DocType: Customer',b'Sales Team Details',b'Rincian Tim Penjualan'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1352',b'Delete permanently?',b'Hapus secara permanen?'
b'DocType: Expense Claim',b'Total Claimed Amount',b'Jumlah Total Diklaim'
b'apps/erpnext/erpnext/config/crm.py +17',b'Potential opportunities for selling.',b'Potensi peluang untuk menjadi penjualan.'
b'DocType: Shareholder',b'Folio no.',b'Folio no.'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +246',b'Invalid {0}',b'Valid {0}'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90',b'Sick Leave',b'Cuti Sakit'
b'DocType: Email Digest',b'Email Digest',b'Ringkasan Surel'
b'DocType: Delivery Note',b'Billing Address Name',b'Nama Alamat Penagihan'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22',b'Department Stores',b'Departmen Store'
,b'Item Delivery Date',b'Tanggal Pengiriman Barang'
b'DocType: Production Plan',b'Material Requested',b'Bahan yang diminta'
b'DocType: Warehouse',b'PIN',b'PIN'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +116',"b""Error '{0}' occured. Arguments {1}.""",b'Kesalahan &#39;{0}&#39; terjadi. Argumen {1}.'
b'DocType: Bin',b'Reserved Qty for sub contract',b'Reserved Qty untuk sub kontrak'
b'DocType: Patient Service Unit',b'Patinet Service Unit',b'Unit Layanan Patinet'
b'DocType: Sales Invoice',b'Base Change Amount (Company Currency)',b'Dasar Nilai Tukar (Mata Uang Perusahaan)'
b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304',b'No accounting entries for the following warehouses',b'Tidak ada entri akuntansi untuk gudang berikut'
b'apps/erpnext/erpnext/projects/doctype/project/project.js +95',b'Save the document first.',b'Simpan dokumen terlebih dahulu.'
b'apps/erpnext/erpnext/shopping_cart/cart.py +74',b'Only {0} in stock for item {1}',b'Hanya {0} yang tersedia untuk item {1}'
b'DocType: Account',b'Chargeable',b'Dapat Dibebankan'
b'DocType: Company',b'Change Abbreviation',b'Ubah Singkatan'
b'apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py +66',b'Pay {0} {1}',b'Bayar {0} {1}'
b'DocType: Expense Claim Detail',b'Expense Date',b'Beban Tanggal'
b'DocType: Item',b'Max Discount (%)',b'Max Diskon (%)'
b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30',b'Credit Days cannot be a negative number',b'Hari Kredit tidak bisa menjadi angka negatif'
b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70',b'Last Order Amount',b'Jumlah Order terakhir'
b'DocType: Cash Flow Mapper',b'e.g Adjustments for:',b'misalnya Penyesuaian untuk:'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +275',"b' {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item'","b'{0} Sampel disimpan berdasarkan batch, tandai Nomor Batch untuk menyimpan sampel barang'"
b'DocType: Task',b'Is Milestone',b'Adalah tonggak'
b'DocType: Delivery Stop',b'Email Sent To',b'Surel Dikirim Ke'
b'DocType: Budget',b'Warn',b'Peringatan: Cuti aplikasi berisi tanggal blok berikut'
b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +81',b'Are you sure you want to unregister?',b'Anda yakin ingin membatalkan pendaftaran?'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +797',b'All items have already been transferred for this Work Order.',b'Semua item telah ditransfer untuk Perintah Kerja ini.'
b'DocType: Appraisal',"b'Any other remarks, noteworthy effort that should go in the records.'","b'Setiap komentar lain, upaya penting yang harus pergi dalam catatan.'"
b'DocType: Asset Maintenance',b'Manufacturing User',b'Manufaktur Pengguna'
b'DocType: Purchase Invoice',b'Raw Materials Supplied',b'Bahan Baku Disupply'
b'DocType: C-Form',b'Series',b'Seri'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +282',b'Currency of the price list {0} must be {1} or {2}',b'Mata uang dari daftar harga {0} harus {1} atau {2}'
b'DocType: Appraisal',b'Appraisal Template',b'Template Penilaian'
b'DocType: Soil Texture',b'Ternary Plot',b'Ternary Plot'
b'DocType: Item Group',b'Item Classification',b'Klasifikasi Stok Barang'
b'DocType: Driver',b'License Number',b'Nomor lisensi'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131',b'Business Development Manager',b'Business Development Manager'
b'DocType: Maintenance Visit Purpose',b'Maintenance Visit Purpose',b'Pemeliharaan Visit Tujuan'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19',b'Invoice Patient Registration',b'Pendaftaran Faktur Pasien'
b'DocType: Crop',b'Period',b'periode'
b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +27',b'General Ledger',b'General Ledger'
b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33',b'Employee {0} on Leave on {1}',b'Karyawan {0} pada Cuti pada {1}'
b'apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10',b'View Leads',b'Lihat Prospek'
b'DocType: Program Enrollment Tool',b'New Program',b'Program baru'
b'DocType: Item Attribute Value',b'Attribute Value',b'Nilai Atribut'
,b'Itemwise Recommended Reorder Level',b'Itemwise Rekomendasi Reorder Tingkat'
b'DocType: Salary Detail',b'Salary Detail',b'Detil gaji'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1070',b'Please select {0} first',b'Silahkan pilih {0} terlebih dahulu'
b'DocType: Appointment Type',b'Physician',b'Dokter'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +872',b'Batch {0} of Item {1} has expired.',b'Kumpulan {0} Barang {1} telah berakhir.'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11',b'Consultations',b'Konsultasi'
b'DocType: Sales Invoice',b'Commission',b'Komisi'
b'apps/erpnext/erpnext/config/manufacturing.py +27',b'Time Sheet for manufacturing.',b'Waktu Lembar untuk manufaktur.'
b'apps/erpnext/erpnext/templates/pages/cart.html +37',b'Subtotal',b'Subtotal'
b'apps/erpnext/erpnext/config/erpnext_integrations.py +18',b'GoCardless SEPA Mandate',b'GoCardless SEPA Mandate'
b'DocType: Physician',b'Charges',b'Biaya'
b'DocType: Production Plan',b'Get Items For Work Order',b'Dapatkan Item Untuk Perintah Kerja'
b'DocType: Salary Detail',b'Default Amount',b'Jumlah Standar'
b'DocType: Lab Test Template',b'Descriptive',b'Deskriptif'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +95',b'Warehouse not found in the system',b'Gudang tidak ditemukan dalam sistem'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115',"b""This Month's Summary""",b'Ringkasan ini Bulan ini'
b'DocType: Quality Inspection Reading',b'Quality Inspection Reading',b'Nilai Inspeksi Mutu'
b'apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25',b'`Freeze Stocks Older Than` should be smaller than %d days.',"b""'Bekukan Persediaan Lebih Lama Dari' harus lebih kecil dari %d hari."""
b'DocType: Tax Rule',b'Purchase Tax Template',b'Pembelian Template Pajak'
b'apps/erpnext/erpnext/utilities/user_progress.py +48',"b""Set a sales goal you'd like to achieve for your company.""",b'Tetapkan sasaran penjualan yang ingin Anda capai untuk perusahaan Anda.'
,b'Project wise Stock Tracking',b'Pelacakan Persediaan menurut Proyek'
b'DocType: GST HSN Code',b'Regional',b'Daerah'
b'apps/erpnext/erpnext/config/healthcare.py +40',b'Laboratory',b'Laboratorium'
b'DocType: Stock Entry Detail',b'Actual Qty (at source/target)',b'Jumlah Aktual (di sumber/target)'
b'DocType: Item Customer Detail',b'Ref Code',b'Ref Kode'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75',b'Customer Group is Required in POS Profile',b'Grup Pelanggan Diperlukan di Profil POS'
b'apps/erpnext/erpnext/config/hr.py +12',b'Employee records.',b'Catatan karyawan.'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +98',b'Please set Next Depreciation Date',b'Silahkan mengatur Berikutnya Penyusutan Tanggal'
b'DocType: HR Settings',b'Payroll Settings',b'Pengaturan Payroll'
b'apps/erpnext/erpnext/config/accounts.py +146',b'Match non-linked Invoices and Payments.',b'Cocokkan Faktur non-linked dan Pembayaran.'
b'DocType: POS Settings',b'POS Settings',b'Pengaturan POS'
b'apps/erpnext/erpnext/templates/pages/cart.html +16',b'Place Order',b'Order'
b'DocType: Email Digest',b'New Purchase Orders',b'Pesanan Pembelian Baru'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24',b'Root cannot have a parent cost center',b'Root tidak dapat memiliki pusat biaya orang tua'
b'apps/erpnext/erpnext/public/js/stock_analytics.js +54',b'Select Brand...',b'Pilih Merek ...'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +32',b'Non Profit (beta)',b'Non Profit (beta)'
b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18',b'Training Events/Results',b'Acara / Hasil Pelatihan'
b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152',b'Accumulated Depreciation as on',b'Akumulasi Penyusutan seperti pada'
b'DocType: Sales Invoice',b'C-Form Applicable',b'C-Form Berlaku'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +438',b'Operation Time must be greater than 0 for Operation {0}',b'Operasi Waktu harus lebih besar dari 0 untuk operasi {0}'
b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +107',b'Warehouse is mandatory',b'Gudang adalah wajib'
b'DocType: Shareholder',b'Address and Contacts',b'Alamat dan Kontak'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67',b'Failed to create website',b'Gagal membuat situs web'
b'DocType: Soil Analysis',b'Mg/K',b'Mg / K'
b'DocType: UOM Conversion Detail',b'UOM Conversion Detail',b'Detil UOM Konversi'
b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +924',b'Retention Stock Entry already created or Sample Quantity not provided',b'Entry Stok Retensi sudah dibuat atau Jumlah Sampel tidak disediakan'
b'DocType: Program',b'Program Abbreviation',b'Singkatan Program'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52',b'Charges are updated in Purchase Receipt against each item',b'Ongkos dalam Nota Pembelian diperbarui terhadap setiap barang'
b'DocType: Warranty Claim',b'Resolved By',b'Terselesaikan Dengan'
b'DocType: Bank Guarantee',b'Start Date',b'Tanggal Mulai'
b'apps/erpnext/erpnext/config/hr.py +75',b'Allocate leaves for a period.',b'Alokasi cuti untuk periode tertentu'
b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42',b'Cheques and Deposits incorrectly cleared',b'Cek dan Deposit tidak benar dibersihkan'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +46',b'Account {0}: You can not assign itself as parent account',b'Akun {0}: Anda tidak dapat menetapkanya sebagai Akun Induk'
b'DocType: Purchase Invoice Item',b'Price List Rate',b'Daftar Harga Tingkat'
b'apps/erpnext/erpnext/utilities/activation.py +72',b'Create customer quotes',b'Buat kutipan pelanggan'
b'DocType: Item',"b'Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.'","b'Tampilkan ""Tersedia"" atau ""Tidak Tersedia"" berdasarkan persediaan di gudang ini.'"
b'apps/erpnext/erpnext/config/manufacturing.py +38',b'Bill of Materials (BOM)',b'Bill of Material (BOM)'
b'DocType: Item',b'Average time taken by the supplier to deliver',b'Rata-rata waktu yang dibutuhkan oleh Supplier untuk memberikan'
b'DocType: Sample Collection',b'Collected By',b'Dikumpulkan Oleh'
b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +35',b'Assessment Result',b'penilaian Hasil'
b'DocType: Hotel Room Package',b'Hotel Room Package',b'Paket kamar hotel'
b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13',b'Hours',b'Jam'
b'DocType: Project',b'Expected Start Date',b'Diharapkan Tanggal Mulai'
b'DocType: Purchase Invoice',b'04-Correction in Invoice',b'04-Koreksi dalam Faktur'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +963',b'Work Order already created for all items with BOM',b'Work Order sudah dibuat untuk semua item dengan BOM'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +60',b'Variant Details Report',b'Laporan Detail Variant'
b'DocType: Setup Progress Action',b'Setup Progress Action',b'Setup Progress Action'
b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +36',b'Buying Price List',b'Daftar harga beli'
b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49',b'Remove item if charges is not applicable to that item',b'Hapus item jika biaya ini tidak berlaku untuk item'
b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21',b'Please select Maintenance Status as Completed or remove Completion Date',b'Harap pilih Status Pemeliharaan sebagai Selesai atau hapus Tanggal Penyelesaian'
b'DocType: Supplier',b'Default Payment Terms Template',b'Template Persyaratan Pembayaran Default'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34',b'Transaction currency must be same as Payment Gateway currency',b'Transaksi mata uang harus sama dengan Payment Gateway mata uang'
b'DocType: Payment Entry',b'Receive',b'Menerima'
b'apps/erpnext/erpnext/templates/pages/rfq.html +75',b'Quotations: ',b'Penawaran:'
b'DocType: Maintenance Visit',b'Fully Completed',b'Sepenuhnya Selesai'
b'apps/erpnext/erpnext/projects/doctype/project/project_list.js +6',b'{0}% Complete',b'{0}% Lengkap'
b'DocType: Employee',b'Educational Qualification',b'Kualifikasi Pendidikan'
b'DocType: Workstation',b'Operating Costs',b'Biaya Operasional'
b'DocType: Budget',b'Action if Accumulated Monthly Budget Exceeded',b'Tindakan jika Akumulasi Anggaran Bulanan Melebihi'
b'DocType: Subscription',b'Submit on creation',b'Kirim pada penciptaan'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +483',b'Currency for {0} must be {1}',b'Mata uang untuk {0} harus {1}'
b'DocType: Asset',b'Disposal Date',b'pembuangan Tanggal'
b'DocType: Daily Work Summary Settings',"b'Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.'","b'Email akan dikirim ke semua Karyawan Aktif perusahaan pada jam tertentu, jika mereka tidak memiliki liburan. Ringkasan tanggapan akan dikirim pada tengah malam.'"
b'DocType: Employee Leave Approver',b'Employee Leave Approver',b'Approver Cuti Karyawan'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +510',b'Row {0}: An Reorder entry already exists for this warehouse {1}',b'Baris {0}: Entri perekam sudah ada untuk gudang ini {1}'
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99',"b'Cannot declare as lost, because Quotation has been made.'","b'Tidak dapat mendeklarasikan sebagai hilang, karena Quotation telah dibuat.'"
b'apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16',b'Training Feedback',b'pelatihan Masukan'
b'DocType: Supplier Scorecard Criteria',b'Supplier Scorecard Criteria',b'Kriteria Scorecard Pemasok'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149',b'Please select Start Date and End Date for Item {0}',b'Silakan pilih Tanggal Mulai dan Tanggal Akhir untuk Item {0}'
b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55',b'Course is mandatory in row {0}',b'Tentu saja adalah wajib berturut-turut {0}'
b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16',b'To date cannot be before from date',b'Sampai saat ini tidak dapat sebelumnya dari tanggal'
b'DocType: Supplier Quotation Item',b'Prevdoc DocType',b'Prevdoc DocType'
b'DocType: Cash Flow Mapper',b'Section Footer',b'Bagian footer'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +304',b'Add / Edit Prices',b'Tambah / Edit Harga'
b'DocType: Batch',b'Parent Batch',b'Induk induk'
b'DocType: Cheque Print Template',b'Cheque Print Template',b'Template Print Cek'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36',b'Chart of Cost Centers',b'Bagan Pusat Biaya'
b'DocType: Lab Test Template',b'Sample Collection',b'Koleksi Sampel'
,b'Requested Items To Be Ordered',b'Produk Diminta Akan Memerintahkan'
b'apps/erpnext/erpnext/public/js/hub/hub_page.js +137',b'My Orders',b'Order saya'
b'DocType: Price List',b'Price List Name',b'Daftar Harga Nama'
b'DocType: BOM',b'Manufacturing',b'Manufaktur'
,b'Ordered Items To Be Delivered',b'Ordered Items Akan Terkirim'
b'DocType: Account',b'Income',b'Penghasilan'
b'DocType: Industry Type',b'Industry Type',b'Jenis Produksi'
b'apps/erpnext/erpnext/templates/includes/cart.js +150',b'Something went wrong!',b'Ada yang salah!'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +105',b'Warning: Leave application contains following block dates',b'Peringatan: Cuti aplikasi berisi tanggal blok berikut'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +275',b'Sales Invoice {0} has already been submitted',b'Faktur Penjualan {0} telah terkirim'
b'DocType: Supplier Scorecard Scoring Criteria',b'Score',b'Skor'
b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25',b'Fiscal Year {0} does not exist',b'Tahun fiskal {0} tidak ada'
b'DocType: Asset Maintenance Log',b'Completion Date',b'Tanggal Penyelesaian'
b'DocType: Purchase Invoice Item',b'Amount (Company Currency)',b'Nilai Jumlah (mata uang perusahaan)'
b'DocType: Agriculture Analysis Criteria',b'Agriculture User',b'Pengguna pertanian'
b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38',b'Valid till date cannot be before transaction date',b'Berlaku sampai tanggal tidak dapat dilakukan sebelum tanggal transaksi'
b'apps/erpnext/erpnext/stock/stock_ledger.py +381',b'{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.',b'{0} unit {1} dibutuhkan dalam {2} pada {3} {4} untuk {5} untuk menyelesaikan transaksi ini.'
b'DocType: Fee Schedule',b'Student Category',b'Mahasiswa Kategori'
b'DocType: Announcement',b'Student',b'Mahasiswa'
b'apps/erpnext/erpnext/config/hr.py +238',b'Organization unit (department) master.',b'Unit Organisasi (kawasan) menguasai.'
b'DocType: Shipping Rule',b'Shipping Rule Type',b'Jenis aturan pengiriman'
b'apps/erpnext/erpnext/utilities/user_progress.py +239',b'Go to Rooms',b'Pergi ke kamar'
b'apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75',b'Please enter message before sending',b'Entrikan pesan sebelum mengirimnya'
b'DocType: Purchase Invoice',b'DUPLICATE FOR SUPPLIER',b'DUPLICATE UNTUK PEMASOK'
b'DocType: Email Digest',b'Pending Quotations',b'tertunda Kutipan'
b'apps/erpnext/erpnext/config/accounts.py +318',b'Point-of-Sale Profile',b'Profil Point of Sale'
b'apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +25',b'{0} should be a value between 0 and 100',b'{0} harus bernilai antara 0 dan 100'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +94',b'Next Depreciation Date cannot be before Available-for-use Date',b'Tanggal Penyusutan Berikutnya tidak boleh sebelum Tanggal Tersedia untuk Penggunaan'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156',b'Unsecured Loans',b'Pinjaman tanpa Jaminan'
b'DocType: Cost Center',b'Cost Center Name',b'Nama Pusat Biaya'
b'DocType: Student',b'B+',b'B +'
b'DocType: HR Settings',b'Max working hours against Timesheet',b'Max jam bekerja melawan Timesheet'
b'DocType: Maintenance Schedule Detail',b'Scheduled Date',b'Dijadwalkan Tanggal'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +214',b'Total Paid Amt',b'Total nilai Bayar'
b'DocType: SMS Center',b'Messages greater than 160 characters will be split into multiple messages',b'Pesan lebih dari 160 karakter akan dipecah menjadi beberapa pesan'
b'DocType: Purchase Receipt Item',b'Received and Accepted',b'Diterima dan Diterima'
b'DocType: Hub Settings',b'Company and Seller Profile',b'Profil Perusahaan dan Penjual'
,b'GST Itemised Sales Register',b'Daftar Penjualan Item GST'
b'DocType: Soil Texture',b'Silt Loam',b'Silt Loam'
,b'Serial No Service Contract Expiry',b'Masa Kadaluwarsa Nomor Seri Kontrak Jasa'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299',b'You cannot credit and debit same account at the same time',b'Anda tidak dapat mengkredit dan mendebit rekening yang sama secara bersamaan'
b'DocType: Vital Signs',"b""Adults' pulse rate is anywhere between 50 and 80 beats per minute.""",b'Denyut nadi orang dewasa adalah antara 50 dan 80 denyut per menit.'
b'DocType: Naming Series',b'Help HTML',b'Bantuan HTML'
b'DocType: Student Group Creation Tool',b'Student Group Creation Tool',b'Alat Grup Pelajar Creation'
b'DocType: Item',b'Variant Based On',b'Varian Berbasis Pada'
b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53',b'Total weightage assigned should be 100%. It is {0}',b'Jumlah weightage ditugaskan harus 100%. Ini adalah {0}'
b'apps/erpnext/erpnext/utilities/user_progress.py +109',b'Your Suppliers',b'Pemasok Anda'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'Please correct the',b'Perbaiki'
b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80',b'Cannot set as Lost as Sales Order is made.',b'Tidak dapat ditetapkan sebagai Hilang sebagai Sales Order dibuat.'
b'DocType: Request for Quotation Item',b'Supplier Part No',b'Pemasok Bagian Tidak'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +382',"b""Cannot deduct when category is for 'Valuation' or 'Vaulation and Total'""",b'tidak bisa memotong ketika kategori adalah untuk &#39;Penilaian&#39; atau &#39;Vaulation dan Total&#39;'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +377',b'Received From',b'Diterima dari'
b'DocType: Lead',b'Converted',b'Dikonversi'
b'DocType: Item',b'Has Serial No',b'Bernomor Seri'
b'DocType: Employee',b'Date of Issue',b'Tanggal Issue'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222',"b""As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}""","b'Sesuai dengan Setelan Pembelian jika Diperlukan Pembelian Diperlukan == &#39;YA&#39;, maka untuk membuat Purchase Invoice, pengguna harus membuat Purchase Receipt terlebih dahulu untuk item {0}'"
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167',b'Row #{0}: Set Supplier for item {1}',b'Row # {0}: Set Supplier untuk item {1}'
b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121',b'Row {0}: Hours value must be greater than zero.',b'Row {0}: nilai Jam harus lebih besar dari nol.'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +195',b'Website Image {0} attached to Item {1} cannot be found',b'Website Image {0} melekat Butir {1} tidak dapat ditemukan'
b'DocType: Issue',b'Content Type',b'Tipe Konten'
b'DocType: Asset',b'Assets',b'Aktiva'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17',b'Computer',b'Komputer'
b'DocType: Item',b'List this Item in multiple groups on the website.',b'Daftar Stok Barang ini dalam beberapa kelompok di website.'
b'DocType: Payment Term',b'Due Date Based On',b'Tanggal Jatuh Tempo Berdasarkan'
b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +82',b'Please set default customer group and territory in Selling Settings',b'Harap atur grup pelanggan dan wilayah default di Setelan Penjualan'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +214',b'{0} {1} does not exist',b'{0} {1} tidak ada'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323',b'Please check Multi Currency option to allow accounts with other currency',b'Silakan periksa opsi Mata multi untuk memungkinkan account dengan mata uang lainnya'
b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +88',b'Item: {0} does not exist in the system',b'Item: {0} tidak ada dalam sistem'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +106',b'You are not authorized to set Frozen value',b'Anda tidak diizinkan menetapkan nilai yg sedang dibekukan'
b'DocType: Payment Reconciliation',b'Get Unreconciled Entries',b'Dapatkan Entries Unreconciled'
b'DocType: Payment Reconciliation',b'From Invoice Date',b'Dari Tanggal Faktur'
b'DocType: Healthcare Settings',b'Laboratory Settings',b'Pengaturan Laboratorium'
b'DocType: Patient Appointment',b'Service Unit',b'Unit Layanan'
b'apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +97',b'Successfully Set Supplier',b'Berhasil Set Supplier'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75',b'Leave Encashment',b'Tinggalkan Pencairan'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +114',b'What does it do?',b'Apa pekerjaannya?'
b'DocType: Crop',b'Byproducts',b'Produk sampingan'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +84',b'To Warehouse',b'Untuk Gudang'
b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26',b'All Student Admissions',b'Semua Penerimaan Mahasiswa'
,b'Average Commission Rate',b'Rata-rata Komisi Tingkat'
b'DocType: Share Balance',b'No of Shares',b'Tidak ada saham'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +448',"b""'Has Serial No' can not be 'Yes' for non-stock item""","b""'Bernomor Seri' tidak dapat \xe2\x80\x98Ya\xe2\x80\x99 untuk barang non-persediaan"""
b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +59',b'Select Status',b'Pilih Status'
b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41',b'Attendance can not be marked for future dates',b'Kehadiran tidak dapat ditandai untuk tanggal masa depan'
b'DocType: Pricing Rule',b'Pricing Rule Help',b'Aturan Harga Bantuan'
b'DocType: School House',b'House Name',b'Nama rumah'
b'DocType: Fee Schedule',b'Total Amount per Student',b'Jumlah Total per Siswa'
b'DocType: Purchase Taxes and Charges',b'Account Head',b'Akun Kepala'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153',b'Electrical',b'Listrik'
b'apps/erpnext/erpnext/utilities/activation.py +100',b'Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts',b'Tambahkan sisa organisasi Anda sebagai pengguna Anda. Anda juga dapat menambahkan mengundang Pelanggan portal Anda dengan menambahkan mereka dari Kontak'
b'DocType: Stock Entry',b'Total Value Difference (Out - In)',b'Total Nilai Selisih (Out - Dalam)'
b'DocType: Grant Application',b'Requested Amount',b'Jumlah yang diminta'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348',b'Row {0}: Exchange Rate is mandatory',b'Row {0}: Kurs adalah wajib'
b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27',b'User ID not set for Employee {0}',b'User ID tidak ditetapkan untuk Karyawan {0}'
b'DocType: Vehicle',b'Vehicle Value',b'Nilai kendaraan'
b'DocType: Crop Cycle',b'Detected Diseases',b'Penyakit Terdeteksi'
b'DocType: Stock Entry',b'Default Source Warehouse',b'Standar Gudang Sumber'
b'DocType: Item',b'Customer Code',b'Kode Pelanggan'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +220',b'Birthday Reminder for {0}',b'Birthday Reminder untuk {0}'
b'DocType: Asset Maintenance Task',b'Last Completion Date',b'Tanggal penyelesaian terakhir'
b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72',b'Days Since Last Order',b'Jumlah Hari Semenjak Order Terakhir'
b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +365',b'Debit To account must be a Balance Sheet account',b'Debit Untuk akun harus rekening Neraca'
b'DocType: Buying Settings',b'Naming Series',b'Series Penamaan'
b'DocType: GoCardless Settings',b'GoCardless Settings',b'Pengaturan GoCardless'
b'DocType: Leave Block List',b'Leave Block List Name',b'Cuti Nama Block List'
b'apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14',b'Insurance Start date should be less than Insurance End date',b'Tanggal asuransi mulai harus kurang dari tanggal asuransi End'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32',b'Stock Assets',b'Asset Persediaan'
b'DocType: Restaurant',b'Active Menu',b'Menu Aktif'
b'DocType: Target Detail',b'Target Qty',b'Qty Target'
b'DocType: Shopping Cart Settings',b'Checkout Settings',b'Pengaturan Checkout'
b'DocType: Student Attendance',b'Present',b'ada'
b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37',b'Delivery Note {0} must not be submitted',b'Pengiriman Note {0} tidak boleh Terkirim'
b'DocType: Notification Control',b'Sales Invoice Message',b'Pesan Faktur Penjualan'
b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27',b'Closing Account {0} must be of type Liability / Equity',b'Penutupan Rekening {0} harus dari jenis Kewajiban / Ekuitas'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +325',b'Salary Slip of employee {0} already created for time sheet {1}',b'Slip Gaji karyawan {0} sudah dibuat untuk daftar absen {1}'
b'DocType: Vehicle Log',b'Odometer',b'Odometer'
b'DocType: Production Plan Item',b'Ordered Qty',b'Qty Terorder'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +744',b'Item {0} is disabled',b'Item {0} dinonaktifkan'
b'DocType: Stock Settings',b'Stock Frozen Upto',b'Stock Frozen Upto'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +930',b'BOM does not contain any stock item',b'BOM tidak berisi barang persediaan apapun'
b'DocType: Chapter',b'Chapter Head',b'Kepala Bab'
b'DocType: Payment Term',b'Month(s) after the end of the invoice month',b'Bulan setelah akhir bulan faktur'
b'apps/erpnext/erpnext/config/projects.py +24',b'Project activity / task.',b'Kegiatan proyek / tugas.'
b'DocType: Vehicle Log',b'Refuelling Details',b'Detail Pengisian'
b'apps/erpnext/erpnext/config/hr.py +104',b'Generate Salary Slips',b'Buat Slip Gaji'
b'apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +25',b'Lab result datetime cannot be before testing datetime',b'Hasil lab datetime tidak bisa sebelum pengujian datetime'
b'DocType: POS Profile',b'Allow user to edit Discount',b'Izinkan pengguna mengedit Diskon'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +55',b'Get customers from',b'Dapatkan pelanggan dari'
b'DocType: Purchase Invoice Item',b'Include Exploded Items',b'Sertakan barang yang meledak'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +45',"b'Buying must be checked, if Applicable For is selected as {0}'","b'Membeli harus dicentang, jika ""Berlaku Untuk"" dipilih sebagai {0}'"
b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40',b'Discount must be less than 100',b'Diskon harus kurang dari 100'
b'DocType: Shipping Rule',b'Restrict to Countries',b'Batasi ke Negara'
b'DocType: Purchase Invoice',b'Write Off Amount (Company Currency)',b'Jumlah Nilai Write Off (mata uang perusahaan)'
b'DocType: Sales Invoice Timesheet',b'Billing Hours',b'Jam penagihan'
b'DocType: Project',b'Total Sales Amount (via Sales Order)',b'Total Jumlah Penjualan (via Sales Order)'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +548',b'Default BOM for {0} not found',b'BOM default untuk {0} tidak ditemukan'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +514',b'Row #{0}: Please set reorder quantity',b'Row # {0}: Silakan mengatur kuantitas menyusun ulang'
b'apps/erpnext/erpnext/public/js/pos/pos.html +20',b'Tap items to add them here',b'Ketuk item untuk menambahkannya di sini'
b'DocType: Fees',b'Program Enrollment',b'Program Pendaftaran'
b'DocType: Share Transfer',b'To Folio No',b'Untuk Folio No'
b'DocType: Landed Cost Voucher',b'Landed Cost Voucher',b'Voucher Landing Cost'
b'apps/erpnext/erpnext/public/js/queries.js +39',b'Please set {0}',b'Silakan set {0}'
b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37',b'{0} - {1} is inactive student',b'{0} - {1} adalah siswa tidak aktif'
b'DocType: Employee',b'Health Details',b'Detail Kesehatan'
b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24',b'To create a Payment Request reference document is required',b'Untuk membuat dokumen referensi Request Request diperlukan'
b'DocType: Soil Texture',b'Sandy Clay',b'Sandy Clay'
b'DocType: Grant Application',b'Assessment  Manager',b'Manajer Penilaian'
b'DocType: Payment Entry',b'Allocate Payment Amount',b'Alokasikan Jumlah Pembayaran'
b'DocType: Employee External Work History',b'Salary',b'Gaji'
b'DocType: Serial No',b'Delivery Document Type',b'Tipe Nota Pengiriman'
b'DocType: Sales Order',b'Partly Delivered',b'Terkirim Sebagian'
b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48',b'Item Code &gt; Item Group &gt; Brand',b'Kode Barang&gt; Kelompok Barang&gt; Merek'
b'DocType: Item Variant Settings',b'Do not update variants on save',b'Jangan perbarui varian pada saat menyimpan data'
b'DocType: Email Digest',b'Receivables',b'Piutang'
b'DocType: Lead Source',b'Lead Source',b'Sumber Prospek'
b'DocType: Customer',b'Additional information regarding the customer.',b'Informasi tambahan mengenai customer.'
b'DocType: Quality Inspection Reading',b'Reading 5',b'Membaca 5'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +236',"b'{0} {1} is associated with {2}, but Party Account is {3}'","b'{0} {1} dikaitkan dengan {2}, namun Akun Para Pihak adalah {3}'"
b'apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7',b'View Lab Tests',b'Lihat Tes Lab'
b'DocType: Purchase Invoice',b'Y',b'Y'
b'DocType: Maintenance Visit',b'Maintenance Date',b'Tanggal Pemeliharaan'
b'DocType: Purchase Invoice Item',b'Rejected Serial No',b'Serial No Barang Ditolak'
b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +82',b'Year start date or end date is overlapping with {0}. To avoid please set company',b'Tahun tanggal mulai atau tanggal akhir ini tumpang tindih dengan {0}. Untuk menghindari silakan atur perusahaan'
b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +122',b'Please mention the Lead Name in Lead {0}',b'Harap sebutkan Nama Prospek di Prospek {0}'
b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156',b'Start date should be less than end date for Item {0}',b'Tanggal mulai harus kurang dari tanggal akhir untuk Item {0}'
b'DocType: Item',"b'Example: ABCD.#####\nIf series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.'","b'Contoh:. ABCD ##### \n Jika seri diatur dan Nomor Seri tidak disebutkan dalam transaksi, maka nomor seri otomatis akan dibuat berdasarkan seri ini. Jika Anda ingin selalu menetapkan Nomor Seri untuk item ini, biarkan kosong.'"
b'DocType: Upload Attendance',b'Upload Attendance',b'Unggah Kehadiran'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +579',b'BOM and Manufacturing Quantity are required',b'BOM dan Kuantitas Manufaktur diperlukan'
b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +50',b'Ageing Range 2',b'Rentang Ageing 2'
b'DocType: SG Creation Tool Course',b'Max Strength',b'Max Kekuatan'
b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +28',b'Installing presets',b'Menginstal preset'
b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +85',b'No Delivery Note selected for Customer {}',b'Tidak ada Catatan Pengiriman yang dipilih untuk Pelanggan {}'
b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +25',b'BOM replaced',b'BOM diganti'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1052',b'Select Items based on Delivery Date',b'Pilih Item berdasarkan Tanggal Pengiriman'
b'DocType: Grant Application',b'Has any past Grant Record',b'Memiliki Record Grant masa lalu'
,b'Sales Analytics',b'Analitika Penjualan'
b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +127',b'Available {0}',b'Tersedia {0}'
,b'Prospects Engaged But Not Converted',b'Prospek Terlibat Tapi Tidak Dikonversi'
b'DocType: Manufacturing Settings',b'Manufacturing Settings',b'Pengaturan manufaktur'
b'apps/erpnext/erpnext/config/setup.py +56',b'Setting up Email',b'Mengatur Email'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57',b'Guardian1 Mobile No',b'Guardian1 Ponsel Tidak'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106',b'Please enter default currency in Company Master',b'Entrikan mata uang default di Perusahaan Guru'
b'DocType: Stock Entry Detail',b'Stock Entry Detail',b'Rincian Entri Persediaan'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +109',b'Daily Reminders',b'Pengingat Harian'
b'DocType: Products Settings',b'Home Page is Products',b'Home Page adalah Produk'
,b'Asset Depreciation Ledger',b'Aset Penyusutan Ledger'
b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +91',b'Tax Rule Conflicts with {0}',b'Aturan pajak Konflik dengan {0}'
b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25',b'New Account Name',b'New Account Name'
b'DocType: Purchase Invoice Item',b'Raw Materials Supplied Cost',b'Biaya Bahan Baku Disediakan'
b'DocType: Selling Settings',b'Settings for Selling Module',b'Pengaturan untuk Jual Modul'
b'DocType: Hotel Room Reservation',b'Hotel Room Reservation',b'Reservasi Kamar Hotel'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115',b'Customer Service',b'Layanan Pelanggan'
b'DocType: BOM',b'Thumbnail',b'Kuku ibu jari'
b'DocType: Item Customer Detail',b'Item Customer Detail',b'Rincian Barang Pelanggan'
b'apps/erpnext/erpnext/config/hr.py +50',b'Offer candidate a Job.',b'Tawarkan Lowongan Kerja kepada Calon'
b'DocType: Notification Control',b'Prompt for Email on Submission of',b'Minta Email untuk Pengiriman'
b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88',b'Total allocated leaves are more than days in the period',b'Jumlah cuti dialokasikan lebih dari hari pada periode'
b'DocType: Land Unit',b'Linked Soil Analysis',b'Analisis Tanah Terkait'
b'DocType: Pricing Rule',b'Percentage',b'Persentase'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70',b'Item {0} must be a stock Item',b'Barang {0} harus barang persediaan'
b'DocType: Manufacturing Settings',b'Default Work In Progress Warehouse',b'Standar Gudang Work In Progress'
b'apps/erpnext/erpnext/config/accounts.py +288',b'Default settings for accounting transactions.',b'Pengaturan default untuk transaksi akuntansi.'
b'DocType: Maintenance Visit',b'MV',b'MV'
b'DocType: Restaurant',b'Default Tax Template',b'Template Pajak Default'
b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +66',b'{0} Students have been enrolled',b'{0} Siswa telah terdaftar'
b'DocType: Fees',b'Student Details',b'Rincian siswa'
b'DocType: Purchase Invoice Item',b'Stock Qty',b'Jumlah Persediaan'
b'DocType: Employee Loan',b'Repayment Period in Months',b'Periode pembayaran di Bulan'
b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26',b'Error: Not a valid id?',b'Kesalahan: Tidak id valid?'
b'DocType: Naming Series',b'Update Series Number',b'Perbarui Nomor Seri'
b'DocType: Account',b'Equity',b'Modal'
b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +78',"b""{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry""","b""{0} {1}: jenis akun 'Laba Rugi' {2} tidak diperbolehkan di Entri Awal"""
b'DocType: Sales Order',b'Printing Details',b'Detai Print dan Cetak'
b'DocType: Task',b'Closing Date',b'Tanggal Penutupan'
b'DocType: Sales Order Item',b'Produced Quantity',b'Jumlah Diproduksi'
b'DocType: Timesheet',b'Work Detail',b'Detail Pekerjaan'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126',b'Engineer',b'Insinyur'
b'DocType: Journal Entry',b'Total Amount Currency',b'Jumlah Total Mata Uang'
b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38',b'Search Sub Assemblies',b'Cari Barang Sub Assembly'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171',b'Item Code required at Row No {0}',b'Item Code dibutuhkan pada Row ada {0}'
b'DocType: GST Account',b'SGST Account',b'Akun SGST'
b'apps/erpnext/erpnext/utilities/user_progress.py +154',b'Go to Items',b'Pergi ke item'
b'DocType: Sales Partner',b'Partner Type',b'Tipe Mitra/Partner'
b'DocType: Purchase Taxes and Charges',b'Actual',b'Aktual'
b'DocType: Restaurant Menu',b'Restaurant Manager',b'Manajer restoran'
b'DocType: Authorization Rule',b'Customerwise Discount',b'Diskon Pelanggan'
b'apps/erpnext/erpnext/config/projects.py +46',b'Timesheet for tasks.',b'Absen untuk tugas-tugas.'
b'DocType: Purchase Invoice',b'Against Expense Account',b'Terhadap Akun Biaya'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +282',b'Installation Note {0} has already been submitted',b'Instalasi Catatan {0} telah Terkirim'
b'DocType: Bank Reconciliation',b'Get Payment Entries',b'Dapatkan Entries Pembayaran'
b'DocType: Quotation Item',b'Against Docname',b'Terhadap Docname'
b'DocType: SMS Center',b'All Employee (Active)',b'Semua Karyawan (Aktif)'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9',b'View Now',b'Lihat Sekarang'
b'DocType: BOM',b'Raw Material Cost',b'Biaya Bahan Baku'
b'DocType: Item Reorder',b'Re-Order Level',b'Tingkat Re-order'
b'apps/erpnext/erpnext/projects/doctype/project/project.js +54',b'Gantt Chart',b'Gantt Bagan'
b'DocType: Crop Cycle',b'Cycle Type',b'Tipe siklus'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99',b'Part-time',b'Part-time'
b'DocType: Employee',b'Applicable Holiday List',b'Daftar Hari Libur yang Berlaku'
b'DocType: Employee',b'Cheque',b'Cek'
b'DocType: Training Event',b'Employee Emails',b'Email Karyawan'
b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +60',b'Series Updated',b'Nomor Seri Diperbarui'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +159',b'Report Type is mandatory',b'Jenis Laporan adalah wajib'
b'DocType: Item',b'Serial Number Series',b'Serial Number Series'
b'apps/erpnext/erpnext/buying/utils.py +68',b'Warehouse is mandatory for stock Item {0} in row {1}',b'Gudang adalah wajib untuk persediaan Barang {0} pada baris {1}'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45',b'Retail & Wholesale',b'Retail & Grosir'
b'DocType: Issue',b'First Responded On',b'Ditangani Pertama kali pada'
b'DocType: Website Item Group',b'Cross Listing of Item in multiple groups',b'Daftar Lintas Item dalam beberapa kelompok'
b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +90',b'Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0}',b'Tahun Anggaran Tanggal Mulai dan Akhir Tahun Fiskal Tanggal sudah ditetapkan pada Tahun Anggaran {0}'
b'DocType: Projects Settings',b'Ignore User Time Overlap',b'Abaikan Waktu Pengguna Tumpang Tindih'
b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +113',b'Clearance Date updated',b'Tanggal Kliring diperbarui'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +146',b'Split Batch',b'Split batch'
b'DocType: Stock Settings',b'Batch Identification',b'Identifikasi Batch'
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +132',b'Successfully Reconciled',b'Berhasil Direkonsiliasi'
b'DocType: Request for Quotation Supplier',b'Download PDF',b'Unduh PDF'
b'DocType: Work Order',b'Planned End Date',b'Tanggal Akhir Planning'
b'DocType: Shareholder',b'Hidden list maintaining the list of contacts linked to Shareholder',b'Daftar tersembunyi menyimpan daftar kontak yang terhubung dengan Pemegang Saham'
b'apps/erpnext/erpnext/config/non_profit.py +63',b'Donor Type information.',b'Informasi Jenis Donor.'
b'DocType: Request for Quotation',b'Supplier Detail',b'pemasok Detil'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100',b'Error in formula or condition: {0}',b'Kesalahan dalam rumus atau kondisi: {0}'
b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +99',b'Invoiced Amount',b'Nilai Tertagih Faktur'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47',b'Criteria weights must add up to 100%',b'Kriteria bobot harus menambahkan hingga 100%'
b'apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7',b'Attendance',b'Absensi'
b'apps/erpnext/erpnext/public/js/pos/pos.html +115',b'Stock Items',b'Barang Persediaan'
b'DocType: BOM',b'Materials',b'Material/Barang'
b'DocType: Leave Block List',"b'If not checked, the list will have to be added to each Department where it has to be applied.'","b'Jika tidak diperiksa, daftar harus ditambahkan ke setiap departemen di mana itu harus diterapkan.'"
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +111',b'Creating {0}',b'Membuat {0}'
b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28',b'Source and Target Warehouse cannot be same',b'Sumber dan Target Gudang tidak bisa sama'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +586',b'Posting date and posting time is mandatory',b'Tanggal posting dan posting waktu adalah wajib'
b'apps/erpnext/erpnext/config/buying.py +76',b'Tax template for buying transactions.',b'Template pajak untuk membeli transaksi.'
,b'Item Prices',b'Harga Barang/Item'
b'DocType: Purchase Order',b'In Words will be visible once you save the Purchase Order.',b'Dalam Kata-kata akan terlihat setelah Anda menyimpan Purchase Order.'
b'DocType: Period Closing Voucher',b'Period Closing Voucher',b'Voucher Tutup Periode'
b'DocType: Consultation',b'Review Details',b'Rincian ulasan'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +185',b'The shareholder does not belong to this company',b'Pemegang saham bukan milik perusahaan ini'
b'DocType: Dosage Form',b'Dosage Form',b'Formulir Dosis'
b'apps/erpnext/erpnext/config/selling.py +67',b'Price List master.',b'List Master Daftar Harga'
b'DocType: Task',b'Review Date',b'Tanggal Ulasan'
b'DocType: Company',b'Series for Asset Depreciation Entry (Journal Entry)',b'Seri untuk Entry Depreciation Aset (Entri Jurnal)'
b'DocType: Membership',b'Member Since',b'Anggota Sejak'
b'DocType: Purchase Invoice',b'Advance Payments',b'Uang Muka Pembayaran(Down Payment / Advance)'
b'DocType: Purchase Taxes and Charges',b'On Net Total',b'Pada Jumlah Net Bersih'
b'apps/erpnext/erpnext/controllers/item_variant.py +92',b'Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4}',b'Nilai untuk Atribut {0} harus berada dalam kisaran {1} ke {2} dalam penambahan {3} untuk Item {4}'
b'DocType: Restaurant Reservation',b'Waitlisted',b'Daftar tunggu'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +124',b'Currency can not be changed after making entries using some other currency',b'Mata uang tidak dapat diubah setelah melakukan entri menggunakan beberapa mata uang lainnya'
b'DocType: Shipping Rule',b'Fixed',b'Tetap'
b'DocType: Vehicle Service',b'Clutch Plate',b'clutch Plat'
b'DocType: Company',b'Round Off Account',b'Akun Pembulatan'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93',b'Administrative Expenses',b'Beban Administrasi'
b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18',b'Consulting',b'Konsultasi'
b'DocType: Customer Group',b'Parent Customer Group',b'Induk Kelompok Pelanggan'
b'DocType: Journal Entry',b'Subscription',b'Berlangganan'
b'DocType: Purchase Invoice',b'Contact Email',b'Email Kontak'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11',b'Fee Creation Pending',b'Penciptaan Biaya Tertunda'
b'DocType: Appraisal Goal',b'Score Earned',b'Skor Earned'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +241',b'Notice Period',b'Masa Pemberitahuan'
b'DocType: Asset Category',b'Asset Category Name',b'Aset Kategori Nama'
b'apps/erpnext/erpnext/setup/doctype/territory/territory.js +13',b'This is a root territory and cannot be edited.',b'Ini adalah wilayah akar dan tidak dapat diedit.'
b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5',b'New Sales Person Name',b'Nama baru Sales Person'
b'DocType: Packing Slip',b'Gross Weight UOM',b'UOM Berat Kotor'
b'DocType: Asset Maintenance Task',b'Preventive Maintenance',b'Pemeliharaan preventif'
b'DocType: Delivery Note Item',b'Against Sales Invoice',b'Terhadap Faktur Penjualan'
b'DocType: Purchase Invoice',b'07-Others',b'07-lainnya'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +151',b'Please enter serial numbers for serialized item ',b'Harap masukkan nomor seri untuk item serial'
b'DocType: Bin',b'Reserved Qty for Production',b'Dicadangkan Jumlah Produksi'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43',b'EcritureNum',b'EcritureNum'
b'DocType: Student Group Creation Tool',"b""Leave unchecked if you don't want to consider batch while making course based groups. """,b'Biarkan tidak dicentang jika Anda tidak ingin mempertimbangkan batch sambil membuat kelompok berbasis kursus.'
b'DocType: Asset',b'Frequency of Depreciation (Months)',b'Frekuensi Penyusutan (Bulan)'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +500',b'Credit Account',b'Akun kredit'
b'DocType: Landed Cost Item',b'Landed Cost Item',b'Jenis Barang Biaya Landing'
b'apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57',b'Show zero values',b'Tampilkan nilai nol'
b'DocType: BOM',b'Quantity of item obtained after manufacturing / repacking from given quantities of raw materials',b'Jumlah Kuantitas Produk yang dihasilkan dari proses manufakturing / repacking dari jumlah kuantitas bahan baku yang disediakan'
b'DocType: Lab Test',b'Test Group',b'Grup Uji'
b'DocType: Payment Reconciliation',b'Receivable / Payable Account',b'Piutang / Account Payable'
b'DocType: Delivery Note Item',b'Against Sales Order Item',b'Terhadap Barang di Order Penjualan'
b'DocType: Company',b'Company Logo',b'Logo perusahaan'
b'apps/erpnext/erpnext/stock/doctype/item/item.py +709',b'Please specify Attribute Value for attribute {0}',b'Silakan tentukan Atribut Nilai untuk atribut {0}'
b'DocType: Item',b'Default Warehouse',b'Standar Gudang'
b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45',b'Budget cannot be assigned against Group Account {0}',b'Anggaran tidak dapat diberikan terhadap Account Group {0}'
b'DocType: Healthcare Settings',b'Patient Registration',b'Pendaftaran Pasien'
b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22',b'Please enter parent cost center',b'Entrikan pusat biaya orang tua'
b'DocType: Delivery Note',b'Print Without Amount',b'Cetak Tanpa Jumlah'
b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +57',b'Depreciation Date',b'penyusutan Tanggal'
,b'Work Orders in Progress',b'Perintah Kerja Sedang Berlangsung'
b'DocType: Issue',b'Support Team',b'Tim Support'
b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36',b'Expiry (In Days)',b'Kadaluwarsa (Dalam Days)'
b'DocType: Appraisal',b'Total Score (Out of 5)',b'Skor Total (Out of 5)'
b'DocType: Fee Structure',b'FS.',b'FS.'
b'DocType: Student Attendance Tool',b'Batch',b'Kumpulan'
b'DocType: Donor',b'Donor Type',b'Jenis Donor'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +27',b'Balance',b'Keseimbangan'
b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66',b'Please select the Company',b'Silahkan pilih Perusahaan'
b'DocType: Room',b'Seating Capacity',b'Kapasitas tempat duduk'
b'DocType: Issue',b'ISS-',b'ISS-'
b'DocType: Lab Test Groups',b'Lab Test Groups',b'Kelompok Uji Lab'
b'DocType: Project',b'Total Expense Claim (via Expense Claims)',b'Jumlah Klaim Beban (via Klaim Beban)'
b'DocType: GST Settings',b'GST Summary',b'Ringkasan GST'
b'apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py +16',b'Please enable default incoming account before creating Daily Work Summary Group',b'Harap aktifkan akun masuk default sebelum membuat Grup Ringkasan Pekerjaan Harian'
b'DocType: Assessment Result',b'Total Score',b'Skor total'
b'DocType: Journal Entry',b'Debit Note',b'Debit Note'
b'DocType: Stock Entry',b'As per Stock UOM',b'Sesuai UOM Persediaan'
b'apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7',b'Not Expired',b'Tidak Kedaluwarsa'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +49',b'ValidDate',b'Tanggal berlaku'
b'DocType: Student Log',b'Achievement',b'Pencapaian'
b'DocType: Batch',b'Source Document Type',b'Jenis Dokumen Sumber'
b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24',b'Following course schedules were created',b'Jadwal kursus berikut telah dibuat'
b'DocType: Journal Entry',b'Total Debit',b'Jumlah Debit'
b'DocType: Manufacturing Settings',b'Default Finished Goods Warehouse',b'Gudang bawaan Selesai Stok Barang'
b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +108',b'Please select Patient',b'Silakan pilih Pasien'
b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76',b'Sales Person',b'Sales Person'
b'DocType: Hotel Room Package',b'Amenities',b'Fasilitas'
b'apps/erpnext/erpnext/config/accounts.py +233',b'Budget and Cost Center',b'Anggaran dan Pusat Biaya'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65',b'Multiple default mode of payment is not allowed',b'Beberapa modus pembayaran default tidak diperbolehkan'
b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5',b'for the',b'Untuk'
,b'Appointment Analytics',b'Penunjukan Analytics'
b'DocType: Vehicle Service',b'Half Yearly',b'Setengah Tahunan'
b'DocType: Lead',b'Blog Subscriber',b'Pelanggan Blog'
b'DocType: Guardian',b'Alternate Number',b'Jumlah alternatif'
b'DocType: Healthcare Settings',b'Consultations in valid days',b'Konsultasi di hari yang benar'
b'DocType: Assessment Plan Criteria',b'Maximum Score',b'Skor maksimum'
b'apps/erpnext/erpnext/config/setup.py +83',b'Create rules to restrict transactions based on values.',b'Buat aturan untuk membatasi transaksi berdasarkan nilai-nilai.'
b'DocType: Cash Flow Mapping Accounts',b'Cash Flow Mapping Accounts',b'Akun Pemetaan Arus Kas'
b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49',b' Group Roll No',b'No. Roll Kelompok'
b'DocType: Batch',b'Manufacturing Date',b'Tanggal pembuatan'
b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9',b'Fee Creation Failed',b'Penciptaan Biaya Gagal'
b'DocType: Opening Invoice Creation Tool',b'Create Missing Party',b'Buat Partai Hilang'
b'DocType: Student Group Creation Tool',b'Leave blank if you make students groups per year',b'Biarkan kosong jika Anda membuat kelompok siswa per tahun'
b'DocType: HR Settings',"b'If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day'","b'Jika dicentang, total ada. dari Hari Kerja akan mencakup libur, dan ini akan mengurangi nilai Gaji Per Hari'"
b'DocType: Purchase Invoice',b'Total Advance',b'Jumlah Uang Muka'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27',b'Change Template Code',b'Ubah Kode Template'
b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +23',b'The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.',b'Jangka Tanggal Akhir tidak dapat lebih awal dari tanggal Term Start. Perbaiki tanggal dan coba lagi.'
b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19',b'Quot Count',"b'Jumlah ""Penawaran""'"
,b'BOM Stock Report',b'Laporan Persediaan BOM'
b'DocType: Stock Reconciliation Item',b'Quantity Difference',b'Perbedaan Kuantitas'
b'DocType: Employee Advance',b'EA-',b'EA-'
b'DocType: Opportunity Item',b'Basic Rate',b'Tarif Dasar'
b'DocType: GL Entry',b'Credit Amount',b'Jumlah kredit'
b'DocType: Cheque Print Template',b'Signatory Position',b'Posisi penandatangan'
b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +173',b'Set as Lost',b'Set as Hilang/Kalah'
b'DocType: Timesheet',b'Total Billable Hours',b'Total Jam Ditagih'
b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4',b'Payment Receipt Note',b'Pembayaran Penerimaan Catatan'
b'apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6',b'This is based on transactions against this Customer. See timeline below for details',b'Hal ini didasarkan pada transaksi terhadap pelanggan ini. Lihat timeline di bawah untuk rincian'
b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +162',b'Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2}',b'Row {0}: Dialokasikan jumlah {1} harus kurang dari atau sama dengan jumlah entri Pembayaran {2}'
b'DocType: Program Enrollment Tool',b'New Academic Term',b'Istilah Akademik Baru'
,b'Course wise Assessment Report',b'Laporan Penilaian yang tepat'
b'DocType: Purchase Invoice',b'Availed ITC State/UT Tax',b'Mengakses ITC State / Pajak UT'
b'DocType: Tax Rule',b'Tax Rule',b'Aturan pajak'
b'DocType: Selling Settings',b'Maintain Same Rate Throughout Sales Cycle',b'Pertahankan Tarif Sama Sepanjang Siklus Penjualan'
b'DocType: Manufacturing Settings',b'Plan time logs outside Workstation Working Hours.',b'Rencana waktu log luar Jam Kerja Workstation.'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +115',b'Dr {0} does not have a Physician Schedule. Add it in Physician master',b'Dr {0} tidak memiliki Jadwal Dokter. Tambahkan di master dokter'
b'apps/erpnext/erpnext/public/js/pos/pos.html +98',b'Customers in Queue',b'Pelanggan di Antrian'
b'DocType: Driver',b'Issuing Date',b'Tanggal penerbitan'
b'DocType: Student',b'Nationality',b'Kebangsaan'
b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +109',b'Submit this Work Order for further processing.',b'Kirimkan Pesanan Kerja ini untuk diproses lebih lanjut.'
,b'Items To Be Requested',b'Items Akan Diminta'
b'DocType: Purchase Order',b'Get Last Purchase Rate',b'Dapatkan Terakhir Purchase Rate'
b'DocType: Company',b'Company Info',b'Info Perusahaan'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1385',b'Select or add new customer',b'Pilih atau menambahkan pelanggan baru'
b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +173',b'Cost center is required to book an expense claim',b'pusat biaya diperlukan untuk memesan klaim biaya'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9',b'Application of Funds (Assets)',b'Penerapan Dana (Aset)'
b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6',b'This is based on the attendance of this Employee',b'Hal ini didasarkan pada kehadiran Karyawan ini'
b'DocType: Assessment Result',b'Summary',b'Ringkasan'
b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112',b'Mark Attendance',b'Mark Kehadiran'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +494',b'Debit Account',b'Akun Debit'
b'DocType: Fiscal Year',b'Year Start Date',b'Tanggal Mulai Tahun'
b'DocType: Attendance',b'Employee Name',b'Nama Karyawan'
b'DocType: Restaurant Order Entry Item',b'Restaurant Order Entry Item',b'Item Item Pemesanan Restoran'
b'DocType: Purchase Invoice',b'Rounded Total (Company Currency)',b'Rounded Jumlah (Perusahaan Mata Uang)'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +96',b'Cannot covert to Group because Account Type is selected.',b'Tidak dapat mengkonversi ke Grup karena Tipe Akun dipilih.'
b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260',b'{0} {1} has been modified. Please refresh.',b'{0} {1} telah diubah. Silahkan refresh.'
b'DocType: Leave Block List',b'Stop users from making Leave Applications on following days.',b'Menghentikan pengguna dari membuat Aplikasi Leave pada hari-hari berikutnya.'
b'DocType: Asset Maintenance Team',b'Maintenance Team Members',b'Anggota Tim Pemeliharaan'
b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63',b'Purchase Amount',b'Jumlah pembelian'
b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +261',b'Supplier Quotation {0} created',b'Pemasok Quotation {0} dibuat'
b'apps/erpnext/erpnext/accounts/report/financial_statements.py +103',b'End Year cannot be before Start Year',b'Akhir Tahun tidak boleh sebelum Mulai Tahun'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234',b'Employee Benefits',b'Manfaat Karyawan'
b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +264',b'Packed quantity must equal quantity for Item {0} in row {1}',b'Dikemas kuantitas harus sama kuantitas untuk Item {0} berturut-turut {1}'
b'DocType: Work Order',b'Manufactured Qty',b'Qty Diproduksi'
b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +78',"b""The shares don't exist with the {0}""",b'Saham tidak ada dengan {0}'
b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64',b'Invoice Created',b'Faktur dibuat'
b'DocType: Asset',b'Out of Order',b'Habis'
b'DocType: Purchase Receipt Item',b'Accepted Quantity',b'Qty Diterima'
b'DocType: Projects Settings',b'Ignore Workstation Time Overlap',b'Abaikan Waktu Workstation Tumpang Tindih'
b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +242',b'Please set a default Holiday List for Employee {0} or Company {1}',b'Silahkan mengatur default Liburan Daftar Karyawan {0} atau Perusahaan {1}'
b'apps/erpnext/erpnext/accounts/party.py +30',b'{0}: {1} does not exists',b'{0}: {1} tidak ada'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76',b'Select Batch Numbers',b'Pilih Batch Numbers'
b'apps/erpnext/erpnext/config/accounts.py +12',b'Bills raised to Customers.',b'Tagihan diajukan ke Pelanggan.'
b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26',b'Project Id',b'Proyek Id'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +534',b'Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2}',b'Row ada {0}: Jumlah dapat tidak lebih besar dari Pending Jumlah terhadap Beban Klaim {1}. Pending Jumlah adalah {2}'
b'DocType: Patient Service Unit',b'Medical Administrator',b'Administrator Medis'
b'DocType: Assessment Plan',b'Schedule',b'Jadwal'
b'DocType: Account',b'Parent Account',b'Rekening Induk'
b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266',b'Available',b'Tersedia'
b'DocType: Quality Inspection Reading',b'Reading 3',b'Membaca 3'
b'DocType: Stock Entry',b'Source Warehouse Address',b'Sumber Alamat Gudang'
,b'Hub',b'Pusat'
b'DocType: GL Entry',b'Voucher Type',b'Voucher Type'
b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1717',b'Price List not found or disabled',b'Daftar Harga tidak ditemukan atau dinonaktifkan'
b'DocType: Student Applicant',b'Approved',b'Disetujui'
b'apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15',b'Price',b'Harga'
b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +267',"b""Employee relieved on {0} must be set as 'Left'""","b""Karyawan lega pada {0} harus ditetapkan sebagai 'Kiri'"""
b'DocType: Hub Settings',b'Last Sync On',b'Sinkron Terakhir Aktif'
b'DocType: Guardian',b'Guardian',b'Wali'
b'DocType: Opening Invoice Creation Tool',b'Create missing customer or supplier.',b'Buat pelanggan atau pemasok yang hilang'
b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42',b'Appraisal {0} created for Employee {1} in the given date range',b'Penilaian {0} telah dibuat untuk karyawan {1} dalam rentang tanggal tertentu'
b'DocType: Academic Term',b'Education',b'Pendidikan'
b'apps/erpnext/erpnext/public/js/pos/pos.html +89',b'Del',b'Del'
b'DocType: Selling Settings',b'Campaign Naming By',b'Penamaan Kampanye Promosi dengan'
b'DocType: Employee',b'Current Address Is',b'Alamat saat ini adalah'
b'apps/erpnext/erpnext/utilities/user_progress.py +51',b'Monthly Sales Target (',b'Target Penjualan Bulanan'
b'DocType: Physician Service Unit Schedule',b'Physician Service Unit Schedule',b'Jadwal Unit Pelayanan Dokter'
b'apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9',b'modified',b'diubah'
b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43',"b""Optional. Sets company's default currency, if not specified.""","b'Opsional. Set mata uang default perusahaan, jika tidak ditentukan.'"
b'DocType: Sales Invoice',b'Customer GSTIN',b'Pelanggan GSTIN'
b'DocType: Crop Cycle',"b""List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease """,b'Daftar penyakit yang terdeteksi di lapangan. Bila dipilih maka secara otomatis akan menambahkan daftar tugas untuk mengatasi penyakit tersebut'
b'DocType: Asset Repair',b'Repair Status',b'Status perbaikan'
b'apps/erpnext/erpnext/config/accounts.py +67',b'Accounting journal entries.',b'Pencatatan Jurnal akuntansi.'
b'DocType: Delivery Note Item',b'Available Qty at From Warehouse',b'Jumlah yang tersedia di Gudang Dari'
b'DocType: POS Profile',b'Account for Change Amount',b'Akun untuk Perubahan Jumlah'
b'DocType: Purchase Invoice',b'input service',b'masukan layanan'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217',b'Row {0}: Party / Account does not match with {1} / {2} in {3} {4}',b'Row {0}: Partai / Rekening tidak sesuai dengan {1} / {2} di {3} {4}'
b'DocType: Maintenance Team Member',b'Maintenance Team Member',b'Anggota Tim Pemeliharaan'
b'DocType: Agriculture Analysis Criteria',b'Soil Analysis',b'Analisis tanah'
b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +13',b'Course Code: ',b'Kode Kursus:'
b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +240',b'Please enter Expense Account',b'Masukan Entrikan Beban Akun'
b'DocType: Account',b'Stock',b'Persediaan'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1095',"b'Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry'","b'Row # {0}: Dokumen Referensi Type harus menjadi salah satu Purchase Order, Faktur Pembelian atau Journal Entri'"
b'DocType: Employee',b'Current Address',b'Alamat saat ini'
b'DocType: Item',"b'If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified'","b'Jika item adalah varian dari item lain maka deskripsi, gambar, harga, pajak dll akan ditetapkan dari template kecuali secara eksplisit ditentukan'"
b'DocType: Serial No',b'Purchase / Manufacture Details',b'Detail Pembelian / Produksi'
b'DocType: Assessment Group',b'Assessment Group',b'Grup penilaian'
b'apps/erpnext/erpnext/config/stock.py +329',b'Batch Inventory',b'Batch Persediaan'
b'DocType: Employee',b'Contract End Date',b'Tanggal Kontrak End'
b'DocType: Sales Order',b'Track this Sales Order against any Project',b'Melacak Order Penjualan ini terhadap Proyek apapun'
b'DocType: Sales Invoice Item',b'Discount and Margin',b'Diskon dan Margin'
b'DocType: Lab Test',b'Prescription',b'Resep'
b'DocType: Project',b'Second Email',b'Email Kedua'
b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +111',b'Not Available',b'Tidak Tersedia'
b'DocType: Pricing Rule',b'Min Qty',b'Min Qty'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36',b'Disable Template',b'Nonaktifkan Template'
b'DocType: GL Entry',b'Transaction Date',b'Transaction Tanggal'
b'DocType: Production Plan Item',b'Planned Qty',b'Qty Planning'
b'apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121',b'Total Tax',b'Total Pajak'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +204',b'For Quantity (Manufactured Qty) is mandatory',b'Untuk Quantity (Diproduksi Qty) adalah wajib'
b'DocType: Stock Entry',b'Default Target Warehouse',b'Standar Sasaran Gudang'
b'DocType: Purchase Invoice',b'Net Total (Company Currency)',b'Jumlah Bersih (Perusahaan Mata Uang)'
b'apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py +14',b'The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.',b'Akhir Tahun Tanggal tidak dapat lebih awal dari Tahun Tanggal Mulai. Perbaiki tanggal dan coba lagi.'
b'DocType: Notification Control',b'Purchase Receipt Message',b'Pesan Nota Penerimaan'
b'DocType: BOM',b'Scrap Items',b'scrap Produk'
b'DocType: Work Order',b'Actual Start Date',b'Tanggal Mulai Aktual'
b'DocType: Sales Order',b'% of materials delivered against this Sales Order',b'% Dari materi yang Terkirim terhadap Sales Order ini'
b'apps/erpnext/erpnext/config/manufacturing.py +18',b'Generate Material Requests (MRP) and Work Orders.',b'Hasilkan Permintaan Bahan (MRP) dan Perintah Kerja.'
b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62',b'Set default mode of payment',b'Tetapkan mode pembayaran default'
b'DocType: Grant Application',b'Withdrawn',b'pendiam'
b'DocType: Hub Settings',b'Hub Settings',b'Pengaturan Hub'
b'DocType: Project',b'Gross Margin %',b'Gross Margin%'
b'DocType: BOM',b'With Operations',b'Dengan Operasi'
b'apps/erpnext/erpnext/accounts/party.py +259',b'Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.',b'Entri Akuntansi telah dibuat dalam mata uang {0} untuk perusahaan {1}. Silakan pilih akun piutang atau hutang dengan mata uang {0}.'
b'DocType: Asset',b'Is Existing Asset',b'Apakah ada Asset'
b'DocType: Salary Detail',b'Statistical Component',b'Komponen statistik'
b'DocType: Warranty Claim',b'If different than customer address',b'Jika berbeda dari alamat pelanggan'
b'DocType: Purchase Invoice',b'Without Payment of Tax',b'Tanpa Pembayaran Pajak'
b'DocType: BOM Operation',b'BOM Operation',b'BOM Operation'
b'apps/erpnext/erpnext/config/stock.py +141',b'Fulfilment',b'Pemenuhan'
b'DocType: Purchase Taxes and Charges',b'On Previous Row Amount',b'Pada Sebelumnya Row Jumlah'
b'DocType: Item',b'Has Expiry Date',b'Memiliki Tanggal Kedaluwarsa'
b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +282',b'Transfer Asset',b'pengalihan Aset'
b'DocType: POS Profile',b'POS Profile',b'POS Profil'
b'DocType: Training Event',b'Event Name',b'Nama acara'
b'DocType: Physician',b'Phone (Office)',b'Telepon (Kantor)'
b'apps/erpnext/erpnext/hooks.py +151',b'Admission',b'Penerimaan'
b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29',b'Admissions for {0}',b'Penerimaan untuk {0}'
b'apps/erpnext/erpnext/config/accounts.py +257',"b'Seasonality for setting budgets, targets etc.'","b'Musiman untuk menetapkan anggaran, target dll'"
b'DocType: Supplier Scorecard Scoring Variable',b'Variable Name',b'Nama variabel'
b'apps/erpnext/erpnext/stock/get_item_details.py +144',"b'Item {0} is a template, please select one of its variants'","b'Item {0} adalah template, silahkan pilih salah satu variannya'"
b'DocType: Asset',b'Asset Category',b'Aset Kategori'
b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31',b'Net pay cannot be negative',b'Gaji bersih yang belum dapat negatif'
b'DocType: Purchase Order',b'Advance Paid',b'Pembayaran Dimuka (Advance)'
b'DocType: Item',b'Item Tax',b'Pajak Stok Barang'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +883',b'Material to Supplier',b'Bahan untuk Supplier'
b'DocType: Soil Texture',b'Loamy Sand',b'Pasir Loamy'
b'DocType: Production Plan',b'Material Request Planning',b'Perencanaan Permintaan Material'
b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +638',b'Excise Invoice',b'Cukai Faktur'
b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16',b'Treshold {0}% appears more than once',b'Treshold {0}% muncul lebih dari sekali'
b'DocType: Expense Claim',b'Employees Email Id',b'ID Email Karyawan'
b'DocType: Employee Attendance Tool',b'Marked Attendance',b'Absensi Terdaftar'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138',b'Current Liabilities',b'Piutang Lancar'
b'apps/erpnext/erpnext/config/selling.py +297',b'Send mass SMS to your contacts',b'Kirim SMS massal ke kontak Anda'
b'DocType: Patient',b'A Positive',b'Positif'
b'DocType: Program',b'Program Name',b'Program Nama'
b'DocType: Purchase Taxes and Charges',b'Consider Tax or Charge for',b'Pertimbangkan Pajak atau Biaya untuk'
b'DocType: Driver',b'Driving License Category',b'Kategori Lisensi Mengemudi'
b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +158',b'No Reference',b'Tidak ada referensi'
b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57',b'Actual Qty is mandatory',b'Qty Aktual wajib diisi'
b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92',"b'{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.'","b'{0} saat ini memiliki posisi Scorecard Pemasok {1}, Pesanan Pembelian untuk pemasok ini harus dikeluarkan dengan hati-hati.'"
b'DocType: Asset Maintenance Team',b'Asset Maintenance Team',b'Tim Pemeliharaan Aset'
b'DocType: Employee Loan',b'Loan Type',b'Jenis pinjaman'
b'DocType: Scheduling Tool',b'Scheduling Tool',b'Alat penjadwalan'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180',b'Credit Card',b'Kartu Kredit'
b'DocType: BOM',b'Item to be manufactured or repacked',b'Item yang akan diproduksi atau dikemas ulang'
b'DocType: Employee Education',b'Major/Optional Subjects',b'Mayor / Opsional Subjek'
b'DocType: Sales Invoice Item',b'Drop Ship',b'Pengiriman Drop Ship'
b'DocType: Driver',b'Suspended',b'Tergantung'
b'DocType: Training Event',b'Attendees',b'peserta'
b'DocType: Employee',"b'Here you can maintain family details like name and occupation of parent, spouse and children'","b'Di sini Anda dapat mempertahankan rincian keluarga seperti nama dan pekerjaan orang tua, pasangan dan anak-anak'"
b'DocType: Academic Term',b'Term End Date',b'Istilah Tanggal Akhir'
b'DocType: Purchase Invoice',b'Taxes and Charges Deducted (Company Currency)',b'Pajak dan Biaya Dikurangi (Perusahaan Mata Uang)'
b'DocType: Item Group',b'General Settings',b'Pengaturan Umum'
b'apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23',b'From Currency and To Currency cannot be same',b'Dari Mata dan Mata Uang Untuk tidak bisa sama'
b'DocType: Stock Entry',b'Repack',b'Repack'
b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6',b'You must Save the form before proceeding',b'Anda harus menyimpan formulir sebelum melanjutkan'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113',b'Please select the Company first',b'Silahkan pilih Perusahaan terlebih dahulu'
b'DocType: Item Attribute',b'Numeric Values',b'Nilai numerik'
b'apps/erpnext/erpnext/public/js/setup_wizard.js +56',b'Attach Logo',b'Pasang Logo'
b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +51',b'Stock Levels',b'Tingkat Persediaan'
b'DocType: Customer',b'Commission Rate',b'Tingkat Komisi'
b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187',b'Created {0} scorecards for {1} between: ',b'Menciptakan {0} scorecard untuk {1} antara:'
b'apps/erpnext/erpnext/stock/doctype/item/item.js +505',b'Make Variant',b'Buat Varian'
b'apps/erpnext/erpnext/config/hr.py +87',b'Block leave applications by department.',b'Blok permintaan cuti per departemen.'
b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +155',"b'Payment Type must be one of Receive, Pay and Internal Transfer'","b'Jenis Pembayaran harus menjadi salah satu Menerima, Pay dan Internal Transfer'"
b'apps/erpnext/erpnext/config/selling.py +184',b'Analytics',b'Analytics'
b'apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25',b'Cart is Empty',b'Cart adalah Kosong'
b'DocType: Vehicle',b'Model',b'Model'
b'DocType: Work Order',b'Actual Operating Cost',b'Biaya Operasi Aktual'
b'DocType: Payment Entry',b'Cheque/Reference No',b'Cek / Referensi Tidak ada'
b'DocType: Soil Texture',b'Clay Loam',b'Clay Loam'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +81',b'Root cannot be edited.',b'Root tidak dapat diedit.'
b'DocType: Item',b'Units of Measure',b'Satuan ukur'
b'DocType: Manufacturing Settings',b'Allow Production on Holidays',b'Izinkan Produksi di hari libur'
b'DocType: Sales Invoice',"b""Customer's Purchase Order Date""",b'Tanggal Order Pembelian Pelanggan'
b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +163',b'Capital Stock',b'Modal / Saham'
b'DocType: Shopping Cart Settings',b'Show Public Attachments',b'Tampilkan Lampiran Umum'
b'DocType: Packing Slip',b'Package Weight Details',b'Paket Berat Detail'
b'DocType: Restaurant Reservation',b'Reservation Time',b'Waktu Reservasi'
b'DocType: Payment Gateway Account',b'Payment Gateway Account',b'Pembayaran Rekening Gateway'
b'DocType: Shopping Cart Settings',b'After payment completion redirect user to selected page.',b'Setelah selesai pembayaran mengarahkan pengguna ke halaman yang dipilih.'
b'DocType: Company',b'Existing Company',b'Perusahaan yang ada'
b'DocType: Healthcare Settings',b'Result Emailed',b'Hasil Diemailkan'
b'apps/erpnext/erpnext/controllers/buying_controller.py +87',"b'Tax Category has been changed to ""Total"" because all the Items are non-stock items'","b'Kategori Pajak telah diubah menjadi ""Total"" karena semua barang adalah barang non-persediaan'"
b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103',b'Please select a csv file',b'Silakan pilih file csv'
b'DocType: Student Leave Application',b'Mark as Present',b'Tandai sebagai Hadir'
b'DocType: Supplier Scorecard',b'Indicator Color',b'Indikator Warna'
b'DocType: Purchase Order',b'To Receive and Bill',b'Untuk Diterima dan Ditagih'
b'apps/erpnext/erpnext/controllers/buying_controller.py +445',b'Row #{0}: Reqd by Date cannot be before Transaction Date',b'Baris # {0}: Reqd by Date tidak boleh sebelum Tanggal Transaksi'
b'apps/erpnext/erpnext/templates/pages/home.html +14',b'Featured Products',b'Produk Pilihan'
b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136',b'Designer',b'Perancang'
b'apps/erpnext/erpnext/config/selling.py +163',b'Terms and Conditions Template',b'Syarat dan Ketentuan Template'
b'DocType: Serial No',b'Delivery Details',b'Detail Pengiriman'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +495',b'Cost Center is required in row {0} in Taxes table for type {1}',b'Biaya Pusat diperlukan dalam baris {0} dalam tabel Pajak untuk tipe {1}'
b'DocType: Program',b'Program Code',b'Kode Program'
b'DocType: Terms and Conditions',b'Terms and Conditions Help',b'Syarat dan Ketentuan Bantuan'
,b'Item-wise Purchase Register',b'Stok Barang-bijaksana Pembelian Register'
b'DocType: Driver',b'Expiry Date',b'Tanggal Berakhir'
b'DocType: Healthcare Settings',b'Employee name and designation in print',b'Nama karyawan dan sebutan di cetak'
,b'accounts-browser',b'account-browser'
b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368',b'Please select Category first',b'Silahkan pilih Kategori terlebih dahulu'
b'apps/erpnext/erpnext/config/projects.py +13',b'Project master.',b'Master Proyek'
b'apps/erpnext/erpnext/controllers/status_updater.py +212',"b'To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.'","b'Untuk memungkinkan penagihan lebih atau pemesanan lebih, perbarui ""Penyisihan"" di Pengaturan Persediaan atau Barang.'"
b'DocType: Global Defaults',b'Do not show any symbol like $ etc next to currencies.',b'Jangan menunjukkan simbol seperti $ etc sebelah mata uang.'
b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +431',b' (Half Day)',b'(Setengah Hari)'
b'DocType: Payment Term',b'Credit Days',b'Hari Kredit'
b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +145',b'Please select Patient to get Lab Tests',b'Silakan pilih Pasien untuk mendapatkan Tes Laboratorium'
b'apps/erpnext/erpnext/utilities/activation.py +128',b'Make Student Batch',b'Membuat Batch Mahasiswa'
b'DocType: Fee Schedule',b'FRQ.',b'FRQ.'
b'DocType: Leave Type',b'Is Carry Forward',b'Apakah Carry Teruskan'
b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +841',b'Get Items from BOM',b'Dapatkan item dari BOM'
b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40',b'Lead Time Days',b'Hari Masa Tenggang'
b'DocType: Cash Flow Mapping',b'Is Income Tax Expense',b'Merupakan Beban Pajak Penghasilan'
b'apps/erpnext/erpnext/controllers/accounts_controller.py +621',b'Row #{0}: Posting Date must be same as purchase date {1} of asset {2}',b'Row # {0}: Posting Tanggal harus sama dengan tanggal pembelian {1} aset {2}'
b'DocType: Program Enrollment',"b""Check this if the Student is residing at the Institute's Hostel.""",b'Periksa ini jika Siswa berada di Institute&#39;s Hostel.'
b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125',b'Please enter Sales Orders in the above table',b'Cukup masukkan Penjualan Pesanan dalam tabel di atas'
,b'Stock Summary',b'Ringkasan Persediaan'
b'apps/erpnext/erpnext/config/assets.py +54',b'Transfer an asset from one warehouse to another',b'Mentransfer aset dari satu gudang ke yang lain'
b'DocType: Vehicle',b'Petrol',b'Bensin'
b'apps/erpnext/erpnext/config/learn.py +217',b'Bill of Materials',b'Bill of Material'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105',b'Row {0}: Party Type and Party is required for Receivable / Payable account {1}',b'Row {0}: Partai Jenis dan Partai diperlukan untuk Piutang / Hutang akun {1}'
b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94',b'Ref Date',b'Ref Tanggal'
b'DocType: Employee',b'Reason for Leaving',b'Alasan Meninggalkan'
b'DocType: BOM Operation',b'Operating Cost(Company Currency)',b'Biaya operasi (Perusahaan Mata Uang)'
b'DocType: Employee Loan Application',b'Rate of Interest',b'Tingkat Tujuan'
b'DocType: Expense Claim Detail',b'Sanctioned Amount',b'Jumlah sanksi'
b'DocType: Item',b'Shelf Life In Days',b'Shelf Life In Days'
b'DocType: GL Entry',b'Is Opening',b'Apakah Membuka'
b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196',b'Row {0}: Debit entry can not be linked with a {1}',b'Baris {0}: Debit masuk tidak dapat dihubungkan dengan {1}'
b'DocType: Journal Entry',b'Subscription Section',b'Bagian Langganan'
b'apps/erpnext/erpnext/accounts/doctype/account/account.py +177',b'Account {0} does not exist',b'Akun {0} tidak ada'
b'DocType: Training Event',b'Training Program',b'Program pelatihan'
b'DocType: Account',b'Cash',b'Kas'
b'DocType: Employee',b'Short biography for website and other publications.',b'Biografi singkat untuk website dan publikasi lainnya.'
