 (Half Day),
 and year: ,
""" does not exists","""Tidak ada"
%  Delivered,Disampaikan%
% Amount Billed,% Jumlah Ditagih
% Billed,Ditagih%
% Completed,Selesai%
% Delivered,Disampaikan%
% Installed,% Terpasang
% Received,% Diterima
% of materials billed against this Purchase Order.,% Bahan ditagih terhadap Purchase Order ini.
% of materials billed against this Sales Order,% Bahan ditagih terhadap Sales Order ini
% of materials delivered against this Delivery Note,% Dari materi yang disampaikan terhadap Pengiriman ini Note
% of materials delivered against this Sales Order,% Dari materi yang disampaikan terhadap Sales Order ini
% of materials ordered against this Material Request,% Bahan memerintahkan terhadap Permintaan Material ini
% of materials received against this Purchase Order,% Dari bahan yang diterima terhadap Purchase Order ini
'Actual Start Date' can not be greater than 'Actual End Date','Sebenarnya Tanggal Mulai' tidak dapat lebih besar dari 'Aktual Tanggal End'
'Based On' and 'Group By' can not be same,'Berdasarkan' dan 'Group By' tidak bisa sama
'Days Since Last Order' must be greater than or equal to zero,'Hari Sejak Orde terakhir' harus lebih besar dari atau sama dengan nol
'Entries' cannot be empty,'Entries' tidak boleh kosong
'Expected Start Date' can not be greater than 'Expected End Date',"""Diharapkan Tanggal Mulai 'tidak dapat lebih besar dari' Diharapkan Tanggal End '"
'From Date' is required,'Dari Tanggal' diperlukan
'From Date' must be after 'To Date','Dari Tanggal' harus setelah 'To Date'
'Has Serial No' can not be 'Yes' for non-stock item,"""Apakah ada Serial 'tidak bisa' Ya 'untuk item non-saham"
'Notification Email Addresses' not specified for recurring invoice,'Pemberitahuan Email Addresses' tidak ditentukan untuk berulang faktur
'Profit and Loss' type account {0} not allowed in Opening Entry,'Laba Rugi' jenis account {0} tidak diperbolehkan dalam Pembukaan Entri
'To Case No.' cannot be less than 'From Case No.','Untuk Kasus No' tidak bisa kurang dari 'Dari Kasus No'
'To Date' is required,'To Date' diperlukan
'Update Stock' for Sales Invoice {0} must be set,'Update Stock' untuk Sales Invoice {0} harus diatur
* Will be calculated in the transaction.,* Akan dihitung dalam transaksi.
1 Currency = [?] FractionFor e.g. 1 USD = 100 Cent,1 Currency = [?] Fraksi  Untuk misalnya 1 USD = 100 Cent
1. To maintain the customer wise item code and to make them searchable based on their code use this option,1.5. Untuk menjaga pelanggan bijaksana kode barang dan membuat mereka dicari berdasarkan penggunaan kode mereka pilihan ini
"<a href=""#Sales Browser/Customer Group"">Add / Edit</a>","<a href=""#Sales Browser/Customer Group""> Add / Edit </ a>"
"<a href=""#Sales Browser/Item Group"">Add / Edit</a>","<a href=""#Sales Browser/Item Group""> Add / Edit </ a>"
"<a href=""#Sales Browser/Territory"">Add / Edit</a>","<a href=""#Sales Browser/Territory""> Tambah / Edit </ a>"
"<h4>Default Template</h4><p>Uses <a href=""http://jinja.pocoo.org/docs/templates/"">Jinja Templating</a> and all the fields of Address (including Custom Fields if any) will be available</p><pre><code>{{ address_line1 }}&lt;br&gt;{% if address_line2 %}{{ address_line2 }}&lt;br&gt;{% endif -%}{{ city }}&lt;br&gt;{% if state %}{{ state }}&lt;br&gt;{% endif -%}{% if pincode %} PIN:  {{ pincode }}&lt;br&gt;{% endif -%}{{ country }}&lt;br&gt;{% if phone %}Phone: {{ phone }}&lt;br&gt;{% endif -%}{% if fax %}Fax: {{ fax }}&lt;br&gt;{% endif -%}{% if email_id %}Email: {{ email_id }}&lt;br&gt;{% endif -%}</code></pre>","<h4> default Template </ h4>  <p> Menggunakan <a href=""http://jinja.pocoo.org/docs/templates/""> Jinja template </ a> dan semua bidang Address ( termasuk Custom Fields jika ada) akan tersedia </ p>  <pre> <code> {{}} address_line1 <br>  {% jika% address_line2} {{}} address_line2 <br> { endif% -%}  {{kota}} <br>  {% jika negara%} {{negara}} <br> {% endif -%}  {% jika pincode%} PIN: {{}} pincode <br> {% endif -%}  {{negara}} <br>  {% jika telepon%} Telepon: {{ponsel}} {<br> endif% -%}  {% jika faks%} Fax: {{}} fax <br> {% endif -%}  {% jika email_id%} Email: {{}} email_id <br> ; {% endif -%}  </ code> </ pre>"
A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Sebuah Kelompok Pelanggan ada dengan nama yang sama, silakan mengubah nama Nasabah atau mengubah nama Grup Pelanggan"
A Customer exists with same name,Nasabah ada dengan nama yang sama
A Lead with this email id should exist,Sebuah Lead dengan id email ini harus ada
A Product or Service,Produk atau Jasa
A Supplier exists with same name,Pemasok dengan nama yang sama sudah terdaftar
A symbol for this currency. For e.g. $,Simbol untuk mata uang ini. Contoh $
AMC Expiry Date,AMC Tanggal Berakhir
Abbr,Abbr
Abbreviation cannot have more than 5 characters,Singkatan tak bisa memiliki lebih dari 5 karakter
Above Value,Nilai di atas
Absent,Absen
Acceptance Criteria,Kriteria Penerimaan
Accepted,Diterima
Accepted + Rejected Qty must be equal to Received quantity for Item {0},Diterima Ditolak + Qty harus sama dengan jumlah yang diterima untuk Item {0}
Accepted Quantity,Diterima Kuantitas
Accepted Warehouse,Gudang Diterima
Account,Akun
Account Balance,Saldo Rekening
Account Created: {0},Akun Dibuat: {0}
Account Details,Rincian Account
Account Head,Akun Kepala
Account Name,Nama Akun
Account Type,Jenis Account
"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Saldo rekening sudah Kredit, Anda tidak diizinkan untuk mengatur 'Balance Harus' sebagai 'Debit'"
"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Saldo rekening sudah di Debit, Anda tidak diizinkan untuk mengatur 'Balance Harus' sebagai 'Kredit'"
Account for the warehouse (Perpetual Inventory) will be created under this Account.,Rekening untuk gudang (Inventaris Perpetual) akan dibuat di bawah Rekening ini.
Account head {0} created,Kepala akun {0} dibuat
Account must be a balance sheet account,Rekening harus menjadi akun neraca
Account with child nodes cannot be converted to ledger,Akun dengan node anak tidak dapat dikonversi ke buku
Account with existing transaction can not be converted to group.,Akun dengan transaksi yang ada tidak dapat dikonversi ke grup.
Account with existing transaction can not be deleted,Akun dengan transaksi yang ada tidak dapat dihapus
Account with existing transaction cannot be converted to ledger,Akun dengan transaksi yang ada tidak dapat dikonversi ke buku
Account {0} cannot be a Group,Akun {0} tidak dapat Kelompok a
Account {0} does not belong to Company {1},Akun {0} bukan milik Perusahaan {1}
Account {0} does not belong to company: {1},Akun {0} bukan milik perusahaan: {1}
Account {0} does not exist,Akun {0} tidak ada
Account {0} has been entered more than once for fiscal year {1},Akun {0} telah dimasukkan lebih dari sekali untuk tahun fiskal {1}
Account {0} is frozen,Akun {0} beku
Account {0} is inactive,Akun {0} tidak aktif
Account {0} is not valid,Akun {0} tidak valid
Account {0} must be of type 'Fixed Asset' as Item {1} is an Asset Item,Akun {0} harus bertipe 'Aset Tetap' sebagai Barang {1} adalah sebuah Aset Barang
Account {0}: Parent account {1} can not be a ledger,Akun {0}: akun Parent {1} tidak dapat buku besar
Account {0}: Parent account {1} does not belong to company: {2},Akun {0}: akun Parent {1} bukan milik perusahaan: {2}
Account {0}: Parent account {1} does not exist,Akun {0}: akun Parent {1} tidak ada
Account {0}: You can not assign itself as parent account,Akun {0}: Anda tidak dapat menetapkan dirinya sebagai rekening induk
Account: {0} can only be updated via \					Stock Transactions,Account: {0} hanya dapat diperbarui melalui \ Transaksi Bursa
Accountant,Akuntan
Accounting,Akuntansi
"Accounting Entries can be made against leaf nodes, called","Entri Akuntansi dapat dilakukan terhadap node daun, yang disebut"
"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Entri Akuntansi beku up to date ini, tak seorang pun bisa melakukan / memodifikasi entri kecuali peran ditentukan di bawah ini."
Accounting journal entries.,Jurnal akuntansi.
Accounts,Rekening
Accounts Browser,Account Browser
Accounts Frozen Upto,Account Frozen Upto
Accounts Payable,Hutang
Accounts Receivable,Piutang
Accounts Settings,Account Settings
Active,Aktif
Active: Will extract emails from ,
Activity,Aktivitas
Activity Log,Log Aktivitas
Activity Log:,Log Aktivitas:
Activity Type,Jenis Kegiatan
Actual,Aktual
Actual Budget,Realisasi Anggaran
Actual Completion Date,Realisasi Tanggal Penyelesaian
Actual Date,Realisasi Tanggal
Actual End Date,Realisasi Tanggal Akhir
Actual Invoice Date,Sebenarnya Faktur Tanggal
Actual Posting Date,Sebenarnya Posting Tanggal
Actual Qty,Realisasi Qty
Actual Qty (at source/target),Aktual Qty (di sumber / target)
Actual Qty After Transaction,Realisasi Qty Setelah Transaksi
Actual Qty: Quantity available in the warehouse.,Jumlah yang sebenarnya: Kuantitas yang tersedia di gudang.
Actual Quantity,Realisasi Kuantitas
Actual Start Date,Aktual Tanggal Mulai
Add,Tambahkan
Add / Edit Taxes and Charges,Tambah / Edit Pajak dan Biaya
Add Child,Tambah Anak
Add Serial No,Tambahkan Serial No
Add Taxes,Tambahkan Pajak
Add Taxes and Charges,Tambahkan Pajak dan Biaya
Add or Deduct,Tambah atau Dikurangi
Add rows to set annual budgets on Accounts.,Tambahkan baris untuk mengatur anggaran tahunan Accounts.
Add to Cart,Add to Cart
Add to calendar on this date,Tambahkan ke kalender pada tanggal ini
Add/Remove Recipients,Tambah / Hapus Penerima
Address,Alamat
Address & Contact,Alamat Kontak
Address & Contacts,Alamat & Kontak
Address Desc,Alamat Penj
Address Details,Alamat Detail
Address HTML,Alamat HTML
Address Line 1,Alamat Baris 1
Address Line 2,Alamat Baris 2
Address Template,Template Alamat
Address Title,Alamat Judul
Address Title is mandatory.,Alamat Judul adalah wajib.
Address Type,Alamat Type
Address master.,Alamat utama.
Administrative Expenses,Beban Administrasi
Administrative Officer,Petugas Administrasi
Advance Amount,Jumlah muka
Advance amount,Jumlah muka
Advances,Uang Muka
Advertisement,iklan
Advertising,Pengiklanan
Aerospace,Aerospace
After Sale Installations,Setelah Sale Instalasi
Against,Terhadap
Against Account,Terhadap Rekening
Against Bill {0} dated {1},Melawan Bill {0} tanggal {1}
Against Docname,Melawan Docname
Against Doctype,Terhadap Doctype
Against Document Detail No,Terhadap Dokumen Detil ada
Against Document No,Melawan Dokumen Tidak
Against Expense Account,Terhadap Beban Akun
Against Income Account,Terhadap Akun Penghasilan
Against Journal Voucher,Melawan Journal Voucher
Against Journal Voucher {0} does not have any unmatched {1} entry,Terhadap Journal Voucher {0} tidak memiliki tertandingi {1} entri
Against Purchase Invoice,Terhadap Purchase Invoice
Against Sales Invoice,Terhadap Faktur Penjualan
Against Sales Order,Terhadap Sales Order
Against Voucher,Melawan Voucher
Against Voucher Type,Terhadap Voucher Type
Ageing Based On,Penuaan Berdasarkan
Ageing Date is mandatory for opening entry,Penuaan Tanggal adalah wajib untuk membuka entri
Ageing date is mandatory for opening entry,Penuaan saat ini adalah wajib untuk membuka entri
Agent,Agen
Aging Date,Penuaan Tanggal
Aging Date is mandatory for opening entry,Penuaan Tanggal adalah wajib untuk membuka entri
Agriculture,Agriculture
Airline,Perusahaan penerbangan
All Addresses.,Semua Addresses.
All Contact,Semua Kontak
All Contacts.,All Contacts.
All Customer Contact,Semua Kontak Pelanggan
All Customer Groups,Semua Grup Pelanggan
All Day,Semua Hari
All Employee (Active),Semua Karyawan (Active)
All Item Groups,Semua Barang Grup
All Lead (Open),Semua Timbal (Open)
All Products or Services.,Semua Produk atau Jasa.
All Sales Partner Contact,Semua Penjualan Partner Kontak
All Sales Person,Semua Penjualan Orang
All Supplier Contact,Semua Pemasok Kontak
All Supplier Types,Semua Jenis Pemasok
All Territories,Semua Territories
"All export related fields like currency, conversion rate, export total, export grand total etc are available in Delivery Note, POS, Quotation, Sales Invoice, Sales Order etc.","Semua bidang ekspor terkait seperti mata uang, tingkat konversi, jumlah ekspor, total ekspor dll besar tersedia dalam Pengiriman Catatan, POS, Quotation, Faktur Penjualan, Sales Order dll"
"All import related fields like currency, conversion rate, import total, import grand total etc are available in Purchase Receipt, Supplier Quotation, Purchase Invoice, Purchase Order etc.","Semua bidang impor terkait seperti mata uang, tingkat konversi, jumlah impor, impor besar jumlah dll tersedia dalam Penerimaan Pembelian, Supplier Quotation, Purchase Invoice, Purchase Order dll"
All items have already been invoiced,Semua item telah ditagih
All these items have already been invoiced,Semua barang-barang tersebut telah ditagih
Allocate,Menyediakan
Allocate leaves for a period.,Mengalokasikan daun untuk suatu periode.
Allocate leaves for the year.,Mengalokasikan daun untuk tahun ini.
Allocated Amount,Dialokasikan Jumlah
Allocated Budget,Anggaran Dialokasikan
Allocated amount,Jumlah yang dialokasikan
Allocated amount can not be negative,Jumlah yang dialokasikan tidak dapat negatif
Allocated amount can not greater than unadusted amount,Jumlah yang dialokasikan tidak bisa lebih besar dari jumlah unadusted
Allow Bill of Materials,Biarkan Bill of Material
Allow Bill of Materials should be 'Yes'. Because one or many active BOMs present for this item,Biarkan Bill of Material harus 'Ya'. Karena satu atau banyak BOMs aktif hadir untuk item ini
Allow Children,Biarkan Anak-anak
Allow Dropbox Access,Izinkan Dropbox Access
Allow Google Drive Access,Izinkan Google Drive Access
Allow Negative Balance,Biarkan Saldo Negatif
Allow Negative Stock,Izinkan Bursa Negatif
Allow Production Order,Izinkan Pesanan Produksi
Allow User,Izinkan Pengguna
Allow Users,Izinkan Pengguna
Allow the following users to approve Leave Applications for block days.,Memungkinkan pengguna berikut untuk menyetujui Leave Aplikasi untuk blok hari.
Allow user to edit Price List Rate in transactions,Memungkinkan pengguna untuk mengedit Daftar Harga Tingkat dalam transaksi
Allowance Percent,Penyisihan Persen
Allowance for over-{0} crossed for Item {1},Penyisihan over-{0} menyeberang untuk Item {1}
Allowance for over-{0} crossed for Item {1}.,Penyisihan over-{0} menyeberang untuk Item {1}.
Allowed Role to Edit Entries Before Frozen Date,Diizinkan Peran ke Sunting Entri Sebelum Frozen Tanggal
Amended From,Diubah Dari
Amount,Jumlah
Amount (Company Currency),Jumlah (Perusahaan Mata Uang)
Amount Paid,Jumlah Dibayar
Amount to Bill,Sebesar Bill
An Customer exists with same name,Sebuah Pelanggan ada dengan nama yang sama
"An Item Group exists with same name, please change the item name or rename the item group","Item Grup ada dengan nama yang sama, ubah nama item atau mengubah nama kelompok barang"
"An item exists with same name ({0}), please change the item group name or rename the item","Sebuah item yang ada dengan nama yang sama ({0}), silakan mengubah nama kelompok barang atau mengubah nama item"
Analyst,Analis
Annual,Tahunan
Another Period Closing Entry {0} has been made after {1},Lain Periode Pendaftaran penutupan {0} telah dibuat setelah {1}
Another Salary Structure {0} is active for employee {0}. Please make its status 'Inactive' to proceed.,Struktur Gaji lain {0} aktif untuk karyawan {0}. Silakan membuat status 'aktif' untuk melanjutkan.
"Any other comments, noteworthy effort that should go in the records.","Ada komentar lain, upaya penting yang harus pergi dalam catatan."
Apparel & Accessories,Pakaian & Aksesoris
Applicability,Penerapan
Applicable For,Berlaku Untuk
Applicable Holiday List,Berlaku Libur
Applicable Territory,Wilayah yang berlaku
Applicable To (Designation),Berlaku Untuk (Penunjukan)
Applicable To (Employee),Berlaku Untuk (Karyawan)
Applicable To (Role),Berlaku Untuk (Peran)
Applicable To (User),Berlaku Untuk (User)
Applicant Name,Nama Pemohon
Applicant for a Job.,Pemohon untuk pekerjaan.
Application of Funds (Assets),Penerapan Dana (Aset)
Applications for leave.,Aplikasi untuk cuti.
Applies to Company,Berlaku untuk Perusahaan
Apply On,Terapkan On
Appraisal,Penilaian
Appraisal Goal,Penilaian Goal
Appraisal Goals,Penilaian Gol
Appraisal Template,Appraisal Template
Appraisal Template Goal,Gol Appraisal Template
Appraisal Template Title,Appraisal Template Judul
Appraisal {0} created for Employee {1} in the given date range,Penilaian {0} diciptakan untuk Employee {1} dalam rentang tanggal tertentu
Apprentice,Magang
Approval Status,Status Persetujuan
Approval Status must be 'Approved' or 'Rejected',Status Persetujuan harus 'Disetujui' atau 'Ditolak'
Approved,Disetujui
Approver,Approver
Approving Role,Menyetujui Peran
Approving Role cannot be same as role the rule is Applicable To,Menyetujui Peran tidak bisa sama dengan peran aturan yang Berlaku Untuk
Approving User,Menyetujui Pengguna
Approving User cannot be same as user the rule is Applicable To,Menyetujui Pengguna tidak bisa sama dengan pengguna aturan yang Berlaku Untuk
Are you sure you want to STOP ,
Are you sure you want to UNSTOP ,
Arrear Amount,Jumlah tunggakan
"As Production Order can be made for this item, it must be a stock item.","Seperti Orde Produksi dapat dibuat untuk item ini, itu harus menjadi barang saham."
As per Stock UOM,Per Saham UOM
"As there are existing stock transactions for this item, you can not change the values of 'Has Serial No', 'Is Stock Item' and 'Valuation Method'","Karena ada transaksi saham yang ada untuk item ini, Anda tidak dapat mengubah nilai-nilai 'Memiliki Serial No', 'Apakah Stock Barang' dan 'Metode Penilaian'"
Asset,Aset
Assistant,Asisten
Associate,Rekan
Atleast one of the Selling or Buying must be selected,Atleast salah satu Jual atau Beli harus dipilih
Atleast one warehouse is mandatory,Atleast satu gudang adalah wajib
Attach Image,Pasang Gambar
Attach Letterhead,Lampirkan Surat
Attach Logo,Pasang Logo
Attach Your Picture,Pasang Gambar Anda
Attendance,Kehadiran
Attendance Date,Kehadiran Tanggal
Attendance Details,Rincian Kehadiran
Attendance From Date,Kehadiran Dari Tanggal
Attendance From Date and Attendance To Date is mandatory,Kehadiran Dari Tanggal dan Kehadiran To Date adalah wajib
Attendance To Date,Kehadiran To Date
Attendance can not be marked for future dates,Kehadiran tidak dapat ditandai untuk tanggal masa depan
Attendance for employee {0} is already marked,Kehadiran bagi karyawan {0} sudah ditandai
Attendance record.,Catatan kehadiran.
Authorization Control,Pengendalian Otorisasi
Authorization Rule,Aturan Otorisasi
Auto Accounting For Stock Settings,Auto Akuntansi Untuk Stock Pengaturan
Auto Material Request,Auto Material Permintaan
Auto-raise Material Request if quantity goes below re-order level in a warehouse,Auto-meningkatkan Permintaan Material jika kuantitas berjalan di bawah tingkat re-order di gudang
Automatically compose message on submission of transactions.,Secara otomatis menulis pesan pada pengajuan transaksi.
Automatically extract Job Applicants from a mail box ,
Automatically extract Leads from a mail box e.g.,Secara otomatis mengekstrak Memimpin dari kotak surat misalnya
Automatically updated via Stock Entry of type Manufacture/Repack,Secara otomatis diperbarui melalui Bursa Masuknya jenis Industri / Repack
Automotive,Ot
Autoreply when a new mail is received,Autoreply ketika mail baru diterima
Available,Tersedia
Available Qty at Warehouse,Qty Tersedia di Gudang
Available Stock for Packing Items,Tersedia Stock untuk Packing Produk
"Available in BOM, Delivery Note, Purchase Invoice, Production Order, Purchase Order, Purchase Receipt, Sales Invoice, Sales Order, Stock Entry, Timesheet","Tersedia dalam BOM, Pengiriman Catatan, Purchase Invoice, Pesanan Produksi, Purchase Order, Penerimaan Pembelian, Faktur Penjualan, Sales Order, Stock Masuk, Timesheet"
Average Age,Rata-rata Usia
Average Commission Rate,Rata-rata Komisi Tingkat
Average Discount,Rata-rata Diskon
Awesome Products,Mengagumkan Produk
Awesome Services,Layanan yang mengagumkan
BOM Detail No,BOM Detil ada
BOM Explosion Item,BOM Ledakan Barang
BOM Item,BOM Barang
BOM No,BOM ada
BOM No. for a Finished Good Item,BOM No untuk jadi baik Barang
BOM Operation,BOM Operasi
BOM Operations,BOM Operasi
BOM Replace Tool,BOM Ganti Alat
BOM number is required for manufactured Item {0} in row {1},Nomor BOM diperlukan untuk diproduksi Barang {0} berturut-turut {1}
BOM number not allowed for non-manufactured Item {0} in row {1},Nomor BOM tidak diperbolehkan untuk non-manufaktur Barang {0} berturut-turut {1}
BOM recursion: {0} cannot be parent or child of {2},BOM rekursi: {0} tidak dapat orang tua atau anak dari {2}
BOM replaced,BOM diganti
BOM {0} for Item {1} in row {2} is inactive or not submitted,BOM {0} untuk Item {1} berturut-turut {2} tidak aktif atau tidak disampaikan
BOM {0} is not active or not submitted,BOM {0} tidak aktif atau tidak disampaikan
BOM {0} is not submitted or inactive BOM for Item {1},BOM {0} bukan disampaikan atau tidak aktif BOM untuk Item {1}
Backup Manager,Backup Manager
Backup Right Now,Backup Right Now
Backups will be uploaded to,Backup akan di-upload ke
Balance Qty,Balance Qty
Balance Sheet,Neraca
Balance Value,Saldo Nilai
Balance for Account {0} must always be {1},Saldo Rekening {0} harus selalu {1}
Balance must be,Balance harus
"Balances of Accounts of type ""Bank"" or ""Cash""","Saldo Rekening jenis ""Bank"" atau ""Cash"""
Bank,Bank
Bank / Cash Account,Bank / Kas Rekening
Bank A/C No.,Bank A / C No
Bank Account,Bank Account/Rekening Bank
Bank Account No.,Rekening Bank No
Bank Accounts,Rekening Bank
Bank Clearance Summary,Izin Bank Summary
Bank Draft,Bank Draft
Bank Name,Nama Bank
Bank Overdraft Account,Cerukan Bank Akun
Bank Reconciliation,5. Bank Reconciliation (Rekonsiliasi Bank)
Bank Reconciliation Detail,Rekonsiliasi Bank Detil
Bank Reconciliation Statement,Pernyataan Bank Rekonsiliasi
Bank Voucher,Bank Voucher
Bank/Cash Balance,Bank / Cash Balance
Banking,Perbankan
Barcode,barcode
Barcode {0} already used in Item {1},Barcode {0} sudah digunakan dalam Butir {1}
Based On,Berdasarkan
Basic,Dasar
Basic Info,Info Dasar
Basic Information,Informasi Dasar
Basic Rate,Tingkat Dasar
Basic Rate (Company Currency),Tingkat Dasar (Perusahaan Mata Uang)
Batch,Sejumlah
Batch (lot) of an Item.,Batch (banyak) dari Item.
Batch Finished Date,Batch Selesai Tanggal
Batch ID,Batch ID
Batch No,Ada Batch
Batch Started Date,Batch Dimulai Tanggal
Batch Time Logs for billing.,Batch Sisa log untuk penagihan.
Batch-Wise Balance History,Batch-Wise Balance Sejarah
Batched for Billing,Batched untuk Billing
Better Prospects,Prospek yang lebih baik
Bill Date,Bill Tanggal
Bill No,Bill ada
Bill No {0} already booked in Purchase Invoice {1},Bill ada {0} sudah memesan di Purchase Invoice {1}
Bill of Material,Bill of Material
Bill of Material to be considered for manufacturing,Bill of Material untuk dipertimbangkan untuk manufaktur
Bill of Materials (BOM),Bill of Material (BOM)
Billable,Ditagih
Billed,Ditagih
Billed Amount,Ditagih Jumlah
Billed Amt,Ditagih Amt
Billing,Penagihan
Billing Address,Alamat Penagihan
Billing Address Name,Alamat Penagihan Nama
Billing Status,Status Penagihan
Bills raised by Suppliers.,Bills diajukan oleh Pemasok.
Bills raised to Customers.,Bills diangkat ke Pelanggan.
Bin,Bin
Bio,Bio
Biotechnology,Bioteknologi
Birthday,Ulang tahun
Block Date,Blok Tanggal
Block Days,Block Hari
Block leave applications by department.,Memblokir aplikasi cuti oleh departemen.
Blog Post,Posting Blog
Blog Subscriber,Blog Subscriber
Blood Group,Kelompok darah
Both Warehouse must belong to same Company,Kedua Gudang harus milik Perusahaan yang sama
Box,Kotak
Branch,Cabang
Brand,Merek
Brand Name,Merek Nama
Brand master.,Master merek.
Brands,Merek
Breakdown,Kerusakan
Broadcasting,Penyiaran
Brokerage,Perdagangan perantara
Budget,Anggaran belanja
Budget Allocated,Anggaran Dialokasikan
Budget Detail,Anggaran Detil
Budget Details,Rincian Anggaran
Budget Distribution,Distribusi anggaran
Budget Distribution Detail,Detil Distribusi Anggaran
Budget Distribution Details,Rincian Distribusi Anggaran
Budget Variance Report,Varians Anggaran Laporan
Budget cannot be set for Group Cost Centers,Anggaran tidak dapat ditetapkan untuk Biaya Pusat Grup
Build Report,Buat Laporan
Bundle items at time of sale.,Bundel item pada saat penjualan.
Business Development Manager,Business Development Manager
Buying,Pembelian
Buying & Selling,Jual Beli &
Buying Amount,Membeli Jumlah
Buying Settings,Membeli Pengaturan
"Buying must be checked, if Applicable For is selected as {0}","Membeli harus diperiksa, jika Berlaku Untuk dipilih sebagai {0}"
C-Form,C-Form
C-Form Applicable,C-Form Berlaku
C-Form Invoice Detail,C-Form Faktur Detil
C-Form No,C-Form ada
C-Form records,C-Form catatan
CENVAT Capital Goods,Cenvat Barang Modal
CENVAT Edu Cess,Cenvat Edu Cess
CENVAT SHE Cess,Cenvat SHE Cess
CENVAT Service Tax,Pelayanan Pajak Cenvat
CENVAT Service Tax Cess 1,Cenvat Pelayanan Pajak Cess 1
CENVAT Service Tax Cess 2,Cenvat Pelayanan Pajak Cess 2
Calculate Based On,Hitung Berbasis On
Calculate Total Score,Hitung Total Skor
Calendar Events,Kalender Acara
Call,Panggilan
Calls,Panggilan
Campaign,Kampanye
Campaign Name,Nama Kampanye
Campaign Name is required,Nama Kampanye diperlukan
Campaign Naming By,Kampanye Penamaan Dengan
Campaign-.####,Kampanye-.# # # #
Can be approved by {0},Dapat disetujui oleh {0}
"Can not filter based on Account, if grouped by Account","Tidak dapat menyaring berdasarkan Account, jika dikelompokkan berdasarkan Rekening"
"Can not filter based on Voucher No, if grouped by Voucher","Tidak dapat menyaring berdasarkan Voucher Tidak, jika dikelompokkan berdasarkan Voucher"
Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Dapat merujuk baris hanya jika jenis biaya adalah 'On Sebelumnya Row Jumlah' atau 'Sebelumnya Row Jumlah'
Cancel Material Visit {0} before cancelling this Customer Issue,Batal Bahan Visit {0} sebelum membatalkan ini Issue Pelanggan
Cancel Material Visits {0} before cancelling this Maintenance Visit,Batal Kunjungan Material {0} sebelum membatalkan ini Maintenance Visit
Cancelled,Cancelled
Cancelling this Stock Reconciliation will nullify its effect.,Membatalkan ini Stock Rekonsiliasi akan meniadakan efeknya.
Cannot Cancel Opportunity as Quotation Exists,Tidak bisa Batal Peluang sebagai Quotation Exists
Cannot approve leave as you are not authorized to approve leaves on Block Dates,Tidak dapat menyetujui cuti karena Anda tidak berwenang untuk menyetujui daun di Blok Dates
Cannot cancel because Employee {0} is already approved for {1},Tidak dapat membatalkan karena Employee {0} sudah disetujui untuk {1}
Cannot cancel because submitted Stock Entry {0} exists,Tidak bisa membatalkan karena disampaikan Stock entri {0} ada
Cannot carry forward {0},Tidak bisa meneruskan {0}
Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Tidak dapat mengubah Tahun Anggaran Tanggal Mulai dan Tanggal Akhir Tahun Anggaran setelah Tahun Anggaran disimpan.
"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Tidak dapat mengubah mata uang default perusahaan, karena ada transaksi yang ada. Transaksi harus dibatalkan untuk mengubah mata uang default."
Cannot convert Cost Center to ledger as it has child nodes,Tidak dapat mengkonversi Biaya Center untuk buku karena memiliki node anak
Cannot covert to Group because Master Type or Account Type is selected.,Tidak dapat mengkonversi ke Grup karena Guru Ketik atau Rekening Type dipilih.
Cannot deactive or cancle BOM as it is linked with other BOMs,Tidak dapat deactive atau cancle BOM seperti yang dihubungkan dengan BOMs lain
"Cannot declare as lost, because Quotation has been made.","Tidak dapat mendeklarasikan sebagai hilang, karena Quotation telah dibuat."
Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Tidak bisa mengurangi ketika kategori adalah untuk 'Penilaian' atau 'Penilaian dan Total'
"Cannot delete Serial No {0} in stock. First remove from stock, then delete.","Tidak dapat menghapus Serial ada {0} di saham. Pertama menghapus dari saham, kemudian hapus."
"Cannot directly set amount. For 'Actual' charge type, use the rate field","Tidak bisa langsung menetapkan jumlah. Untuk 'sebenarnya' jenis biaya, menggunakan kolom tingkat"
"Cannot overbill for Item {0} in row {0} more than {1}. To allow overbilling, please set in Stock Settings","Tidak bisa overbill untuk Item {0} di baris {0} lebih dari {1}. Untuk memungkinkan mark up, atur di Bursa Settings"
Cannot produce more Item {0} than Sales Order quantity {1},Tidak dapat menghasilkan lebih Barang {0} daripada kuantitas Sales Order {1}
Cannot refer row number greater than or equal to current row number for this Charge type,Tidak dapat merujuk nomor baris yang lebih besar dari atau sama dengan nomor baris saat ini untuk jenis Biaya ini
Cannot return more than {0} for Item {1},Tidak dapat kembali lebih dari {0} untuk Item {1}
Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Tidak dapat memilih jenis biaya sebagai 'Pada Row Sebelumnya Jumlah' atau 'On Sebelumnya Row Jumlah' untuk baris pertama
Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for valuation. You can select only 'Total' option for previous row amount or previous row total,Tidak bisa memilih jenis biaya sebagai 'Pada Row Sebelumnya Jumlah' atau 'On Sebelumnya Row Jumlah' untuk penilaian. Anda dapat memilih hanya 'Jumlah' pilihan untuk jumlah baris sebelumnya atau total baris sebelumnya
Cannot set as Lost as Sales Order is made.,Tidak dapat ditetapkan sebagai Hilang sebagai Sales Order dibuat.
Cannot set authorization on basis of Discount for {0},Tidak dapat mengatur otorisasi atas dasar Diskon untuk {0}
Capacity,kapasitas
Capacity Units,Unit Kapasitas
Capital Account,Transaksi Modal
Capital Equipments,Peralatan Modal
Carry Forward,Carry Teruskan
Carry Forwarded Leaves,Carry Leaves Diteruskan
Case No(s) already in use. Try from Case No {0},Kasus ada (s) sudah digunakan. Coba dari Case ada {0}
Case No. cannot be 0,Kasus No tidak bisa 0
Cash,kas
Cash In Hand,Cash In Hand
Cash Voucher,Voucher Cash
Cash or Bank Account is mandatory for making payment entry,Kas atau Rekening Bank wajib untuk membuat entri pembayaran
Cash/Bank Account,Rekening Kas / Bank
Casual Leave,Santai Cuti
Cell Number,Nomor Cell
Change UOM for an Item.,Mengubah UOM untuk Item.
Change the starting / current sequence number of an existing series.,Mengubah mulai / nomor urut saat ini dari seri yang ada.
Channel Partner,Mitra Channel
Charge of type 'Actual' in row {0} cannot be included in Item Rate,Mengisi tipe 'sebenarnya' berturut-turut {0} tidak dapat dimasukkan dalam Butir Tingkat
Chargeable,Dibebankan
Charity and Donations,Amal dan Sumbangan
Chart Name,Bagan Nama
Chart of Accounts,Chart of Account
Chart of Cost Centers,Bagan Pusat Biaya
Check how the newsletter looks in an email by sending it to your email.,Periksa bagaimana newsletter terlihat dalam email dengan mengirimkannya ke email Anda.
"Check if recurring invoice, uncheck to stop recurring or put proper End Date","Periksa apakah berulang faktur, hapus centang untuk menghentikan berulang atau menempatkan tepat Tanggal Akhir"
"Check if you need automatic recurring invoices. After submitting any sales invoice, Recurring section will be visible.","Periksa apakah Anda memerlukan faktur berulang otomatis. Setelah mengirimkan setiap faktur penjualan, bagian Berulang akan terlihat."
Check if you want to send salary slip in mail to each employee while submitting salary slip,Periksa apakah Anda ingin mengirim Slip gaji mail ke setiap karyawan saat mengirimkan Slip gaji
Check this if you want to force the user to select a series before saving. There will be no default if you check this.,Periksa ini jika Anda ingin untuk memaksa pengguna untuk memilih seri sebelum menyimpan. Tidak akan ada default jika Anda memeriksa ini.
Check this if you want to show in website,Periksa ini jika Anda ingin menunjukkan di website
Check this to disallow fractions. (for Nos),Centang untuk melarang fraksi. (Untuk Nos)
Check this to pull emails from your mailbox,Periksa ini untuk menarik email dari kotak surat Anda
Check to activate,Periksa untuk mengaktifkan
Check to make Shipping Address,Periksa untuk memastikan Alamat Pengiriman
Check to make primary address,Periksa untuk memastikan alamat utama
Chemical,Kimia
Cheque,Cek
Cheque Date,Cek Tanggal
Cheque Number,Nomor Cek
Child account exists for this account. You can not delete this account.,Akun anak ada untuk akun ini. Anda tidak dapat menghapus akun ini.
City,Kota
City/Town,Kota / Kota
Claim Amount,Klaim Jumlah
Claims for company expense.,Klaim untuk biaya perusahaan.
Class / Percentage,Kelas / Persentase
Classic,Klasik
Clear Table,Jelas Table
Clearance Date,Izin Tanggal
Clearance Date not mentioned,Izin Tanggal tidak disebutkan
Clearance date cannot be before check date in row {0},Tanggal clearance tidak bisa sebelum tanggal check-in baris {0}
Click on 'Make Sales Invoice' button to create a new Sales Invoice.,Klik 'Buat Sales Invoice' tombol untuk membuat Faktur Penjualan baru.
Click on a link to get options to expand get options ,
Client,Client (Nasabah)
Close Balance Sheet and book Profit or Loss.,Tutup Neraca dan Perhitungan Laba Rugi atau buku.
Closed,Tertutup
Closing (Cr),Penutup (Cr)
Closing (Dr),Penutup (Dr)
Closing Account Head,Menutup Akun Kepala
Closing Account {0} must be of type 'Liability',Menutup Akun {0} harus bertipe 'Kewajiban'
Closing Date,Closing Date
Closing Fiscal Year,Penutup Tahun Anggaran
Closing Qty,Penutup Qty
Closing Value,Penutup Nilai
CoA Help,CoA Bantuan
Code,Kode
Cold Calling,Calling Dingin
Color,Warna
Column Break,Kolom Istirahat
Comma separated list of email addresses,Koma daftar alamat email dipisahkan
Comment,Komentar
Comments,Komentar
Commercial,Komersial
Commission,Komisi
Commission Rate,Komisi Tingkat
Commission Rate (%),Komisi Rate (%)
Commission on Sales,Komisi Penjualan
Commission rate cannot be greater than 100,Tingkat komisi tidak dapat lebih besar dari 100
Communication,Komunikasi
Communication HTML,Komunikasi HTML
Communication History,Sejarah Komunikasi
Communication log.,Log komunikasi.
Communications,Komunikasi
Company,Perusahaan
Company (not Customer or Supplier) master.,Perusahaan (tidak Pelanggan atau Pemasok) Master.
Company Abbreviation,Singkatan Perusahaan
Company Details,Detail Perusahaan
Company Email,Perusahaan Email
"Company Email ID not found, hence mail not sent","Perusahaan Email ID tidak ditemukan, maka surat tidak terkirim"
Company Info,Info Perusahaan
Company Name,Company Name
Company Settings,Pengaturan Perusahaan
Company is missing in warehouses {0},Perusahaan hilang di gudang {0}
Company is required,Perusahaan diwajibkan
Company registration numbers for your reference. Example: VAT Registration Numbers etc.,Nomor registrasi perusahaan untuk referensi Anda. Contoh: Pendaftaran PPN Nomor dll
Company registration numbers for your reference. Tax numbers etc.,Nomor registrasi perusahaan untuk referensi Anda. Nomor pajak dll
"Company, Month and Fiscal Year is mandatory","Perusahaan, Bulan dan Tahun Anggaran adalah wajib"
Compensatory Off,Kompensasi Off
Complete,Selesai
Complete Setup,Pengaturan Lengkap
Completed,Selesai
Completed Production Orders,Pesanan Produksi Selesai
Completed Qty,Selesai Qty
Completion Date,Tanggal Penyelesaian
Completion Status,Status Penyelesaian
Computer,Komputer
Computers,Komputer
Confirmation Date,Konfirmasi Tanggal
Confirmed orders from Customers.,Dikonfirmasi pesanan dari pelanggan.
Consider Tax or Charge for,Pertimbangkan Pajak atau Biaya untuk
Considered as Opening Balance,Dianggap sebagai Membuka Balance
Considered as an Opening Balance,Dianggap sebagai Saldo Pembukaan
Consultant,Konsultan
Consulting,Konsultasi
Consumable,Consumable
Consumable Cost,Biaya Consumable
Consumable cost per hour,Biaya konsumsi per jam
Consumed Qty,Dikonsumsi Qty
Consumer Products,Produk Konsumen
Contact,Kontak
Contact Control,Kontak Kontrol
Contact Desc,Contact Info
Contact Details,Kontak Detail
Contact Email,Email Kontak
Contact HTML,Hubungi HTML
Contact Info,Informasi Kontak
Contact Mobile No,Kontak Mobile No
Contact Name,Nama Kontak
Contact No.,Hubungi Nomor
Contact Person,Contact Person
Contact Type,Hubungi Type
Contact master.,Kontak utama.
Contacts,Kontak
Content,Isi Halaman
Content Type,Content Type
Contra Voucher,Contra Voucher
Contract,Kontrak
Contract End Date,Tanggal Kontrak End
Contract End Date must be greater than Date of Joining,Kontrak Tanggal Akhir harus lebih besar dari Tanggal Bergabung
Contribution (%),Kontribusi (%)
Contribution to Net Total,Kontribusi terhadap Net Jumlah
Conversion Factor,Faktor konversi
Conversion Factor is required,Faktor konversi diperlukan
Conversion factor cannot be in fractions,Faktor konversi tidak dapat di fraksi
Conversion factor for default Unit of Measure must be 1 in row {0},Faktor konversi untuk Unit default Ukur harus 1 berturut-turut {0}
Conversion rate cannot be 0 or 1,Tingkat konversi tidak bisa 0 atau 1
Convert into Recurring Invoice,Mengkonversi menjadi Faktur Berulang
Convert to Group,Konversikan ke Grup
Convert to Ledger,Convert to Ledger
Converted,Dikonversi
Copy From Item Group,Salin Dari Barang Grup
Cosmetics,Kosmetik
Cost Center,Biaya Pusat
Cost Center Details,Biaya Pusat Detail
Cost Center Name,Biaya Nama Pusat
Cost Center is required for 'Profit and Loss' account {0},Biaya Pusat diperlukan untuk akun 'Laba Rugi' {0}
Cost Center is required in row {0} in Taxes table for type {1},Biaya Pusat diperlukan dalam baris {0} dalam tabel Pajak untuk tipe {1}
Cost Center with existing transactions can not be converted to group,Biaya Center dengan transaksi yang ada tidak dapat dikonversi ke grup
Cost Center with existing transactions can not be converted to ledger,Biaya Center dengan transaksi yang ada tidak dapat dikonversi ke buku
Cost Center {0} does not belong to Company {1},Biaya Pusat {0} bukan milik Perusahaan {1}
Cost of Goods Sold,Harga Pokok Penjualan
Costing,Biaya
Country,Negara
Country Name,Nama Negara
Country wise default Address Templates,Negara bijaksana Alamat bawaan Template
"Country, Timezone and Currency","Country, Timezone dan Mata Uang"
Create Bank Voucher for the total salary paid for the above selected criteria,Buat Bank Voucher untuk gaji total yang dibayarkan untuk kriteria pilihan di atas
Create Customer,Buat Pelanggan
Create Material Requests,Buat Permintaan Material
Create New,Buat New
Create Opportunity,Buat Peluang
Create Production Orders,Buat Pesanan Produksi
Create Quotation,Buat Quotation
Create Receiver List,Buat Daftar Penerima
Create Salary Slip,Buat Slip Gaji
Create Stock Ledger Entries when you submit a Sales Invoice,Buat Bursa Ledger Entries ketika Anda mengirimkan Faktur Penjualan
"Create and manage daily, weekly and monthly email digests.","Membuat dan mengelola harian, mingguan dan bulanan mencerna email."
Create rules to restrict transactions based on values.,Buat aturan untuk membatasi transaksi berdasarkan nilai-nilai.
Created By,Dibuat Oleh
Creates salary slip for above mentioned criteria.,Membuat Slip gaji untuk kriteria yang disebutkan di atas.
Creation Date,Tanggal Pembuatan
Creation Document No,Penciptaan Dokumen Tidak
Creation Document Type,Pembuatan Dokumen Type
Creation Time,Waktu Pembuatan
Credentials,Surat kepercayaan
Credit,Piutang
Credit Amt,Kredit Jumlah Yang
Credit Card,Kartu Kredit
Credit Card Voucher,Voucher Kartu Kredit
Credit Controller,Kontroler Kredit
Credit Days,Hari Kredit
Credit Limit,Batas Kredit
Credit Note,Nota Kredit
Credit To,Kredit Untuk
Currency,Mata uang
Currency Exchange,Kurs Mata Uang
Currency Name,Nama Mata Uang
Currency Settings,Pengaturan Mata Uang
Currency and Price List,Mata Uang dan Daftar Harga
Currency exchange rate master.,Menguasai nilai tukar mata uang.
Current Address,Alamat saat ini
Current Address Is,Alamat saat ini adalah
Current Assets,Aset Lancar
Current BOM,BOM saat ini
Current BOM and New BOM can not be same,BOM Lancar dan New BOM tidak bisa sama
Current Fiscal Year,Tahun Anggaran saat ini
Current Liabilities,Kewajiban Lancar
Current Stock,Stok saat ini
Current Stock UOM,Stok saat ini UOM
Current Value,Nilai saat ini
Custom,Disesuaikan
Custom Autoreply Message,Kustom Autoreply Pesan
Custom Message,Custom Pesan
Customer,Layanan Pelanggan
Customer (Receivable) Account,Pelanggan (Piutang) Rekening
Customer / Item Name,Pelanggan / Item Nama
Customer / Lead Address,Pelanggan / Lead Alamat
Customer / Lead Name,Pelanggan / Lead Nama
Customer > Customer Group > Territory,Pelanggan> Grup Pelanggan> Wilayah
Customer Account Head,Nasabah Akun Kepala
Customer Acquisition and Loyalty,Akuisisi Pelanggan dan Loyalitas
Customer Address,Alamat pelanggan
Customer Addresses And Contacts,Alamat Pelanggan Dan Kontak
Customer Addresses and Contacts,Alamat pelanggan dan Kontak
Customer Code,Kode Pelanggan
Customer Codes,Kode Pelanggan
Customer Details,Rincian pelanggan
Customer Feedback,Pelanggan Umpan
Customer Group,Kelompok Pelanggan
Customer Group / Customer,Kelompok Pelanggan / Pelanggan
Customer Group Name,Nama Kelompok Pelanggan
Customer Intro,Intro Pelanggan
Customer Issue,Nasabah Isu
Customer Issue against Serial No.,Issue pelanggan terhadap Serial Number
Customer Name,Nama nasabah
Customer Naming By,Penamaan Pelanggan Dengan
Customer Service,Layanan Pelanggan
Customer database.,Database pelanggan.
Customer is required,Pelanggan diwajibkan
Customer master.,Master pelanggan.
Customer required for 'Customerwise Discount',Pelanggan yang dibutuhkan untuk 'Customerwise Diskon'
Customer {0} does not belong to project {1},Pelanggan {0} bukan milik proyek {1}
Customer {0} does not exist,Pelanggan {0} tidak ada
Customer's Item Code,Nasabah Item Code
Customer's Purchase Order Date,Nasabah Purchase Order Tanggal
Customer's Purchase Order No,Nasabah Purchase Order No
Customer's Purchase Order Number,Nasabah Purchase Order Nomor
Customer's Vendor,Penjual Nasabah
Customers Not Buying Since Long Time,Pelanggan Tidak Membeli Sejak Long Time
Customerwise Discount,Customerwise Diskon
Customize,Sesuaikan
Customize the Notification,Sesuaikan Pemberitahuan
Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,Sesuaikan teks pengantar yang berlangsung sebagai bagian dari email itu. Setiap transaksi memiliki teks pengantar yang terpisah.
DN Detail,DN Detil
Daily,Sehari-hari
Daily Time Log Summary,Harian Waktu Log Summary
Database Folder ID,Database Folder ID
Database of potential customers.,Database pelanggan potensial.
Date,Tanggal
Date Format,Format Tanggal
Date Of Retirement,Tanggal Of Pensiun
Date Of Retirement must be greater than Date of Joining,Tanggal Of Pensiun harus lebih besar dari Tanggal Bergabung
Date is repeated,Tanggal diulang
Date of Birth,Tanggal Lahir
Date of Issue,Tanggal Issue
Date of Joining,Tanggal Bergabung
Date of Joining must be greater than Date of Birth,Tanggal Bergabung harus lebih besar dari Tanggal Lahir
Date on which lorry started from supplier warehouse,Tanggal truk mulai dari pemasok gudang
Date on which lorry started from your warehouse,Tanggal truk mulai dari gudang Anda
Dates,Tanggal
Days Since Last Order,Hari Sejak Orde terakhir
Days for which Holidays are blocked for this department.,Hari yang Holidays diblokir untuk departemen ini.
Dealer,Dealer (Pelaku)
Debit,Debet
Debit Amt,Debit Amt
Debit Note,Debit Note
Debit To,Debit Untuk
Debit and Credit not equal for this voucher. Difference is {0}.,Debit dan Kredit tidak sama untuk voucher ini. Perbedaan adalah {0}.
Deduct,Mengurangi
Deduction,Deduksi
Deduction Type,Pengurangan Type
Deduction1,Deduction1
Deductions,Pengurangan
Default,Dfault
Default Account,Standar Akun
Default Address Template cannot be deleted,Template Default Address tidak bisa dihapus
Default Amount,Jumlah standar
Default BOM,Standar BOM
Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,Standar rekening Bank / Cash akan secara otomatis diperbarui di POS Invoice saat mode ini dipilih.
Default Bank Account,Standar Rekening Bank
Default Buying Cost Center,Standar Biaya Membeli Pusat
Default Buying Price List,Standar Membeli Daftar Harga
Default Cash Account,Standar Rekening Kas
Default Company,Standar Perusahaan
Default Currency,Currency Default
Default Customer Group,Bawaan Pelanggan Grup
Default Expense Account,Beban standar Akun
Default Income Account,Akun Pendapatan standar
Default Item Group,Default Item Grup
Default Price List,Standar List Harga
Default Purchase Account in which cost of the item will be debited.,Standar Pembelian Akun di mana biaya tersebut akan didebet.
Default Selling Cost Center,Default Jual Biaya Pusat
Default Settings,Pengaturan standar
Default Source Warehouse,Sumber standar Gudang
Default Stock UOM,Bawaan Stock UOM
Default Supplier,Standar Pemasok
Default Supplier Type,Standar Pemasok Type
Default Target Warehouse,Standar Sasaran Gudang
Default Territory,Wilayah standar
Default Unit of Measure,Standar Satuan Ukur
"Default Unit of Measure can not be changed directly because you have already made some transaction(s) with another UOM. To change default UOM, use 'UOM Replace Utility' tool under Stock module.","Standar Unit Ukur tidak dapat diubah secara langsung karena Anda telah membuat beberapa transaksi (s) dengan UOM lain. Untuk mengubah UOM default, gunakan 'UOM Ganti Utilitas' alat di bawah modul Stock."
Default Valuation Method,Metode standar Penilaian
Default Warehouse,Standar Gudang
Default Warehouse is mandatory for stock Item.,Standar Warehouse adalah wajib bagi saham Barang.
Default settings for accounting transactions.,Pengaturan default untuk transaksi akuntansi.
Default settings for buying transactions.,Pengaturan default untuk membeli transaksi.
Default settings for selling transactions.,Pengaturan default untuk menjual transaksi.
Default settings for stock transactions.,Pengaturan default untuk transaksi saham.
Defense,Pertahanan
"Define Budget for this Cost Center. To set budget action, see <a href=""#!List/Company"">Company Master</a>","Tentukan Anggaran Biaya Pusat ini. Untuk mengatur aksi anggaran, lihat <a href = ""#!Daftar / Perusahaan ""> Perusahaan Master </ a>"
Del,Del
Delete,Hapus
Delete {0} {1}?,Hapus {0} {1}?
Delivered,Disampaikan
Delivered Items To Be Billed,Produk Disampaikan Akan Ditagih
Delivered Qty,Disampaikan Qty
Delivered Serial No {0} cannot be deleted,Disampaikan Serial ada {0} tidak dapat dihapus
Delivery Date,Tanggal Pengiriman
Delivery Details,Detail Pengiriman
Delivery Document No,Pengiriman Dokumen Tidak
Delivery Document Type,Pengiriman Dokumen Type
Delivery Note,Pengiriman Note
Delivery Note Item,Pengiriman Barang Note
Delivery Note Items,Pengiriman Note Items
Delivery Note Message,Pengiriman Note Pesan
Delivery Note No,Pengiriman Note No
Delivery Note Required,Pengiriman Note Diperlukan
Delivery Note Trends,Tren pengiriman Note
Delivery Note {0} is not submitted,Pengiriman Note {0} tidak disampaikan
Delivery Note {0} must not be submitted,Pengiriman Note {0} tidak boleh disampaikan
Delivery Notes {0} must be cancelled before cancelling this Sales Order,Catatan pengiriman {0} harus dibatalkan sebelum membatalkan Sales Order ini
Delivery Status,Status Pengiriman
Delivery Time,Waktu Pengiriman
Delivery To,Pengiriman Untuk
Department,Departemen
Department Stores,Departmen Store
Depends on LWP,Tergantung pada LWP
Depreciation,Penyusutan
Description,Deskripsi
Description HTML,Deskripsi HTML
Designation,Penunjukan
Designer,Perancang
Detailed Breakup of the totals,Breakup rinci dari total
Details,Penjelasan
Difference (Dr - Cr),Perbedaan (Dr - Cr)
Difference Account,Perbedaan Akun
"Difference Account must be a 'Liability' type account, since this Stock Reconciliation is an Opening Entry","Perbedaan Akun harus rekening jenis 'Kewajiban', karena ini Stock Rekonsiliasi adalah sebuah entri Opening"
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.,UOM berbeda untuk item akan menyebabkan salah (Total) Nilai Berat Bersih. Pastikan Berat Bersih dari setiap item di UOM sama.
Direct Expenses,Beban Langsung
Direct Income,Penghasilan Langsung
Disable,Nonaktifkan
Disable Rounded Total,Nonaktifkan Rounded Jumlah
Disabled,Dinonaktifkan
Discount  %,Diskon%
Discount %,Diskon%
Discount (%),Diskon (%)
Discount Amount,Jumlah Diskon
"Discount Fields will be available in Purchase Order, Purchase Receipt, Purchase Invoice","Diskon Fields akan tersedia dalam Purchase Order, Penerimaan Pembelian, Purchase Invoice"
Discount Percentage,Persentase Diskon
Discount Percentage can be applied either against a Price List or for all Price List.,Persentase Diskon dapat diterapkan baik terhadap Daftar Harga atau untuk semua List Price.
Discount must be less than 100,Diskon harus kurang dari 100
Discount(%),Diskon (%)
Dispatch,Pengiriman
Display all the individual items delivered with the main items,Menampilkan semua item individual disampaikan dengan item utama
Distribute transport overhead across items.,Mendistribusikan overhead transportasi di seluruh item.
Distribution,Distribusi
Distribution Id,Id Distribusi
Distribution Name,Nama Distribusi
Distributor,Distributor
Divorced,Bercerai
Do Not Contact,Jangan Hubungi
Do not show any symbol like $ etc next to currencies.,Jangan menunjukkan simbol seperti $ etc sebelah mata uang.
Do really want to unstop production order: ,
Do you really want to STOP ,
Do you really want to STOP this Material Request?,Apakah Anda benar-benar ingin BERHENTI Permintaan Bahan ini?
Do you really want to Submit all Salary Slip for month {0} and year {1},Apakah Anda benar-benar ingin Menyerahkan semua Slip Gaji untuk bulan {0} dan tahun {1}
Do you really want to UNSTOP ,
Do you really want to UNSTOP this Material Request?,Apakah Anda benar-benar ingin unstop Permintaan Bahan ini?
Do you really want to stop production order: ,
Doc Name,Doc Nama
Doc Type,Doc Type
Document Description,Dokumen Deskripsi
Document Type,Jenis Dokumen
Documents,Docuements
Domain,Domain
Don't send Employee Birthday Reminders,Jangan mengirim Karyawan Ulang Tahun Pengingat
Download Materials Required,Unduh Bahan yang dibutuhkan
Download Reconcilation Data,Ambil rekonsiliasi data
Download Template,Download Template
Download a report containing all raw materials with their latest inventory status,Download laporan yang berisi semua bahan baku dengan status persediaan terbaru mereka
"Download the Template, fill appropriate data and attach the modified file.","Unduh Template, isi data yang tepat dan melampirkan file dimodifikasi."
"Download the Template, fill appropriate data and attach the modified file.All dates and employee combination in the selected period will come in the template, with existing attendance records","Unduh Template, isi data yang tepat dan melampirkan file dimodifikasi. Semua tanggal dan kombinasi karyawan dalam jangka waktu yang dipilih akan datang dalam template, dengan catatan kehadiran yang ada"
Draft,Konsep
Dropbox,Dropbox
Dropbox Access Allowed,Dropbox Access Diizinkan
Dropbox Access Key,Dropbox Access Key
Dropbox Access Secret,Dropbox Access Rahasia
Due Date,Tanggal Jatuh Tempo
Due Date cannot be after {0},Tanggal jatuh tempo tidak boleh setelah {0}
Due Date cannot be before Posting Date,Tanggal jatuh tempo tidak bisa sebelum Tanggal Posting
Duplicate Entry. Please check Authorization Rule {0},Gandakan entri. Silakan periksa Peraturan Otorisasi {0}
Duplicate Serial No entered for Item {0},Gandakan Serial ada dimasukkan untuk Item {0}
Duplicate entry,Gandakan entri
Duplicate row {0} with same {1},Baris duplikat {0} dengan sama {1}
Duties and Taxes,Tugas dan Pajak
ERPNext Setup,ERPNext Pengaturan
Earliest,Terlama
Earnest Money,Uang Earnest
Earning,Earning
Earning & Deduction,Earning & Pengurangan
Earning Type,Produktif Type
Earning1,Earning1
Edit,Ubah
Edu. Cess on Excise,Edu. Cess tentang Cukai
Edu. Cess on Service Tax,Edu. Cess Pajak Layanan
Edu. Cess on TDS,Edu. Cess pada TDS
Education,Pendidikan
Educational Qualification,Kualifikasi pendidikan
Educational Qualification Details,Kualifikasi Pendidikan Detail
Eg. smsgateway.com/api/send_sms.cgi,Misalnya. smsgateway.com / api / send_sms.cgi
Either debit or credit amount is required for {0},Entah debit atau jumlah kredit diperlukan untuk {0}
Either target qty or target amount is mandatory,Entah sasaran qty atau jumlah target adalah wajib
Either target qty or target amount is mandatory.,Entah Target qty atau jumlah target adalah wajib.
Electrical,Listrik
Electricity Cost,Biaya Listrik
Electricity cost per hour,Biaya listrik per jam
Electronics,Elektronik
Email,siska_chute34@yahoo.com
Email Digest,Email Digest
Email Digest Settings,Email Digest Pengaturan
Email Digest: ,
Email Id,Email Id
"Email Id where a job applicant will email e.g. ""jobs@example.com""","Email Id di mana pelamar pekerjaan akan mengirimkan email misalnya ""jobs@example.com"""
Email Notifications,Notifikasi Email
Email Sent?,Email Terkirim?
"Email id must be unique, already exists for {0}","Email id harus unik, sudah ada untuk {0}"
Email ids separated by commas.,Id email dipisahkan dengan koma.
"Email settings to extract Leads from sales email id e.g. ""sales@example.com""","Setelan email untuk mengekstrak Memimpin dari id email penjualan misalnya ""sales@example.com"""
Emergency Contact,Darurat Kontak
Emergency Contact Details,Detail Darurat Kontak
Emergency Phone,Darurat Telepon
Employee,Karyawan
Employee Birthday,Ulang Tahun Karyawan
Employee Details,Detail Karyawan
Employee Education,Pendidikan Karyawan
Employee External Work History,Karyawan Eksternal Riwayat Pekerjaan
Employee Information,Informasi Karyawan
Employee Internal Work History,Karyawan Kerja internal Sejarah
Employee Internal Work Historys,Karyawan internal Kerja historys
Employee Leave Approver,Karyawan Tinggalkan Approver
Employee Leave Balance,Cuti Karyawan Balance
Employee Name,Nama Karyawan
Employee Number,Jumlah Karyawan
Employee Records to be created by,Rekaman Karyawan yang akan dibuat oleh
Employee Settings,Pengaturan Karyawan
Employee Type,Tipe Karyawan
"Employee designation (e.g. CEO, Director etc.).","Penunjukan Karyawan (misalnya CEO, Direktur dll)."
Employee master.,Master Karyawan.
Employee record is created using selected field. ,
Employee records.,Catatan karyawan.
Employee relieved on {0} must be set as 'Left',Karyawan lega pada {0} harus ditetapkan sebagai 'Kiri'
Employee {0} has already applied for {1} between {2} and {3},Karyawan {0} telah diterapkan untuk {1} antara {2} dan {3}
Employee {0} is not active or does not exist,Karyawan {0} tidak aktif atau tidak ada
Employee {0} was on leave on {1}. Cannot mark attendance.,Karyawan {0} sedang cuti pada {1}. Tidak bisa menandai kehadiran.
Employees Email Id,Karyawan Email Id
Employment Details,Rincian Pekerjaan
Employment Type,Jenis Pekerjaan
Enable / disable currencies.,Mengaktifkan / menonaktifkan mata uang.
Enabled,Diaktifkan
Encashment Date,Pencairan Tanggal
End Date,Tanggal Berakhir
End Date can not be less than Start Date,Tanggal akhir tidak boleh kurang dari Tanggal Mulai
End date of current invoice's period,Tanggal akhir periode faktur saat ini
End of Life,Akhir Kehidupan
Energy,Energi
Engineer,Insinyur
Enter Verification Code,Masukkan Kode Verifikasi
Enter campaign name if the source of lead is campaign.,Masukkan nama kampanye jika sumber timbal adalah kampanye.
Enter department to which this Contact belongs,Memasukkan departemen yang Kontak ini milik
Enter designation of this Contact,Masukkan penunjukan Kontak ini
"Enter email id separated by commas, invoice will be mailed automatically on particular date","Masukkan id email dipisahkan dengan koma, invoice akan dikirimkan secara otomatis pada tanggal tertentu"
Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,Masukkan item dan qty direncanakan untuk yang Anda ingin meningkatkan pesanan produksi atau download bahan baku untuk analisis.
Enter name of campaign if source of enquiry is campaign,Masukkan nama kampanye jika sumber penyelidikan adalah kampanye
"Enter static url parameters here (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)","Masukkan parameter url statis di sini (Misalnya pengirim = ERPNext, username = ERPNext, password = 1234 dll)"
Enter the company name under which Account Head will be created for this Supplier,Masukkan nama perusahaan di mana Akun Kepala akan dibuat untuk Pemasok ini
Enter url parameter for message,Masukkan parameter url untuk pesan
Enter url parameter for receiver nos,Masukkan parameter url untuk penerima nos
Entertainment & Leisure,Hiburan & Kenyamanan
Entertainment Expenses,Beban Hiburan
Entries,Entri
Entries against ,
Entries are not allowed against this Fiscal Year if the year is closed.,Entri tidak diperbolehkan melawan Tahun Anggaran ini jika tahun ditutup.
Equity,Modal
Error: {0} > {1},Kesalahan: {0}> {1}
Estimated Material Cost,Perkiraan Biaya Material
"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Bahkan jika ada beberapa Aturan Harga dengan prioritas tertinggi, kemudian mengikuti prioritas internal diterapkan:"
Everyone can read,Setiap orang dapat membaca
"Example: ABCD.#####If 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.",". Contoh: ABCD # # # # #  Jika seri diatur Serial dan ada tidak disebutkan dalam transaksi, nomor seri maka otomatis akan dibuat berdasarkan seri ini. Jika Anda selalu ingin secara eksplisit menyebutkan Serial Nos untuk item ini. biarkan kosong ini."
Exchange Rate,Nilai Tukar
Excise Duty 10,Cukai Tugas 10
Excise Duty 14,Cukai Tugas 14
Excise Duty 4,Cukai Duty 4
Excise Duty 8,Cukai Duty 8
Excise Duty @ 10,Cukai Duty @ 10
Excise Duty @ 14,Cukai Duty @ 14
Excise Duty @ 4,Cukai Duty @ 4
Excise Duty @ 8,Cukai Duty @ 8
Excise Duty Edu Cess 2,Cukai Edu Cess 2
Excise Duty SHE Cess 1,Cukai SHE Cess 1
Excise Page Number,Jumlah Cukai Halaman
Excise Voucher,Voucher Cukai
Execution,Eksekusi
Executive Search,Pencarian eksekutif
Exemption Limit,Batas Pembebasan
Exhibition,Pameran
Existing Customer,Pelanggan yang sudah ada
Exit,Keluar
Exit Interview Details,Detail Exit Interview
Expected,Diharapkan
Expected Completion Date can not be less than Project Start Date,Diharapkan Tanggal Penyelesaian tidak bisa kurang dari Tanggal mulai Proyek
Expected Date cannot be before Material Request Date,Diharapkan Tanggal tidak bisa sebelum Material Request Tanggal
Expected Delivery Date,Diharapkan Pengiriman Tanggal
Expected Delivery Date cannot be before Purchase Order Date,Diharapkan Pengiriman Tanggal tidak bisa sebelum Purchase Order Tanggal
Expected Delivery Date cannot be before Sales Order Date,Diharapkan Pengiriman Tanggal tidak bisa sebelum Sales Order Tanggal
Expected End Date,Diharapkan Tanggal Akhir
Expected Start Date,Diharapkan Tanggal Mulai
Expense,Biaya
Expense / Difference account ({0}) must be a 'Profit or Loss' account,Beban akun / Difference ({0}) harus akun 'Laba atau Rugi'
Expense Account,Beban Akun
Expense Account is mandatory,Beban Rekening wajib
Expense Claim,Beban Klaim
Expense Claim Approved,Beban Klaim Disetujui
Expense Claim Approved Message,Beban Klaim Disetujui Pesan
Expense Claim Detail,Beban Klaim Detil
Expense Claim Details,Rincian Beban Klaim
Expense Claim Rejected,Beban Klaim Ditolak
Expense Claim Rejected Message,Beban Klaim Ditolak Pesan
Expense Claim Type,Beban Klaim Type
Expense Claim has been approved.,Beban Klaim telah disetujui.
Expense Claim has been rejected.,Beban Klaim telah ditolak.
Expense Claim is pending approval. Only the Expense Approver can update status.,Beban Klaim sedang menunggu persetujuan. Hanya Approver Beban dapat memperbarui status.
Expense Date,Beban Tanggal
Expense Details,Rincian Biaya
Expense Head,Beban Kepala
Expense account is mandatory for item {0},Rekening pengeluaran adalah wajib untuk item {0}
Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Beban atau Selisih akun adalah wajib untuk Item {0} karena dampak keseluruhan nilai saham
Expenses,Beban
Expenses Booked,Beban Dipesan
Expenses Included In Valuation,Biaya Termasuk Dalam Penilaian
Expenses booked for the digest period,Biaya dipesan untuk periode digest
Expiry Date,Tanggal Berakhir
Exports,Ekspor
External,Eksternal
Extract Emails,Ekstrak Email
FCFS Rate,FCFS Tingkat
Failed: ,
Family Background,Latar Belakang Keluarga
Fax,Fax
Features Setup,Fitur Pengaturan
Feed,Makan varg
Feed Type,Pakan Type
Feedback,Umpan balik
Female,Perempuan
Fetch exploded BOM (including sub-assemblies),Fetch meledak BOM (termasuk sub-rakitan)
"Field available in Delivery Note, Quotation, Sales Invoice, Sales Order","Bidang yang tersedia di Delivery Note, Quotation, Faktur Penjualan, Sales Order"
Files Folder ID,File Folder ID
Fill the form and save it,Isi formulir dan menyimpannya
Filter based on customer,Filter berdasarkan pelanggan
Filter based on item,Filter berdasarkan pada item
Financial / accounting year.,Keuangan / akuntansi tahun.
Financial Analytics,Analytics keuangan
Financial Services,Jasa Keuangan
Financial Year End Date,Tahun Keuangan Akhir Tanggal
Financial Year Start Date,Tahun Buku Tanggal mulai
Finished Goods,Barang Jadi
First Name,Nama Depan
First Responded On,Pertama Menanggapi On
Fiscal Year,Tahun Fiskal
Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Tahun Anggaran Tanggal Mulai dan Akhir Tahun Fiskal Tanggal sudah ditetapkan pada Tahun Anggaran {0}
Fiscal Year Start Date and Fiscal Year End Date cannot be more than a year apart.,Tahun Fiskal Tanggal Mulai dan Akhir Tahun Fiskal Tanggal tidak bisa lebih dari satu tahun terpisah.
Fiscal Year Start Date should not be greater than Fiscal Year End Date,Tahun Anggaran Tanggal Mulai tidak boleh lebih besar dari Fiscal Year End Tanggal
Fixed Asset,Fixed Asset
Fixed Assets,Aktiva Tetap
Follow via Email,Ikuti via Email
"Following table will show values if items are sub - contracted. These values will be fetched from the master of ""Bill of Materials"" of sub - contracted items.","Tabel berikut akan menunjukkan nilai jika item sub - kontrak. Nilai-nilai ini akan diambil dari master ""Bill of Materials"" dari sub - kontrak item."
Food,Makanan
"Food, Beverage & Tobacco","Makanan, Minuman dan Tembakau"
"For 'Sales BOM' 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 'Sales BOM' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Untuk 'Penjualan BOM' item, Gudang, Serial No dan Batch ada akan dipertimbangkan dari meja 'Daftar Packing'. Jika Gudang dan Batch ada yang sama untuk semua item kemasan untuk setiap 'Penjualan BOM' item, nilai-nilai dapat dimasukkan dalam tabel Barang utama, nilai akan disalin ke meja 'Daftar Packing'."
For Company,Untuk Perusahaan
For Employee,Untuk Karyawan
For Employee Name,Untuk Nama Karyawan
For Price List,Untuk Daftar Harga
For Production,Untuk Produksi
For Reference Only.,Untuk Referensi Only.
For Sales Invoice,Untuk Sales Invoice
For Server Side Print Formats,Untuk Server Side Format Cetak
For Supplier,Untuk Pemasok
For Warehouse,Untuk Gudang
For Warehouse is required before Submit,Untuk Gudang diperlukan sebelum Submit
"For e.g. 2012, 2012-13","Untuk misalnya 2012, 2012-13"
For reference,Untuk referensi
For reference only.,Untuk referensi saja.
"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Untuk kenyamanan pelanggan, kode ini dapat digunakan dalam format cetak seperti Faktur dan Pengiriman Catatan"
Fraction,Pecahan
Fraction Units,Unit Fraksi
Freeze Stock Entries,Freeze Entries Stock
Freeze Stocks Older Than [Days],Bekukan Saham Lama Dari [Hari]
Freight and Forwarding Charges,Pengangkutan dan Forwarding Biaya
Friday,Jum'at
From,Dari
From Bill of Materials,Dari Bill of Material
From Company,Dari Perusahaan
From Currency,Dari Mata
From Currency and To Currency cannot be same,Dari Mata dan Mata Uang Untuk tidak bisa sama
From Customer,Dari Pelanggan
From Customer Issue,Dari Pelanggan Issue
From Date,Dari Tanggal
From Date cannot be greater than To Date,Dari Tanggal tidak dapat lebih besar dari To Date
From Date must be before To Date,Dari Tanggal harus sebelum To Date
From Date should be within the Fiscal Year. Assuming From Date = {0},Dari tanggal harus dalam Tahun Anggaran. Dengan asumsi Dari Tanggal = {0}
From Delivery Note,Dari Delivery Note
From Employee,Dari Karyawan
From Lead,Dari Timbal
From Maintenance Schedule,Dari Pemeliharaan Jadwal
From Material Request,Dari Material Permintaan
From Opportunity,Dari Peluang
From Package No.,Dari Package No
From Purchase Order,Dari Purchase Order
From Purchase Receipt,Dari Penerimaan Pembelian
From Quotation,Dari Quotation
From Sales Order,Dari Sales Order
From Supplier Quotation,Dari Pemasok Quotation
From Time,Dari Waktu
From Value,Dari Nilai
From and To dates required,Dari dan Untuk tanggal yang Anda inginkan
From value must be less than to value in row {0},Dari nilai harus kurang dari nilai dalam baris {0}
Frozen,Beku
Frozen Accounts Modifier,Frozen Account Modifier
Fulfilled,Terpenuhi
Full Name,Nama Lengkap
Full-time,Full-time
Fully Billed,Sepenuhnya Ditagih
Fully Completed,Sepenuhnya Selesai
Fully Delivered,Sepenuhnya Disampaikan
Furniture and Fixture,Furniture dan Fixture
Further accounts can be made under Groups but entries can be made against Ledger,Rekening lebih lanjut dapat dibuat di bawah Grup tetapi entri dapat dilakukan terhadap Ledger
"Further accounts can be made under Groups, but entries can be made against Ledger","Rekening lebih lanjut dapat dibuat di bawah Grup, namun entri dapat dilakukan terhadap Ledger"
Further nodes can be only created under 'Group' type nodes,Node lebih lanjut dapat hanya dibuat di bawah tipe node 'Grup'
GL Entry,GL Entri
Gantt Chart,Gantt Bagan
Gantt chart of all tasks.,Gantt chart dari semua tugas.
Gender,Jenis Kelamin
General,Umum
General Ledger,General Ledger
Generate Description HTML,Hasilkan Deskripsi HTML
Generate Material Requests (MRP) and Production Orders.,Menghasilkan Permintaan Material (MRP) dan Pesanan Produksi.
Generate Salary Slips,Menghasilkan Gaji Slips
Generate Schedule,Menghasilkan Jadwal
Generates HTML to include selected image in the description,Menghasilkan HTML untuk memasukkan gambar yang dipilih dalam deskripsi
Get Advances Paid,Dapatkan Uang Muka Dibayar
Get Advances Received,Dapatkan Uang Muka Diterima
Get Current Stock,Dapatkan Stok saat ini
Get Items,Dapatkan Produk
Get Items From Sales Orders,Dapatkan Item Dari Penjualan Pesanan
Get Items from BOM,Dapatkan item dari BOM
Get Last Purchase Rate,Dapatkan Terakhir Purchase Rate
Get Outstanding Invoices,Dapatkan Posisi Faktur
Get Relevant Entries,Dapatkan Entries Relevan
Get Sales Orders,Dapatkan Pesanan Penjualan
Get Specification Details,Dapatkan Spesifikasi Detail
Get Stock and Rate,Dapatkan Saham dan Tingkat
Get Template,Dapatkan Template
Get Terms and Conditions,Dapatkan Syarat dan Ketentuan
Get Unreconciled Entries,Dapatkan Entries Unreconciled
Get Weekly Off Dates,Dapatkan Weekly Off Tanggal
"Get valuation rate and available stock at source/target warehouse on mentioned posting date-time. If serialized item, please press this button after entering serial nos.","Dapatkan tingkat penilaian dan stok yang tersedia di sumber / target gudang di postingan disebutkan tanggal-waktu. Jika serial barang, silahkan tekan tombol ini setelah memasuki nos serial."
Global Defaults,Default global
Global POS Setting {0} already created for company {1},Pengaturan POS global {0} sudah dibuat untuk perusahaan {1}
Global Settings,Pengaturan global
"Go to the appropriate group (usually Application of Funds > Current Assets > Bank Accounts and create a new Account Ledger (by clicking on Add Child) of type ""Bank""","Pergi ke grup yang sesuai (biasanya Penerapan Dana> Aset Lancar> Rekening Bank dan membuat Akun baru Ledger (dengan mengklik Tambahkan Child) tipe ""Bank"""
"Go to the appropriate group (usually Source of Funds > Current Liabilities > Taxes and Duties and create a new Account Ledger (by clicking on Add Child) of type ""Tax"" and do mention the Tax rate.","Pergi ke grup yang sesuai (biasanya Sumber Dana> Kewajiban Lancar> Pajak dan Bea dan membuat Akun baru Ledger (dengan mengklik Tambahkan Child) tipe ""Pajak"" dan jangan menyebutkan tingkat pajak."
Goal,Sasaran
Goals,tujuan
Goods received from Suppliers.,Barang yang diterima dari pemasok.
Google Drive,Google Drive
Google Drive Access Allowed,Google Drive Access Diizinkan
Government,pemerintahan
Graduate,Lulusan
Grand Total,Grand Total
Grand Total (Company Currency),Grand Total (Perusahaan Mata Uang)
"Grid ""","Grid """
Grocery,Toko bahan makanan
Gross Margin %,Gross Margin%
Gross Margin Value,Margin Nilai Gross
Gross Pay,Gross Bayar
Gross Pay + Arrear Amount +Encashment Amount - Total Deduction,Gross Pay + + Pencairan tunggakan Jumlah Jumlah - Total Pengurangan
Gross Profit,Laba Kotor
Gross Profit (%),Laba Kotor (%)
Gross Weight,Berat Kotor
Gross Weight UOM,Berat Kotor UOM
Group,Grup
Group by Account,Group by Akun
Group by Voucher,Group by Voucher
Group or Ledger,Grup atau Ledger
Groups,Grup
HR Manager,HR Manager
HR Settings,Pengaturan HR
HTML / Banner that will show on the top of product list.,HTML / Banner yang akan muncul di bagian atas daftar produk.
Half Day,Half Day
Half Yearly,Setengah Tahunan
Half-yearly,Setengah tahun sekali
Happy Birthday!,Happy Birthday!
Hardware,Perangkat keras
Has Batch No,Memiliki Batch ada
Has Child Node,Memiliki Anak Node
Has Serial No,Memiliki Serial No
Head of Marketing and Sales,Kepala Pemasaran dan Penjualan
Header,Header
Health Care,Perawatan Kesehatan
Health Concerns,Kekhawatiran Kesehatan
Health Details,Detail Kesehatan
Held On,Diadakan Pada
Help HTML,Bantuan HTML
"Help: To link to another record in the system, use ""#Form/Note/[Note Name]"" as the Link URL. (don't use ""http://"")","Bantuan: Untuk link ke catatan lain dalam sistem, gunakan ""# Form / Note / [Catatan Nama]"" sebagai link URL. (Tidak menggunakan ""http://"")"
"Here you can maintain family details like name and occupation of parent, spouse and children","Di sini Anda dapat mempertahankan rincian keluarga seperti nama dan pekerjaan orang tua, pasangan dan anak-anak"
"Here you can maintain height, weight, allergies, medical concerns etc","Di sini Anda dapat mempertahankan tinggi, berat, alergi, masalah medis dll"
Hide Currency Symbol,Sembunyikan Currency Symbol
High,Tinggi
History In Company,Sejarah Dalam Perusahaan
Hold,Memegang
Holiday,Liburan
Holiday List,Liburan List
Holiday List Name,Nama Libur
Holiday master.,Master Holiday.
Holidays,Liburan
Home,Halaman Utama
Host,Inang
"Host, Email and Password required if emails are to be pulled","Tuan, Email dan Password diperlukan jika email yang ditarik"
Hour,Jam
Hour Rate,Tingkat Jam
Hour Rate Labour,Jam Tingkat Buruh
Hours,Jam
How Pricing Rule is applied?,Bagaimana Rule Harga diterapkan?
How frequently?,Seberapa sering?
"How should this currency be formatted? If not set, will use system defaults","Bagaimana seharusnya mata uang ini akan diformat? Jika tidak diatur, akan menggunakan default sistem"
Human Resources,Sumber Daya Manusia
Identification of the package for the delivery (for print),Identifikasi paket untuk pengiriman (untuk mencetak)
If Income or Expense,Jika Penghasilan atau Beban
If Monthly Budget Exceeded,Jika Anggaran Bulanan Melebihi
"If Sale BOM is defined, the actual BOM of the Pack is displayed as table. Available in Delivery Note and Sales Order","Jika Sale BOM didefinisikan, BOM sebenarnya Pack ditampilkan sebagai tabel. Tersedia dalam Pengiriman Note dan Sales Order"
"If Supplier Part Number exists for given Item, it gets stored here","Jika Pemasok Part Number ada untuk keterberian Barang, hal itu akan disimpan di sini"
If Yearly Budget Exceeded,Jika Anggaran Tahunan Melebihi
"If checked, BOM for sub-assembly items will be considered for getting raw materials. Otherwise, all sub-assembly items will be treated as a raw material.","Jika dicentang, BOM untuk item sub-assembly akan dipertimbangkan untuk mendapatkan bahan baku. Jika tidak, semua item sub-assembly akan diperlakukan sebagai bahan baku."
"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Jika dicentang, total ada. dari Hari Kerja akan mencakup libur, dan ini akan mengurangi nilai Gaji Per Hari"
"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Jika dicentang, jumlah pajak akan dianggap sebagai sudah termasuk dalam Jumlah Tingkat Cetak / Print"
If different than customer address,Jika berbeda dari alamat pelanggan
"If disable, 'Rounded Total' field will not be visible in any transaction","Jika disable, lapangan 'Rounded Jumlah' tidak akan terlihat dalam setiap transaksi"
"If enabled, the system will post accounting entries for inventory automatically.","Jika diaktifkan, sistem akan posting entri akuntansi untuk persediaan otomatis."
If more than one package of the same type (for print),Jika lebih dari satu paket dari jenis yang sama (untuk mencetak)
"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Jika beberapa Aturan Harga terus menang, pengguna akan diminta untuk mengatur Prioritas manual untuk menyelesaikan konflik."
"If no change in either Quantity or Valuation Rate, leave the cell blank.","Jika tidak ada perubahan baik Quantity atau Tingkat Penilaian, biarkan kosong sel."
If not applicable please enter: NA,Jika tidak berlaku silahkan masukkan: NA
"If not checked, the list will have to be added to each Department where it has to be applied.","Jika tidak diperiksa, daftar harus ditambahkan ke setiap departemen di mana itu harus diterapkan."
"If selected Pricing Rule is made for 'Price', it will overwrite Price List. Pricing Rule price is the final price, 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.","Jika Rule Harga yang dipilih dibuat untuk 'Harga', itu akan menimpa Daftar Harga. Harga Rule harga adalah harga akhir, sehingga tidak ada diskon lebih lanjut harus diterapkan. Oleh karena itu, dalam transaksi seperti Sales Order, Purchase Order dll, itu akan diambil di lapangan 'Tingkat', daripada bidang 'Daftar Harga Tingkat'."
"If specified, send the newsletter using this email address","Jika ditentukan, mengirim newsletter menggunakan alamat email ini"
"If the account is frozen, entries are allowed to restricted users.","Jika account beku, entri yang diizinkan untuk pengguna terbatas."
"If this Account represents a Customer, Supplier or Employee, set it here.","Jika Akun ini merupakan Pelanggan, Pemasok atau Karyawan, mengaturnya di sini."
"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.","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 didahulukan jika ada beberapa Aturan Harga dengan kondisi yang sama."
If you follow Quality Inspection. Enables Item QA Required and QA No in Purchase Receipt,Jika Anda mengikuti Inspeksi Kualitas. Memungkinkan Barang QA Diperlukan dan QA ada di Penerimaan Pembelian
If you have Sales Team and Sale Partners (Channel Partners)  they can be tagged and maintain their contribution in the sales activity,Jika Anda memiliki Tim Penjualan dan Penjualan Mitra (Mitra Channel) mereka dapat ditandai dan mempertahankan kontribusi mereka dalam aktivitas penjualan
"If you have created a standard template in Purchase Taxes and Charges Master, select one and click on the button below.","Jika Anda telah membuat template standar dalam Pajak Pembelian dan Guru Beban, pilih salah satu dan klik tombol di bawah."
"If you have created a standard template in Sales Taxes and Charges Master, select one and click on the button below.","Jika Anda telah membuat template standar dalam Penjualan Pajak dan Biaya Guru, pilih salah satu dan klik tombol di bawah."
"If you have long print formats, this feature can be used to split the page to be printed on multiple pages with all headers and footers on each page","Jika Anda memiliki format cetak yang panjang, fitur ini dapat digunakan untuk membagi halaman yang akan dicetak pada beberapa halaman dengan semua header dan footer pada setiap halaman"
If you involve in manufacturing activity. Enables Item 'Is Manufactured',Jika Anda terlibat dalam aktivitas manufaktur. Memungkinkan Barang 'Apakah Diproduksi'
Ignore,Mengabaikan
Ignore Pricing Rule,Abaikan Aturan Harga
Ignored: ,
Image,Gambar
Image View,Citra Tampilan
Implementation Partner,Implementasi Mitra
Import Attendance,Impor Kehadiran
Import Failed!,Impor Gagal!
Import Log,Impor Log
Import Successful!,Impor Sukses!
Imports,Impor
In Hours,Pada Jam
In Process,Dalam Proses
In Qty,Dalam Qty
In Value,Dalam Nilai
In Words,Dalam Kata
In Words (Company Currency),Dalam Kata-kata (Perusahaan Mata Uang)
In Words (Export) will be visible once you save the Delivery Note.,Dalam Kata-kata (Ekspor) akan terlihat sekali Anda menyimpan Delivery Note.
In Words will be visible once you save the Delivery Note.,Dalam Kata-kata akan terlihat sekali Anda menyimpan Delivery Note.
In Words will be visible once you save the Purchase Invoice.,Dalam Kata-kata akan terlihat setelah Anda menyimpan Faktur Pembelian.
In Words will be visible once you save the Purchase Order.,Dalam Kata-kata akan terlihat setelah Anda menyimpan Purchase Order.
In Words will be visible once you save the Purchase Receipt.,Dalam Kata-kata akan terlihat setelah Anda menyimpan Penerimaan Pembelian.
In Words will be visible once you save the Quotation.,Dalam Kata-kata akan terlihat sekali Anda menyimpan Quotation tersebut.
In Words will be visible once you save the Sales Invoice.,Dalam Kata-kata akan terlihat setelah Anda menyimpan Faktur Penjualan.
In Words will be visible once you save the Sales Order.,Dalam Kata-kata akan terlihat setelah Anda menyimpan Sales Order.
Incentives,Insentif
Include Reconciled Entries,Sertakan Entri Berdamai
Include holidays in Total no. of Working Days,Sertakan liburan di total no. dari Hari Kerja
Income,Penghasilan
Income / Expense,Penghasilan / Beban
Income Account,Akun Penghasilan
Income Booked,Penghasilan Memesan
Income Tax,Pajak Penghasilan
Income Year to Date,Tahun Penghasilan Tanggal
Income booked for the digest period,Penghasilan dipesan untuk periode digest
Incoming,Incoming
Incoming Rate,Tingkat yang masuk
Incoming quality inspection.,Pemeriksaan mutu yang masuk.
Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Jumlah yang salah dari General Ledger Entries ditemukan. Anda mungkin telah memilih Account salah dalam transaksi.
Incorrect or Inactive BOM {0} for Item {1} at row {2},Salah atau Nonaktif BOM {0} untuk Item {1} pada baris {2}
Indicates that the package is a part of this delivery (Only Draft),Menunjukkan bahwa paket tersebut merupakan bagian dari pengiriman ini (Hanya Draft)
Indirect Expenses,Biaya tidak langsung
Indirect Income,Penghasilan tidak langsung
Individual,Individu
Industry,Industri
Industry Type,Jenis Industri
Inspected By,Diperiksa Oleh
Inspection Criteria,Kriteria Pemeriksaan
Inspection Required,Inspeksi Diperlukan
Inspection Type,Inspeksi Type
Installation Date,Instalasi Tanggal
Installation Note,Instalasi Note
Installation Note Item,Instalasi Catatan Barang
Installation Note {0} has already been submitted,Instalasi Catatan {0} telah disampaikan
Installation Status,Status Instalasi
Installation Time,Instalasi Waktu
Installation date cannot be before delivery date for Item {0},Tanggal instalasi tidak bisa sebelum tanggal pengiriman untuk Item {0}
Installation record for a Serial No.,Catatan instalasi untuk No Serial
Installed Qty,Terpasang Qty
Instructions,Instruksi
Integrate incoming support emails to Support Ticket,Mengintegrasikan email support masuk untuk Mendukung Tiket
Interested,Tertarik
Intern,Menginternir
Internal,Internal
Internet Publishing,Penerbitan Internet
Introduction,Pendahuluan
Invalid Barcode,Barcode valid
Invalid Barcode or Serial No,Barcode valid atau Serial No
Invalid Mail Server. Please rectify and try again.,Mail Server tidak valid. Harap memperbaiki dan coba lagi.
Invalid Master Name,Nama Guru tidak valid
Invalid User Name or Support Password. Please rectify and try again.,Valid Nama Pengguna atau Dukungan Password. Harap memperbaiki dan coba lagi.
Invalid quantity specified for item {0}. Quantity should be greater than 0.,Kuantitas tidak valid untuk item {0}. Jumlah harus lebih besar dari 0.
Inventory,Inventarisasi
Inventory & Support,Inventarisasi & Dukungan
Investment Banking,Perbankan Investasi
Investments,Investasi
Invoice Date,Faktur Tanggal
Invoice Details,Detail Invoice
Invoice No,Faktur ada
Invoice Number,Nomor Faktur
Invoice Period From,Faktur Periode Dari
Invoice Period From and Invoice Period To dates mandatory for recurring invoice,Faktur Periode Dari dan Faktur Period Untuk tanggal wajib untuk berulang faktur
Invoice Period To,Periode Faktur Untuk
Invoice Type,Invoice Type
Invoice/Journal Voucher Details,Invoice / Journal Voucher Detail
Invoiced Amount (Exculsive Tax),Faktur Jumlah (Pajak exculsive)
Is Active,Aktif
Is Advance,Apakah Muka
Is Cancelled,Apakah Dibatalkan
Is Carry Forward,Apakah Carry Teruskan
Is Default,Apakah default
Is Encash,Apakah menjual
Is Fixed Asset Item,Apakah Fixed Asset Barang
Is LWP,Apakah LWP
Is Opening,Apakah Membuka
Is Opening Entry,Apakah Masuk Membuka
Is POS,Apakah POS
Is Primary Contact,Apakah Kontak Utama
Is Purchase Item,Apakah Pembelian Barang
Is Sales Item,Apakah Penjualan Barang
Is Service Item,Apakah Layanan Barang
Is Stock Item,Apakah Stock Barang
Is Sub Contracted Item,Apakah Sub Kontrak Barang
Is Subcontracted,Apakah subkontrak
Is this Tax included in Basic Rate?,Apakah Pajak ini termasuk dalam Basic Rate?
Issue,Isu
Issue Date,Tanggal dibuat
Issue Details,Detail Issue
Issued Items Against Production Order,Tahun Produk Terhadap Orde Produksi
It can also be used to create opening stock entries and to fix stock value.,Hal ini juga dapat digunakan untuk membuat entri saham membuka dan memperbaiki nilai saham.
Item,Barang
Item Advanced,Item Lanjutan
Item Barcode,Item Barcode
Item Batch Nos,Item Batch Nos
Item Code,Item Code
Item Code > Item Group > Brand,Item Code> Barang Grup> Merek
Item Code and Warehouse should already exist.,Item Code dan Gudang harus sudah ada.
Item Code cannot be changed for Serial No.,Item Code tidak dapat diubah untuk Serial Number
Item Code is mandatory because Item is not automatically numbered,Item Code adalah wajib karena Item tidak secara otomatis nomor
Item Code required at Row No {0},Item Code dibutuhkan pada Row ada {0}
Item Customer Detail,Barang Pelanggan Detil
Item Description,Item Description
Item Desription,Item Desription
Item Details,Item detail
Item Group,Item Grup
Item Group Name,Nama Item Grup
Item Group Tree,Item Grup Pohon
Item Group not mentioned in item master for item {0},Item Grup tidak disebutkan dalam master barang untuk item {0}
Item Groups in Details,Item Grup dalam Rincian
Item Image (if not slideshow),Barang Gambar (jika tidak slideshow)
Item Name,Nama Item
Item Naming By,Item Penamaan Dengan
Item Price,Item Price
Item Prices,Harga Barang
Item Quality Inspection Parameter,Barang Kualitas Parameter Inspeksi
Item Reorder,Item Reorder
Item Serial No,Item Serial No
Item Serial Nos,Item Serial Nos
Item Shortage Report,Item Kekurangan Laporan
Item Supplier,Item Pemasok
Item Supplier Details,Item Pemasok Rincian
Item Tax,Pajak Barang
Item Tax Amount,Jumlah Pajak Barang
Item Tax Rate,Tarif Pajak Barang
Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Item Pajak Row {0} harus memiliki akun Pajak jenis atau Penghasilan atau Beban atau Dibebankan
Item Tax1,Item Tax1
Item To Manufacture,Barang Untuk Industri
Item UOM,Barang UOM
Item Website Specification,Item Situs Spesifikasi
Item Website Specifications,Item Situs Spesifikasi
Item Wise Tax Detail,Barang Wise Detil Pajak
Item Wise Tax Detail ,
Item is required,Item diperlukan
Item is updated,Item diperbarui
Item master.,Master barang.
"Item must be a purchase item, as it is present in one or many Active BOMs","Item harus item pembelian, karena hadir dalam satu atau banyak BOMs Aktif"
Item or Warehouse for row {0} does not match Material Request,Item atau Gudang untuk baris {0} Material tidak cocok Permintaan
Item table can not be blank,Tabel barang tidak boleh kosong
Item to be manufactured or repacked,Item yang akan diproduksi atau dikemas ulang
Item valuation updated,Item penilaian diperbarui
Item will be saved by this name in the data base.,Barang akan disimpan dengan nama ini dalam data base.
Item {0} appears multiple times in Price List {1},Item {0} muncul beberapa kali dalam Daftar Harga {1}
Item {0} does not exist,Item {0} tidak ada
Item {0} does not exist in the system or has expired,Item {0} tidak ada dalam sistem atau telah berakhir
Item {0} does not exist in {1} {2},Item {0} tidak ada di {1} {2}
Item {0} has already been returned,Item {0} telah dikembalikan
Item {0} has been entered multiple times against same operation,Barang {0} telah dimasukkan beberapa kali melawan operasi yang sama
Item {0} has been entered multiple times with same description or date,Item {0} sudah dimasukkan beberapa kali dengan deskripsi atau tanggal yang sama
Item {0} has been entered multiple times with same description or date or warehouse,Item {0} sudah dimasukkan beberapa kali dengan deskripsi atau tanggal atau gudang yang sama
Item {0} has been entered twice,Item {0} telah dimasukkan dua kali
Item {0} has reached its end of life on {1},Item {0} telah mencapai akhir hidupnya pada {1}
Item {0} ignored since it is not a stock item,Item {0} diabaikan karena bukan barang stok
Item {0} is cancelled,Item {0} dibatalkan
Item {0} is not Purchase Item,Item {0} tidak Pembelian Barang
Item {0} is not a serialized Item,Item {0} bukan merupakan Barang serial
Item {0} is not a stock Item,Item {0} bukan merupakan saham Barang
Item {0} is not active or end of life has been reached,Item {0} tidak aktif atau akhir hidup telah tercapai
Item {0} is not setup for Serial Nos. Check Item master,Barang {0} tidak setup untuk Serial Nos Periksa Barang induk
Item {0} is not setup for Serial Nos. Column must be blank,Barang {0} tidak setup untuk Serial Nos Kolom harus kosong
Item {0} must be Sales Item,Item {0} harus Penjualan Barang
Item {0} must be Sales or Service Item in {1},Item {0} harus Penjualan atau Jasa Barang di {1}
Item {0} must be Service Item,Item {0} harus Layanan Barang
Item {0} must be a Purchase Item,Item {0} harus Pembelian Barang
Item {0} must be a Sales Item,Item {0} harus Item Penjualan
Item {0} must be a Service Item.,Item {0} harus Layanan Barang.
Item {0} must be a Sub-contracted Item,Item {0} harus Item Sub-kontrak
Item {0} must be a stock Item,Item {0} harus stok Barang
Item {0} must be manufactured or sub-contracted,Item {0} harus diproduksi atau sub-kontrak
Item {0} not found,Item {0} tidak ditemukan
Item {0} with Serial No {1} is already installed,Item {0} dengan Serial No {1} sudah diinstal
Item {0} with same description entered twice,Item {0} dengan deskripsi yang sama dimasukkan dua kali
"Item, Warranty, AMC (Annual Maintenance Contract) details will be automatically fetched when Serial Number is selected.","Barang, Garansi, AMC (Tahunan Kontrak Pemeliharaan) detail akan otomatis diambil ketika Serial Number dipilih."
Item-wise Price List Rate,Barang-bijaksana Daftar Harga Tingkat
Item-wise Purchase History,Barang-bijaksana Riwayat Pembelian
Item-wise Purchase Register,Barang-bijaksana Pembelian Register
Item-wise Sales History,Item-wise Penjualan Sejarah
Item-wise Sales Register,Item-wise Daftar Penjualan
"Item: {0} managed batch-wise, can not be reconciled using \					Stock Reconciliation, instead use Stock Entry","Item: {0} dikelola batch-bijaksana, tidak dapat didamaikan dengan menggunakan \ Bursa Rekonsiliasi, sebagai gantinya menggunakan Stock Entri"
Item: {0} not found in the system,Item: {0} tidak ditemukan dalam sistem
Items,Items
Items To Be Requested,Items Akan Diminta
Items required,Barang yang dibutuhkan
"Items to be requested which are ""Out of Stock"" considering all warehouses based on projected qty and minimum order qty","Item harus diminta yang ""Out of Stock"" mengingat semua gudang berdasarkan qty diproyeksikan dan pesanan minimum qty"
Items which do not exist in Item master can also be entered on customer's request,Barang-barang yang tidak ada dalam Butir utama juga dapat dimasukkan pada permintaan pelanggan
Itemwise Discount,Itemwise Diskon
Itemwise Recommended Reorder Level,Itemwise Rekomendasi Reorder Tingkat
Job Applicant,Pemohon Job
Job Opening,Pembukaan Job
Job Profile,Profil Job
Job Title,Jabatan
"Job profile, qualifications required etc.","Profil pekerjaan, kualifikasi yang dibutuhkan dll"
Jobs Email Settings,Pengaturan Jobs Email
Journal Entries,Entries Journal
Journal Entry,Jurnal Entri
Journal Voucher,Journal Voucher
Journal Voucher Detail,Journal Voucher Detil
Journal Voucher Detail No,Journal Voucher Detil ada
Journal Voucher {0} does not have account {1} or already matched,Journal Voucher {0} tidak memiliki akun {1} atau sudah cocok
Journal Vouchers {0} are un-linked,Journal Voucher {0} yang un-linked
Keep a track of communication related to this enquiry which will help for future reference.,Menyimpan melacak komunikasi yang berkaitan dengan penyelidikan ini yang akan membantu untuk referensi di masa mendatang.
Keep it web friendly 900px (w) by 100px (h),Simpan web 900px ramah (w) oleh 100px (h)
Key Performance Area,Key Bidang Kinerja
Key Responsibility Area,Key Responsibility area
Kg,Kg
LR Date,LR Tanggal
LR No,LR ada
Label,Label
Landed Cost Item,Landed Biaya Barang
Landed Cost Items,Landed Biaya Produk
Landed Cost Purchase Receipt,Landed Biaya Penerimaan Pembelian
Landed Cost Purchase Receipts,Mendarat Penerimaan Biaya Pembelian
Landed Cost Wizard,Landed Biaya Wisaya
Landed Cost updated successfully,Biaya Landed berhasil diperbarui
Language,Bahasa
Last Name,Nama Belakang
Last Purchase Rate,Tingkat Pembelian Terakhir
Latest,Terbaru
Lead,Lead
Lead Details,Detail Timbal
Lead Id,Timbal Id
Lead Name,Timbal Nama
Lead Owner,Timbal Owner
Lead Source,Sumber utama
Lead Status,Status Timbal
Lead Time Date,Timbal Waktu Tanggal
Lead Time Days,Memimpin Waktu Hari
Lead Time days is number of days by which this item is expected in your warehouse. This days is fetched in Material Request when you select this item.,Hari Waktu Timbal adalah jumlah hari dimana item ini diharapkan di gudang Anda. Hari ini diambil di Material Request ketika Anda memilih item ini.
Lead Type,Timbal Type
Lead must be set if Opportunity is made from Lead,Timbal harus diatur jika Peluang terbuat dari Timbal
Leave Allocation,Tinggalkan Alokasi
Leave Allocation Tool,Tinggalkan Alokasi Alat
Leave Application,Tinggalkan Aplikasi
Leave Approver,Tinggalkan Approver
Leave Approvers,Tinggalkan yang menyetujui
Leave Balance Before Application,Tinggalkan Saldo Sebelum Aplikasi
Leave Block List,Tinggalkan Block List
Leave Block List Allow,Tinggalkan Block List Izinkan
Leave Block List Allowed,Tinggalkan Block List Diizinkan
Leave Block List Date,Tinggalkan Block List Tanggal
Leave Block List Dates,Tinggalkan Block List Tanggal
Leave Block List Name,Tinggalkan Nama Block List
Leave Blocked,Tinggalkan Diblokir
Leave Control Panel,Tinggalkan Control Panel
Leave Encashed?,Tinggalkan dicairkan?
Leave Encashment Amount,Tinggalkan Pencairan Jumlah
Leave Type,Tinggalkan Type
Leave Type Name,Tinggalkan Type Nama
Leave Without Pay,Tinggalkan Tanpa Bayar
Leave application has been approved.,Pengajuan cuti telah disetujui.
Leave application has been rejected.,Pengajuan cuti telah ditolak.
Leave approver must be one of {0},Tinggalkan approver harus menjadi salah satu {0}
Leave blank if considered for all branches,Biarkan kosong jika dipertimbangkan untuk semua cabang
Leave blank if considered for all departments,Biarkan kosong jika dianggap untuk semua departemen
Leave blank if considered for all designations,Biarkan kosong jika dipertimbangkan untuk semua sebutan
Leave blank if considered for all employee types,Biarkan kosong jika dipertimbangkan untuk semua jenis karyawan
"Leave can be approved by users with Role, ""Leave Approver""","Tinggalkan dapat disetujui oleh pengguna dengan Role, ""Tinggalkan Approver"""
Leave of type {0} cannot be longer than {1},Tinggalkan jenis {0} tidak boleh lebih dari {1}
Leaves Allocated Successfully for {0},Daun Dialokasikan Berhasil untuk {0}
Leaves for type {0} already allocated for Employee {1} for Fiscal Year {0},Daun untuk tipe {0} sudah dialokasikan untuk Karyawan {1} Tahun Anggaran {0}
Leaves must be allocated in multiples of 0.5,"Daun harus dialokasikan dalam kelipatan 0,5"
Ledger,Buku besar
Ledgers,Buku Pembantu
Left,Waktu tersisa
Legal,Hukum
Legal Expenses,Beban Legal
Letter Head,Surat Kepala
Letter Heads for print templates.,Surat Kepala untuk mencetak template.
Level,Level
Lft,Lft
Liability,Kewajiban
List a few of your customers. They could be organizations or individuals.,Daftar beberapa pelanggan Anda. Mereka bisa menjadi organisasi atau individu.
List a few of your suppliers. They could be organizations or individuals.,Daftar beberapa pemasok Anda. Mereka bisa menjadi organisasi atau individu.
List items that form the package.,Daftar item yang membentuk paket.
List this Item in multiple groups on the website.,Daftar Barang ini dalam beberapa kelompok di website.
"List your products or services that you buy or sell. Make sure to check the Item Group, Unit of Measure and other properties when you start.","Daftar produk atau jasa yang Anda membeli atau menjual. Pastikan untuk memeriksa Grup Barang, Satuan Ukur dan properti lainnya ketika Anda mulai."
"List your tax heads (e.g. VAT, Excise; they should have unique names) and their standard rates. This will create a standard template, which you can edit and add more later.","Daftar kepala pajak Anda (misalnya PPN, Cukai, mereka harus memiliki nama yang unik) dan tingkat standar mereka. Ini akan membuat template standar, yang dapat Anda edit dan menambahkannya kemudian."
Loading...,Memuat...
Loans (Liabilities),Kredit (Kewajiban)
Loans and Advances (Assets),Pinjaman Uang Muka dan (Aset)
Local,[Daerah
Login,Masuk
Login with your new User ID,Login dengan User ID baru Anda
Logo,Logo
Logo and Letter Heads,Logo dan Surat Kepala
Lost,Tersesat
Lost Reason,Kehilangan Alasan
Low,Rendah
Lower Income,Penghasilan rendah
MTN Details,MTN Detail
Main,Utama
Main Reports,Laporan Utama
Maintain Same Rate Throughout Sales Cycle,Menjaga Tingkat Sama Sepanjang Siklus Penjualan
Maintain same rate throughout purchase cycle,Mempertahankan tingkat yang sama sepanjang siklus pembelian
Maintenance,Pemeliharaan
Maintenance Date,Pemeliharaan Tanggal
Maintenance Details,Detail Maintenance
Maintenance Schedule,Jadwal pemeliharaan
Maintenance Schedule Detail,Jadwal pemeliharaan Detil
Maintenance Schedule Item,Jadwal pemeliharaan Barang
Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Jadwal pemeliharaan tidak dihasilkan untuk semua item. Silahkan klik 'Menghasilkan Jadwal'
Maintenance Schedule {0} exists against {0},Jadwal pemeliharaan {0} ada terhadap {0}
Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Jadwal pemeliharaan {0} harus dibatalkan sebelum membatalkan Sales Order ini
Maintenance Schedules,Jadwal pemeliharaan
Maintenance Status,Status pemeliharaan
Maintenance Time,Pemeliharaan Waktu
Maintenance Type,Pemeliharaan Type
Maintenance Visit,Pemeliharaan Visit
Maintenance Visit Purpose,Pemeliharaan Visit Tujuan
Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Pemeliharaan Kunjungan {0} harus dibatalkan sebelum membatalkan Sales Order ini
Maintenance start date can not be before delivery date for Serial No {0},Tanggal mulai pemeliharaan tidak bisa sebelum tanggal pengiriman untuk Serial No {0}
Major/Optional Subjects,Mayor / Opsional Subjek
Make ,
Make Accounting Entry For Every Stock Movement,Membuat Entri Akuntansi Untuk Setiap Gerakan Stock
Make Bank Voucher,Membuat Bank Voucher
Make Credit Note,Membuat Nota Kredit
Make Debit Note,Membuat Debit Note
Make Delivery,Membuat Pengiriman
Make Difference Entry,Membuat Perbedaan Entri
Make Excise Invoice,Membuat Cukai Faktur
Make Installation Note,Membuat Instalasi Note
Make Invoice,Membuat Invoice
Make Maint. Schedule,Buat Maint. Jadwal
Make Maint. Visit,Buat Maint. Kunjungan
Make Maintenance Visit,Membuat Maintenance Visit
Make Packing Slip,Membuat Packing Slip
Make Payment,Lakukan Pembayaran
Make Payment Entry,Membuat Entri Pembayaran
Make Purchase Invoice,Membuat Purchase Invoice
Make Purchase Order,Membuat Purchase Order
Make Purchase Receipt,Membuat Pembelian Penerimaan
Make Salary Slip,Membuat Slip Gaji
Make Salary Structure,Membuat Struktur Gaji
Make Sales Invoice,Membuat Sales Invoice
Make Sales Order,Membuat Sales Order
Make Supplier Quotation,Membuat Pemasok Quotation
Make Time Log Batch,Membuat Waktu Log Batch
Male,Laki-laki
Manage Customer Group Tree.,Manage Group Pelanggan Pohon.
Manage Sales Partners.,Mengelola Penjualan Partners.
Manage Sales Person Tree.,Mengelola Penjualan Orang Pohon.
Manage Territory Tree.,Kelola Wilayah Pohon.
Manage cost of operations,Mengelola biaya operasional
Management,Manajemen
Manager,Manajer
"Mandatory if Stock Item is ""Yes"". Also the default warehouse where reserved quantity is set from Sales Order.","Wajib jika Stock Item ""Yes"". Juga gudang standar di mana kuantitas milik diatur dari Sales Order."
Manufacture against Sales Order,Industri melawan Sales Order
Manufacture/Repack,Industri / Repack
Manufactured Qty,Diproduksi Qty
Manufactured quantity will be updated in this warehouse,Kuantitas Diproduksi akan diperbarui di gudang ini
Manufactured quantity {0} cannot be greater than planned quanitity {1} in Production Order {2},Kuantitas Diproduksi {0} Tidak dapat lebih besar dari yang direncanakan quanitity {1} dalam Orde Produksi {2}
Manufacturer,Pabrikan
Manufacturer Part Number,Produsen Part Number
Manufacturing,Manufaktur
Manufacturing Quantity,Manufacturing Quantity
Manufacturing Quantity is mandatory,Manufaktur Kuantitas adalah wajib
Margin,Margin
Marital Status,Status Perkawinan
Market Segment,Segmen Pasar
Marketing,Pemasaran
Marketing Expenses,Beban Pemasaran
Married,Belum Menikah
Mass Mailing,Mailing massa
Master Name,Guru Nama
Master Name is mandatory if account type is Warehouse,Guru Nama adalah wajib jika jenis account adalah Gudang
Master Type,Guru Type
Masters,Masters
Match non-linked Invoices and Payments.,Cocokkan Faktur non-linked dan Pembayaran.
Material Issue,Material Isu
Material Receipt,Material Receipt
Material Request,Permintaan Material
Material Request Detail No,Permintaan Detil Material ada
Material Request For Warehouse,Permintaan Material Untuk Gudang
Material Request Item,Material Permintaan Barang
Material Request Items,Permintaan Produk Bahan
Material Request No,Permintaan Material yang
Material Request Type,Permintaan Jenis Bahan
Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Permintaan Bahan maksimal {0} dapat dibuat untuk Item {1} terhadap Sales Order {2}
Material Request used to make this Stock Entry,Permintaan bahan yang digunakan untuk membuat Masuk Bursa ini
Material Request {0} is cancelled or stopped,Permintaan Material {0} dibatalkan atau dihentikan
Material Requests for which Supplier Quotations are not created,Permintaan Material yang Pemasok Kutipan tidak diciptakan
Material Requests {0} created,Permintaan Material {0} dibuat
Material Requirement,Material Requirement
Material Transfer,Material Transfer
Materials,bahan materi
Materials Required (Exploded),Bahan yang dibutuhkan (Meledak)
Max 5 characters,Max 5 karakter
Max Days Leave Allowed,Max Hari Cuti Diizinkan
Max Discount (%),Max Diskon (%)
Max Qty,Max Qty
Max discount allowed for item: {0} is {1}%,Diskon Max diperbolehkan untuk item: {0} {1}%
Maximum Amount,Jumlah Maksimum
Maximum allowed credit is {0} days after posting date,Kredit maksimum yang diijinkan adalah {0} hari setelah tanggal postingan
Maximum {0} rows allowed,Maksimum {0} baris diperbolehkan
Maxiumm discount for Item {0} is {1}%,Diskon Maxiumm untuk Item {0} adalah {1}%
Medical,Medis
Medium,Sedang
"Merging is only possible if following properties are same in both records. Group or Ledger, Root Type, Company","Penggabungan hanya mungkin jika sifat berikut sama di kedua catatan. Grup atau Ledger, Akar Type, Perusahaan"
Message,Pesan
Message Parameter,Parameter pesan
Message Sent,Pesan Terkirim
Message updated,Pesan diperbarui
Messages,Pesan
Messages greater than 160 characters will be split into multiple messages,Pesan lebih dari 160 karakter akan dipecah menjadi beberapa pesan
Middle Income,Penghasilan Tengah
Milestone,Batu
Milestone Date,Milestone Tanggal
Milestones,Milestones
Milestones will be added as Events in the Calendar,Milestones akan ditambahkan sebagai Acara di Kalender
Min Order Qty,Min Order Qty
Min Qty,Min Qty
Min Qty can not be greater than Max Qty,Min Qty tidak dapat lebih besar dari Max Qty
Minimum Amount,Jumlah Minimum
Minimum Order Qty,Minimum Order Qty
Minute,Menit
Misc Details,Lain-lain Detail
Miscellaneous Expenses,Beban lain-lain
Miscelleneous,Miscelleneous
Mobile No,Ponsel Tidak ada
Mobile No.,Ponsel Nomor
Mode of Payment,Mode Pembayaran
Modern,Modern
Monday,Senin
Month,Bulan
Monthly,Bulanan
Monthly Attendance Sheet,Lembar Kehadiran Bulanan
Monthly Earning & Deduction,Bulanan Pendapatan & Pengurangan
Monthly Salary Register,Gaji Bulanan Daftar
Monthly salary statement.,Pernyataan gaji bulanan.
More Details,Detail Lebih
More Info,Info Selengkapnya
Motion Picture & Video,Motion Picture & Video
Moving Average,Moving Average
Moving Average Rate,Moving Average Tingkat
Mr,Mr
Ms,Ms
Multiple Item prices.,Multiple Item harga.
"Multiple Price Rule exists with same criteria, please resolve \			conflict by assigning priority. Price Rules: {0}","Beberapa Aturan Harga ada dengan kriteria yang sama, silahkan menyelesaikan \ konflik dengan menetapkan prioritas. Aturan Harga: {0}"
Music,Musik
Must be Whole Number,Harus Nomor Utuh
Name,Nama
Name and Description,Nama dan Deskripsi
Name and Employee ID,Nama dan ID Karyawan
"Name of new Account. Note: Please don't create accounts for Customers and Suppliers, they are created automatically from the Customer and Supplier master","Nama Akun baru. Catatan: Tolong jangan membuat account untuk Pelanggan dan Pemasok, mereka dibuat secara otomatis dari Nasabah dan Pemasok utama"
Name of person or organization that this address belongs to.,Nama orang atau organisasi yang alamat ini milik.
Name of the Budget Distribution,Nama Distribusi Anggaran
Naming Series,Penamaan Series
Negative Quantity is not allowed,Jumlah negatif tidak diperbolehkan
Negative Stock Error ({6}) for Item {0} in Warehouse {1} on {2} {3} in {4} {5},Kesalahan Stock negatif ({6}) untuk Item {0} Gudang {1} di {2} {3} in {4} {5}
Negative Valuation Rate is not allowed,Tingkat Penilaian negatif tidak diperbolehkan
Negative balance in Batch {0} for Item {1} at Warehouse {2} on {3} {4},Saldo negatif dalam Batch {0} untuk Item {1} di Gudang {2} pada {3} {4}
Net Pay,Pay Net
Net Pay (in words) will be visible once you save the Salary Slip.,Pay Bersih (dalam kata-kata) akan terlihat setelah Anda menyimpan Slip Gaji.
Net Profit / Loss,Laba / Rugi
Net Total,Jumlah Bersih
Net Total (Company Currency),Jumlah Bersih (Perusahaan Mata Uang)
Net Weight,Berat Bersih
Net Weight UOM,Berat Bersih UOM
Net Weight of each Item,Berat Bersih dari setiap Item
Net pay cannot be negative,Gaji bersih yang belum dapat negatif
Never,Tidak Pernah
New ,
New Account,Akun baru
New Account Name,New Account Name
New BOM,New BOM
New Communications,Komunikasi Baru
New Company,Perusahaan Baru
New Cost Center,Biaya Pusat baru
New Cost Center Name,Baru Nama Biaya Pusat
New Delivery Notes,Catatan Pengiriman Baru
New Enquiries,Pertanyaan Baru
New Leads,Memimpin Baru
New Leave Application,Tinggalkan Aplikasi Baru
New Leaves Allocated,Daun baru Dialokasikan
New Leaves Allocated (In Days),Daun baru Dialokasikan (Dalam Hari)
New Material Requests,Permintaan Bahan Baru
New Projects,Proyek Baru
New Purchase Orders,Pesanan Pembelian Baru
New Purchase Receipts,Penerimaan Pembelian Baru
New Quotations,Kutipan Baru
New Sales Orders,Penjualan New Orders
New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Baru Serial ada tidak dapat memiliki Gudang. Gudang harus diatur oleh Bursa Masuk atau Penerimaan Pembelian
New Stock Entries,Entri New Stock
New Stock UOM,New Stock UOM
New Stock UOM is required,New Stock UOM diperlukan
New Stock UOM must be different from current stock UOM,New Stock UOM harus berbeda dari UOM saham saat ini
New Supplier Quotations,Pemasok Kutipan Baru
New Support Tickets,Dukungan Tiket Baru
New UOM must NOT be of type Whole Number,New UOM TIDAK harus dari jenis Whole Number
New Workplace,Kerja baru
Newsletter,Laporan berkala
Newsletter Content,Newsletter Konten
Newsletter Status,Newsletter Status
Newsletter has already been sent,Newsletter telah terkirim
"Newsletters to contacts, leads.","Newsletter ke kontak, memimpin."
Newspaper Publishers,Koran Publishers
Next,Berikutnya
Next Contact By,Berikutnya Contact By
Next Contact Date,Berikutnya Hubungi Tanggal
Next Date,Berikutnya Tanggal
Next email will be sent on:,Email berikutnya akan dikirim pada:
No,Nomor
No Customer Accounts found.,Tidak ada Rekening Nasabah ditemukan.
No Customer or Supplier Accounts found,"Tidak ada pelanggan, atau pemasok Akun ditemukan"
No Expense Approvers. Please assign 'Expense Approver' Role to atleast one user,Tidak ada yang menyetujui Beban. Silakan menetapkan 'Beban Approver' Peran untuk minimal satu pengguna
No Item with Barcode {0},Ada Barang dengan Barcode {0}
No Item with Serial No {0},Tidak ada Barang dengan Serial No {0}
No Items to pack,Tidak ada item untuk berkemas
No Leave Approvers. Please assign 'Leave Approver' Role to atleast one user,Tidak Cuti yang menyetujui. Silakan menetapkan Peran 'Leave Approver' untuk minimal satu pengguna
No Permission,Tidak ada Izin
No Production Orders created,Tidak ada Pesanan Produksi dibuat
No Supplier Accounts found. Supplier Accounts are identified based on 'Master Type' value in account record.,Tidak Pemasok Akun ditemukan. Akun pemasok diidentifikasi berdasarkan nilai 'Guru Type' dalam catatan akun.
No accounting entries for the following warehouses,Tidak ada entri akuntansi untuk gudang berikut
No addresses created,Tidak ada alamat dibuat
No contacts created,Tidak ada kontak dibuat
No default Address Template found. Please create a new one from Setup > Printing and Branding > Address Template.,Tidak ada Alamat bawaan Template ditemukan. Harap membuat yang baru dari Pengaturan> Percetakan dan Branding> Template Alamat.
No default BOM exists for Item {0},Tidak ada standar BOM ada untuk Item {0}
No description given,Tidak diberikan deskripsi
No employee found,Tidak ada karyawan yang ditemukan
No employee found!,Tidak ada karyawan ditemukan!
No of Requested SMS,Tidak ada dari Diminta SMS
No of Sent SMS,Tidak ada dari Sent SMS
No of Visits,Tidak ada Kunjungan
No permission,Tidak ada izin
No record found,Tidak ada catatan ditemukan
No records found in the Invoice table,Tidak ada catatan yang ditemukan dalam tabel Faktur
No records found in the Payment table,Tidak ada catatan yang ditemukan dalam tabel Pembayaran
No salary slip found for month: ,
Non Profit,Non Profit
Nos,Nos
Not Active,Tidak Aktif
Not Applicable,Tidak Berlaku
Not Available,Tidak Tersedia
Not Billed,Tidak Ditagih
Not Delivered,Tidak Disampaikan
Not Set,Tidak Diatur
Not allowed to update stock transactions older than {0},Tidak diizinkan untuk memperbarui transaksi saham lebih tua dari {0}
Not authorized to edit frozen Account {0},Tidak berwenang untuk mengedit Akun frozen {0}
Not authroized since {0} exceeds limits,Tidak Authroized sejak {0} melebihi batas
Not permitted,Tidak diijinkan
Note,Catatan
Note User,Catatan Pengguna
"Note: Backups and files are not deleted from Dropbox, you will have to delete them manually.","Catatan: backup dan file tidak dihapus dari Dropbox, Anda harus menghapusnya secara manual."
"Note: Backups and files are not deleted from Google Drive, you will have to delete them manually.","Catatan: backup dan file tidak dihapus dari Google Drive, Anda harus menghapusnya secara manual."
Note: Due Date exceeds the allowed credit days by {0} day(s),Catatan: Karena Tanggal melebihi hari-hari kredit diperbolehkan oleh {0} hari (s)
Note: Email will not be sent to disabled users,Catatan: Email tidak akan dikirim ke pengguna cacat
Note: Item {0} entered multiple times,Catatan: Barang {0} masuk beberapa kali
Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Catatan: Entry Pembayaran tidak akan dibuat karena 'Cash atau Rekening Bank tidak ditentukan
Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Catatan: Sistem tidak akan memeriksa over-pengiriman dan over-booking untuk Item {0} kuantitas atau jumlah 0
Note: There is not enough leave balance for Leave Type {0},Catatan: Tidak ada saldo cuti cukup bagi Leave Type {0}
Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Catatan: Biaya Pusat ini adalah Group. Tidak bisa membuat entri akuntansi terhadap kelompok-kelompok.
Note: {0},Catatan: {0}
Notes,Catatan
Notes:,Catatan:
Nothing to request,Tidak ada yang meminta
Notice (days),Notice (hari)
Notification Control,Pemberitahuan Kontrol
Notification Email Address,Pemberitahuan Alamat Email
Notify by Email on creation of automatic Material Request,Memberitahu melalui Email pada penciptaan Permintaan Bahan otomatis
Number Format,Nomor Format
Offer Date,Penawaran Tanggal
Office,Kantor
Office Equipments,Peralatan Kantor
Office Maintenance Expenses,Beban Pemeliharaan Kantor
Office Rent,Kantor Sewa
Old Parent,Induk tua
On Net Total,Pada Bersih Jumlah
On Previous Row Amount,Pada Sebelumnya Row Jumlah
On Previous Row Total,Pada Sebelumnya Row Jumlah
Online Auctions,Lelang Online
Only Leave Applications with status 'Approved' can be submitted,Hanya Tinggalkan Aplikasi status 'Disetujui' dapat diajukan
"Only Serial Nos with status ""Available"" can be delivered.","Hanya Serial Nos status ""Available"" dapat disampaikan."
Only leaf nodes are allowed in transaction,Hanya node daun yang diperbolehkan dalam transaksi
Only the selected Leave Approver can submit this Leave Application,Hanya dipilih Cuti Approver dapat mengirimkan Aplikasi Cuti ini
Open,Buka
Open Production Orders,Pesanan terbuka Produksi
Open Tickets,Buka Tiket
Opening (Cr),Pembukaan (Cr)
Opening (Dr),Pembukaan (Dr)
Opening Date,Tanggal pembukaan
Opening Entry,Membuka Entri
Opening Qty,Membuka Qty
Opening Time,Membuka Waktu
Opening Value,Nilai Membuka
Opening for a Job.,Membuka untuk Job.
Operating Cost,Biaya Operasi
Operation Description,Operasi Deskripsi
Operation No,Operasi Tidak ada
Operation Time (mins),Operasi Waktu (menit)
Operation {0} is repeated in Operations Table,Operasi {0} diulangi dalam Operasi Tabel
Operation {0} not present in Operations Table,Operasi {0} tidak hadir dalam Operasi Tabel
Operations,Operasi
Opportunity,Kesempatan
Opportunity Date,Peluang Tanggal
Opportunity From,Peluang Dari
Opportunity Item,Peluang Barang
Opportunity Items,Peluang Produk
Opportunity Lost,Peluang Hilang
Opportunity Type,Peluang Type
Optional. This setting will be used to filter in various transactions.,Opsional. Pengaturan ini akan digunakan untuk menyaring dalam berbagai transaksi.
Order Type,Pesanan Type
Order Type must be one of {0},Pesanan Type harus menjadi salah satu {0}
Ordered,Ordered
Ordered Items To Be Billed,Memerintahkan Items Akan Ditagih
Ordered Items To Be Delivered,Memerintahkan Items Akan Disampaikan
Ordered Qty,Memerintahkan Qty
"Ordered Qty: Quantity ordered for purchase, but not received.","Memerintahkan Qty: Jumlah memerintahkan untuk pembelian, tetapi tidak diterima."
Ordered Quantity,Memerintahkan Kuantitas
Orders released for production.,Pesanan dirilis untuk produksi.
Organization Name,Nama Organisasi
Organization Profile,Profil Organisasi
Organization branch master.,Cabang master organisasi.
Organization unit (department) master.,Unit Organisasi (kawasan) menguasai.
Other,Lain-lain
Other Details,Detail lainnya
Others,Lainnya
Out Qty,Out Qty
Out Value,Out Nilai
Out of AMC,Dari AMC
Out of Warranty,Out of Garansi
Outgoing,Ramah
Outstanding Amount,Jumlah yang luar biasa
Outstanding for {0} cannot be less than zero ({1}),Posisi untuk {0} tidak bisa kurang dari nol ({1})
Overhead,Atas
Overheads,Overhead
Overlapping conditions found between:,Kondisi Tumpang Tindih ditemukan antara:
Overview,Pratinjau
Owned,Dimiliki
Owner,Pemilik
P L A - Cess Portion,PLA - Cess Bagian
PL or BS,PL atau BS
PO Date,PO Tanggal
PO No,PO No
POP3 Mail Server,POP3 Mail Server
POP3 Mail Settings,POP3 Mail Settings
POP3 mail server (e.g. pop.gmail.com),POP3 server mail (misalnya pop.gmail.com)
POP3 server e.g. (pop.gmail.com),POP3 server misalnya (pop.gmail.com)
POS Setting,Pengaturan POS
POS Setting required to make POS Entry,Pengaturan POS diperlukan untuk membuat POS Entri
POS Setting {0} already created for user: {1} and company {2},Pengaturan POS {0} sudah diciptakan untuk pengguna: {1} dan perusahaan {2}
POS View,Lihat POS
PR Detail,PR Detil
Package Item Details,Paket Item detail
Package Items,Paket Items
Package Weight Details,Paket Berat Detail
Packed Item,Barang Dikemas
Packed quantity must equal quantity for Item {0} in row {1},Dikemas kuantitas harus sama kuantitas untuk Item {0} berturut-turut {1}
Packing Details,Packing Detail
Packing List,Packing List
Packing Slip,Packing Slip
Packing Slip Item,Packing Slip Barang
Packing Slip Items,Packing Slip Items
Packing Slip(s) cancelled,Packing slip (s) dibatalkan
Page Break,Halaman Istirahat
Page Name,Nama Halaman
Paid Amount,Dibayar Jumlah
Paid amount + Write Off Amount can not be greater than Grand Total,Jumlah yang dibayarkan + Write Off Jumlah tidak bisa lebih besar dari Grand Total
Pair,Pasangkan
Parameter,{0}Para{/0}{1}me{/1}{0}ter{/0}
Parent Account,Rekening Induk
Parent Cost Center,Parent Biaya Pusat
Parent Customer Group,Induk Pelanggan Grup
Parent Detail docname,Induk Detil docname
Parent Item,Induk Barang
Parent Item Group,Induk Barang Grup
Parent Item {0} must be not Stock Item and must be a Sales Item,Induk Barang {0} harus tidak Stock Barang dan harus Item Penjualan
Parent Party Type,Type Partai Induk
Parent Sales Person,Penjualan Induk Orang
Parent Territory,Wilayah Induk
Parent Website Page,Induk Website Halaman
Parent Website Route,Parent Situs Route
Parenttype,Parenttype
Part-time,Part-time
Partially Completed,Sebagian Selesai
Partly Billed,Sebagian Ditagih
Partly Delivered,Sebagian Disampaikan
Partner Target Detail,Mitra Sasaran Detil
Partner Type,Mitra Type
Partner's Website,Partner Website
Party,Pihak
Party Account,Akun Party
Party Type,Type Partai
Party Type Name,Jenis Party Nama
Passive,Pasif
Passport Number,Nomor Paspor
Password,Kata sandi
Pay To / Recd From,Pay To / RECD Dari
Payable,Hutang
Payables,Hutang
Payables Group,Hutang Grup
Payment Days,Hari Pembayaran
Payment Due Date,Tanggal Jatuh Tempo Pembayaran
Payment Period Based On Invoice Date,Masa Pembayaran Berdasarkan Faktur Tanggal
Payment Reconciliation,Rekonsiliasi Pembayaran
Payment Reconciliation Invoice,Rekonsiliasi Pembayaran Faktur
Payment Reconciliation Invoices,Faktur Rekonsiliasi Pembayaran
Payment Reconciliation Payment,Rekonsiliasi Pembayaran Pembayaran
Payment Reconciliation Payments,Pembayaran Rekonsiliasi Pembayaran
Payment Type,Jenis Pembayaran
Payment cannot be made for empty cart,Pembayaran tidak dapat dibuat untuk keranjang kosong
Payment of salary for the month {0} and year {1},Pembayaran gaji untuk bulan {0} dan tahun {1}
Payments,2. Payment (Pembayaran)
Payments Made,Pembayaran Dibuat
Payments Received,Pembayaran Diterima
Payments made during the digest period,Pembayaran dilakukan selama periode digest
Payments received during the digest period,Pembayaran yang diterima selama periode digest
Payroll Settings,Pengaturan Payroll
Pending,Menunggu
Pending Amount,Pending Jumlah
Pending Items {0} updated,Pending Items {0} diperbarui
Pending Review,Pending Ulasan
Pending SO Items For Purchase Request,Pending SO Items Untuk Pembelian Permintaan
Pension Funds,Dana pensiun
Percent Complete,Persen Lengkap
Percentage Allocation,Persentase Alokasi
Percentage Allocation should be equal to 100%,Persentase Alokasi harus sama dengan 100%
Percentage variation in quantity to be allowed while receiving or delivering this item.,Variasi persentase kuantitas yang diizinkan saat menerima atau memberikan item ini.
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.,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.
Performance appraisal.,Penilaian kinerja.
Period,periode
Period Closing Voucher,Voucher Periode penutupan
Periodicity,Masa haid
Permanent Address,Permanent Alamat
Permanent Address Is,Alamat permanen Apakah
Permission,Izin
Personal,Pribadi
Personal Details,Data Pribadi
Personal Email,Email Pribadi
Pharmaceutical,Farmasi
Pharmaceuticals,Farmasi
Phone,Telepon
Phone No,Telepon yang
Piecework,Pekerjaan yg dibayar menurut hasil yg dikerjakan
Pincode,Kode PIN
Place of Issue,Tempat Issue
Plan for maintenance visits.,Rencana kunjungan pemeliharaan.
Planned Qty,Rencana Qty
"Planned Qty: Quantity, for which, Production Order has been raised, but is pending to be manufactured.","Rencana Qty: Kuantitas, yang, Orde Produksi telah dibangkitkan, tetapi tertunda akan diproduksi."
Planned Quantity,Direncanakan Kuantitas
Planning,Perencanaan
Plant,Tanaman
Plant and Machinery,Tanaman dan Mesin
Please Enter Abbreviation or Short Name properly as it will be added as Suffix to all Account Heads.,Silakan Singkatan atau Nama pendek dengan benar karena akan ditambahkan sebagai Suffix kepada semua Kepala Akun.
Please Update SMS Settings,Silahkan Perbarui Pengaturan SMS
Please add expense voucher details,Harap tambahkan beban rincian voucher
Please add to Modes of Payment from Setup.,Silahkan menambah Mode Pembayaran dari Setup.
Please check 'Is Advance' against Account {0} if this is an advance entry.,Silakan periksa 'Apakah Muka' terhadap Rekening {0} jika ini adalah sebuah entri muka.
Please click on 'Generate Schedule',Silahkan klik 'Menghasilkan Jadwal'
Please click on 'Generate Schedule' to fetch Serial No added for Item {0},Silahkan klik 'Menghasilkan Jadwal' untuk mengambil Serial yang ditambahkan untuk Item {0}
Please click on 'Generate Schedule' to get schedule,Silahkan klik 'Menghasilkan Jadwal' untuk mendapatkan jadwal
Please create Customer from Lead {0},Silakan membuat pelanggan dari Lead {0}
Please create Salary Structure for employee {0},Silakan membuat Struktur Gaji untuk karyawan {0}
Please create new account from Chart of Accounts.,Silahkan buat akun baru dari Bagan Akun.
Please do NOT create Account (Ledgers) for Customers and Suppliers. They are created directly from the Customer / Supplier masters.,Mohon TIDAK membuat Account (Buku Pembantu) untuk Pelanggan dan Pemasok. Mereka diciptakan langsung dari Nasabah / Pemasok master.
Please enter 'Expected Delivery Date',Masukkan 'Diharapkan Pengiriman Tanggal'
Please enter 'Is Subcontracted' as Yes or No,Masukkan 'Apakah subkontrak' sebagai Ya atau Tidak
Please enter 'Repeat on Day of Month' field value,Masukkan 'Ulangi pada Hari Bulan' nilai bidang
Please enter Account Receivable/Payable group in company master,Cukup masukkan Piutang / Hutang group in master perusahaan
Please enter Approving Role or Approving User,Masukkan Menyetujui Peran atau Menyetujui Pengguna
Please enter BOM for Item {0} at row {1},Masukkan BOM untuk Item {0} pada baris {1}
Please enter Company,Masukkan Perusahaan
Please enter Cost Center,Masukkan Biaya Pusat
Please enter Delivery Note No or Sales Invoice No to proceed,Masukkan Pengiriman Note ada atau Faktur Penjualan Tidak untuk melanjutkan
Please enter Employee Id of this sales parson,Masukkan Id Karyawan pendeta penjualan ini
Please enter Expense Account,Masukkan Beban Akun
Please enter Item Code to get batch no,Masukkan Item Code untuk mendapatkan bets tidak
Please enter Item Code.,Masukkan Item Code.
Please enter Item first,Masukkan Barang pertama
Please enter Maintaince Details first,Cukup masukkan Maintaince Detail pertama
Please enter Master Name once the account is created.,Masukkan Nama Guru setelah account dibuat.
Please enter Planned Qty for Item {0} at row {1},Masukkan Planned Qty untuk Item {0} pada baris {1}
Please enter Production Item first,Masukkan Produksi Barang pertama
Please enter Purchase Receipt No to proceed,Masukkan Penerimaan Pembelian ada untuk melanjutkan
Please enter Reference date,Harap masukkan tanggal Referensi
Please enter Warehouse for which Material Request will be raised,Masukkan Gudang yang Material Permintaan akan dibangkitkan
Please enter Write Off Account,Cukup masukkan Write Off Akun
Please enter atleast 1 invoice in the table,Masukkan minimal 1 faktur dalam tabel
Please enter company first,Silahkan masukkan perusahaan pertama
Please enter company name first,Silahkan masukkan nama perusahaan pertama
Please enter default Unit of Measure,Masukkan Satuan default Ukur
Please enter default currency in Company Master,Masukkan mata uang default di Perusahaan Guru
Please enter email address,Masukkan alamat email
Please enter item details,Masukkan detil item
Please enter message before sending,Masukkan pesan sebelum mengirimnya
Please enter parent account group for warehouse account,Masukkan rekening kelompok orangtua untuk account warehouse
Please enter parent cost center,Masukkan pusat biaya orang tua
Please enter quantity for Item {0},Mohon masukkan untuk Item {0}
Please enter relieving date.,Silahkan masukkan menghilangkan date.
Please enter sales order in the above table,Masukkan order penjualan pada tabel di atas
Please enter valid Company Email,Masukkan Perusahaan valid Email
Please enter valid Email Id,Silahkan lakukan validasi Email Id
Please enter valid Personal Email,Silahkan lakukan validasi Email Pribadi
Please enter valid mobile nos,Masukkan nos ponsel yang valid
Please find attached Sales Invoice #{0},Silakan menemukan terlampir Faktur Penjualan # {0}
Please install dropbox python module,Silakan instal modul python dropbox
Please mention no of visits required,Harap menyebutkan tidak ada kunjungan yang diperlukan
Please pull items from Delivery Note,Silakan tarik item dari Pengiriman Note
Please save the Newsletter before sending,Harap menyimpan Newsletter sebelum dikirim
Please save the document before generating maintenance schedule,Harap menyimpan dokumen sebelum menghasilkan jadwal pemeliharaan
Please see attachment,Silakan lihat lampiran
Please select Bank Account,Silakan pilih Rekening Bank
Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,Silakan pilih Carry Teruskan jika Anda juga ingin menyertakan keseimbangan fiskal tahun sebelumnya daun tahun fiskal ini
Please select Category first,Silahkan pilih Kategori pertama
Please select Charge Type first,Silakan pilih Mengisi Tipe pertama
Please select Fiscal Year,Silahkan pilih Tahun Anggaran
Please select Group or Ledger value,Silahkan pilih Grup atau Ledger nilai
Please select Incharge Person's name,Silahkan pilih nama Incharge Orang
Please select Invoice Type and Invoice Number in atleast one row,Silakan pilih Invoice Type dan Faktur Jumlah minimal dalam satu baris
"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Sales BOM","Silakan pilih Barang di mana ""Apakah Stock Item"" adalah ""Tidak"" dan ""Apakah Penjualan Item"" adalah ""Ya"" dan tidak ada Penjualan BOM lainnya"
Please select Price List,Silakan pilih Daftar Harga
Please select Start Date and End Date for Item {0},Silakan pilih Tanggal Mulai dan Tanggal Akhir untuk Item {0}
Please select Time Logs.,Silakan pilih Sisa log.
Please select a csv file,Silakan pilih file csv
Please select a valid csv file with data,Silakan pilih file csv dengan data yang valid
Please select a value for {0} quotation_to {1},Silakan pilih nilai untuk {0} quotation_to {1}
"Please select an ""Image"" first","Harap pilih ""Gambar"" pertama"
Please select charge type first,Silakan pilih jenis charge pertama
Please select company first,Silakan pilih perusahaan pertama
Please select company first.,Silakan pilih perusahaan pertama.
Please select item code,Silahkan pilih kode barang
Please select month and year,Silakan pilih bulan dan tahun
Please select prefix first,Silakan pilih awalan pertama
Please select the document type first,Silakan pilih jenis dokumen pertama
Please select weekly off day,Silakan pilih dari hari mingguan
Please select {0},Silahkan pilih {0}
Please select {0} first,Silahkan pilih {0} pertama
Please select {0} first.,Silahkan pilih {0} pertama.
Please set Dropbox access keys in your site config,Silakan set tombol akses Dropbox di situs config Anda
Please set Google Drive access keys in {0},Silakan set tombol akses Google Drive di {0}
Please set default Cash or Bank account in Mode of Payment {0},Silakan set Cash standar atau rekening Bank Mode Pembayaran {0}
Please set default value {0} in Company {0},Silakan set nilai default {0} di Perusahaan {0}
Please set {0},Silakan set {0}
Please setup Employee Naming System in Human Resource > HR Settings,Silahkan pengaturan Penamaan Sistem Karyawan di Sumber Daya Manusia> Pengaturan SDM
Please setup numbering series for Attendance via Setup > Numbering Series,Silahkan pengaturan seri penomoran untuk Kehadiran melalui Pengaturan> Penomoran Series
Please setup your chart of accounts before you start Accounting Entries,Silakan pengaturan grafik Anda account sebelum Anda mulai Entries Akuntansi
Please specify,Silakan tentukan
Please specify Company,Silakan tentukan Perusahaan
Please specify Company to proceed,Silahkan tentukan Perusahaan untuk melanjutkan
Please specify Default Currency in Company Master and Global Defaults,Silakan tentukan Currency Default dalam Perseroan Guru dan Default global
Please specify a,Silakan tentukan
Please specify a valid 'From Case No.',Silakan tentukan valid 'Dari Kasus No'
Please specify a valid Row ID for {0} in row {1},Silakan tentukan ID Row berlaku untuk {0} berturut-turut {1}
Please specify either Quantity or Valuation Rate or both,Silakan tentukan baik Quantity atau Tingkat Penilaian atau keduanya
Please submit to update Leave Balance.,Harap kirimkan untuk memperbarui Leave Balance.
Plot,Plot
Plot By,Plot By
Point of Sale,Point of Sale
Point-of-Sale Setting,Point-of-Sale Pengaturan
Post Graduate,Pasca Sarjana
Postal,Pos
Postal Expenses,Beban pos
Posting Date,Tanggal Posting
Posting Time,Posting Waktu
Posting date and posting time is mandatory,Tanggal posting dan posting waktu adalah wajib
Posting timestamp must be after {0},Posting timestamp harus setelah {0}
Potential opportunities for selling.,Potensi peluang untuk menjual.
Preferred Billing Address,Disukai Alamat Penagihan
Preferred Shipping Address,Disukai Alamat Pengiriman
Prefix,Awalan
Present,ada
Prevdoc DocType,Prevdoc DocType
Prevdoc Doctype,Prevdoc Doctype
Preview,Pratayang
Previous,Sebelumnya
Previous Work Experience,Pengalaman Kerja Sebelumnya
Price,Harga
Price / Discount,Harga / Diskon
Price List,Daftar Harga
Price List Currency,Daftar Harga Mata uang
Price List Currency not selected,Daftar Harga Mata uang tidak dipilih
Price List Exchange Rate,Daftar Harga Tukar
Price List Name,Daftar Harga Nama
Price List Rate,Daftar Harga Tingkat
Price List Rate (Company Currency),Daftar Harga Rate (Perusahaan Mata Uang)
Price List master.,Daftar harga Master.
Price List must be applicable for Buying or Selling,Harga List harus berlaku untuk Membeli atau Jual
Price List not selected,Daftar Harga tidak dipilih
Price List {0} is disabled,Daftar Harga {0} dinonaktifkan
Price or Discount,Harga atau Diskon
Pricing Rule,Aturan Harga
Pricing Rule Help,Aturan Harga Bantuan
"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Rule harga pertama dipilih berdasarkan 'Terapkan On' lapangan, yang dapat Barang, Barang Grup atau Merek."
"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Rule harga dibuat untuk menimpa Daftar Harga / mendefinisikan persentase diskon, berdasarkan beberapa kriteria."
Pricing Rules are further filtered based on quantity.,Aturan harga selanjutnya disaring berdasarkan kuantitas.
Print Format Style,Print Format Style
Print Heading,Cetak Pos
Print Without Amount,Cetak Tanpa Jumlah
Print and Stationary,Cetak dan Alat Tulis
Printing and Branding,Percetakan dan Branding
Priority,Prioritas
Private Equity,Private Equity
Privilege Leave,Privilege Cuti
Probation,Percobaan
Process Payroll,Proses Payroll
Produced,Diproduksi
Produced Quantity,Diproduksi Jumlah
Product Enquiry,Enquiry Produk
Production,Produksi
Production Order,Pesanan Produksi
Production Order status is {0},Status pesanan produksi adalah {0}
Production Order {0} must be cancelled before cancelling this Sales Order,Pesanan produksi {0} harus dibatalkan sebelum membatalkan Sales Order ini
Production Order {0} must be submitted,Pesanan produksi {0} harus diserahkan
Production Orders,Pesanan Produksi
Production Orders in Progress,Pesanan produksi di Progress
Production Plan Item,Rencana Produksi Barang
Production Plan Items,Rencana Produksi Produk
Production Plan Sales Order,Rencana Produksi Sales Order
Production Plan Sales Orders,Rencana Produksi Pesanan Penjualan
Production Planning Tool,Alat Perencanaan Produksi
Products,Produk
"Products will be sorted by weight-age in default searches. More the weight-age, higher the product will appear in the list.","Produk akan diurutkan menurut beratnya usia dalam pencarian default. Lebih berat usia, tinggi produk akan muncul dalam daftar."
Professional Tax,Profesional Pajak
Profit and Loss,Laba Rugi
Profit and Loss Statement,Laba Rugi
Project,Proyek
Project Costing,Project Costing
Project Details,Detail Proyek
Project Manager,Manager Project
Project Milestone,Proyek Milestone
Project Milestones,Milestones Proyek
Project Name,Nama Proyek
Project Start Date,Proyek Tanggal Mulai
Project Type,Jenis proyek
Project Value,Nilai Proyek
Project activity / task.,Kegiatan proyek / tugas.
Project master.,Menguasai proyek.
Project will get saved and will be searchable with project name given,Proyek akan diselamatkan dan akan dicari dengan nama proyek yang diberikan
Project wise Stock Tracking,Project Tracking Stock bijaksana
Project-wise data is not available for Quotation,Data proyek-bijaksana tidak tersedia untuk Quotation
Projected,Proyeksi
Projected Qty,Proyeksi Jumlah
Projects,Proyek
Projects & System,Proyek & Sistem
Prompt for Email on Submission of,Prompt untuk Email pada Penyampaian
Proposal Writing,Penulisan Proposal
Provide email id registered in company,Menyediakan email id yang terdaftar di perusahaan
Provisional Profit / Loss (Credit),Laba Provisional / Rugi (Kredit)
Public,Publik
Published on website at: {0},Ditampilkan di website di: {0}
Publishing,Penerbitan
Pull sales orders (pending to deliver) based on the above criteria,Tarik pesanan penjualan (pending untuk memberikan) berdasarkan kriteria di atas
Purchase,Pembelian
Purchase / Manufacture Details,Detail Pembelian / Industri
Purchase Analytics,Pembelian Analytics
Purchase Common,Pembelian Umum
Purchase Details,Rincian pembelian
Purchase Discounts,Membeli Diskon
Purchase Invoice,Purchase Invoice
Purchase Invoice Advance,Pembelian Faktur Muka
Purchase Invoice Advances,Uang Muka Pembelian Faktur
Purchase Invoice Item,Purchase Invoice Barang
Purchase Invoice Trends,Pembelian Faktur Trends
Purchase Invoice {0} is already submitted,Purchase Invoice {0} sudah disampaikan
Purchase Order,Purchase Order
Purchase Order Item,Purchase Order Barang
Purchase Order Item No,Purchase Order Item No
Purchase Order Item Supplied,Purchase Order Barang Disediakan
Purchase Order Items,Purchase Order Items
Purchase Order Items Supplied,Purchase Order Items Disediakan
Purchase Order Items To Be Billed,Purchase Order Items Akan Ditagih
Purchase Order Items To Be Received,Purchase Order Items Akan Diterima
Purchase Order Message,Pesan Purchase Order
Purchase Order Required,Pesanan Pembelian Diperlukan
Purchase Order Trends,Pesanan Pembelian Trends
Purchase Order number required for Item {0},Nomor Purchase Order yang diperlukan untuk Item {0}
Purchase Order {0} is 'Stopped',Pesanan Pembelian {0} 'Berhenti'
Purchase Order {0} is not submitted,Purchase Order {0} tidak disampaikan
Purchase Orders given to Suppliers.,Pembelian Pesanan yang diberikan kepada Pemasok.
Purchase Receipt,Penerimaan Pembelian
Purchase Receipt Item,Penerimaan Pembelian Barang
Purchase Receipt Item Supplied,Penerimaan Pembelian Barang Disediakan
Purchase Receipt Item Supplieds,Penerimaan Pembelian Barang Supplieds
Purchase Receipt Items,Penerimaan Pembelian Produk
Purchase Receipt Message,Penerimaan Pembelian Pesan
Purchase Receipt No,Penerimaan Pembelian ada
Purchase Receipt Required,Penerimaan Pembelian Diperlukan
Purchase Receipt Trends,Tren Penerimaan Pembelian
Purchase Receipt number required for Item {0},Nomor Penerimaan Pembelian diperlukan untuk Item {0}
Purchase Receipt {0} is not submitted,Penerimaan Pembelian {0} tidak disampaikan
Purchase Register,Pembelian Register
Purchase Return,Pembelian Kembali
Purchase Returned,Pembelian Returned
Purchase Taxes and Charges,Pajak Pembelian dan Biaya
Purchase Taxes and Charges Master,Pajak Pembelian dan Biaya Guru
Purchse Order number required for Item {0},Nomor pesanan purchse diperlukan untuk Item {0}
Purpose,Tujuan
Purpose must be one of {0},Tujuan harus menjadi salah satu {0}
QA Inspection,QA Inspeksi
Qty,Qty
Qty Consumed Per Unit,Qty Dikonsumsi Per Unit
Qty To Manufacture,Qty Untuk Industri
Qty as per Stock UOM,Qty per Saham UOM
Qty to Deliver,Qty untuk Menyampaikan
Qty to Order,Qty to Order
Qty to Receive,Qty untuk Menerima
Qty to Transfer,Jumlah Transfer
Qualification,Kualifikasi
Quality,Kualitas
Quality Inspection,Inspeksi Kualitas
Quality Inspection Parameters,Parameter Inspeksi Kualitas
Quality Inspection Reading,Inspeksi Kualitas Reading
Quality Inspection Readings,Bacaan Inspeksi Kualitas
Quality Inspection required for Item {0},Kualitas Inspeksi diperlukan untuk Item {0}
Quality Management,Manajemen Kualitas
Quantity,Kuantitas
Quantity Requested for Purchase,Kuantitas Diminta Pembelian
Quantity and Rate,Jumlah dan Tingkat
Quantity and Warehouse,Kuantitas dan Gudang
Quantity cannot be a fraction in row {0},Kuantitas tidak bisa menjadi fraksi di baris {0}
Quantity for Item {0} must be less than {1},Kuantitas untuk Item {0} harus kurang dari {1}
Quantity in row {0} ({1}) must be same as manufactured quantity {2},Jumlah berturut-turut {0} ({1}) harus sama dengan jumlah yang diproduksi {2}
Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Jumlah barang yang diperoleh setelah manufaktur / repacking dari mengingat jumlah bahan baku
Quantity required for Item {0} in row {1},Kuantitas yang dibutuhkan untuk Item {0} berturut-turut {1}
Quarter,Perempat
Quarterly,Triwulanan
Quick Help,Bantuan Cepat
Quotation,Kutipan
Quotation Item,Quotation Barang
Quotation Items,Quotation Items
Quotation Lost Reason,Quotation Kehilangan Alasan
Quotation Message,Quotation Pesan
Quotation To,Quotation Untuk
Quotation Trends,Quotation Trends
Quotation {0} is cancelled,Quotation {0} dibatalkan
Quotation {0} not of type {1},Quotation {0} bukan dari jenis {1}
Quotations received from Suppliers.,Kutipan yang diterima dari pemasok.
Quotes to Leads or Customers.,Harga untuk Memimpin atau Pelanggan.
Raise Material Request when stock reaches re-order level,Angkat Permintaan Bahan ketika saham mencapai tingkat re-order
Raised By,Dibesarkan Oleh
Raised By (Email),Dibesarkan Oleh (Email)
Random,Acak
Range,Jarak
Rate,Menilai
Rate ,
Rate (%),Rate (%)
Rate (Company Currency),Rate (Perusahaan Mata Uang)
Rate Of Materials Based On,Laju Bahan Berbasis On
Rate and Amount,Rate dan Jumlah
Rate at which Customer Currency is converted to customer's base currency,Tingkat di mana Pelanggan Mata Uang dikonversi ke mata uang dasar pelanggan
Rate at which Price list currency is converted to company's base currency,Tingkat di mana mata uang Daftar Harga dikonversi ke mata uang dasar perusahaan
Rate at which Price list currency is converted to customer's base currency,Tingkat di mana mata uang Daftar Harga dikonversi ke mata uang dasar pelanggan
Rate at which customer's currency is converted to company's base currency,Tingkat di mana mata uang pelanggan dikonversi ke mata uang dasar perusahaan
Rate at which supplier's currency is converted to company's base currency,Tingkat di mana mata uang pemasok dikonversi ke mata uang dasar perusahaan
Rate at which this tax is applied,Tingkat di mana pajak ini diterapkan
Raw Material,Bahan Baku
Raw Material Item Code,Bahan Baku Item Code
Raw Materials Supplied,Disediakan Bahan Baku
Raw Materials Supplied Cost,Biaya Bahan Baku Disediakan
Raw material cannot be same as main Item,Bahan baku tidak bisa sama dengan Butir utama
Re-Order Level,Re-Order Tingkat
Re-Order Qty,Re-Order Qty
Re-order,Re-order
Re-order Level,Re-order Tingkat
Re-order Qty,Re-order Qty
Read,Membaca
Reading 1,Membaca 1
Reading 10,Membaca 10
Reading 2,Membaca 2
Reading 3,Membaca 3
Reading 4,Membaca 4
Reading 5,Membaca 5
Reading 6,Membaca 6
Reading 7,Membaca 7
Reading 8,Membaca 8
Reading 9,Membaca 9
Real Estate,Real Estate
Reason,Alasan
Reason for Leaving,Alasan Meninggalkan
Reason for Resignation,Alasan pengunduran diri
Reason for losing,Alasan untuk kehilangan
Recd Quantity,Recd Kuantitas
Receivable,Piutang
Receivable / Payable account will be identified based on the field Master Type,Piutang akun / Hutang akan diidentifikasi berdasarkan bidang Guru Type
Receivables,Piutang
Receivables / Payables,Piutang / Hutang
Receivables Group,Piutang Grup
Received Date,Diterima Tanggal
Received Items To Be Billed,Produk Diterima Akan Ditagih
Received Qty,Diterima Qty
Received and Accepted,Diterima dan Diterima
Receiver List,Receiver Daftar
Receiver List is empty. Please create Receiver List,Receiver List kosong. Silakan membuat Receiver List
Receiver Parameter,Receiver Parameter
Recipients,Penerima
Reconcile,Mendamaikan
Reconciliation Data,Rekonsiliasi data
Reconciliation HTML,Rekonsiliasi HTML
Reconciliation JSON,Rekonsiliasi JSON
Record item movement.,Gerakan barang Rekam.
Recurring Id,Berulang Id
Recurring Invoice,Faktur Berulang
Recurring Type,Berulang Type
Reduce Deduction for Leave Without Pay (LWP),Mengurangi Pengurangan untuk Tinggalkan Tanpa Bayar (LWP)
Reduce Earning for Leave Without Pay (LWP),Mengurangi Produktif untuk Tinggalkan Tanpa Bayar (LWP)
Ref,Ref
Ref Code,Ref Kode
Ref SQ,Ref SQ
Reference,Referensi
Reference #{0} dated {1},Referensi # {0} tanggal {1}
Reference Date,Referensi Tanggal
Reference Name,Referensi Nama
Reference No & Reference Date is required for {0},Referensi ada & Referensi Tanggal diperlukan untuk {0}
Reference No is mandatory if you entered Reference Date,Referensi ada adalah wajib jika Anda memasukkan Referensi Tanggal
Reference Number,Nomor Referensi
Reference Row #,Referensi Row #
Refresh,Segarkan
Registration Details,Detail Pendaftaran
Registration Info,Info Pendaftaran
Rejected,Ditolak
Rejected Quantity,Ditolak Kuantitas
Rejected Serial No,Ditolak Serial No
Rejected Warehouse,Gudang Ditolak
Rejected Warehouse is mandatory against regected item,Gudang Ditolak adalah wajib terhadap barang regected
Relation,Hubungan
Relieving Date,Menghilangkan Tanggal
Relieving Date must be greater than Date of Joining,Menghilangkan Tanggal harus lebih besar dari Tanggal Bergabung
Remark,Komentar
Remarks,Keterangan
Remarks Custom,Keterangan Kustom
Rename,Ubah nama
Rename Log,Rename Log
Rename Tool,Rename Alat
Rent Cost,Sewa Biaya
Rent per hour,Sewa per jam
Rented,Sewaan
Repeat on Day of Month,Ulangi pada Hari Bulan
Replace,Mengganti
Replace Item / BOM in all BOMs,Ganti Barang / BOM di semua BOMs
Replied,Menjawab
Report Date,Tanggal Laporan
Report Type,Jenis Laporan
Report Type is mandatory,Jenis Laporan adalah wajib
Reports to,Laporan untuk
Reqd By Date,Reqd By Date
Reqd by Date,Reqd berdasarkan Tanggal
Request Type,Permintaan Type
Request for Information,Request for Information
Request for purchase.,Permintaan pembelian.
Requested,Diminta
Requested For,Diminta Untuk
Requested Items To Be Ordered,Produk Diminta Akan Memerintahkan
Requested Items To Be Transferred,Produk Diminta Akan Ditransfer
Requested Qty,Diminta Qty
"Requested Qty: Quantity requested for purchase, but not ordered.","Diminta Qty: Jumlah yang diminta untuk pembelian, tetapi tidak memerintahkan."
Requests for items.,Permintaan untuk item.
Required By,Diperlukan Oleh
Required Date,Diperlukan Tanggal
Required Qty,Diperlukan Qty
Required only for sample item.,Diperlukan hanya untuk item sampel.
Required raw materials issued to the supplier for producing a sub - contracted item.,Bahan baku yang dibutuhkan dikeluarkan ke pemasok untuk memproduksi sub - item yang dikontrak.
Research,Penelitian
Research & Development,Penelitian & Pengembangan
Researcher,Peneliti
Reseller,Reseller
Reserved,Reserved
Reserved Qty,Reserved Qty
"Reserved Qty: Quantity ordered for sale, but not delivered.","Reserved Qty: Jumlah memerintahkan untuk dijual, tapi tidak disampaikan."
Reserved Quantity,Reserved Kuantitas
Reserved Warehouse,Gudang Reserved
Reserved Warehouse in Sales Order / Finished Goods Warehouse,Reserved Gudang di Sales Order / Barang Jadi Gudang
Reserved Warehouse is missing in Sales Order,Gudang Reserved hilang di Sales Order
Reserved Warehouse required for stock Item {0} in row {1},Reserved Gudang diperlukan untuk stok Barang {0} berturut-turut {1}
Reserved warehouse required for stock item {0},Reserved gudang diperlukan untuk item saham {0}
Reserves and Surplus,Cadangan dan Surplus
Reset Filters,Atur Ulang Filter
Resignation Letter Date,Surat Pengunduran Diri Tanggal
Resolution,Resolusi
Resolution Date,Resolusi Tanggal
Resolution Details,Detail Resolusi
Resolved By,Terselesaikan Dengan
Rest Of The World,Istirahat Of The World
Retail,Eceran
Retail & Wholesale,Retail & Grosir
Retailer,Pengecer
Review Date,Ulasan Tanggal
Rgt,Rgt
Role Allowed to edit frozen stock,Peran Diizinkan untuk mengedit saham beku
Role that is allowed to submit transactions that exceed credit limits set.,Peran yang diperbolehkan untuk mengirimkan transaksi yang melebihi batas kredit yang ditetapkan.
Root Type,Akar Type
Root Type is mandatory,Akar Type adalah wajib
Root account can not be deleted,Account root tidak bisa dihapus
Root cannot be edited.,Root tidak dapat diedit.
Root cannot have a parent cost center,Root tidak dapat memiliki pusat biaya orang tua
Rounded Off,Rounded Off
Rounded Total,Rounded Jumlah
Rounded Total (Company Currency),Rounded Jumlah (Perusahaan Mata Uang)
Row # ,
Row # {0}: ,
Row #{0}: Ordered qty can not less than item's minimum order qty (defined in item master).,Row # {0}: qty Memerintahkan tidak bisa kurang dari minimum qty pesanan item (didefinisikan dalam master barang).
Row #{0}: Please specify Serial No for Item {1},Row # {0}: Silakan tentukan Serial ada untuk Item {1}
Row {0}: Account does not match with \						Purchase Invoice Credit To account,Row {0}: Akun tidak cocok dengan \ Purchase Invoice Kredit Untuk account
Row {0}: Account does not match with \						Sales Invoice Debit To account,Row {0}: Akun tidak cocok dengan \ Penjualan Faktur Debit Untuk account
Row {0}: Conversion Factor is mandatory,Row {0}: Faktor Konversi adalah wajib
Row {0}: Credit entry can not be linked with a Purchase Invoice,Row {0}: entry Kredit tidak dapat dihubungkan dengan Faktur Pembelian
Row {0}: Debit entry can not be linked with a Sales Invoice,Row {0}: entry Debit tidak dapat dihubungkan dengan Faktur Penjualan
Row {0}: Payment amount must be less than or equals to invoice outstanding amount. Please refer Note below.,Row {0}: Jumlah pembayaran harus kurang dari atau sama dengan faktur jumlah yang terhutang. Silakan lihat Catatan di bawah.
Row {0}: Qty is mandatory,Row {0}: Qty adalah wajib
"Row {0}: Qty not avalable in warehouse {1} on {2} {3}.					Available Qty: {4}, Transfer Qty: {5}","Row {0}: Qty tidak avalable di gudang {1} pada {2} {3}. Qty Tersedia: {4}, transfer Qty: {5}"
"Row {0}: To set {1} periodicity, difference between from and to date \						must be greater than or equal to {2}","Row {0}: Untuk mengatur {1} periodisitas, perbedaan antara dari dan sampai saat ini \ harus lebih besar dari atau sama dengan {2}"
Row {0}:Start Date must be before End Date,Row {0}: Tanggal awal harus sebelum Tanggal Akhir
Rules for adding shipping costs.,Aturan untuk menambahkan biaya pengiriman.
Rules for applying pricing and discount.,Aturan untuk menerapkan harga dan diskon.
Rules to calculate shipping amount for a sale,Aturan untuk menghitung jumlah pengiriman untuk penjualan
S.O. No.,SO No
SHE Cess on Excise,SHE Cess tentang Cukai
SHE Cess on Service Tax,SHE CESS Pajak Layanan
SHE Cess on TDS,SHE Cess pada TDS
SMS Center,SMS Center
SMS Gateway URL,SMS Gateway URL
SMS Log,SMS Log
SMS Parameter,Parameter SMS
SMS Sender Name,Pengirim SMS Nama
SMS Settings,Pengaturan SMS
SO Date,SO Tanggal
SO Pending Qty,SO Pending Qty
SO Qty,SO Qty
Salary,Gaji
Salary Information,Informasi Gaji
Salary Manager,Gaji Manajer
Salary Mode,Modus Gaji
Salary Slip,Slip Gaji
Salary Slip Deduction,Slip Gaji Pengurangan
Salary Slip Earning,Slip Gaji Produktif
Salary Slip of employee {0} already created for this month,Slip Gaji karyawan {0} sudah diciptakan untuk bulan ini
Salary Structure,Struktur Gaji
Salary Structure Deduction,Struktur Gaji Pengurangan
Salary Structure Earning,Struktur Gaji Produktif
Salary Structure Earnings,Laba Struktur Gaji
Salary breakup based on Earning and Deduction.,Gaji perpisahan berdasarkan Produktif dan Pengurangan.
Salary components.,Komponen gaji.
Salary template master.,Master Gaji Template.
Sales,Penjualan
Sales Analytics,Penjualan Analytics
Sales BOM,Penjualan BOM
Sales BOM Help,Penjualan BOM Bantuan
Sales BOM Item,Penjualan BOM Barang
Sales BOM Items,Penjualan BOM Items
Sales Browser,Penjualan Browser
Sales Details,Detail Penjualan
Sales Discounts,Penjualan Diskon
Sales Email Settings,Pengaturan Penjualan Email
Sales Expenses,Beban Penjualan
Sales Extras,Penjualan Ekstra
Sales Funnel,Penjualan Saluran
Sales Invoice,Faktur Penjualan
Sales Invoice Advance,Faktur Penjualan Muka
Sales Invoice Item,Faktur Penjualan Barang
Sales Invoice Items,Faktur Penjualan Produk
Sales Invoice Message,Penjualan Faktur Pesan
Sales Invoice No,Penjualan Faktur ada
Sales Invoice Trends,Faktur Penjualan Trends
Sales Invoice {0} has already been submitted,Faktur Penjualan {0} telah disampaikan
Sales Invoice {0} must be cancelled before cancelling this Sales Order,Faktur Penjualan {0} harus dibatalkan sebelum membatalkan Sales Order ini
Sales Order,Sales Order
Sales Order Date,Sales Order Tanggal
Sales Order Item,Sales Order Barang
Sales Order Items,Sales Order Items
Sales Order Message,Sales Order Pesan
Sales Order No,Sales Order No
Sales Order Required,Sales Order Diperlukan
Sales Order Trends,Sales Order Trends
Sales Order required for Item {0},Sales Order yang diperlukan untuk Item {0}
Sales Order {0} is not submitted,Sales Order {0} tidak disampaikan
Sales Order {0} is not valid,Sales Order {0} tidak valid
Sales Order {0} is stopped,Sales Order {0} dihentikan
Sales Partner,Penjualan Mitra
Sales Partner Name,Penjualan Mitra Nama
Sales Partner Target,Penjualan Mitra Sasaran
Sales Partners Commission,Penjualan Mitra Komisi
Sales Person,Penjualan Orang
Sales Person Name,Penjualan Person Nama
Sales Person Target Variance Item Group-Wise,Penjualan Orang Sasaran Variance Barang Group-Wise
Sales Person Targets,Target Penjualan Orang
Sales Person-wise Transaction Summary,Penjualan Orang-bijaksana Rangkuman Transaksi
Sales Register,Daftar Penjualan
Sales Return,Penjualan Kembali
Sales Returned,Penjualan Kembali
Sales Taxes and Charges,Pajak Penjualan dan Biaya
Sales Taxes and Charges Master,Penjualan Pajak dan Biaya Guru
Sales Team,Tim Penjualan
Sales Team Details,Rincian Tim Penjualan
Sales Team1,Penjualan team1
Sales and Purchase,Penjualan dan Pembelian
Sales campaigns.,Kampanye penjualan.
Salutation,Salam
Sample Size,Ukuran Sampel
Sanctioned Amount,Jumlah sanksi
Saturday,Sabtu
Schedule,Jadwal
Schedule Date,Jadwal Tanggal
Schedule Details,Jadwal Detail
Scheduled,Dijadwalkan
Scheduled Date,Dijadwalkan Tanggal
Scheduled to send to {0},Dijadwalkan untuk mengirim ke {0}
Scheduled to send to {0} recipients,Dijadwalkan untuk mengirim ke {0} penerima
Scheduler Failed Events,Acara Scheduler Gagal
School/University,Sekolah / Universitas
Score (0-5),Skor (0-5)
Score Earned,Skor Earned
Score must be less than or equal to 5,Skor harus kurang dari atau sama dengan 5
Scrap %,Scrap%
Seasonality for setting budgets.,Musiman untuk menetapkan anggaran.
Secretary,Sekretaris
Secured Loans,Pinjaman Aman
Securities & Commodity Exchanges,Efek & Bursa Komoditi
Securities and Deposits,Efek dan Deposit
"See ""Rate Of Materials Based On"" in Costing Section","Lihat ""Rate Of Material Berbasis"" dalam Biaya Bagian"
"Select ""Yes"" for sub - contracting items","Pilih ""Ya"" untuk sub - kontraktor item"
"Select ""Yes"" if this item is used for some internal purpose in your company.","Pilih ""Ya"" jika item ini digunakan untuk tujuan internal perusahaan Anda."
"Select ""Yes"" if this item represents some work like training, designing, consulting etc.","Pilih ""Ya"" jika item ini mewakili beberapa pekerjaan seperti pelatihan, merancang, konsultasi dll"
"Select ""Yes"" if you are maintaining stock of this item in your Inventory.","Pilih ""Ya"" jika Anda mempertahankan stok item dalam persediaan Anda."
"Select ""Yes"" if you supply raw materials to your supplier to manufacture this item.","Pilih ""Ya"" jika Anda memasok bahan baku ke pemasok Anda untuk memproduksi item ini."
Select Brand...,Pilih Merek ...
Select Budget Distribution to unevenly distribute targets across months.,Pilih Distribusi Anggaran untuk merata mendistribusikan target di bulan.
"Select Budget Distribution, if you want to track based on seasonality.","Pilih Distribusi Anggaran, jika Anda ingin melacak berdasarkan musim."
Select Company...,Pilih Perusahaan ...
Select DocType,Pilih DocType
Select Fiscal Year...,Pilih Tahun Anggaran ...
Select Items,Pilih Produk
Select Project...,Pilih Project ...
Select Purchase Receipts,Pilih Penerimaan Pembelian
Select Sales Orders,Pilih Pesanan Penjualan
Select Sales Orders from which you want to create Production Orders.,Pilih Penjualan Pesanan dari mana Anda ingin membuat Pesanan Produksi.
Select Time Logs and Submit to create a new Sales Invoice.,Pilih Waktu Log dan Kirim untuk membuat Faktur Penjualan baru.
Select Transaction,Pilih Transaksi
Select Warehouse...,Pilih Gudang ...
Select Your Language,Pilih Bahasa Anda
Select account head of the bank where cheque was deposited.,Pilih kepala rekening bank mana cek diendapkan.
Select company name first.,Pilih nama perusahaan pertama.
Select template from which you want to get the Goals,Pilih template dari mana Anda ingin mendapatkan Goals
Select the Employee for whom you are creating the Appraisal.,Pilih Karyawan untuk siapa Anda menciptakan Appraisal.
Select the period when the invoice will be generated automatically,Pilih periode ketika invoice akan dibuat secara otomatis
Select the relevant company name if you have multiple companies,Pilih nama perusahaan yang bersangkutan jika Anda memiliki beberapa perusahaan
Select the relevant company name if you have multiple companies.,Pilih nama perusahaan yang bersangkutan jika Anda memiliki beberapa perusahaan.
Select who you want to send this newsletter to,Pilih yang Anda ingin mengirim newsletter ini untuk
Select your home country and check the timezone and currency.,Pilih negara asal Anda dan memeriksa zona waktu dan mata uang.
"Selecting ""Yes"" will allow this item to appear in Purchase Order , Purchase Receipt.","Memilih ""Ya"" akan memungkinkan item ini muncul di Purchase Order, Penerimaan Pembelian."
"Selecting ""Yes"" will allow this item to figure in Sales Order, Delivery Note","Memilih ""Ya"" akan memungkinkan item ini untuk mencari di Sales Order, Delivery Note"
"Selecting ""Yes"" will allow you to create Bill of Material showing raw material and operational costs incurred to manufacture this item.","Memilih ""Ya"" akan memungkinkan Anda untuk membuat Bill dari Material menunjukkan bahan baku dan biaya operasional yang dikeluarkan untuk memproduksi item ini."
"Selecting ""Yes"" will allow you to make a Production Order for this item.","Memilih ""Ya"" akan memungkinkan Anda untuk membuat Order Produksi untuk item ini."
"Selecting ""Yes"" will give a unique identity to each entity of this item which can be viewed in the Serial No master.","Memilih ""Ya"" akan memberikan identitas unik untuk setiap entitas dari produk ini yang dapat dilihat dalam Serial No guru."
Selling,Penjualan
Selling Settings,Jual Pengaturan
"Selling must be checked, if Applicable For is selected as {0}","Jual harus diperiksa, jika Berlaku Untuk dipilih sebagai {0}"
Send,Kirim
Send Autoreply,Kirim Autoreply
Send Email,Kirim Email
Send From,Kirim Dari
Send Notifications To,Kirim Pemberitahuan Untuk
Send Now,Kirim sekarang
Send SMS,Kirim SMS
Send To,Kirim Ke
Send To Type,Kirim ke Ketik
Send mass SMS to your contacts,Kirim SMS massal ke kontak Anda
Send to this list,Kirim ke daftar ini
Sender Name,Pengirim Nama
Sent On,Dikirim Pada
Separate production order will be created for each finished good item.,Order produksi yang terpisah akan dibuat untuk setiap item barang jadi.
Serial No,Serial ada
Serial No / Batch,Serial No / Batch
Serial No Details,Serial Tidak Detail
Serial No Service Contract Expiry,Serial No Layanan Kontrak kadaluarsa
Serial No Status,Serial ada Status
Serial No Warranty Expiry,Serial No Garansi kadaluarsa
Serial No is mandatory for Item {0},Serial ada adalah wajib untuk Item {0}
Serial No {0} created,Serial ada {0} dibuat
Serial No {0} does not belong to Delivery Note {1},Serial ada {0} bukan milik Pengiriman Note {1}
Serial No {0} does not belong to Item {1},Serial ada {0} bukan milik Barang {1}
Serial No {0} does not belong to Warehouse {1},Serial ada {0} bukan milik Gudang {1}
Serial No {0} does not exist,Serial ada {0} tidak ada
Serial No {0} has already been received,Serial ada {0} telah diterima
Serial No {0} is under maintenance contract upto {1},Serial ada {0} berada di bawah kontrak pemeliharaan upto {1}
Serial No {0} is under warranty upto {1},Serial ada {0} masih dalam garansi upto {1}
Serial No {0} not in stock,Serial ada {0} bukan dalam stok
Serial No {0} quantity {1} cannot be a fraction,Serial ada {0} kuantitas {1} tak bisa menjadi pecahan
Serial No {0} status must be 'Available' to Deliver,Tidak ada Status {0} Serial harus 'Tersedia' untuk Menyampaikan
Serial Nos Required for Serialized Item {0},Serial Nos Diperlukan untuk Serial Barang {0}
Serial Number Series,Serial Number Series
Serial number {0} entered more than once,Serial number {0} masuk lebih dari sekali
Serialized Item {0} cannot be updated \					using Stock Reconciliation,Serial Barang {0} tidak dapat diperbarui \ menggunakan Stock Rekonsiliasi
Series,Seri
Series List for this Transaction,Daftar Series Transaksi ini
Series Updated,Seri Diperbarui
Series Updated Successfully,Seri Diperbarui Berhasil
Series is mandatory,Series adalah wajib
Series {0} already used in {1},Seri {0} sudah digunakan dalam {1}
Service,Layanan
Service Address,Layanan Alamat
Service Tax,Pelayanan Pajak
Services,Layanan
Set,Tetapkan
"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Set Nilai Default seperti Perusahaan, Mata Uang, Tahun Anggaran Current, dll"
Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Menetapkan anggaran Group-bijaksana Barang di Wilayah ini. Anda juga bisa memasukkan musiman dengan menetapkan Distribusi.
Set Status as Available,Set Status sebagai Tersedia
Set as Default,Set sebagai Default
Set as Lost,Set as Hilang
Set prefix for numbering series on your transactions,Mengatur awalan untuk penomoran seri pada transaksi Anda
Set targets Item Group-wise for this Sales Person.,Target Set Barang Group-bijaksana untuk Penjualan Orang ini.
Setting Account Type helps in selecting this Account in transactions.,Mengatur Tipe Akun membantu dalam memilih Akun ini dalam transaksi.
Setting this Address Template as default as there is no other default,Mengatur Template Alamat ini sebagai default karena tidak ada standar lainnya
Setting up...,Menyiapkan ...
Settings,Pengaturan
Settings for HR Module,Pengaturan untuk modul HR
"Settings to extract Job Applicants from a mailbox e.g. ""jobs@example.com""","Pengaturan untuk mengekstrak Job Pelamar dari misalnya mailbox ""jobs@example.com"""
Setup,Pengaturan
Setup Already Complete!!,Pengaturan Sudah Selesai!!
Setup Complete,Pengaturan Selesai
Setup SMS gateway settings,Pengaturan gerbang Pengaturan SMS
Setup Series,Pengaturan Series
Setup Wizard,Setup Wizard
Setup incoming server for jobs email id. (e.g. jobs@example.com),Pengaturan server masuk untuk pekerjaan email id. (Misalnya jobs@example.com)
Setup incoming server for sales email id. (e.g. sales@example.com),Pengaturan server masuk untuk email penjualan id. (Misalnya sales@example.com)
Setup incoming server for support email id. (e.g. support@example.com),Pengaturan server masuk untuk email dukungan id. (Misalnya support@example.com)
Share,Bagikan
Share With,Dengan berbagi
Shareholders Funds,Pemegang Saham Dana
Shipments to customers.,Pengiriman ke pelanggan.
Shipping,Pengiriman
Shipping Account,Account Pengiriman
Shipping Address,Alamat Pengiriman
Shipping Amount,Pengiriman Jumlah
Shipping Rule,Aturan Pengiriman
Shipping Rule Condition,Aturan Pengiriman Kondisi
Shipping Rule Conditions,Aturan Pengiriman Kondisi
Shipping Rule Label,Peraturan Pengiriman Label
Shop,Toko
Shopping Cart,Daftar Belanja
Short biography for website and other publications.,Biografi singkat untuk website dan publikasi lainnya.
"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Tampilkan ""In Stock"" atau ""Tidak di Bursa"" didasarkan pada stok yang tersedia di gudang ini."
"Show / Hide features like Serial Nos, POS etc.","Tampilkan / Sembunyikan fitur seperti Serial Nos, POS dll"
Show In Website,Tampilkan Di Website
Show a slideshow at the top of the page,Tampilkan slideshow di bagian atas halaman
Show in Website,Tampilkan Website
Show rows with zero values,Tampilkan baris dengan nilai nol
Show this slideshow at the top of the page,Tampilkan slide ini di bagian atas halaman
Sick Leave,Cuti Sakit
Signature,Tanda Tangan
Signature to be appended at the end of every email,Tanda tangan yang akan ditambahkan pada akhir setiap email
Single,Tunggal
Single unit of an Item.,Unit tunggal Item.
Sit tight while your system is being setup. This may take a few moments.,Duduk diam sementara sistem anda sedang setup. Ini mungkin memerlukan beberapa saat.
Slideshow,Rangkai Salindia
Soap & Detergent,Sabun & Deterjen
Software,Perangkat lunak
Software Developer,Software Developer
"Sorry, Serial Nos cannot be merged","Maaf, Serial Nos tidak dapat digabungkan"
"Sorry, companies cannot be merged","Maaf, perusahaan tidak dapat digabungkan"
Source,Sumber
Source File,File Sumber
Source Warehouse,Sumber Gudang
Source and target warehouse cannot be same for row {0},Sumber dan target gudang tidak bisa sama untuk baris {0}
Source of Funds (Liabilities),Sumber Dana (Kewajiban)
Source warehouse is mandatory for row {0},Sumber gudang adalah wajib untuk baris {0}
Spartan,Tabah
"Special Characters except ""-"" and ""/"" not allowed in naming series","Karakter khusus kecuali ""-"" dan ""/"" tidak diperbolehkan dalam penamaan seri"
Specification Details,Detail Spesifikasi
Specifications,Spesifikasi
"Specify a list of Territories, for which, this Price List is valid","Tentukan daftar Territories, yang, Daftar Harga ini berlaku"
"Specify a list of Territories, for which, this Shipping Rule is valid","Tentukan daftar Territories, yang, Aturan Pengiriman ini berlaku"
"Specify a list of Territories, for which, this Taxes Master is valid","Tentukan daftar Territories, yang, ini Pajak Guru berlaku"
"Specify the operations, operating cost and give a unique Operation no to your operations.","Tentukan operasi, biaya operasi dan memberikan Operation unik ada pada operasi Anda."
Split Delivery Note into packages.,Membagi Pengiriman Catatan ke dalam paket.
Sports,Olahraga
Sr,Sr
Standard,Standar
Standard Buying,Standard Membeli
Standard Reports,Laporan standar
Standard Selling,Standard Jual
Standard contract terms for Sales or Purchase.,Ketentuan kontrak standar untuk Penjualan atau Pembelian.
Start,Mulai
Start Date,Tanggal Mulai
Start date of current invoice's period,Tanggal faktur periode saat ini mulai
Start date should be less than end date for Item {0},Tanggal mulai harus kurang dari tanggal akhir untuk Item {0}
State,Propinsi
Statement of Account,Pernyataan Rekening
Static Parameters,Parameter Statis
Status,Status
Status must be one of {0},Status harus menjadi salah satu {0}
Status of {0} {1} is now {2},Status {0} {1} sekarang {2}
Status updated to {0},Status diperbarui ke {0}
Statutory info and other general information about your Supplier,Info Statutory dan informasi umum lainnya tentang Pemasok Anda
Stay Updated,Tetap Diperbarui
Stock,Stock
Stock Adjustment,Penyesuaian Stock
Stock Adjustment Account,Penyesuaian Stock Akun
Stock Ageing,Stock Penuaan
Stock Analytics,Stock Analytics
Stock Assets,Aset saham
Stock Balance,Stock Balance
Stock Entries already created for Production Order ,
Stock Entry,Stock Entri
Stock Entry Detail,Stock Masuk Detil
Stock Expenses,Beban saham
Stock Frozen Upto,Stock Frozen Upto
Stock Ledger,Bursa Ledger
Stock Ledger Entry,Bursa Ledger entri
Stock Ledger entries balances updated,Bursa Ledger entri saldo diperbarui
Stock Level,Tingkat Stock
Stock Liabilities,Kewajiban saham
Stock Projected Qty,Stock Proyeksi Jumlah
Stock Queue (FIFO),Stock Queue (FIFO)
Stock Received But Not Billed,Stock Diterima Tapi Tidak Ditagih
Stock Reconcilation Data,Stock rekonsiliasi data
Stock Reconcilation Template,Stock rekonsiliasi Template
Stock Reconciliation,Stock Rekonsiliasi
"Stock Reconciliation can be used to update the stock on a particular date, usually as per physical inventory.","Stock Rekonsiliasi dapat digunakan untuk memperbarui saham pada tanggal tertentu, biasanya sesuai persediaan fisik."
Stock Settings,Pengaturan saham
Stock UOM,Stock UOM
Stock UOM Replace Utility,Stock UOM Ganti Utilitas
Stock UOM updatd for Item {0},Saham UOM updatd untuk Item {0}
Stock Uom,Stock UoM
Stock Value,Nilai saham
Stock Value Difference,Nilai saham Perbedaan
Stock balances updated,Saldo saham diperbarui
Stock cannot be updated against Delivery Note {0},Stock tidak dapat diperbarui terhadap Delivery Note {0}
Stock entries exist against warehouse {0} cannot re-assign or modify 'Master Name',Entri Stock ada terhadap gudang {0} tidak dapat menetapkan kembali atau memodifikasi 'Guru Nama'
Stock transactions before {0} are frozen,Transaksi saham sebelum {0} dibekukan
Stop,Berhenti
Stop Birthday Reminders,Berhenti Ulang Tahun Pengingat
Stop Material Request,Berhenti Material Permintaan
Stop users from making Leave Applications on following days.,Menghentikan pengguna dari membuat Aplikasi Leave pada hari-hari berikutnya.
Stop!,Berhenti!
Stopped,Terhenti
Stopped order cannot be cancelled. Unstop to cancel.,Agar Berhenti tidak dapat dibatalkan. Unstop untuk membatalkan.
Stores,Toko
Stub,Puntung
Sub Assemblies,Sub Assemblies
"Sub-currency. For e.g. ""Cent""","Sub-currency. Untuk misalnya ""Cent """
Subcontract,Kontrak tambahan
Subject,Perihal
Submit Salary Slip,Kirim Slip Gaji
Submit all salary slips for the above selected criteria,Menyerahkan semua slip gaji kriteria pilihan di atas
Submit this Production Order for further processing.,Kirim Produksi ini Order untuk diproses lebih lanjut.
Submitted,Dikirim
Subsidiary,Anak Perusahaan
Successful: ,
Successfully Reconciled,Berhasil Berdamai
Suggestions,Saran
Sunday,Minggu
Supplier,Pemasok
Supplier (Payable) Account,Pemasok (Hutang) Rekening
Supplier (vendor) name as entered in supplier master,Pemasok (vendor) nama sebagai dimasukkan dalam pemasok utama
Supplier > Supplier Type,Pemasok> Pemasok Type
Supplier Account Head,Pemasok Akun Kepala
Supplier Address,Pemasok Alamat
Supplier Addresses and Contacts,Pemasok Alamat dan Kontak
Supplier Details,Pemasok Rincian
Supplier Intro,Pemasok Intro
Supplier Invoice Date,Pemasok Faktur Tanggal
Supplier Invoice No,Pemasok Faktur ada
Supplier Name,Pemasok Nama
Supplier Naming By,Pemasok Penamaan Dengan
Supplier Part Number,Pemasok Part Number
Supplier Quotation,Pemasok Quotation
Supplier Quotation Item,Pemasok Barang Quotation
Supplier Reference,Pemasok Referensi
Supplier Type,Pemasok Type
Supplier Type / Supplier,Pemasok Type / Pemasok
Supplier Type master.,Pemasok Type induk.
Supplier Warehouse,Pemasok Gudang
Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Pemasok Gudang wajib untuk Pembelian Penerimaan sub-kontrak
Supplier database.,Database Supplier.
Supplier master.,Pemasok utama.
Supplier warehouse where you have issued raw materials for sub - contracting,Pemasok gudang di mana Anda telah mengeluarkan bahan baku untuk sub - kontraktor
Supplier-Wise Sales Analytics,Pemasok-Wise Penjualan Analytics
Support,Mendukung
Support Analtyics,Dukungan Analtyics
Support Analytics,Dukungan Analytics
Support Email,Dukungan Email
Support Email Settings,Dukungan Pengaturan Email
Support Password,Dukungan Sandi
Support Ticket,Dukungan Tiket
Support queries from customers.,Permintaan dukungan dari pelanggan.
Symbol,simbol
Sync Support Mails,Sync Dukungan Email
Sync with Dropbox,Sinkron dengan Dropbox
Sync with Google Drive,Sinkronisasi dengan Google Drive
System,Sistem
System Settings,Pengaturan Sistem
"System User (login) ID. If set, it will become default for all HR forms.","Pengguna Sistem (login) ID. Jika diset, itu akan menjadi default untuk semua bentuk HR."
TDS (Advertisement),TDS (Iklan)
TDS (Commission),TDS (Komisi)
TDS (Contractor),TDS (Kontraktor)
TDS (Interest),TDS (Interest)
TDS (Rent),TDS (Rent)
TDS (Salary),TDS (Gaji)
Target  Amount,Target Jumlah
Target Detail,Sasaran Detil
Target Details,Sasaran Detail
Target Details1,Sasaran Details1
Target Distribution,Target Distribusi
Target On,Sasaran On
Target Qty,Sasaran Qty
Target Warehouse,Target Gudang
Target warehouse in row {0} must be same as Production Order,Target gudang di baris {0} harus sama dengan Orde Produksi
Target warehouse is mandatory for row {0},Target gudang adalah wajib untuk baris {0}
Task,Tugas
Task Details,Rincian Tugas
Tasks,Tugas
Tax,PPN
Tax Amount After Discount Amount,Jumlah pajak Setelah Diskon Jumlah
Tax Assets,Aset pajak
Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,Pajak Kategori tidak bisa 'Penilaian' atau 'Penilaian dan Total' karena semua item item non-saham
Tax Rate,Tarif Pajak
Tax and other salary deductions.,Pajak dan pemotongan gaji lainnya.
Tax detail table fetched from item master as a string and stored in this field.Used for Taxes and Charges,Tabel rinci Pajak diambil dari master barang sebagai string dan disimpan dalam bidang ini. Digunakan untuk Pajak dan Biaya
Tax template for buying transactions.,Template pajak untuk membeli transaksi.
Tax template for selling transactions.,Template Pajak menjual transaksi.
Taxable,Kena PPN
Taxes,PPN
Taxes and Charges,Pajak dan Biaya
Taxes and Charges Added,Pajak dan Biaya Ditambahkan
Taxes and Charges Added (Company Currency),Pajak dan Biaya Ditambahkan (Perusahaan Mata Uang)
Taxes and Charges Calculation,Pajak dan Biaya Perhitungan
Taxes and Charges Deducted,Pajak dan Biaya Dikurangi
Taxes and Charges Deducted (Company Currency),Pajak dan Biaya Dikurangi (Perusahaan Mata Uang)
Taxes and Charges Total,Pajak dan Biaya Jumlah
Taxes and Charges Total (Company Currency),Pajak dan Biaya Jumlah (Perusahaan Mata Uang)
Technology,Teknologi
Telecommunications,Telekomunikasi
Telephone Expenses,Beban Telepon
Television,Televisi
Template,Contoh
Template for performance appraisals.,Template untuk penilaian kinerja.
Template of terms or contract.,Template istilah atau kontrak.
Temporary Accounts (Assets),Akun Sementara (Aset)
Temporary Accounts (Liabilities),Akun Sementara (Kewajiban)
Temporary Assets,Aset Temporary
Temporary Liabilities,Kewajiban Sementara
Term Details,Rincian Term
Terms,Istilah
Terms and Conditions,Syarat dan Ketentuan
Terms and Conditions Content,Syarat dan Ketentuan Konten
Terms and Conditions Details,Syarat dan Ketentuan Detail
Terms and Conditions Template,Syarat dan Ketentuan Template
Terms and Conditions1,Syarat dan Conditions1
Terretory,Terretory
Territory,Wilayah
Territory / Customer,Wilayah / Pelanggan
Territory Manager,Territory Manager
Territory Name,Wilayah Nama
Territory Target Variance Item Group-Wise,Wilayah Sasaran Variance Barang Group-Wise
Territory Targets,Target Wilayah
Test,tes
Test Email Id,Uji Email Id
Test the Newsletter,Uji Newsletter
The BOM which will be replaced,BOM yang akan diganti
The First User: You,Pengguna Pertama: Anda
"The Item that represents the Package. This Item must have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes""","Item yang mewakili Paket tersebut. Barang ini harus ""Apakah Stock Item"" sebagai ""Tidak"" dan ""Apakah Penjualan Item"" sebagai ""Ya"""
The Organization,Organisasi
"The account head under Liability, in which Profit/Loss will be booked","Account kepala di bawah Kewajiban, di mana Laba / Rugi akan dipesan"
The date on which next invoice will be generated. It is generated on submit.,Tanggal dimana faktur berikutnya akan dihasilkan. Hal ini dihasilkan di submit.
The date on which recurring invoice will be stop,Tanggal dimana berulang faktur akan berhenti
"The day of the month on which auto invoice will be generated e.g. 05, 28 etc ",
The day(s) on which you are applying for leave are holiday. You need not apply for leave.,Hari (s) yang Anda lamar untuk cuti adalah liburan. Anda tidak perlu mengajukan cuti.
The first Leave Approver in the list will be set as the default Leave Approver,The Approver Cuti pertama dalam daftar akan ditetapkan sebagai default Tinggalkan Approver
The first user will become the System Manager (you can change that later).,Pengguna pertama akan menjadi System Manager (Anda dapat mengubah nanti).
The gross weight of the package. Usually net weight + packaging material weight. (for print),Berat kotor paket. Berat + kemasan biasanya net berat bahan. (Untuk mencetak)
The name of your company for which you are setting up this system.,Nama perusahaan Anda yang Anda sedang mengatur sistem ini.
The net weight of this package. (calculated automatically as sum of net weight of items),Berat bersih package ini. (Dihitung secara otomatis sebagai jumlah berat bersih item)
The new BOM after replacement,The BOM baru setelah penggantian
The rate at which Bill Currency is converted into company's base currency,Tingkat di mana Bill Currency diubah menjadi mata uang dasar perusahaan
The unique id for tracking all recurring invoices. It is generated on submit.,Id yang unik untuk melacak semua tagihan berulang. Hal ini dihasilkan di submit.
"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Kemudian Pricing Aturan disaring berdasarkan Pelanggan, Kelompok Pelanggan, Wilayah, Supplier, Supplier Type, Kampanye, Penjualan Mitra dll"
There are more holidays than working days this month.,Ada lebih dari hari kerja libur bulan ini.
"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Hanya ada satu Peraturan Pengiriman Kondisi dengan nilai kosong atau 0 untuk ""To Nilai"""
There is not enough leave balance for Leave Type {0},Tidak ada saldo cuti cukup bagi Leave Type {0}
There is nothing to edit.,Tidak ada yang mengedit.
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.,Ada kesalahan. Salah satu alasan yang mungkin bisa jadi Anda belum menyimpan formulir. Silahkan hubungi support@erpnext.com jika masalah terus berlanjut.
There were errors.,Ada kesalahan.
This Currency is disabled. Enable to use in transactions,Mata uang ini dinonaktifkan. Aktifkan untuk digunakan dalam transaksi
This Leave Application is pending approval. Only the Leave Apporver can update status.,Aplikasi Cuti ini menunggu persetujuan. Hanya Tinggalkan Apporver dapat memperbarui status.
This Time Log Batch has been billed.,Batch Waktu Log ini telah ditagih.
This Time Log Batch has been cancelled.,Batch Waktu Log ini telah dibatalkan.
This Time Log conflicts with {0},Ini Waktu Log bertentangan dengan {0}
This format is used if country specific format is not found,Format ini digunakan jika format khusus negara tidak ditemukan
This is a root account and cannot be edited.,Ini adalah account root dan tidak dapat diedit.
This is a root customer group and cannot be edited.,Ini adalah kelompok pelanggan akar dan tidak dapat diedit.
This is a root item group and cannot be edited.,Ini adalah kelompok barang akar dan tidak dapat diedit.
This is a root sales person and cannot be edited.,Ini adalah orang penjualan akar dan tidak dapat diedit.
This is a root territory and cannot be edited.,Ini adalah wilayah akar dan tidak dapat diedit.
This is an example website auto-generated from ERPNext,Ini adalah situs contoh auto-dihasilkan dari ERPNext
This is the number of the last created transaction with this prefix,Ini adalah jumlah transaksi yang diciptakan terakhir dengan awalan ini
This will be used for setting rule in HR module,Ini akan digunakan untuk menetapkan aturan dalam modul HR
Thread HTML,Thread HTML
Thursday,Kamis
Time Log,Waktu Log
Time Log Batch,Waktu Log Batch
Time Log Batch Detail,Waktu Log Batch Detil
Time Log Batch Details,Waktu Log Detail Batch
Time Log Batch {0} must be 'Submitted',Waktu Log Batch {0} harus 'Dikirim'
Time Log Status must be Submitted.,Waktu Log Status harus Dikirim.
Time Log for tasks.,Waktu Log untuk tugas-tugas.
Time Log is not billable,Waktu Log tidak dapat ditagih
Time Log {0} must be 'Submitted',Waktu Log {0} harus 'Dikirim'
Time Zone,"Zona Waktu: GMT +2; CET +1, dan EST (AS-Timur) +7"
Time Zones,Zona Waktu
Time and Budget,Waktu dan Anggaran
Time at which items were delivered from warehouse,Waktu di mana barang dikirim dari gudang
Time at which materials were received,Waktu di mana bahan yang diterima
Title,Judul
Titles for print templates e.g. Proforma Invoice.,Judul untuk mencetak template misalnya Proforma Invoice.
To,untuk
To Currency,Untuk Mata
To Date,Untuk Tanggal
To Date should be same as From Date for Half Day leave,Untuk tanggal harus sama dengan Dari Tanggal untuk cuti Half Day
To Date should be within the Fiscal Year. Assuming To Date = {0},Untuk tanggal harus dalam Tahun Anggaran. Dengan asumsi To Date = {0}
To Discuss,Untuk Diskusikan
To Do List,To Do List
To Package No.,Untuk Paket No
To Produce,Untuk Menghasilkan
To Time,Untuk Waktu
To Value,Untuk Menghargai
To Warehouse,Untuk Gudang
"To add child nodes, explore tree and click on the node under which you want to add more nodes.","Untuk menambahkan node anak, mengeksplorasi pohon dan klik pada node di mana Anda ingin menambahkan lebih banyak node."
"To assign this issue, use the ""Assign"" button in the sidebar.","Untuk menetapkan masalah ini, gunakan ""Assign"" tombol di sidebar."
To create a Bank Account,Untuk membuat Rekening Bank
To create a Tax Account,Untuk membuat Akun Pajak
"To create an Account Head under a different company, select the company and save customer.","Untuk membuat Kepala Akun bawah perusahaan yang berbeda, pilih perusahaan dan menyimpan pelanggan."
To date cannot be before from date,Sampai saat ini tidak dapat sebelumnya dari tanggal
To enable <b>Point of Sale</b> features,Untuk mengaktifkan <b> Point of Sale </ b> fitur
To enable <b>Point of Sale</b> view,Untuk mengaktifkan <b> Point of Sale </ b> Tampilan
To get Item Group in details table,Untuk mendapatkan Barang Group di tabel rincian
"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Untuk mencakup pajak berturut-turut {0} di tingkat Barang, pajak dalam baris {1} juga harus disertakan"
"To merge, following properties must be same for both items","Untuk bergabung, sifat berikut harus sama untuk kedua item"
"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Untuk tidak berlaku Rule Harga dalam transaksi tertentu, semua Aturan Harga yang berlaku harus dinonaktifkan."
"To set this Fiscal Year as Default, click on 'Set as Default'","Untuk mengatur Tahun Anggaran ini sebagai Default, klik 'Set as Default'"
To track any installation or commissioning related work after sales,Untuk melacak instalasi atau commissioning kerja terkait setelah penjualan
"To track brand name in the following documents Delivery Note, Opportunity, Material Request, Item, Purchase Order, Purchase Voucher, Purchaser Receipt, Quotation, Sales Invoice, Sales BOM, Sales Order, Serial No","Untuk melacak nama merek di berikut dokumen Delivery Note, Opportunity, Permintaan Bahan, Barang, Purchase Order, Voucher Pembelian, Pembeli Penerimaan, Quotation, Faktur Penjualan, Penjualan BOM, Sales Order, Serial No"
To track item in sales and purchase documents based on their serial nos. This is can also used to track warranty details of the product.,Untuk melacak item dalam penjualan dan dokumen pembelian berdasarkan nos serial mereka. Hal ini juga dapat digunakan untuk melacak rincian garansi produk.
To track items in sales and purchase documents with batch nos<br><b>Preferred Industry: Chemicals etc</b>,Untuk melacak barang dalam penjualan dan pembelian dokumen dengan bets nos <br> <b> Preferred Industri: Kimia etc </ b>
To track items using barcode. You will be able to enter items in Delivery Note and Sales Invoice by scanning barcode of item.,Untuk melacak item menggunakan barcode. Anda akan dapat memasukkan item dalam Pengiriman Note dan Faktur Penjualan dengan memindai barcode barang.
Too many columns. Export the report and print it using a spreadsheet application.,Terlalu banyak kolom. Mengekspor laporan dan mencetaknya menggunakan aplikasi spreadsheet.
Tools,Alat-alat
Total,Total
Total ({0}),Jumlah ({0})
Total Advance,Jumlah Uang Muka
Total Amount,Jumlah Total
Total Amount To Pay,Jumlah Total Untuk Bayar
Total Amount in Words,Jumlah Total Kata
Total Billing This Year: ,
Total Characters,Jumlah Karakter
Total Claimed Amount,Jumlah Total Diklaim
Total Commission,Jumlah Komisi
Total Cost,Total Biaya
Total Credit,Jumlah Kredit
Total Debit,Jumlah Debit
Total Debit must be equal to Total Credit. The difference is {0},Jumlah Debit harus sama dengan total kredit. Perbedaannya adalah {0}
Total Deduction,Jumlah Pengurangan
Total Earning,Total Penghasilan
Total Experience,Jumlah Pengalaman
Total Hours,Jumlah Jam
Total Hours (Expected),Jumlah Jam (Diharapkan)
Total Invoiced Amount,Jumlah Total Tagihan
Total Leave Days,Jumlah Cuti Hari
Total Leaves Allocated,Jumlah Daun Dialokasikan
Total Message(s),Total Pesan (s)
Total Operating Cost,Total Biaya Operasional
Total Points,Jumlah Poin
Total Raw Material Cost,Total Biaya Bahan Baku
Total Sanctioned Amount,Jumlah Total Disahkan
Total Score (Out of 5),Skor Total (Out of 5)
Total Tax (Company Currency),Pajak Jumlah (Perusahaan Mata Uang)
Total Taxes and Charges,Jumlah Pajak dan Biaya
Total Taxes and Charges (Company Currency),Jumlah Pajak dan Biaya (Perusahaan Mata Uang)
Total allocated percentage for sales team should be 100,Persentase total yang dialokasikan untuk tim penjualan harus 100
Total amount of invoices received from suppliers during the digest period,Jumlah total tagihan yang diterima dari pemasok selama periode digest
Total amount of invoices sent to the customer during the digest period,Jumlah total tagihan dikirim ke pelanggan selama masa digest
Total cannot be zero,Jumlah tidak boleh nol
Total in words,Jumlah kata
Total points for all goals should be 100. It is {0},Jumlah poin untuk semua tujuan harus 100. Ini adalah {0}
Total valuation for manufactured or repacked item(s) can not be less than total valuation of raw materials,Total penilaian untuk diproduksi atau dikemas ulang item (s) tidak bisa kurang dari penilaian total bahan baku
Total weightage assigned should be 100%. It is {0},Jumlah weightage ditugaskan harus 100%. Ini adalah {0}
Totals,Total
Track Leads by Industry Type.,Melacak Memimpin menurut Industri Type.
Track this Delivery Note against any Project,Melacak Pengiriman ini Catatan terhadap Proyek apapun
Track this Sales Order against any Project,Melacak Pesanan Penjualan ini terhadap Proyek apapun
Transaction,Transaksi
Transaction Date,Transaction Tanggal
Transaction not allowed against stopped Production Order {0},Transaksi tidak diperbolehkan berhenti melawan Orde Produksi {0}
Transfer,Transfer
Transfer Material,Material Transfer
Transfer Raw Materials,Mentransfer Bahan Baku
Transferred Qty,Ditransfer Qty
Transportation,Transportasi
Transporter Info,Info Transporter
Transporter Name,Transporter Nama
Transporter lorry number,Nomor Transporter truk
Travel,Perjalanan
Travel Expenses,Biaya Perjalanan
Tree Type,Jenis Pohon
Tree of Item Groups.,Pohon Item Grup.
Tree of finanial Cost Centers.,Pohon Pusat Biaya finanial.
Tree of finanial accounts.,Pohon rekening finanial.
Trial Balance,Trial Balance
Tuesday,Selasa
Type,Jenis
Type of document to rename.,Jenis dokumen untuk mengubah nama.
"Type of leaves like casual, sick etc.","Jenis daun seperti kasual, dll sakit"
Types of Expense Claim.,Jenis Beban Klaim.
Types of activities for Time Sheets,Jenis kegiatan untuk Waktu Sheets
"Types of employment (permanent, contract, intern etc.).","Jenis pekerjaan (permanen, kontrak, magang dll)."
UOM Conversion Detail,Detil UOM Konversi
UOM Conversion Details,UOM Detail Konversi
UOM Conversion Factor,UOM Faktor Konversi
UOM Conversion factor is required in row {0},Faktor UOM Konversi diperlukan berturut-turut {0}
UOM Name,Nama UOM
UOM coversion factor required for UOM: {0} in Item: {1},Faktor coversion UOM diperlukan untuk UOM: {0} di Item: {1}
Under AMC,Di bawah AMC
Under Graduate,Under Graduate
Under Warranty,Berdasarkan Jaminan
Unit,Satuan
Unit of Measure,Satuan Ukur
Unit of Measure {0} has been entered more than once in Conversion Factor Table,Satuan Ukur {0} telah dimasukkan lebih dari sekali dalam Faktor Konversi Tabel
"Unit of measurement of this item (e.g. Kg, Unit, No, Pair).","Unit pengukuran item ini (misalnya Kg, Unit, No, Pair)."
Units/Hour,Unit / Jam
Units/Shifts,Unit / Shift
Unpaid,Tunggakan
Unreconciled Payment Details,Rincian Pembayaran Unreconciled
Unscheduled,Terjadwal
Unsecured Loans,Pinjaman Tanpa Jaminan
Unstop,Unstop
Unstop Material Request,Unstop Material Permintaan
Unstop Purchase Order,Unstop Purchase Order
Unsubscribed,Berhenti berlangganan
Update,Perbarui
Update Clearance Date,Perbarui Izin Tanggal
Update Cost,Pembaruan Biaya
Update Finished Goods,Barang pembaruan Selesai
Update Landed Cost,Pembaruan Landed Cost
Update Series,Pembaruan Series
Update Series Number,Pembaruan Series Number
Update Stock,Perbarui Stock
Update bank payment dates with journals.,Perbarui tanggal pembayaran bank dengan jurnal.
Update clearance date of Journal Entries marked as 'Bank Vouchers',Tanggal pembaruan clearance Entries Journal ditandai sebagai 'Bank Voucher'
Updated,Diperbarui
Updated Birthday Reminders,Diperbarui Ulang Tahun Pengingat
Upload Attendance,Upload Kehadiran
Upload Backups to Dropbox,Upload Backup ke Dropbox
Upload Backups to Google Drive,Upload Backup ke Google Drive
Upload HTML,Upload HTML
Upload a .csv file with two columns: the old name and the new name. Max 500 rows.,Upload file csv dengan dua kolom:. Nama lama dan nama baru. Max 500 baris.
Upload attendance from a .csv file,Upload kehadiran dari file csv.
Upload stock balance via csv.,Upload keseimbangan saham melalui csv.
Upload your letter head and logo - you can edit them later.,Upload kop surat dan logo - Anda dapat mengedit mereka nanti.
Upper Income,Atas Penghasilan
Urgent,Mendesak
Use Multi-Level BOM,Gunakan Multi-Level BOM
Use SSL,Gunakan SSL
Used for Production Plan,Digunakan untuk Rencana Produksi
User,Pengguna
User ID,ID Pemakai
User ID not set for Employee {0},User ID tidak ditetapkan untuk Karyawan {0}
User Name,Nama Pengguna
User Name or Support Password missing. Please enter and try again.,Nama Pengguna atau Dukungan Sandi hilang. Silakan masuk dan coba lagi.
User Remark,Keterangan Pengguna
User Remark will be added to Auto Remark,Keterangan Pengguna akan ditambahkan ke Auto Remark
User Remarks is mandatory,Pengguna Keterangan adalah wajib
User Specific,User Specific
User must always select,Pengguna harus selalu pilih
User {0} is already assigned to Employee {1},Pengguna {0} sudah ditugaskan untuk Karyawan {1}
User {0} is disabled,Pengguna {0} dinonaktifkan
Username,satria pasha
Users with this role are allowed to create / modify accounting entry before frozen date,Pengguna dengan peran ini diperbolehkan untuk membuat / memodifikasi entri akuntansi sebelum tanggal beku
Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Pengguna dengan peran ini diperbolehkan untuk mengatur account beku dan membuat / memodifikasi entri akuntansi terhadap rekening beku
Utilities,Keperluan
Utility Expenses,Beban utilitas
Valid For Territories,Berlaku Untuk Wilayah
Valid From,Valid Dari
Valid Upto,Valid Upto
Valid for Territories,Berlaku untuk Wilayah
Validate,Mengesahkan
Valuation,Valuation
Valuation Method,Metode Penilaian
Valuation Rate,Tingkat Penilaian
Valuation Rate required for Item {0},Penilaian Tingkat diperlukan untuk Item {0}
Valuation and Total,Penilaian dan Total
Value,Nilai
Value or Qty,Nilai atau Qty
Vehicle Dispatch Date,Kendaraan Dispatch Tanggal
Vehicle No,Kendaraan yang
Venture Capital,Modal Ventura
Verified By,Diverifikasi oleh
View Ledger,View Ledger
View Now,Lihat Sekarang
Visit report for maintenance call.,Kunjungi laporan untuk panggilan pemeliharaan.
Voucher #,Voucher #
Voucher Detail No,Detil Voucher ada
Voucher Detail Number,Voucher Nomor Detil
Voucher ID,Voucher ID
Voucher No,Voucher Tidak ada
Voucher Type,Voucher Type
Voucher Type and Date,Voucher Jenis dan Tanggal
Walk In,Walk In
Warehouse,Gudang
Warehouse Contact Info,Gudang Info Kontak
Warehouse Detail,Gudang Detil
Warehouse Name,Gudang Nama
Warehouse and Reference,Gudang dan Referensi
Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Gudang tidak dapat dihapus sebagai entri stok buku ada untuk gudang ini.
Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Gudang hanya dapat diubah melalui Bursa Masuk / Delivery Note / Penerimaan Pembelian
Warehouse cannot be changed for Serial No.,Gudang tidak dapat diubah untuk Serial Number
Warehouse is mandatory for stock Item {0} in row {1},Gudang adalah wajib bagi saham Barang {0} berturut-turut {1}
Warehouse is missing in Purchase Order,Gudang yang hilang dalam Purchase Order
Warehouse not found in the system,Gudang tidak ditemukan dalam sistem
Warehouse required for stock Item {0},Gudang diperlukan untuk stok Barang {0}
Warehouse where you are maintaining stock of rejected items,Gudang di mana Anda mempertahankan stok item ditolak
Warehouse {0} can not be deleted as quantity exists for Item {1},Gudang {0} tidak dapat dihapus sebagai kuantitas ada untuk Item {1}
Warehouse {0} does not belong to company {1},Gudang {0} bukan milik perusahaan {1}
Warehouse {0} does not exist,Gudang {0} tidak ada
Warehouse {0}: Company is mandatory,Gudang {0}: Perusahaan wajib
Warehouse {0}: Parent account {1} does not bolong to the company {2},Gudang {0}: akun Parent {1} tidak Bolong kepada perusahaan {2}
Warehouse-Wise Stock Balance,Gudang-Wise Stock Balance
Warehouse-wise Item Reorder,Gudang-bijaksana Barang Reorder
Warehouses,Gudang
Warehouses.,Gudang.
Warn,Memperingatkan
Warning: Leave application contains following block dates,Peringatan: Tinggalkan aplikasi berisi tanggal blok berikut
Warning: Material Requested Qty is less than Minimum Order Qty,Peringatan: Material Diminta Qty kurang dari Minimum Order Qty
Warning: Sales Order {0} already exists against same Purchase Order number,Peringatan: Sales Order {0} sudah ada terhadap nomor Purchase Order yang sama
Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Peringatan: Sistem tidak akan memeriksa overbilling karena jumlahnya untuk Item {0} pada {1} adalah nol
Warranty / AMC Details,Garansi / Detail AMC
Warranty / AMC Status,Garansi / Status AMC
Warranty Expiry Date,Garansi Tanggal Berakhir
Warranty Period (Days),Masa Garansi (Hari)
Warranty Period (in days),Masa Garansi (dalam hari)
We buy this Item,Kami membeli item ini
We sell this Item,Kami menjual item ini
Website,Situs Web
Website Description,Website Description
Website Item Group,Situs Barang Grup
Website Item Groups,Situs Barang Grup
Website Settings,Pengaturan situs web
Website Warehouse,Situs Gudang
Wednesday,Rabu
Weekly,Mingguan
Weekly Off,Weekly Off
Weight UOM,Berat UOM
"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Berat disebutkan, \n Harap menyebutkan ""Berat UOM"" terlalu"
Weightage,Weightage
Weightage (%),Weightage (%)
Welcome,Selamat Datang
Welcome to ERPNext. Over the next few minutes we will help you setup your ERPNext account. Try and fill in as much information as you have even if it takes a bit longer. It will save you a lot of time later. Good Luck!,Selamat Datang di ERPNext. Selama beberapa menit berikutnya kami akan membantu Anda setup account ERPNext Anda. Cobalah dan mengisi sebanyak mungkin informasi sebagai Anda memiliki bahkan jika dibutuhkan sedikit lebih lama. Ini akan menghemat banyak waktu. Selamat!
Welcome to ERPNext. Please select your language to begin the Setup Wizard.,Selamat Datang di ERPNext. Silahkan pilih bahasa Anda untuk memulai Setup Wizard.
What does it do?,Apa gunanya?
"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.","Ketika salah satu transaksi yang diperiksa ""Dikirim"", email pop-up secara otomatis dibuka untuk mengirim email ke terkait ""Kontak"" dalam transaksi itu, dengan transaksi sebagai lampiran. Pengguna mungkin atau mungkin tidak mengirim email."
"When submitted, the system creates difference entries to set the given stock and valuation on this date.","Ketika disampaikan, sistem menciptakan entri perbedaan untuk mengatur saham yang diberikan dan penilaian pada tanggal ini."
Where items are stored.,Dimana item disimpan.
Where manufacturing operations are carried out.,Dimana operasi manufaktur dilakukan.
Widowed,Janda
Will be calculated automatically when you enter the details,Akan dihitung secara otomatis ketika Anda memasukkan rincian
Will be updated after Sales Invoice is Submitted.,Akan diperbarui setelah Faktur Penjualan yang Dikirim.
Will be updated when batched.,Akan diperbarui bila batched.
Will be updated when billed.,Akan diperbarui saat ditagih.
Wire Transfer,Transfer
With Operations,Dengan Operasi
With Period Closing Entry,Dengan Periode penutupan Entri
Work Details,Rincian Kerja
Work Done,Pekerjaan Selesai
Work In Progress,Bekerja In Progress
Work-in-Progress Warehouse,Kerja-in Progress-Gudang
Work-in-Progress Warehouse is required before Submit,Kerja-in-Progress Gudang diperlukan sebelum Submit
Working,Kerja
Working Days,Hari Kerja
Workstation,Workstation
Workstation Name,Workstation Nama
Write Off Account,Menulis Off Akun
Write Off Amount,Menulis Off Jumlah
Write Off Amount <=,Menulis Off Jumlah <=
Write Off Based On,Menulis Off Berbasis On
Write Off Cost Center,Menulis Off Biaya Pusat
Write Off Outstanding Amount,Menulis Off Jumlah Outstanding
Write Off Voucher,Menulis Off Voucher
Wrong Template: Unable to find head row.,Template yang salah: Tidak dapat menemukan baris kepala.
Year,Tahun
Year Closed,Tahun Ditutup
Year End Date,Tanggal Akhir Tahun
Year Name,Tahun Nama
Year Start Date,Tahun Tanggal Mulai
Year of Passing,Tahun Passing
Yearly,Tahunan
Yes,Ya
You are not authorized to add or update entries before {0},Anda tidak diizinkan untuk menambah atau memperbarui entri sebelum {0}
You are not authorized to set Frozen value,Anda tidak diizinkan untuk menetapkan nilai Beku
You are the Expense Approver for this record. Please Update the 'Status' and Save,Anda adalah Approver Beban untuk catatan ini. Silakan Update 'Status' dan Simpan
You are the Leave Approver for this record. Please Update the 'Status' and Save,Anda adalah Leave Approver untuk catatan ini. Silakan Update 'Status' dan Simpan
You can enter any date manually,Anda dapat memasukkan setiap tanggal secara manual
You can enter the minimum quantity of this item to be ordered.,Anda dapat memasukkan jumlah minimum dari item ini yang akan dipesan.
You can not change rate if BOM mentioned agianst any item,Anda tidak dapat mengubah tingkat jika BOM disebutkan agianst item
You can not enter both Delivery Note No and Sales Invoice No. Please enter any one.,Anda tidak dapat memasukkan kedua Delivery Note ada dan Faktur Penjualan No Masukkan salah satu.
You can not enter current voucher in 'Against Journal Voucher' column,Anda tidak bisa masuk voucher saat ini di 'Melawan Journal Voucher' kolom
You can set Default Bank Account in Company master,Anda dapat mengatur default Bank Account menguasai Perusahaan
You can start by selecting backup frequency and granting access for sync,Anda dapat memulai dengan memilih frekuensi backup dan memberikan akses untuk sinkronisasi
You can submit this Stock Reconciliation.,Anda bisa mengirimkan ini Stock Rekonsiliasi.
You can update either Quantity or Valuation Rate or both.,Anda dapat memperbarui baik Quantity atau Tingkat Penilaian atau keduanya.
You cannot credit and debit same account at the same time,Anda tidak dapat kredit dan mendebit rekening yang sama pada waktu yang sama
You have entered duplicate items. Please rectify and try again.,Anda telah memasuki duplikat item. Harap memperbaiki dan coba lagi.
You may need to update: {0},Anda mungkin perlu memperbarui: {0}
You must Save the form before proceeding,Anda harus Simpan formulir sebelum melanjutkan
Your Customer's TAX registration numbers (if applicable) or any general information,Nomor registrasi PAJAK Pelanggan Anda (jika ada) atau informasi umum setiap
Your Customers,Pelanggan Anda
Your Login Id,Login Id Anda
Your Products or Services,Produk atau Jasa
Your Suppliers,Pemasok Anda
Your email address,Alamat email Anda
Your financial year begins on,Tahun buku Anda dimulai di
Your financial year ends on,Tahun keuangan Anda berakhir pada
Your sales person who will contact the customer in future,Orang sales Anda yang akan menghubungi pelanggan di masa depan
Your sales person will get a reminder on this date to contact the customer,Orang penjualan Anda akan mendapatkan pengingat pada tanggal ini untuk menghubungi pelanggan
Your setup is complete. Refreshing...,Setup Anda selesai. Refreshing ...
Your support email id - must be a valid email - this is where your emails will come!,Dukungan email id Anda - harus email yang valid - ini adalah di mana email akan datang!
[Error],[Kesalahan]
[Select],[Select]
`Freeze Stocks Older Than` should be smaller than %d days.,`Freeze Saham Lama Dari` harus lebih kecil dari% d hari.
and,Dan
are not allowed.,tidak diperbolehkan.
assigned by,ditugaskan oleh
cannot be greater than 100,tidak dapat lebih besar dari 100
"e.g. ""Build tools for builders""","misalnya ""Membangun alat untuk pembangun """
"e.g. ""MC""","misalnya ""MC """
"e.g. ""My Company LLC""","misalnya ""My Company LLC """
e.g. 5,misalnya 5
"e.g. Bank, Cash, Credit Card","misalnya Bank, Kas, Kartu Kredit"
"e.g. Kg, Unit, Nos, m","misalnya Kg, Unit, Nos, m"
e.g. VAT,misalnya PPN
eg. Cheque Number,misalnya. Nomor Cek
example: Next Day Shipping,Contoh: Hari Berikutnya Pengiriman
lft,lft
old_parent,old_parent
rgt,rgt
subject,subyek
to,to
website page link,tautan halaman situs web
{0} '{1}' not in Fiscal Year {2},{0} '{1}' tidak dalam Tahun Anggaran {2}
{0} Credit limit {0} crossed,{0} limit kredit {0} menyeberangi
{0} Serial Numbers required for Item {0}. Only {0} provided.,{0} Serial Number diperlukan untuk Item {0}. Hanya {0} disediakan.
{0} budget for Account {1} against Cost Center {2} will exceed by {3},{0} anggaran untuk Akun {1} terhadap Biaya Pusat {2} akan melebihi oleh {3}
{0} can not be negative,{0} tidak dapat negatif
{0} created,{0} dibuat
{0} does not belong to Company {1},{0} bukan milik Perusahaan {1}
{0} entered twice in Item Tax,{0} masuk dua kali dalam Pajak Barang
{0} is an invalid email address in 'Notification Email Address',{0} adalah alamat email yang tidak valid dalam 'Pemberitahuan Alamat Email'
{0} is mandatory,{0} adalah wajib
{0} is mandatory for Item {1},{0} adalah wajib untuk Item {1}
{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} adalah wajib. Mungkin catatan mata uang tidak diciptakan untuk {1} ke {} 2.
{0} is not a stock Item,{0} bukan merupakan saham Barang
{0} is not a valid Batch Number for Item {1},{0} tidak Nomor Batch berlaku untuk Item {1}
{0} is not a valid Leave Approver. Removing row #{1}.,{0} tidak valid Tinggalkan Approver. Menghapus row # {1}.
{0} is not a valid email id,{0} bukan id email yang valid
{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} sekarang default Tahun Anggaran. Silahkan refresh browser Anda untuk perubahan untuk mengambil efek.
{0} is required,{0} diperlukan
{0} must be a Purchased or Sub-Contracted Item in row {1},{0} harus Dibeli Sub-Kontrak atau Barang berturut-turut {1}
{0} must be reduced by {1} or you should increase overflow tolerance,{0} harus dikurangi oleh {1} atau Anda harus meningkatkan toleransi melimpah
{0} must have role 'Leave Approver',{0} harus memiliki peran 'Leave Approver'
{0} valid serial nos for Item {1},{0} nos seri berlaku untuk Item {1}
{0} {1} against Bill {2} dated {3},{0} {1} terhadap Bill {2} tanggal {3}
{0} {1} against Invoice {2},{0} {1} terhadap Faktur {2}
{0} {1} has already been submitted,{0} {1} telah diserahkan
{0} {1} has been modified. Please refresh.,{0} {1} telah dimodifikasi. Silahkan refresh.
{0} {1} is not submitted,{0} {1} tidak disampaikan
{0} {1} must be submitted,{0} {1} harus diserahkan
{0} {1} not in any Fiscal Year,{0} {1} tidak dalam Tahun Anggaran
{0} {1} status is 'Stopped',{0} {1} status 'Berhenti'
{0} {1} status is Stopped,{0} Status {1} adalah Berhenti
{0} {1} status is Unstopped,{0} {1} status unstopped
{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Biaya Pusat adalah wajib untuk Item {2}
{0}: {1} not found in Invoice Details table,{0}: {1} tidak ditemukan dalam Faktur Rincian table
