DocType: Accounting Period,Period Name,Jina la Kipindi
DocType: Employee,Salary Mode,Njia ya Mshahara
apps/erpnext/erpnext/public/js/hub/marketplace.js,Register,Jisajili
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Partially Received,Imepokelewa kwa Sehemu
DocType: Patient,Divorced,Talaka
DocType: Support Settings,Post Route Key,Njia ya Njia ya Chapisho
DocType: Buying Settings,Allow Item to be added multiple times in a transaction,Ruhusu Item kuongezwa mara nyingi katika shughuli
DocType: Content Question,Content Question,Swali la Yaliyomo
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,Cancel Material Visit {0} before cancelling this Warranty Claim,Futa Ziara ya Nyenzo {0} kabla ya kufuta madai ya Waranti
DocType: Customer Feedback Table,Qualitative Feedback,Majibu ya Sifa
apps/erpnext/erpnext/config/education.py,Assessment Reports,Ripoti za Tathmini
DocType: Invoice Discounting,Accounts Receivable Discounted Account,Akaunti zinazopatikana Akaunti iliyopunguzwa
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting_list.js,Canceled,Imefutwa
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Consumer Products,Bidhaa za Watumiaji
DocType: Supplier Scorecard,Notify Supplier,Arifaza Wasambazaji
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.js,Please select Party Type first,Tafadhali chagua Aina ya Chama kwanza
DocType: Item,Customer Items,Vitu vya Wateja
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Liabilities,Madeni
DocType: Project,Costing and Billing,Gharama na Ulipaji
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Advance account currency should be same as company currency {0},Fedha ya awali ya akaunti lazima iwe sawa na sarafu ya kampuni {0}
DocType: QuickBooks Migrator,Token Endpoint,Mwisho wa Tokeni
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} can not be a ledger,Akaunti {0}: Akaunti ya Mzazi {1} haiwezi kuwa kiongozi
DocType: Item,Publish Item to hub.erpnext.com,Chapisha Jumuiya ya hub.erpnext.com
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Cannot find active Leave Period,Haiwezi kupata Kipindi cha Kuondoka
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Evaluation,Tathmini
DocType: Item,Default Unit of Measure,Kitengo cha Kupima chaguo-msingi
DocType: SMS Center,All Sales Partner Contact,Mawasiliano Yote ya Mshirika wa Mauzo
DocType: Department,Leave Approvers,Acha vibali
DocType: Employee,Bio / Cover Letter,Barua ya Bio / Jalada
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Search Items ...,Vitu vya Kutafuta ...
DocType: Patient Encounter,Investigations,Uchunguzi
DocType: Restaurant Order Entry,Click Enter To Add,Bonyeza Ingia Kuongeza
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py,"Missing value for Password, API Key or Shopify URL","Thamani ya Hifadhi ya Nenosiri, Muhimu wa API au Duka la Duka"
DocType: Employee,Rented,Ilipangwa
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,All Accounts,Akaunti zote
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,Cannot transfer Employee with status Left,Haiwezi kuhamisha Mfanyakazi na hali ya kushoto
DocType: Vehicle Service,Mileage,Mileage
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Do you really want to scrap this asset?,Je! Kweli unataka kugawa kipengee hiki?
DocType: Drug Prescription,Update Schedule,Sasisha Ratiba
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js,Select Default Supplier,Chagua Mtoa Default
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js,Show Employee,Onyesha Mfanyakazi
DocType: Payroll Period,Standard Tax Exemption Amount,Kiwango cha Msamaha wa Ushuru
DocType: Exchange Rate Revaluation Account,New Exchange Rate,Kiwango cha New Exchange
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Currency is required for Price List {0},Fedha inahitajika kwa Orodha ya Bei {0}
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Itahesabiwa katika shughuli.
DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT -YYYY.-
DocType: Purchase Order,Customer Contact,Mawasiliano ya Wateja
DocType: Shift Type,Enable Auto Attendance,Washa Kuhudhuria Moja kwa moja
DocType: Lost Reason Detail,Opportunity Lost Reason,Fursa waliopotea Sababu
DocType: Patient Appointment,Check availability,Angalia upatikanaji
DocType: Retention Bonus,Bonus Payment Date,Tarehe ya Malipo ya Bonasi
DocType: Employee,Job Applicant,Mwombaji wa Ayubu
DocType: Job Card,Total Time in Mins,Jumla ya Muda katika Pesa
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py,This is based on transactions against this Supplier. See timeline below for details,Hii inategemea mashirikiano dhidi ya Wasambazaji huu. Tazama kalenda ya chini kwa maelezo zaidi
DocType: Manufacturing Settings,Overproduction Percentage For Work Order,Asilimia ya upungufu kwa Kazi ya Kazi
DocType: Landed Cost Voucher,MAT-LCV-.YYYY.-,MAT-LCV -YYYY.-
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Legal,Kisheria
DocType: Sales Invoice,Transport Receipt Date,Tarehe ya Rekodi ya Usafiri
DocType: Shopify Settings,Sales Order Series,Mipango ya Utaratibu wa Mauzo
DocType: Vital Signs,Tongue,Lugha
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Actual type tax cannot be included in Item rate in row {0},Kodi halisi ya aina haiwezi kuingizwa katika kiwango cha kipengee kwenye mstari {0}
DocType: Allowed To Transact With,Allowed To Transact With,Imeruhusiwa Kufanikisha Na
DocType: Bank Guarantee,Customer,Wateja
DocType: Purchase Receipt Item,Required By,Inahitajika
DocType: Delivery Note,Return Against Delivery Note,Kurudi dhidi ya Kumbuka utoaji
DocType: Asset Category,Finance Book Detail,Maelezo ya Kitabu cha Fedha
apps/erpnext/erpnext/assets/doctype/asset/asset.py,All the depreciations has been booked,Uchakavu wote umehifadhiwa
DocType: Purchase Order,% Billed,Imelipwa
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Payroll Number,Nambari ya malipo
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Exchange Rate must be same as {0} {1} ({2}),Kiwango cha Exchange lazima iwe sawa na {0} {1} ({2})
DocType: Employee Tax Exemption Declaration,HRA Exemption,Ufafanuzi wa HRA
DocType: Sales Invoice,Customer Name,Jina la Wateja
DocType: Vehicle,Natural Gas,Gesi ya asili
DocType: Project,Message will sent to users to get their status on the project,Ujumbe utatumwa kwa watumiaji kupata hali yao kwenye mradi huo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Bank account cannot be named as {0},Akaunti ya benki haiwezi kuitwa jina la {0}
DocType: Employee Tax Exemption Declaration,HRA as per Salary Structure,HRA kwa Muundo wa Mshahara
DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,Viongozi (au makundi) ambayo Maingilio ya Uhasibu hufanywa na mizani huhifadhiwa.
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Outstanding for {0} cannot be less than zero ({1}),Bora kwa {0} haiwezi kuwa chini ya sifuri ({1})
apps/erpnext/erpnext/public/js/controllers/transaction.js,Service Stop Date cannot be before Service Start Date,Tarehe ya Kuacha Huduma haiwezi kuwa kabla ya Tarehe ya Huduma ya Huduma
DocType: Manufacturing Settings,Default 10 mins,Default 10 mins
DocType: Leave Type,Leave Type Name,Acha Jina Aina
apps/erpnext/erpnext/templates/pages/projects.js,Show open,Onyesha wazi
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Series Updated Successfully,Mfululizo umehifadhiwa kwa ufanisi
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html,Checkout,Angalia
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} in row {1},{0} mfululizo {1}
DocType: Asset Finance Book,Depreciation Start Date,Tarehe ya kuanza ya kushuka kwa thamani
DocType: Pricing Rule,Apply On,Tumia Ombi
DocType: Item Price,Multiple Item prices.,Vipengee vya Bidhaa nyingi.
,Purchase Order Items To Be Received,Vitu vya Utaratibu wa Ununuzi Ili Kupokea
DocType: SMS Center,All Supplier Contact,Mawasiliano Yote ya Wasambazaji
DocType: Support Settings,Support Settings,Mipangilio ya Kusaidia
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0} is added in the child company {1},Akaunti {0} imeongezwa katika kampuni ya watoto {1}
apps/erpnext/erpnext/erpnext_integrations/doctype/exotel_settings/exotel_settings.py,Invalid credentials,Uthibitishaji batili
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Available (whether in full op part),ITC Inapatikana (iwe katika sehemu kamili)
DocType: Amazon MWS Settings,Amazon MWS Settings,Mipangilio ya MWS ya Amazon
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Vouchers,Inashughulikia Vocha
apps/erpnext/erpnext/utilities/transaction_base.py,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Row # {0}: Kiwango lazima kiwe sawa na {1}: {2} ({3} / {4})
,Batch Item Expiry Status,Kipengee cha Muhtasari wa Kipengee Hali
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Bank Draft,Rasimu ya Benki
DocType: Journal Entry,ACC-JV-.YYYY.-,ACC-JV -YYYY.-
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Late Entries,Jumla ya Marekebisho ya Marehemu
DocType: Mode of Payment Account,Mode of Payment Account,Akaunti ya Akaunti ya Malipo
apps/erpnext/erpnext/config/healthcare.py,Consultation,Ushauri
DocType: Accounts Settings,Show Payment Schedule in Print,Onyesha Ratiba ya Malipo katika Chapisha
apps/erpnext/erpnext/stock/doctype/item/item.py,Item Variants updated,Bidhaa anuwai imesasishwa
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py,Sales and Returns,Mauzo na Kurudi
apps/erpnext/erpnext/stock/doctype/item/item.js,Show Variants,Onyesha Mabadiliko
DocType: Academic Term,Academic Term,Muda wa Elimu
DocType: Employee Tax Exemption Sub Category,Employee Tax Exemption Sub Category,Kutolewa kwa Wafanyakazi wa Ushuru Jamii Kundi
apps/erpnext/erpnext/regional/italy/utils.py,Please set an Address on the Company '%s',Tafadhali weka Anwani kwenye Kampuni &#39;% s&#39;
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py,Material,Nyenzo
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of benefit application pro-rata component\
			amount and previous claimed amount",Ufikiaji mkubwa wa mfanyakazi {0} unaozidi {1} kwa jumla ya {2} ya sehemu ya faida ya programu ya faida ya kiasi na kiasi cha awali cha kudai
DocType: Opening Invoice Creation Tool Item,Quantity,Wingi
,Customers Without Any Sales Transactions,Wateja bila Shughuli Zote za Mauzo
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Accounts table cannot be blank.,Jedwali la Akaunti hawezi kuwa tupu.
DocType: Delivery Trip,Use Google Maps Direction API to calculate estimated arrival times,Tumia API ya Uelekezaji wa Ramani za Google kuhesabu nyakati za kuwasili zinazokadiriwa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Loans (Liabilities),Mikopo (Madeni)
DocType: Patient Encounter,Encounter Time,Kukutana Muda
DocType: Staffing Plan Detail,Total Estimated Cost,Jumla ya Gharama zilizohesabiwa
DocType: Employee Education,Year of Passing,Mwaka wa Kupitisha
DocType: Routing,Routing Name,Jina la Routing
DocType: Item,Country of Origin,Nchi ya asili
DocType: Soil Texture,Soil Texture Criteria,Vigezo vya Maandishi ya Udongo
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,In Stock,Katika Stock
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js,Primary Contact Details,Maelezo ya Mawasiliano ya Msingi
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open Issues,Masuala ya Fungua
DocType: Production Plan Item,Production Plan Item,Kipengee cha Mpango wa Uzalishaji
DocType: Leave Ledger Entry,Leave Ledger Entry,Acha Kuingia kwa Ledger
apps/erpnext/erpnext/hr/doctype/employee/employee.py,User {0} is already assigned to Employee {1},Mtumiaji {0} tayari amepewa Wafanyakazi {1}
DocType: Lab Test Groups,Add new line,Ongeza mstari mpya
apps/erpnext/erpnext/utilities/activation.py,Create Lead,Unda Kiongozi
DocType: Production Plan,Projected Qty Formula,Mfumo wa Qty uliyotarajiwa
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Health Care,Huduma ya afya
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,Delay in payment (Days),Kuchelewa kwa malipo (Siku)
DocType: Payment Terms Template Detail,Payment Terms Template Detail,Masharti ya Malipo Kigezo Maelezo
DocType: Hotel Room Reservation,Guest Name,Jina la Wageni
DocType: Delivery Note,Issue Credit Note,Suala la Mikopo
DocType: Lab Prescription,Lab Prescription,Dawa ya Dawa
,Delay Days,Siku za kuchelewa
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,Service Expense,Gharama za Huduma
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Serial Number: {0} is already referenced in Sales Invoice: {1},Nambari ya Serial: {0} tayari imeelezea katika Invoice ya Mauzo: {1}
DocType: Bank Statement Transaction Invoice Item,Invoice,Invoice
DocType: Employee Tax Exemption Declaration Category,Maximum Exempted Amount,Kiasi cha juu cha Msamaha
DocType: Purchase Invoice Item,Item Weight Details,Kipengee Maelezo ya Uzito
DocType: Asset Maintenance Log,Periodicity,Periodicity
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Fiscal Year {0} is required,Mwaka wa Fedha {0} inahitajika
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py,Net Profit/Loss,Faida / Upotezaji wa jumla
DocType: Employee Group Table,ERPNext User ID,Kitambulisho cha Mtumiaji cha ERPNext
DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,Umbali wa chini kati ya safu ya mimea kwa ukuaji bora
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Please select Patient to get prescribed procedure,Tafadhali chagua Mgonjwa kupata utaratibu uliowekwa
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Defense,Ulinzi
DocType: Salary Component,Abbr,Abbr
DocType: Appraisal Goal,Score (0-5),Score (0-5)
DocType: Tally Migration,Tally Creditors Account,Akaunti ya Wahasibu wa Tally
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: {1} {2} does not match with {3},Row {0}: {1} {2} hailingani na {3}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Row # {0}:,Row # {0}:
DocType: Timesheet,Total Costing Amount,Kiasi cha jumla ya gharama
DocType: Sales Invoice,Vehicle No,Hakuna Gari
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Please select Price List,Tafadhali chagua Orodha ya Bei
DocType: Accounts Settings,Currency Exchange Settings,Mipangilio ya Kubadilisha Fedha
DocType: Work Order Operation,Work In Progress,Kazi inaendelea
DocType: Leave Control Panel,Branch (optional),Tawi (hiari)
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,Row {0}: user has not applied rule <b>{1}</b> on the item <b>{2}</b>,Row {0}: Mtumiaji hajatumia sheria <b>{1}</b> kwenye bidhaa <b>{2}</b>
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py,Please select date,Tafadhali chagua tarehe
DocType: Item Price,Minimum Qty ,Uchina cha Chini
DocType: Finance Book,Finance Book,Kitabu cha Fedha
DocType: Patient Encounter,HLC-ENC-.YYYY.-,HLC-ENC -YYYY.-
DocType: Daily Work Summary Group,Holiday List,Orodha ya likizo
apps/erpnext/erpnext/config/quality_management.py,Review and Action,Mapitio na Kitendo
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,This employee already has a log with the same timestamp.{0},Mfanyikazi huyu tayari ana logi na alama ya muda sawa. {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Accountant,Mhasibu
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Selling Price List,Orodha ya Bei ya Kuuza
DocType: Patient,Tobacco Current Use,Tabibu Matumizi ya Sasa
apps/erpnext/erpnext/selling/report/customer_wise_item_price/customer_wise_item_price.py,Selling Rate,Kiwango cha Mauzo
DocType: Cost Center,Stock User,Mtumiaji wa hisa
DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
DocType: Delivery Stop,Contact Information,Maelezo ya Mawasiliano
apps/erpnext/erpnext/public/js/hub/pages/Search.vue,Search for anything ...,Tafuta chochote ...
DocType: Company,Phone No,No Simu
DocType: Delivery Trip,Initial Email Notification Sent,Arifa ya awali ya barua pepe iliyotumwa
DocType: Bank Statement Settings,Statement Header Mapping,Maelezo ya Ramani ya kichwa
,Sales Partners Commission,Tume ya Washirika wa Mauzo
DocType: Soil Texture,Sandy Clay Loam,Mchanga wa Clay Mchanga
DocType: Purchase Invoice,Rounding Adjustment,Marekebisho ya Upangaji
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation cannot have more than 5 characters,Hali haiwezi kuwa na wahusika zaidi ya 5
DocType: Amazon MWS Settings,AU,AU
DocType: Payment Order,Payment Request,Ombi la Malipo
apps/erpnext/erpnext/config/retail.py,To view logs of Loyalty Points assigned to a Customer.,Kuangalia kumbukumbu za Uaminifu Pointi zilizopewa Wateja.
DocType: Asset,Value After Depreciation,Thamani Baada ya kushuka kwa thamani
DocType: Student,O+,O +
apps/erpnext/erpnext/stock/doctype/material_request/material_request_dashboard.py,Related,Kuhusiana
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance date can not be less than employee's joining date,Tarehe ya kuhudhuria haiwezi kuwa chini ya tarehe ya kujiunga na mfanyakazi
DocType: Grading Scale,Grading Scale Name,Kuweka Jina la Scale
DocType: Employee Training,Training Date,Tarehe ya Mafunzo
apps/erpnext/erpnext/public/js/hub/marketplace.js,Add Users to Marketplace,Ongeza Watumiaji kwenye Marketplace
apps/erpnext/erpnext/accounts/doctype/account/account.js,This is a root account and cannot be edited.,Hii ni akaunti ya mizizi na haiwezi kuhaririwa.
DocType: POS Profile,Company Address,Anwani ya Kampuni
DocType: BOM,Operations,Uendeshaji
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Cannot set authorization on basis of Discount for {0},Haiwezi kuweka idhini kulingana na Punguzo la {0}
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill JSON cannot be generated for Sales Return as of now,E-Way Bill JSON haiwezi kuzalishwa kwa Uuzaji wa Uuzaji kama wa sasa
DocType: Subscription,Subscription Start Date,Tarehe ya Kuanza ya Usajili
DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Appointment charges.,Akaunti zilizopatikana zinazotumiwa kutumiwa ikiwa haziwekwa katika Mgonjwa ili uweze kulipa gharama za Uteuzi.
DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Weka faili ya .csv na nguzo mbili, moja kwa jina la zamani na moja kwa jina jipya"
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Address 2,Kutoka kwenye Anwani ya 2
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_proof_submission/employee_tax_exemption_proof_submission.js,Get Details From Declaration,Pata Maelezo Kutoka kwa Azimio
apps/erpnext/erpnext/accounts/utils.py,{0} {1} not in any active Fiscal Year.,{0} {1} sio mwaka wowote wa Fedha.
DocType: Packed Item,Parent Detail docname,Jina la jina la Mzazi
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,"Reference: {0}, Item Code: {1} and Customer: {2}","Rejea: {0}, Msimbo wa Item: {1} na Wateja: {2}"
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py,{0} {1} is not present in the parent company,{0} {1} haipo katika kampuni ya mzazi
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Trial Period End Date Cannot be before Trial Period Start Date,Tarehe ya mwisho ya kipindi cha majaribio Haiwezi kuwa kabla ya Tarehe ya Kuanza ya Kipindi
apps/erpnext/erpnext/utilities/user_progress.py,Kg,Kilo
DocType: Tax Withholding Category,Tax Withholding Category,Jamii ya Kuzuia Ushuru
apps/erpnext/erpnext/assets/doctype/asset_value_adjustment/asset_value_adjustment.py,Cancel the journal entry {0} first,Futa kuingia kwa gazeti {0} kwanza
DocType: Purchase Invoice,ACC-PINV-.YYYY.-,ACC-PINV -YYYY.-
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,BOM is not specified for subcontracting item {0} at row {1},BOM haijainishwa kwa kipengee cha kutenganisha {0} katika mfululizo {1}
DocType: Vital Signs,Reflexes,Reflexes
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js,{0} Result submittted,Matokeo ya {0} yaliyotolewa
DocType: Item Attribute,Increment,Uingizaji
apps/erpnext/erpnext/templates/pages/search_help.py,Help Results for,Matokeo ya Msaada kwa
apps/erpnext/erpnext/public/js/stock_analytics.js,Select Warehouse...,Chagua Warehouse ...
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Advertising,Matangazo
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py,Same Company is entered more than once,Kampuni sawa imeingia zaidi ya mara moja
DocType: Patient,Married,Ndoa
apps/erpnext/erpnext/accounts/party.py,Not permitted for {0},Hairuhusiwi kwa {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Get items from,Pata vitu kutoka
DocType: Stock Entry,Send to Subcontractor,Tuma kwa Subcontractor
DocType: Purchase Invoice,Apply Tax Withholding Amount,Tumia Kizuizi cha Ushuru wa Kuomba
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Total completed qty can not be greater than for quantity,Jumla ya qty iliyokamilishwa haiwezi kuwa kubwa kuliko kwa wingi
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Stock cannot be updated against Delivery Note {0},Hifadhi haiwezi kurekebishwa dhidi ya Kumbuka Utoaji {0}
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Total Amount Credited,Jumla ya Kizuizi
apps/erpnext/erpnext/templates/generators/item_group.html,No items listed,Hakuna vitu vilivyoorodheshwa
DocType: Asset Repair,Error Description,Maelezo ya Hitilafu
DocType: Payment Reconciliation,Reconcile,Kuunganishwa
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Grocery,Kula
DocType: Quality Inspection Reading,Reading 1,Kusoma 1
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Pension Funds,Mfuko wa Pensheni
DocType: Exchange Rate Revaluation Account,Gain/Loss,Kupata / Kupoteza
DocType: Crop,Perennial,Kudumu
DocType: Program,Is Published,Imechapishwa
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show Delivery Notes,Onyesha Vidokezo vya Uwasilishaji
apps/erpnext/erpnext/controllers/status_updater.py,"To allow over billing, update ""Over Billing Allowance"" in Accounts Settings or the Item.","Ili kuruhusu malipo zaidi, sasisha &quot;Idhini ya malipo ya juu ya bili&quot; katika Mipangilio ya Akaunti au Bidhaa."
DocType: Patient Appointment,Procedure,Utaratibu
DocType: Accounts Settings,Use Custom Cash Flow Format,Tumia Format ya Msajili wa Fedha ya Desturi
DocType: SMS Center,All Sales Person,Mtu wa Mauzo wote
DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,** Usambazaji wa kila mwezi ** husaidia kusambaza Bajeti / Target miezi miwili ikiwa una msimu katika biashara yako.
apps/erpnext/erpnext/accounts/page/pos/pos.js,Not items found,Si vitu vilivyopatikana
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Structure Missing,Mfumo wa Mshahara Ukosefu
DocType: Lead,Person Name,Jina la Mtu
,Supplier Ledger Summary,Muhtasari wa Ledger
DocType: Sales Invoice Item,Sales Invoice Item,Bidhaa Invoice Bidhaa
DocType: Quality Procedure Table,Quality Procedure Table,Jedwali la Utaratibu wa Ubora
DocType: Account,Credit,Mikopo
DocType: POS Profile,Write Off Cost Center,Andika Kituo cha Gharama
apps/erpnext/erpnext/public/js/setup_wizard.js,"e.g. ""Primary School"" or ""University""",mfano &quot;Shule ya Msingi&quot; au &quot;Chuo Kikuu&quot;
apps/erpnext/erpnext/config/stock.py,Stock Reports,Ripoti za hisa
DocType: Warehouse,Warehouse Detail,Maelezo ya Ghala
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py,Last carbon check date cannot be a future date,Tarehe ya mwisho ya kuangalia kaboni haiwezi kuwa tarehe ya baadaye
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,Tarehe ya Mwisho wa Mwisho haiwezi kuwa baadaye kuliko Tarehe ya Mwisho wa Mwaka wa Mwaka wa Chuo ambazo neno hilo limeunganishwa (Mwaka wa Chuo {}). Tafadhali tengeneza tarehe na jaribu tena.
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","&quot;Je, Mali isiyohamishika&quot; hawezi kufunguliwa, kama rekodi ya Malipo ipo dhidi ya kipengee"
DocType: Delivery Trip,Departure Time,Wakati wa Kuondoka
DocType: Vehicle Service,Brake Oil,Mafuta ya Brake
DocType: Tax Rule,Tax Type,Aina ya Kodi
,Completed Work Orders,Maagizo ya Kazi Iliyokamilishwa
DocType: Support Settings,Forum Posts,Ujumbe wa Vikao
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Kazi imejumuishwa kama kazi ya msingi. Ila ikiwa kuna suala lolote juu ya usindikaji nyuma, mfumo utaongeza maoni juu ya kosa kwenye Maridhiano haya ya Hisa na kurudi kwenye hatua ya Rasimu."
apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Kiwango cha Ushuru
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Huna mamlaka ya kuongeza au kusasisha safu kabla ya {0}
DocType: Leave Policy,Leave Policy Details,Acha maelezo ya Sera
DocType: BOM,Item Image (if not slideshow),Image Image (kama si slideshow)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order {3}. Please update operation status via Job Card {4}.,Njia # {0}: Operesheni {1} haijakamilika kwa {2} qty ya bidhaa kumaliza katika Agizo la Kazi {3}. Tafadhali sasisha hali ya operesheni kupitia Kadi ya kazi {4}.
DocType: Work Order Operation,(Hour Rate / 60) * Actual Operation Time,(Kiwango cha Saa / 60) * Muda halisi wa Uendeshaji
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Row # {0}: Aina ya Kumbukumbu ya Kumbukumbu lazima iwe moja ya Madai ya Madai au Ingia ya Jarida
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select BOM,Chagua BOM
DocType: SMS Log,SMS Log,Ingia ya SMS
DocType: Call Log,Ringing,Kupigia
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Delivered Items,Gharama ya Vitu Vilivyotolewa
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py,The holiday on {0} is not between From Date and To Date,Likizo ya {0} si kati ya Tarehe na Tarehe
DocType: Inpatient Record,Admission Scheduled,Uingizaji ulipangwa
DocType: Student Log,Student Log,Ingia ya Wanafunzi
apps/erpnext/erpnext/config/buying.py,Templates of supplier standings.,Matukio ya kusimama kwa wasambazaji.
DocType: Lead,Interested,Inastahili
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,Opening,Ufunguzi
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Program: ,Programu:
DocType: Item,Copy From Item Group,Nakala Kutoka Kundi la Bidhaa
DocType: Journal Entry,Opening Entry,Kuingia Uingiaji
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Account Pay Only,Malipo ya Akaunti tu
DocType: Loan,Repay Over Number of Periods,Rejesha Zaidi ya Kipindi cha Kipindi
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Quantity to Produce can not be less than Zero,Wingi wa Kutengeneza hauwezi kuwa chini ya Zero
DocType: Stock Entry,Additional Costs,Gharama za ziada
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction can not be converted to group.,Akaunti na shughuli zilizopo haziwezi kubadilishwa kuwa kikundi.
DocType: Lead,Product Enquiry,Utafutaji wa Bidhaa
DocType: Education Settings,Validate Batch for Students in Student Group,Thibitisha Batch kwa Wanafunzi katika Kikundi cha Wanafunzi
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,No leave record found for employee {0} for {1},Hakuna rekodi ya kuondoka iliyopatikana kwa mfanyakazi {0} kwa {1}
DocType: Company,Unrealized Exchange Gain/Loss Account,Akaunti isiyopunguzwa ya Kupatikana / Akaunti ya Kupoteza
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Please enter company first,Tafadhali ingiza kampuni kwanza
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Please select Company first,Tafadhali chagua Kampuni kwanza
DocType: Employee Education,Under Graduate,Chini ya Uhitimu
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Status Notification in HR Settings.,Tafadhali weka template default kwa Taarifa ya Hali ya Kuacha katika Mipangilio ya HR.
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/sales_partner_target_variance_based_on_item_group.js,Target On,Target On
DocType: BOM,Total Cost,Gharama ya jumla
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.js,Allocation Expired!,Ugawaji Umemalizika!
DocType: Soil Analysis,Ca/K,Ca / K
DocType: Leave Type,Maximum Carry Forwarded Leaves,Upeo Kubeba majani yaliyosafishwa
DocType: Salary Slip,Employee Loan,Mkopo wa Wafanyakazi
DocType: Additional Salary,HR-ADS-.YY.-.MM.-,HR-ADS-YY .-. MM.-
DocType: Fee Schedule,Send Payment Request Email,Tuma Email Request Request
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Item {0} does not exist in the system or has expired,Item {0} haipo katika mfumo au imeisha muda
DocType: Supplier,Leave blank if the Supplier is blocked indefinitely,Acha tupu ikiwa Muuzaji amezuiwa kwa muda usiojulikana
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Real Estate,Real Estate
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Statement of Account,Taarifa ya Akaunti
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Pharmaceuticals,Madawa
DocType: Purchase Invoice Item,Is Fixed Asset,"Je, ni Mali isiyohamishika"
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show Future Payments,Onyesha Malipo ya Baadaye
DocType: Patient,HLC-PAT-.YYYY.-,HLC-PAT -YYYY.-
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,This bank account is already synchronized,Akaunti hii ya benki tayari imesawazishwa
DocType: Homepage,Homepage Section,Sehemu ya ukurasa
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work Order has been {0},Kazi ya Kazi imekuwa {0}
DocType: Budget,Applicable on Purchase Order,Inatumika kwa Utaratibu wa Ununuzi
DocType: Item,STO-ITEM-.YYYY.-,STO-ITEM-YYYY.-
apps/erpnext/erpnext/hr/doctype/hr_settings/hr_settings.py,Password policy for Salary Slips is not set,Sera ya nenosiri ya Slips Slary haijawekwa
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Duplicate customer group found in the cutomer group table,Duplicate kundi la mteja kupatikana katika meza cutomer kundi
DocType: Location,Location Name,Jina la Mahali
DocType: Quality Procedure Table,Responsible Individual,Kuwajibika Mtu mmoja mmoja
DocType: Naming Series,Prefix,Kiambatisho
apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html,Event Location,Eneo la Tukio
apps/erpnext/erpnext/selling/report/customer_wise_item_price/customer_wise_item_price.py,Available Stock,Inapatikana Duka
DocType: Asset Settings,Asset Settings,Mipangilio ya Mali
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Inatumiwa
DocType: Student,B-,B-
DocType: Assessment Result,Grade,Daraja
DocType: Restaurant Table,No of Seats,Hakuna Viti
DocType: Sales Invoice,Overdue and Discounted,Imepitwa na kupunguzwa
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Simu Imekataliwa
DocType: Sales Invoice Item,Delivered By Supplier,Iliyotolewa na Wafanyabiashara
DocType: Asset Maintenance Task,Asset Maintenance Task,Kazi ya Matengenezo ya Mali
DocType: SMS Center,All Contact,Mawasiliano yote
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Annual Salary,Mshahara wa Kila mwaka
DocType: Daily Work Summary,Daily Work Summary,Muhtasari wa Kazi ya Kila siku
DocType: Period Closing Voucher,Closing Fiscal Year,Kufunga Mwaka wa Fedha
apps/erpnext/erpnext/accounts/party.py,{0} {1} is frozen,{0} {1} imehifadhiwa
apps/erpnext/erpnext/setup/doctype/company/company.py,Please select Existing Company for creating Chart of Accounts,Tafadhali chagua Kampuni iliyopo kwa kuunda Chati ya Akaunti
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Expenses,Gharama za Hifadhi
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Select Target Warehouse,Chagua Ghala la Target
apps/erpnext/erpnext/hr/doctype/employee/employee.js,Please enter Preferred Contact Email,Tafadhali ingiza barua pepe ya Mawasiliano ya Preferred
DocType: Purchase Invoice Item,Accepted Qty,Iliyokubaliwa Qty
DocType: Journal Entry,Contra Entry,Uingizaji wa Contra
DocType: Journal Entry Account,Credit in Company Currency,Mikopo katika Kampuni ya Fedha
DocType: Lab Test UOM,Lab Test UOM,Mtihani wa UAM wa Lab
DocType: Delivery Note,Installation Status,Hali ya Ufungaji
DocType: BOM,Quality Inspection Template,Kigezo cha Uhakiki wa Ubora
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,"Do you want to update attendance?<br>Present: {0}\
					<br>Absent: {1}",Unataka update wahudhuriaji? <br> Sasa: {0} \ <br> Haipo: {1}
apps/erpnext/erpnext/controllers/buying_controller.py,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Ilikubaliwa + Uchina uliopokea lazima uwe sawa na wingi uliopokea kwa Item {0}
DocType: Item,Supply Raw Materials for Purchase,Vifaa vya Raw kwa Ununuzi
DocType: Agriculture Analysis Criteria,Fertilizer,Mbolea
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
				Item {0} is added with and without Ensure Delivery by \
				Serial No.",Haiwezi kuhakikisha utoaji wa Serial Hakuna kama \ Item {0} imeongezwa na bila ya Kuhakikisha Utoaji kwa \ Nambari ya Serial
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,At least one mode of payment is required for POS invoice.,Angalau mode moja ya malipo inahitajika kwa ankara za POS.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Batch no is required for batched item {0},Batch hapana inahitajika kwa bidhaa iliyopigwa {0}
DocType: Bank Statement Transaction Invoice Item,Bank Statement Transaction Invoice Item,Taarifa ya Benki ya Invoice Item
DocType: Salary Detail,Tax on flexible benefit,Kodi kwa faida rahisi
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item {0} is not active or end of life has been reached,Kipengee {0} sio kazi au mwisho wa uhai umefikiwa
DocType: Student Admission Program,Minimum Age,Umri mdogo
apps/erpnext/erpnext/utilities/user_progress.py,Example: Basic Mathematics,Mfano: Msabati Msingi
DocType: Customer,Primary Address,Anwani ya Msingi
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Diff Qty,Tofauti
DocType: Production Plan,Material Request Detail,Maelezo ya Maelezo ya Nyenzo
DocType: Selling Settings,Default Quotation Validity Days,Siku za Uthibitishaji wa Nukuu za Default
apps/erpnext/erpnext/controllers/accounts_controller.py,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Ili ni pamoja na kodi katika mstari {0} katika kiwango cha kipengee, kodi katika safu {1} lazima pia ziingizwe"
apps/erpnext/erpnext/config/quality_management.py,Quality Procedure.,Utaratibu wa Ubora.
DocType: SMS Center,SMS Center,Kituo cha SMS
DocType: Payroll Entry,Validate Attendance,Thibitisha Mahudhurio
DocType: Sales Invoice,Change Amount,Badilisha kiasi
DocType: Party Tax Withholding Config,Certificate Received,Hati ya Kupokea
DocType: GST Settings,Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Weka thamani ya ankara kwa B2C. B2CL na B2CS zimehesabiwa kulingana na thamani hii ya ankara.
DocType: BOM Update Tool,New BOM,BOM mpya
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Prescribed Procedures,Taratibu zilizowekwa
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js,Show only POS,Onyesha POS tu
DocType: Supplier Group,Supplier Group Name,Jina la kundi la wasambazaji
DocType: Driver,Driving License Categories,Makundi ya leseni ya kuendesha gari
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please enter Delivery Date,Tafadhali ingiza tarehe ya utoaji
DocType: Depreciation Schedule,Make Depreciation Entry,Fanya kuingia kwa kushuka kwa thamani
DocType: Closed Document,Closed Document,Hati iliyofungwa
DocType: HR Settings,Leave Settings,Acha Mipangilio
DocType: Appraisal Template Goal,KRA,KRA
DocType: Lead,Request Type,Aina ya Ombi
DocType: Purpose of Travel,Purpose of Travel,Kusudi la Safari
DocType: Payroll Period,Payroll Periods,Kipindi cha Mishahara
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Broadcasting,Matangazo
apps/erpnext/erpnext/config/retail.py,Setup mode of POS (Online / Offline),Mipangilio ya POS (Online / Offline)
DocType: Manufacturing Settings,Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order,Inalemaza uumbaji wa kumbukumbu za wakati dhidi ya Maagizo ya Kazi. Uendeshaji hautafuatiwa dhidi ya Kazi ya Kazi
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Execution,Utekelezaji
apps/erpnext/erpnext/config/manufacturing.py,Details of the operations carried out.,Maelezo ya shughuli zilizofanywa.
DocType: Asset Maintenance Log,Maintenance Status,Hali ya Matengenezo
DocType: Purchase Invoice Item,Item Tax Amount Included in Value,Kiwango cha Kodi ya Bidhaa Pamoja na Thamani
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py,Membership Details,Maelezo ya Uanachama
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Muuzaji inahitajika dhidi ya akaunti inayolipwa {2}
apps/erpnext/erpnext/config/buying.py,Items and Pricing,Vitu na bei
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,Total hours: {0},Masaa yote: {0}
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,From Date should be within the Fiscal Year. Assuming From Date = {0},Kutoka Tarehe lazima iwe ndani ya Mwaka wa Fedha. Kutokana na Tarehe = {0}
DocType: Patient Medical Record,HLC-PMR-.YYYY.-,HLC-PMR -YYYY.-
DocType: Drug Prescription,Interval,Muda
DocType: Pricing Rule,Promotional Scheme Id,Kitambulisho cha Mpango wa Uendelezaji
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Preference,Upendeleo
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward Supplies(liable to reverse charge,Ugavi wa ndani (inawajibika kubadilisha malipo
DocType: Supplier,Individual,Kila mtu
DocType: Academic Term,Academics User,Mwanafunzi wa Wasomi
DocType: Cheque Print Template,Amount In Figure,Kiasi Kielelezo
DocType: Loan Application,Loan Info,Info Loan
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,All Other ITC,ITC nyingine zote
apps/erpnext/erpnext/config/crm.py,Plan for maintenance visits.,Mpango wa ziara za matengenezo.
DocType: Supplier Scorecard Period,Supplier Scorecard Period,Kipindi cha Scorecard Kipindi
DocType: Support Settings,Search APIs,Tafuta API
DocType: Share Transfer,Share Transfer,Shiriki Uhamisho
,Expiring Memberships,Kuondoa Uanachama
apps/erpnext/erpnext/templates/pages/home.html,Read blog,Soma blogi
DocType: POS Profile,Customer Groups,Vikundi vya Wateja
apps/erpnext/erpnext/public/js/financial_statements.js,Financial Statements,Taarifa za Fedha
DocType: Guardian,Students,Wanafunzi
apps/erpnext/erpnext/config/buying.py,Rules for applying pricing and discount.,Sheria ya kutumia bei na discount.
DocType: Daily Work Summary,Daily Work Summary Group,Kikundi cha Muhtasari wa Kazi Kila siku
DocType: Practitioner Schedule,Time Slots,Muda wa Muda
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py,Price List must be applicable for Buying or Selling,Orodha ya Bei lazima iwezekanavyo kwa Ununuzi au Ununuzi
DocType: Shift Assignment,Shift Request,Ombi la Shift
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Installation date cannot be before delivery date for Item {0},Tarehe ya usanii haiwezi kuwa kabla ya tarehe ya utoaji wa Bidhaa {0}
DocType: Purchase Invoice Item,Discount on Price List Rate (%),Punguzo kwa Orodha ya Bei Kiwango (%)
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js,Item Template,Kigezo cha Kigezo
DocType: Job Offer,Select Terms and Conditions,Chagua Masharti na Masharti
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Out Value,Thamani ya nje
DocType: Bank Statement Settings Item,Bank Statement Settings Item,Mipangilio ya Taarifa ya Benki
DocType: Woocommerce Settings,Woocommerce Settings,Mipangilio ya Woocommerce
DocType: Leave Ledger Entry,Transaction Name,Jina la manunuzi
DocType: Production Plan,Sales Orders,Maagizo ya Mauzo
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Multiple Loyalty Program found for the Customer. Please select manually.,Mpango wa Uaminifu Mingi uliopatikana kwa Wateja. Tafadhali chagua manually.
DocType: Purchase Taxes and Charges,Valuation,Vigezo
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Set as Default,Weka kama Msingi
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Expiry date is mandatory for selected item.,Tarehe ya kumalizika ni ya lazima kwa bidhaa iliyochaguliwa.
,Purchase Order Trends,Mwelekeo wa Utaratibu wa Ununuzi
apps/erpnext/erpnext/utilities/user_progress.py,Go to Customers,Nenda kwa Wateja
DocType: Hotel Room Reservation,Late Checkin,Checkin ya muda mfupi
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Finding linked payments,Kupata malipo yaliyounganishwa
apps/erpnext/erpnext/templates/emails/request_for_quotation.html,The request for quotation can be accessed by clicking on the following link,Ombi la nukuu inaweza kupatikana kwa kubonyeza kiungo kinachofuata
DocType: Quiz Result,Selected Option,Chaguo lililochaguliwa
DocType: SG Creation Tool Course,SG Creation Tool Course,Njia ya Uumbaji wa SG
DocType: Bank Statement Transaction Invoice Item,Payment Description,Maelezo ya Malipo
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Insufficient Stock,Hifadhi haitoshi
DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Zima Mipangilio ya Uwezo na Ufuatiliaji wa Muda
DocType: Email Digest,New Sales Orders,Amri mpya ya Mauzo
DocType: Bank Account,Bank Account,Akaunti ya benki
DocType: Travel Itinerary,Check-out Date,Tarehe ya Kuangalia
DocType: Leave Type,Allow Negative Balance,Ruhusu Kiwango cha Mizani
apps/erpnext/erpnext/projects/doctype/project_type/project_type.py,You cannot delete Project Type 'External',Huwezi kufuta Aina ya Mradi &#39;Nje&#39;
apps/erpnext/erpnext/public/js/utils.js,Select Alternate Item,Chagua kipengee cha Mbadala
DocType: Employee,Create User,Unda Mtumiaji
DocType: Selling Settings,Default Territory,Eneo la Default
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Television,Televisheni
DocType: Work Order Operation,Updated via 'Time Log',Imesasishwa kupitia &#39;Ingia ya Muda&#39;
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Select the customer or supplier.,Chagua mteja au muuzaji.
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Select only one Priority as Default.,Chagua Kipaumbele kimoja tu kama Chaguo-msingi.
apps/erpnext/erpnext/controllers/taxes_and_totals.py,Advance amount cannot be greater than {0} {1},Kiasi cha juu hawezi kuwa kikubwa kuliko {0} {1}
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Muda wa muda umekwisha, slot {0} kwa {1} huingilia slot ya kutosha {2} kwa {3}"
DocType: Naming Series,Series List for this Transaction,Orodha ya Mfululizo kwa Shughuli hii
DocType: Company,Enable Perpetual Inventory,Wezesha Mali ya daima
DocType: Bank Guarantee,Charges Incurred,Malipo yaliyoingizwa
apps/erpnext/erpnext/public/js/education/lms/quiz.js,Something went wrong while evaluating the quiz.,Kuna kitu kilienda vibaya wakati wa kukagua jaribio.
DocType: Company,Default Payroll Payable Account,Akaunti ya malipo ya malipo ya malipo
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Edit Details,Maelezo ya Hariri
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Update Email Group,Sasisha Kikundi cha Barua pepe
DocType: POS Profile,Only show Customer of these Customer Groups,Onyesha tu Mteja wa Makundi haya ya Wateja
DocType: Sales Invoice,Is Opening Entry,"Je, unafungua kuingia"
apps/erpnext/erpnext/public/js/conf.js,Documentation,Nyaraka
DocType: Lab Test Template,"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Ikiwa haukufunguliwa, kipengee hakika kuonekana katika Invoice ya Mauzo, lakini inaweza kutumika katika viumbe vya mtihani wa kikundi."
DocType: Customer Group,Mention if non-standard receivable account applicable,Eleza ikiwa akaunti isiyo ya kawaida inayotumika inatumika
DocType: Course Schedule,Instructor Name,Jina la Mwalimu
DocType: Company,Arrear Component,Kipengele cha nyuma
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.py,Stock Entry has been already created against this Pick List,Uingilio wa hisa tayari umeundwa dhidi ya Orodha hii ya Chagua
DocType: Supplier Scorecard,Criteria Setup,Uwekaji wa Kanuni
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,For Warehouse is required before Submit,Kwa Ghala inahitajika kabla ya Wasilisha
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Received On,Imepokea
DocType: Codification Table,Medical Code,Kanuni ya Matibabu
apps/erpnext/erpnext/config/integrations.py,Connect Amazon with ERPNext,Unganisha Amazon na ERPNext
apps/erpnext/erpnext/templates/generators/item/item_configure.html,Contact Us,Wasiliana nasi
DocType: Delivery Note Item,Against Sales Invoice Item,Dhidi ya Bidhaa ya Invoice Item
DocType: Agriculture Analysis Criteria,Linked Doctype,Doctype inayohusiana
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Financing,Fedha Nasi kutoka kwa Fedha
apps/erpnext/erpnext/accounts/page/pos/pos.js,"LocalStorage is full , did not save","Mitaa ya Mitaa imejaa, haikuhifadhi"
DocType: Lead,Address & Contact,Anwani na Mawasiliano
DocType: Leave Allocation,Add unused leaves from previous allocations,Ongeza majani yasiyotumika kutoka kwa mgao uliopita
DocType: Sales Partner,Partner website,Mtandao wa wavuti
DocType: Restaurant Order Entry,Add Item,Ongeza kitu
DocType: Party Tax Withholding Config,Party Tax Withholding Config,Mpangilio wa Kodi ya Kuzuia Ushuru
DocType: Lab Test,Custom Result,Matokeo ya Desturi
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.js,Bank accounts added,Akaunti za benki ziliongezwa
DocType: Call Log,Contact Name,Jina la Mawasiliano
DocType: Plaid Settings,Synchronize all accounts every hour,Sawazisha akaunti zote kila saa
DocType: Course Assessment Criteria,Course Assessment Criteria,Vigezo vya Tathmini ya Kozi
DocType: Pricing Rule Detail,Rule Applied,Sheria Imetumika
DocType: Service Level Priority,Resolution Time Period,Kipindi cha Wakati wa Azimio
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Tax Id: ,Id ya kodi:
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student ID: ,Kitambulisho cha Mwanafunzi:
DocType: POS Customer Group,POS Customer Group,Kundi la Wateja wa POS
DocType: Healthcare Practitioner,Practitioner Schedules,Mipango ya Watendaji
DocType: Cheque Print Template,Line spacing for amount in words,Upeo wa mstari wa kiasi kwa maneno
DocType: Vehicle,Additional Details,Maelezo ya ziada
apps/erpnext/erpnext/templates/generators/bom.html,No description given,Hakuna maelezo yaliyotolewa
apps/erpnext/erpnext/config/buying.py,Request for purchase.,Omba la ununuzi.
DocType: POS Closing Voucher Details,Collected Amount,Kukusanya Kiasi
DocType: Lab Test,Submitted Date,Tarehe iliyotolewa
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Company field is required,Sehemu ya kampuni inahitajika
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py,This is based on the Time Sheets created against this project,Hii inategemea Majedwali ya Muda yaliyoundwa dhidi ya mradi huu
DocType: Call Log,Recording URL,Kurekodi URL
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,Start Date cannot be before the current date,Tarehe ya kuanza haiwezi kuwa kabla ya tarehe ya sasa
,Open Work Orders,Omba Kazi za Kazi
DocType: Healthcare Practitioner,Out Patient Consulting Charge Item,Nje Mchapishaji wa Ushauri wa Patient
DocType: Payment Term,Credit Months,Miezi ya Mikopo
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Net Pay cannot be less than 0,Net Pay haiwezi kuwa chini ya 0
DocType: Contract,Fulfilled,Imetimizwa
DocType: Inpatient Record,Discharge Scheduled,Kuondolewa Imepangwa
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Relieving Date must be greater than Date of Joining,Tarehe ya Kuondoa lazima iwe kubwa kuliko Tarehe ya kujiunga
DocType: POS Closing Voucher,Cashier,Msaidizi
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Leaves per Year,Majani kwa mwaka
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Row {0}: Tafadhali angalia &#39;Je, Advance&#39; dhidi ya Akaunti {1} ikiwa hii ni kuingia mapema."
apps/erpnext/erpnext/stock/utils.py,Warehouse {0} does not belong to company {1},Ghala {0} sio wa kampuni {1}
DocType: Email Digest,Profit & Loss,Faida &amp; Kupoteza
apps/erpnext/erpnext/utilities/user_progress.py,Litre,Vitabu
DocType: Task,Total Costing Amount (via Time Sheet),Kiwango cha jumla cha gharama (kupitia Karatasi ya Muda)
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py,Please setup Students under Student Groups,Tafadhali kuanzisha Wanafunzi chini ya Vikundi vya Wanafunzi
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Complete Job,Kazi kamili
DocType: Item Website Specification,Item Website Specification,Ufafanuzi wa Tovuti
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Leave Blocked,Acha Kuzuiwa
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} has reached its end of life on {1},Kipengee {0} kilifikia mwisho wa maisha kwa {1}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Bank Entries,Entries ya Benki
DocType: Customer,Is Internal Customer,Ni Wateja wa Ndani
DocType: Crop,Annual,Kila mwaka
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"If Auto Opt In is checked, then the customers will be automatically linked with the concerned Loyalty Program (on save)","Ikiwa Auto Opt In inakaguliwa, basi wateja watahusishwa moja kwa moja na Mpango wa Uaminifu unaohusika (juu ya kuokoa)"
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Toleo la Upatanisho wa hisa
DocType: Stock Entry,Sales Invoice No,Nambari ya ankara ya mauzo
DocType: Website Filter Field,Website Filter Field,Uwanja wa Kichujio cha Wavuti
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Supply Type,Aina ya Ugavi
DocType: Material Request Item,Min Order Qty,Uchina wa Uchina
DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Kozi ya Uumbaji wa Wanafunzi wa Wanafunzi
DocType: Lead,Do Not Contact,Usiwasiliane
apps/erpnext/erpnext/utilities/user_progress.py,People who teach at your organisation,Watu ambao hufundisha katika shirika lako
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Software Developer,Msanidi Programu
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Create Sample Retention Stock Entry,Unda Wasilisho la Hifadhi la Sampuli
DocType: Item,Minimum Order Qty,Kiwango cha chini cha Uchina
DocType: Supplier,Supplier Type,Aina ya Wasambazaji
DocType: Course Scheduling Tool,Course Start Date,Tarehe ya Kuanza Kozi
,Student Batch-Wise Attendance,Uhudhuriaji wa Kundi la Wanafunzi
DocType: POS Profile,Allow user to edit Rate,Ruhusu mtumiaji kuhariri Kiwango
DocType: Item,Publish in Hub,Chapisha katika Hub
DocType: Student Admission,Student Admission,Uingizaji wa Wanafunzi
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is cancelled,Kipengee {0} kimefutwa
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Depreciation Start Date is entered as past date,Upungufu Row {0}: Tarehe ya Kuondoa Dhamana imeingia kama tarehe iliyopita
DocType: Contract Template,Fulfilment Terms and Conditions,Masharti na Masharti ya kukamilika
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Material Request,Ombi la Nyenzo
DocType: Bank Reconciliation,Update Clearance Date,Sasisha tarehe ya kufuta
apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,Bundle Qty,Kifungu Qty
,GSTR-2,GSTR-2
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Kipengee {0} haipatikani kwenye meza ya &#39;Vifaa vya Raw zinazotolewa&#39; katika Manunuzi ya Ununuzi {1}
DocType: Salary Slip,Total Principal Amount,Jumla ya Kiasi Kikubwa
DocType: Student Guardian,Relation,Uhusiano
DocType: Quiz Result,Correct,Sahihi
DocType: Student Guardian,Mother,Mama
DocType: Restaurant Reservation,Reservation End Time,Muda wa Mwisho wa Uhifadhi
DocType: Crop,Biennial,Biennial
,BOM Variance Report,Ripoti ya kutofautiana ya BOM
apps/erpnext/erpnext/config/selling.py,Confirmed orders from Customers.,Amri zilizohakikishwa kutoka kwa Wateja.
DocType: Purchase Receipt Item,Rejected Quantity,Nambari ya Kukataliwa
apps/erpnext/erpnext/education/doctype/fees/fees.py,Payment request {0} created,Ombi la kulipa {0} limeundwa
DocType: Inpatient Record,Admitted Datetime,Saa ya tarehe iliyokubaliwa
DocType: Work Order,Backflush raw materials from work-in-progress warehouse,Weka vifaa vya malighafi kutoka ghala ya kazi-in-progress
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Open Orders,Fungua Maagizo
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Unable to find Salary Component {0},Imeshindwa kupata sehemu ya Mshahara {0}
apps/erpnext/erpnext/healthcare/setup.py,Low Sensitivity,Sensitivity Low
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_log/shopify_log.js,Order rescheduled for sync,Amri imewekwa tena kwa usawazishaji
apps/erpnext/erpnext/templates/emails/training_event.html,Please confirm once you have completed your training,Tafadhali thibitisha mara moja umekamilisha mafunzo yako
DocType: Lead,Suggestions,Mapendekezo
DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Weka bajeti za hekima za busara katika eneo hili. Unaweza pia kujumuisha msimu kwa kuweka Usambazaji.
DocType: Plaid Settings,Plaid Public Key,Ufunguo wa Umma uliowekwa
DocType: Payment Term,Payment Term Name,Jina la Muda wa Malipo
DocType: Healthcare Settings,Create documents for sample collection,Unda nyaraka za ukusanyaji wa sampuli
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Malipo dhidi ya {0} {1} haiwezi kuwa kubwa zaidi kuliko Kiasi Kikubwa {2}
apps/erpnext/erpnext/patches/v11_0/add_healthcare_service_unit_tree_root.py,All Healthcare Service Units,Huduma zote za huduma za afya
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Converting Opportunity,Juu ya Kubadilisha Fursa
DocType: Bank Account,Address HTML,Weka HTML
DocType: Lead,Mobile No.,Simu ya Simu
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html,Mode of Payments,Hali ya Malipo
DocType: Maintenance Schedule,Generate Schedule,Tengeneza Ratiba
DocType: Purchase Invoice Item,Expense Head,Mkuu wa gharama
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select Charge Type first,Tafadhali chagua Aina ya Chapa kwanza
DocType: Crop,"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Unaweza kufafanua kazi zote zinazohitajika kwa mazao haya hapa. Shamba la siku linatumiwa kutaja siku ambayo kazi inahitaji kufanywa, 1 kuwa siku ya 1, nk."
DocType: Student Group Student,Student Group Student,Mwanafunzi wa Kikundi cha Wanafunzi
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Latest,Latest
DocType: Asset Maintenance Task,2 Yearly,2 kwa mwaka
DocType: Education Settings,Education Settings,Mipangilio ya Elimu
DocType: Vehicle Service,Inspection,Ukaguzi
apps/erpnext/erpnext/regional/italy/utils.py,E-Invoicing Information Missing,Kukosekana kwa habari ya Uwakilishi
DocType: Leave Allocation,HR-LAL-.YYYY.-,HR-LAL -YYYY.-
DocType: Exchange Rate Revaluation Account,Balance In Base Currency,Mizani Katika Fedha ya Msingi
DocType: Supplier Scorecard Scoring Standing,Max Grade,Daraja la Max
DocType: Email Digest,New Quotations,Nukuu mpya
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Attendance not submitted for {0} as {1} on leave.,Mahudhurio hayajawasilishwa kwa {0} kama {1} wakati wa kuondoka.
DocType: Journal Entry,Payment Order,Ulipaji wa Malipo
DocType: Employee Tax Exemption Declaration,Income From Other Sources,Mapato Kutoka kwa Vyanzo Vingine
DocType: Warehouse,"If blank, parent Warehouse Account or company default will be considered","Ikiwa iko wazi, Akaunti ya Ghala la mzazi au chaguo-msingi cha kampuni itazingatiwa"
DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,Mipango ya mishahara ya barua pepe kwa mfanyakazi kulingana na barua pepe iliyopendekezwa iliyochaguliwa katika Mfanyakazi
DocType: Tax Rule,Shipping County,Kata ya Meli
DocType: Currency Exchange,For Selling,Kwa Kuuza
apps/erpnext/erpnext/config/desktop.py,Learn,Jifunze
,Trial Balance (Simple),Mizani ya jaribio (Rahisi)
DocType: Purchase Invoice Item,Enable Deferred Expense,Wezesha gharama zilizofanywa
DocType: Asset,Next Depreciation Date,Tarehe ya Uzito ya pili
apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Shughuli ya Gharama kwa Wafanyakazi
DocType: Accounts Settings,Settings for Accounts,Mipangilio ya Akaunti
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Supplier Invoice No exists in Purchase Invoice {0},Invozi ya Wauzaji Hakuna ipo katika ankara ya ununuzi {0}
apps/erpnext/erpnext/config/crm.py,Manage Sales Person Tree.,Dhibiti Mti wa Watu wa Mauzo.
DocType: Job Applicant,Cover Letter,Barua ya maombi
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Outstanding Cheques and Deposits to clear,Cheki Bora na Deposits ili kufuta
DocType: Item,Synced With Hub,Ilifananishwa na Hub
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward supplies from ISD,Vifaa vya ndani kutoka ISD
DocType: Driver,Fleet Manager,Meneja wa Fleet
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Row #{0}: {1} can not be negative for item {2},Row # {0}: {1} haiwezi kuwa hasi kwa kipengee {2}
apps/erpnext/erpnext/setup/doctype/company/company.js,Wrong Password,Nywila isiyo sahihi
DocType: POS Profile,Offline POS Settings,Mipangilio ya POS ya nje ya mtandao
DocType: Stock Entry Detail,Reference Purchase Receipt,Risiti ya Ununuzi wa Marejeo
DocType: Stock Reconciliation,MAT-RECO-.YYYY.-,MAT-RECO -YYYY.-
apps/erpnext/erpnext/templates/includes/cart/cart_items.html,Variant Of,Tofauti Ya
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Completed Qty can not be greater than 'Qty to Manufacture',Uchina uliokamilika hauwezi kuwa mkubwa kuliko &#39;Uchina kwa Utengenezaji&#39;
apps/erpnext/erpnext/public/js/purchase_trends_filters.js,Period based On,Kipindi kinachozingatia
DocType: Period Closing Voucher,Closing Account Head,Kufunga kichwa cha Akaunti
DocType: Employee,External Work History,Historia ya Kazi ya Kazi
apps/erpnext/erpnext/projects/doctype/task/task.py,Circular Reference Error,Hitilafu ya Kumbukumbu ya Circular
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student Report Card,Kadi ya Ripoti ya Wanafunzi
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Pin Code,Kutoka kwa Kanuni ya Pin
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show Sales Person,Onyesha Mtu wa Uuzaji
DocType: Appointment Type,Is Inpatient,"Je, ni mgonjwa"
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Name,Jina la Guardian1
DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,Katika Maneno (Kuhamisha) itaonekana wakati unapohifadhi Kumbuka Utoaji.
DocType: Cheque Print Template,Distance from left edge,Umbali kutoka makali ya kushoto
apps/erpnext/erpnext/utilities/bot.py,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} vitengo vya {{1}] (# Fomu / Bidhaa / {1}) vilivyopatikana [{2}] (# Fomu / Ghala / {2})
DocType: Lead,Industry,Sekta
DocType: BOM Item,Rate & Amount,Kiwango na Kiasi
apps/erpnext/erpnext/config/website.py,Settings for website product listing,Mipangilio ya orodha ya bidhaa za wavuti
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Amount of Integrated Tax,Kiasi cha Ushuru Unaojumuishwa
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Arifa kwa barua pepe juu ya uumbaji wa Nyenzo ya Nyenzo ya Moja kwa moja
DocType: Accounting Dimension,Dimension Name,Jina la Vipimo
apps/erpnext/erpnext/healthcare/setup.py,Resistant,Wanakabiliwa
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py,Please set Hotel Room Rate on {},Tafadhali weka Kiwango cha Chumba cha Hoteli kwenye {}
DocType: Journal Entry,Multi Currency,Fedha nyingi
DocType: Bank Statement Transaction Invoice Item,Invoice Type,Aina ya ankara
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Valid from date must be less than valid upto date,Inayotumika kutoka tarehe lazima iwe chini ya tarehe halali halali
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Exception occurred while reconciling {0},Kuondoa kulitokea wakati wa kupatanisha {0}
DocType: Purchase Invoice,Set Accepted Warehouse,Weka Ghala Iliyokubaliwa
DocType: Employee Benefit Claim,Expense Proof,Ushahidi wa gharama
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.py,Saving {0},Inahifadhi {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Delivery Note,Kumbuka Utoaji
DocType: Patient Encounter,Encounter Impression,Kukutana na Mchapishaji
apps/erpnext/erpnext/config/help.py,Setting up Taxes,Kuweka Kodi
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of Sold Asset,Gharama ya Malipo ya Kuuza
DocType: Volunteer,Morning,Asubuhi
apps/erpnext/erpnext/accounts/utils.py,Payment Entry has been modified after you pulled it. Please pull it again.,Ulipaji wa Malipo umebadilishwa baada ya kuvuta. Tafadhali futa tena.
DocType: Program Enrollment Tool,New Student Batch,Kikundi kipya cha Wanafunzi
apps/erpnext/erpnext/accounts/doctype/item_tax_template/item_tax_template.py,{0} entered twice in Item Tax,{0} imeingia mara mbili katika Kodi ya Item
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Summary for this week and pending activities,Muhtasari wa wiki hii na shughuli zinazosubiri
DocType: Student Applicant,Admitted,Imekubaliwa
DocType: Workstation,Rent Cost,Gharama ya Kodi
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid transactions sync error,Makosa ya kusawazisha shughuli
DocType: Leave Ledger Entry,Is Expired,Imemaliza muda wake
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py,Amount After Depreciation,Kiasi Baada ya kushuka kwa thamani
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Upcoming Calendar Events,Matukio ya kalenda ijayo
apps/erpnext/erpnext/public/js/templates/item_quick_entry.html,Variant Attributes,Tabia za aina tofauti
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Please select month and year,Tafadhali chagua mwezi na mwaka
DocType: Employee,Company Email,Kampuni ya barua pepe
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,User has not applied rule on the invoice {0},Mtumiaji hajatumia sheria kwenye ankara {0}
DocType: GL Entry,Debit Amount in Account Currency,Kiwango cha Debit katika Fedha za Akaunti
DocType: Supplier Scorecard,Scoring Standings,Kusimamisha Msimamo
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Value,Thamani ya Utaratibu
DocType: Certified Consultant,Certified Consultant,Mshauri Msaidiwa
apps/erpnext/erpnext/config/accounting.py,Bank/Cash transactions against party or for internal transfer,Shughuli za Benki / Cash dhidi ya chama au kwa uhamisho wa ndani
DocType: Shipping Rule,Valid for Countries,Halali kwa Nchi
apps/erpnext/erpnext/hr/doctype/training_event/training_event.py,End time cannot be before start time,Wakati wa mwisho hauwezi kuwa kabla ya kuanza
apps/erpnext/erpnext/templates/generators/item/item_configure.js,1 exact match.,Mechi 1 kamili.
apps/erpnext/erpnext/stock/doctype/item/item.js,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,Jedwali hili ni Kigezo na hawezi kutumika katika shughuli. Vipengee vya kipengee vitachapishwa kwenye vipengee isipokuwa &#39;Hakuna nakala&#39; imewekwa
DocType: Grant Application,Grant Application,Programu ya Ruzuku
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Total Order Considered,Amri ya Jumla imezingatiwa
DocType: Certification Application,Not Certified,Si kuthibitishwa
DocType: Asset Value Adjustment,New Asset Value,Thamani mpya ya Mali
DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,Kiwango ambacho Fedha ya Wateja inabadilishwa kwa sarafu ya msingi ya wateja
DocType: Course Scheduling Tool,Course Scheduling Tool,Chombo cha Mpangilio wa Kozi
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Row # {0}: Invoice ya Ununuzi haiwezi kufanywa dhidi ya mali iliyopo {1}
DocType: Crop Cycle,LInked Analysis,Uchunguzi LInked
DocType: POS Closing Voucher,POS Closing Voucher,Voucher ya POS ya Kufungwa
apps/erpnext/erpnext/support/doctype/issue_priority/issue_priority.py,Issue Priority Already Exists,Maswala ya Kipaumbele tayari Yapo
DocType: Invoice Discounting,Loan Start Date,Mkopo wa Kuanza tarehe
DocType: Contract,Lapsed,Imeshindwa
DocType: Item Tax Template Detail,Tax Rate,Kiwango cha Kodi
apps/erpnext/erpnext/education/doctype/course_activity/course_activity.py,Course Enrollment {0} does not exists,Uandikishaji wa kozi {0} haipo
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Application period cannot be across two allocation records,Kipindi cha maombi haiwezi kuwa rekodi mbili za ugawaji
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,{0} already allocated for Employee {1} for period {2} to {3},{0} tayari imetengwa kwa Mfanyakazi {1} kwa muda {2} hadi {3}
DocType: Buying Settings,Backflush Raw Materials of Subcontract Based On,Rejesha vifaa vya Raw vya Subcontract Based On
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Purchase Invoice {0} is already submitted,Invozi ya Ununuzi {0} imewasilishwa tayari
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Batch No must be same as {1} {2},Row # {0}: Kundi Hakuna lazima iwe sawa na {1} {2}
DocType: Material Request Plan Item,Material Request Plan Item,Nambari ya Mpango wa Nambari
DocType: Leave Type,Allow Encashment,Ruhusu Encashment
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Convert to non-Group,Badilisha kwa mashirika yasiyo ya Kundi
DocType: Exotel Settings,Account SID,Akaunti SID
DocType: Bank Statement Transaction Invoice Item,Invoice Date,Tarehe ya ankara
DocType: GL Entry,Debit Amount,Kiwango cha Debit
apps/erpnext/erpnext/accounts/party.py,There can only be 1 Account per Company in {0} {1},Kunaweza tu Akaunti 1 kwa Kampuni katika {0} {1}
DocType: Support Search Source,Response Result Key Path,Matokeo ya majibu Njia muhimu
DocType: Journal Entry,Inter Company Journal Entry,Uingizaji wa Taarifa ya Kampuni ya Inter
apps/erpnext/erpnext/accounts/party.py,Due Date cannot be before Posting / Supplier Invoice Date,Tarehe inayostahili haiwezi kuwa kabla ya Tarehe ya Kuwasilisha / Usambazaji
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,For quantity {0} should not be grater than work order quantity {1},Kwa wingi {0} haipaswi kuwa grater kuliko wingi wa kazi ya kazi {1}
DocType: Employee Training,Employee Training,Mafunzo ya Mwajiri
DocType: Quotation Item,Additional Notes,Vidokezo vya ziada
DocType: Purchase Order,% Received,Imepokea
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Create Student Groups,Unda Vikundi vya Wanafunzi
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Available quantity is {0}, you need {1}","Kiasi kinachopatikana ni {0}, unahitaji {1}"
DocType: Volunteer,Weekends,Mwishoni mwa wiki
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Credit Note Amount,Kiwango cha Kumbuka Mikopo
DocType: Setup Progress Action,Action Document,Kitambulisho cha Hatua
DocType: Chapter Member,Website URL,URL ya Tovuti
,Finished Goods,Bidhaa zilizokamilishwa
DocType: Delivery Note,Instructions,Maelekezo
DocType: Quality Inspection,Inspected By,Iliyotambuliwa na
DocType: Asset,ACC-ASS-.YYYY.-,ACC-ASS-YYYY.-
DocType: Asset Maintenance Log,Maintenance Type,Aina ya Matengenezo
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is not enrolled in the Course {2},{0} - {1} hajasajiliwa katika Kozi {2}
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student Name: ,Jina la Mwanafunzi:
DocType: POS Closing Voucher,Difference,Tofauti
DocType: Delivery Settings,Delay between Delivery Stops,Punguza muda kati ya Utoaji wa Utoaji
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Serial No {0} does not belong to Delivery Note {1},Serial Hakuna {0} sio wa Kumbuka Kumbuka {1}
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,"There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.","Inaonekana kuna shida na Configuration ya GoCardless ya seva. Usijali, ikiwa hali ya kushindwa, kiasi hicho kitarejeshwa kwa akaunti yako."
apps/erpnext/erpnext/templates/pages/demo.html,ERPNext Demo,ERPNext Demo
apps/erpnext/erpnext/public/js/utils/item_selector.js,Add Items,Ongeza Vitu
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Kipimo cha Ubora wa Bidhaa
DocType: Leave Application,Leave Approver Name,Acha Jina la Msaidizi
DocType: Depreciation Schedule,Schedule Date,Tarehe ya Ratiba
DocType: Amazon MWS Settings,FR,FR
DocType: Packed Item,Packed Item,Kipengee cha Ufungashaji
DocType: Job Offer Term,Job Offer Term,Kazi ya Kutoa Kazi
apps/erpnext/erpnext/config/buying.py,Default settings for buying transactions.,Mipangilio ya mipangilio ya kununua shughuli.
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,Activity Cost exists for Employee {0} against Activity Type - {1},Shughuli ya Gharama ipo kwa Mfanyakazi {0} dhidi ya Aina ya Shughuli - {1}
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Get Students From,Sehemu ya lazima - Pata Wanafunzi Kutoka
DocType: Program Enrollment,Enrolled courses,Kozi iliyosajiliwa
DocType: Currency Exchange,Currency Exchange,Kubadilisha Fedha
apps/erpnext/erpnext/support/doctype/issue/issue.js,Resetting Service Level Agreement.,Inarejesha Mkataba wa Kiwango cha Huduma.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Item Name,Jina la kipengee
DocType: Authorization Rule,Approving User  (above authorized value),Kupitisha Mtumiaji (juu ya thamani iliyoidhinishwa)
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Credit Balance,Mizani ya Mikopo
DocType: Employee,Widowed,Mjane
DocType: Request for Quotation,Request for Quotation,Ombi la Nukuu
DocType: Healthcare Settings,Require Lab Test Approval,Inahitaji idhini ya Mtihani wa Lab
DocType: Attendance,Working Hours,Saa za kazi
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Total Outstanding,Jumla ya Kipaumbele
DocType: Naming Series,Change the starting / current sequence number of an existing series.,Badilisha idadi ya mwanzo / ya sasa ya mlolongo wa mfululizo uliopo.
DocType: Accounts Settings,Percentage you are allowed to bill more against the amount ordered. For example: If the order value is $100 for an item and tolerance is set as 10% then you are allowed to bill for $110.,Asilimia unaruhusiwa kutoza zaidi dhidi ya kiasi kilichoamriwa. Kwa mfano: Ikiwa dhamana ya agizo ni $ 100 kwa bidhaa na uvumilivu umewekwa kama 10% basi unaruhusiwa kutoza kwa $ 110.
DocType: Dosage Strength,Strength,Nguvu
apps/erpnext/erpnext/public/js/controllers/transaction.js,Cannot find Item with this barcode,Huwezi kupata kipengee na barcode hii
apps/erpnext/erpnext/accounts/page/pos/pos.js,Create a new Customer,Unda Wateja wapya
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Expiring On,Kuzimia
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Ikiwa Sheria nyingi za bei zinaendelea kushinda, watumiaji wanaombwa kuweka Kipaumbele kwa mikono ili kutatua migogoro."
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Purchase Return,Ununuzi wa Kurudisha
apps/erpnext/erpnext/utilities/activation.py,Create Purchase Orders,Unda Amri ya Ununuzi
,Purchase Register,Daftari ya Ununuzi
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Patient not found,Mgonjwa haipatikani
DocType: Landed Cost Item,Applicable Charges,Malipo ya kuomba
DocType: Workstation,Consumable Cost,Gharama zinazoweza kutumika
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Response Time for {0} at index {1} can't be greater than Resolution Time.,Wakati wa Kujibu kwa {0} kwenye index {1} hauwezi kuwa mkubwa kuliko Wakati wa Azimio.
DocType: Purchase Receipt,Vehicle Date,Tarehe ya Gari
DocType: Campaign Email Schedule,Campaign Email Schedule,Ratiba ya barua pepe ya Kampeni
DocType: Student Log,Medical,Matibabu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Please select Drug,Tafadhali chagua Dawa
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Lead Owner cannot be same as the Lead,Mmiliki wa kiongozi hawezi kuwa sawa na Kiongozi
DocType: Announcement,Receiver,Mpokeaji
DocType: Location,Area UOM,Simu ya UOM
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,Workstation is closed on the following dates as per Holiday List: {0},Kazi imefungwa kwenye tarehe zifuatazo kama kwa orodha ya likizo: {0}
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Opportunities,Fursa
DocType: Lab Test Template,Single,Mmoja
DocType: Compensatory Leave Request,Work From Date,Kazi Kutoka Tarehe
DocType: Salary Slip,Total Loan Repayment,Ulipaji wa Mkopo wa Jumla
DocType: Project User,View attachments,Angalia viambatisho
DocType: Account,Cost of Goods Sold,Gharama ya bidhaa zilizouzwa
DocType: Article,Publish Date,Chapisha Tarehe
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please enter Cost Center,Tafadhali ingiza Kituo cha Gharama
DocType: Drug Prescription,Dosage,Kipimo
DocType: Journal Entry Account,Sales Order,Uagizaji wa Mauzo
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Avg. Selling Rate,Mg. Kiwango cha Mauzo
DocType: Assessment Plan,Examiner Name,Jina la Mchunguzi
DocType: Lab Test Template,No Result,Hakuna Matokeo
DocType: Woocommerce Settings,"The fallback series is ""SO-WOO-"".",Mfululizo wa kurudi nyuma ni &quot;So-WOO-&quot;.
DocType: Purchase Invoice Item,Quantity and Rate,Wingi na Kiwango
DocType: Delivery Note,% Installed,Imewekwa
apps/erpnext/erpnext/utilities/user_progress.py,Classrooms/ Laboratories etc where lectures can be scheduled.,"Madarasa / Maabara, nk ambapo mihadhara inaweza kufanyika."
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Company currencies of both the companies should match for Inter Company Transactions.,Fedha za Kampuni ya makampuni hayo yote yanapaswa kufanana na Shughuli za Inter Company.
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Please enter company name first,Tafadhali ingiza jina la kampuni kwanza
DocType: Travel Itinerary,Non-Vegetarian,Wasio Mboga
DocType: Purchase Invoice,Supplier Name,Jina la wauzaji
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Read the ERPNext Manual,Soma Mwongozo wa ERPNext
DocType: HR Settings,Show Leaves Of All Department Members In Calendar,Onyesha Majani ya Wajumbe Wote wa Idara Katika Kalenda
DocType: Purchase Invoice,01-Sales Return,Kurudi kwa Mauzo ya 01
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Qty per BOM Line,Qty kwa kila BOM Line
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,Temporarily on Hold,Kwa muda Ukizingatia
DocType: Account,Is Group,Ni Kikundi
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Credit Note {0} has been created automatically,Maelezo ya Mikopo {0} yameundwa moja kwa moja
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Request for Raw Materials,Omba kwa Malighafi
DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Weka kwa moja kwa moja Serial Nos kulingana na FIFO
DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,Angalia Nambari ya Nambari ya Invoice ya Wauzaji
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js,Primary Address Details,Maelezo ya Anwani ya Msingi
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Public token is missing for this bank,Baina ya umma haipo kwenye benki hii
DocType: Vehicle Service,Oil Change,Mabadiliko ya Mafuta
DocType: Leave Encashment,Leave Balance,Acha Mizani
DocType: Asset Maintenance Log,Asset Maintenance Log,Ingia ya Matengenezo ya Mali
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,'To Case No.' cannot be less than 'From Case No.',&#39;Kwa Kesi Hapana&#39; haiwezi kuwa chini ya &#39;Kutoka Kesi Na.&#39;
DocType: Certification Application,Non Profit,Sio Faida
DocType: Production Plan,Not Started,Haijaanza
DocType: Lead,Channel Partner,Mshiriki wa Channel
DocType: Account,Old Parent,Mzazi wa Kale
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Academic Year,Sehemu ya lazima - Mwaka wa Elimu
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} is not associated with {2} {3},{0} {1} haihusiani na {2} {3}
DocType: Opportunity,Converted By,Imegeuzwa na
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,You need to login as a Marketplace User before you can add any reviews.,Unahitaji kuingia kama Mtumiaji wa Soko kabla ya kuongeza maoni yoyote.
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0} : Operation is required against the raw material item {1},Row {0}: Uendeshaji unahitajika dhidi ya bidhaa za malighafi {1}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Please set default payable account for the company {0},Tafadhali weka akaunti ya malipo yenye malipo ya kampuni {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Transaction not allowed against stopped Work Order {0},Shughuli haziruhusiwi dhidi ya kusimamishwa Kazi ya Kazi {0}
DocType: Setup Progress Action,Min Doc Count,Hesabu ya Kidogo
apps/erpnext/erpnext/config/manufacturing.py,Global settings for all manufacturing processes.,Mipangilio ya Global kwa mchakato wa utengenezaji wote.
DocType: Accounts Settings,Accounts Frozen Upto,Akaunti Yamehifadhiwa Upto
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Process Day Book Data,Takwimu za Siku ya Kitabu
DocType: SMS Log,Sent On,Imepelekwa
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Incoming call from {0},Simu inayokuja kutoka {0}
apps/erpnext/erpnext/stock/doctype/item/item.py,Attribute {0} selected multiple times in Attributes Table,Ishara {0} imechaguliwa mara nyingi kwenye Jedwali la Attributes
DocType: HR Settings,Employee record is created using selected field. ,Rekodi ya wafanyakazi ni kuundwa kwa kutumia shamba iliyochaguliwa.
DocType: Sales Order,Not Applicable,Siofaa
DocType: Amazon MWS Settings,UK,Uingereza
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Opening Invoice Item,Ufunguzi wa Bidhaa ya Invoice
DocType: Request for Quotation Item,Required Date,Tarehe inahitajika
DocType: Accounts Settings,Billing Address,Mahali deni litakapotumwa
DocType: Bank Statement Settings,Statement Headers,Taarifa za kichwa
DocType: Travel Request,Costing,Gharama
DocType: Tax Rule,Billing County,Kata ya Billing
DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Ikiwa hunakiliwa, kiasi cha kodi kitachukuliwa kama tayari kilijumuishwa katika Kiwango cha Kuchapa / Kipengee cha Kuchapa"
DocType: Request for Quotation,Message for Supplier,Ujumbe kwa Wafanyabiashara
DocType: BOM,Work Order,Kazi ya Kazi
DocType: Sales Invoice,Total Qty,Uchina wa jumla
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 Barua ya barua pepe
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
					to cancel this document","Tafadhali futa Mfanyikazi <a href=""#Form/Employee/{0}"">{0}</a> \ ili kughairi hati hii"
DocType: Item,Show in Website (Variant),Onyesha kwenye tovuti (Tofauti)
DocType: Employee,Health Concerns,Mateso ya Afya
DocType: Payroll Entry,Select Payroll Period,Chagua Kipindi cha Mishahara
DocType: Purchase Invoice,Unpaid,Hailipwa
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for sale,Imehifadhiwa kwa ajili ya kuuza
DocType: Packing Slip,From Package No.,Kutoka kwa pakiti No.
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Row #{0}: Payment document is required to complete the transaction,Njia # {0}: Hati ya malipo inahitajika kukamilisha ununuzi
DocType: Item Attribute,To Range,Kupanga
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Securities and Deposits,Usalama na Deposits
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Haiwezi kubadilisha njia ya hesabu, kwa kuwa kuna shughuli dhidi ya vitu vingine ambavyo hazina njia ya hesabu"
DocType: Student Report Generation Tool,Attended by Parents,Kuhudhuria na Wazazi
apps/erpnext/erpnext/hr/doctype/shift_assignment/shift_assignment.py,Employee {0} has already applied for {1} on {2} : ,Mfanyakazi {0} tayari ameomba kwa {1} juu ya {2}:
DocType: Inpatient Record,AB Positive,AB Chanya
DocType: Job Opening,Description of a Job Opening,Maelezo ya Kufungua kazi
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Pending activities for today,Shughuli zinasubiri leo
DocType: Salary Structure,Salary Component for timesheet based payroll.,Kipengele cha Mshahara kwa malipo ya nyakati ya maraheet.
DocType: Driver,Applicable for external driver,Inahitajika kwa dereva wa nje
DocType: Sales Order Item,Used for Production Plan,Kutumika kwa Mpango wa Uzalishaji
DocType: BOM,Total Cost (Company Currency),Gharama ya Jumla (Fedha ya Kampuni)
DocType: Loan,Total Payment,Malipo ya Jumla
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Cannot cancel transaction for Completed Work Order.,Haiwezi kufuta manunuzi ya Amri ya Kazi Iliyokamilishwa.
DocType: Manufacturing Settings,Time Between Operations (in mins),Muda Kati ya Uendeshaji (kwa muda mfupi)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,PO already created for all sales order items,PO tayari imeundwa kwa vitu vyote vya utaratibu wa mauzo
DocType: Healthcare Service Unit,Occupied,Imewekwa
DocType: Clinical Procedure,Consumables,Matumizi
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js,Include Default Book Entries,Jumuisha Ingizo Mbadala za Kitabu
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} is cancelled so the action cannot be completed,{0} {1} imefutwa ili hatua haiwezi kukamilika
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Planned Qty: Quantity, for which, Work Order has been raised, but is pending to be manufactured.","Qty iliyopangwa: Wingi, ambayo, Agizo la Kazi limeinuliwa, lakini inasubiri kutengenezwa."
DocType: Customer,Buyer of Goods and Services.,Mnunuzi wa Bidhaa na Huduma.
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,'employee_field_value' and 'timestamp' are required.,&#39;staff_field_value&#39; na &#39;barabara ya muda&#39; inahitajika.
DocType: Journal Entry,Accounts Payable,Akaunti za kulipwa
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,The amount of {0} set in this payment request is different from the calculated amount of all payment plans: {1}. Make sure this is correct before submitting the document.,Kiasi cha {0} kilichowekwa katika ombi hili la malipo ni tofauti na kiasi cha mahesabu ya mipango yote ya malipo: {1}. Hakikisha hii ni sahihi kabla ya kuwasilisha hati.
DocType: Patient,Allergies,Dawa
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,The selected BOMs are not for the same item,BOM zilizochaguliwa sio kwa bidhaa moja
apps/erpnext/erpnext/stock/doctype/item_variant_settings/item_variant_settings.py,Cannot set the field <b>{0}</b> for copying in variants,Haiwezi kuweka shamba <b>{0}</b> kwa kunakili kwa anuwai
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Item Code,Badilisha Msimbo wa Kipengee
DocType: Supplier Scorecard Standing,Notify Other,Arifa nyingine
DocType: Vital Signs,Blood Pressure (systolic),Shinikizo la damu (systolic)
apps/erpnext/erpnext/controllers/buying_controller.py,{0} {1} is {2},{0} {1} ni {2}
DocType: Item Price,Valid Upto,Halafu Upto
DocType: Leave Type,Expire Carry Forwarded Leaves (Days),Endesha Kubeba Majani yaliyosafirishwa (Siku)
DocType: Training Event,Workshop,Warsha
DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Angalia Amri za Ununuzi
apps/erpnext/erpnext/utilities/user_progress.py,List a few of your customers. They could be organizations or individuals.,Andika orodha ya wateja wako wachache. Wanaweza kuwa mashirika au watu binafsi.
DocType: Employee Tax Exemption Proof Submission,Rented From Date,Ilipangwa Tarehe
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Enough Parts to Build,Vipande vyenye Kujenga
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Please save first,Tafadhali kuokoa kwanza
DocType: POS Profile User,POS Profile User,Mtumiaji wa Programu ya POS
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Row {0}: Depreciation Start Date is required,Row {0}: Tarehe ya Kuondoa Tamaa inahitajika
DocType: Purchase Invoice Item,Service Start Date,Tarehe ya Kuanza Huduma
DocType: Subscription Invoice,Subscription Invoice,Invoice ya Usajili
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Direct Income,Mapato ya moja kwa moja
DocType: Patient Appointment,Date TIme,Tarehe TIme
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"Can not filter based on Account, if grouped by Account","Haiwezi kuchuja kulingana na Akaunti, ikiwa imewekwa na Akaunti"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Administrative Officer,Afisa wa Usimamizi
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Course,Tafadhali chagua kozi
DocType: Codification Table,Codification Table,Jedwali la Ushauri
DocType: Timesheet Detail,Hrs,Hrs
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Changes in {0},Mabadiliko katika {0}
DocType: Employee Skill,Employee Skill,Ujuzi wa Mfanyikazi
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Difference Account,Akaunti ya Tofauti
DocType: Pricing Rule,Discount on Other Item,Punguzo kwa Bidhaa nyingine
DocType: Purchase Invoice,Supplier GSTIN,GSTIN wa Wasambazaji
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,View Form,Fomu ya Kutazama
DocType: Work Order,Additional Operating Cost,Gharama za ziada za uendeshaji
DocType: Lab Test Template,Lab Routine,Daima Lab
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Cosmetics,Vipodozi
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Please select Completion Date for Completed Asset Maintenance Log,Tafadhali chagua tarehe ya kukamilika kwa Ingia ya Matengenezo ya Malifafishwa
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} is not the default supplier for any items.,{0} sio mtoaji wa chaguo-msingi wa vitu vyovyote.
apps/erpnext/erpnext/stock/doctype/item/item.py,"To merge, following properties must be same for both items","Ili kuunganisha, mali zifuatazo lazima ziwe sawa kwa vitu vyote viwili"
DocType: Supplier,Block Supplier,Weka wauzaji
DocType: Shipping Rule,Net Weight,Weight Net
DocType: Job Opening,Planned number of Positions,Idadi ya Vyeo
DocType: Employee,Emergency Phone,Simu ya dharura
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,{0} {1} does not exist.,{0} {1} haipo.
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Buy,Nunua
,Serial No Warranty Expiry,Serial Hakuna Mwisho wa Udhamini
DocType: Sales Invoice,Offline POS Name,Jina la POS la Nje ya mtandao
DocType: Task,Dependencies,Kuzingatia
apps/erpnext/erpnext/utilities/user_progress.py,Student Application,Maombi ya Wanafunzi
DocType: Bank Statement Transaction Payment Item,Payment Reference,Kumbukumbu ya Malipo
DocType: Supplier,Hold Type,Weka Aina
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Please define grade for Threshold 0%,Tafadhali fafanua daraja la Msingi 0%
DocType: Bank Statement Transaction Payment Item,Bank Statement Transaction Payment Item,Taarifa ya Benki ya Bidhaa ya Malipo ya Malipo
DocType: Sales Order,To Deliver,Ili Kuokoa
DocType: Purchase Invoice Item,Item,Kipengee
apps/erpnext/erpnext/healthcare/setup.py,High Sensitivity,Sensitivity High
apps/erpnext/erpnext/config/non_profit.py,Volunteer Type information.,Aina ya kujitolea habari.
DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,Kigezo cha Ramani ya Mapato ya Fedha
DocType: Travel Request,Costing Details,Maelezo ya gharama
apps/erpnext/erpnext/selling/report/sales_partner_transaction_summary/sales_partner_transaction_summary.js,Show Return Entries,Onyesha Maingizo ya Kurudi
apps/erpnext/erpnext/accounts/page/pos/pos.js,Serial no item cannot be a fraction,Serial hakuna bidhaa haiwezi kuwa sehemu
DocType: Journal Entry,Difference (Dr - Cr),Tofauti (Dr - Cr)
DocType: Bank Guarantee,Providing,Kutoa
DocType: Account,Profit and Loss,Faida na Kupoteza
DocType: Tally Migration,Tally Migration,Uhamiaji wa kawaida
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,"Not permitted, configure Lab Test Template as required","Hairuhusiwi, sanidi Kigezo cha Mtihani wa Lab kama inavyohitajika"
DocType: Patient,Risk Factors,Mambo ya Hatari
DocType: Patient,Occupational Hazards and Environmental Factors,Hatari za Kazi na Mambo ya Mazingira
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Stock Entries already created for Work Order ,Entries Entries tayari kuundwa kwa Kazi Order
apps/erpnext/erpnext/templates/pages/cart.html,See past orders,Tazama maagizo ya zamani
DocType: Vital Signs,Respiratory rate,Kiwango cha kupumua
apps/erpnext/erpnext/config/help.py,Managing Subcontracting,Kusimamia Kudhibiti Msaada
DocType: Vital Signs,Body Temperature,Joto la Mwili
DocType: Project,Project will be accessible on the website to these users,Mradi utapatikana kwenye tovuti kwa watumiaji hawa
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},Haiwezi kufuta {0} {1} kwa sababu Serial No {2} sio ya ghala {3}
DocType: Detected Disease,Disease,Magonjwa
DocType: Company,Default Deferred Expense Account,Akaunti ya Msamaha iliyochaguliwa
apps/erpnext/erpnext/config/projects.py,Define Project type.,Eleza aina ya Mradi.
DocType: Supplier Scorecard,Weighting Function,Weighting Kazi
DocType: Employee Tax Exemption Proof Submission,Total Actual Amount,Jumla ya Kiasi halisi
DocType: Healthcare Practitioner,OP Consulting Charge,Ushauri wa ushauri wa OP
apps/erpnext/erpnext/utilities/user_progress.py,Setup your ,Weka yako
DocType: Student Report Generation Tool,Show Marks,Onyesha alama
DocType: Support Settings,Get Latest Query,Pata Jitihada za Mwisho
DocType: Quotation,Rate at which Price list currency is converted to company's base currency,Kiwango ambacho sarafu ya orodha ya Bei inabadilishwa kwa sarafu ya msingi ya kampuni
apps/erpnext/erpnext/setup/doctype/company/company.py,Account {0} does not belong to company: {1},Akaunti {0} sio ya kampuni: {1}
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation already used for another company,Hali tayari kutumika kwa kampuni nyingine
DocType: Selling Settings,Default Customer Group,Kikundi cha Wateja Chaguo-msingi
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Payment Tems,Vipimo vya Malipo
DocType: Employee,IFSC Code,IFSC Kanuni
DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Ikiwa imezima, shamba &#39;Rounded Total&#39; halitaonekana katika shughuli yoyote"
DocType: BOM,Operating Cost,Gharama za uendeshaji
DocType: Crop,Produced Items,Vitu vinavyotengenezwa
DocType: Bank Statement Transaction Entry,Match Transaction to Invoices,Mchanganyiko wa mechi kwa ankara
apps/erpnext/erpnext/erpnext_integrations/exotel_integration.py,Error in Exotel incoming call,Kosa katika Exotel simu inayoingia
DocType: Sales Order Item,Gross Profit,Faida Pato
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Unblock Invoice,Fungua ankara
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,Increment cannot be 0,Uingizaji hauwezi kuwa 0
DocType: Company,Delete Company Transactions,Futa Shughuli za Kampuni
DocType: Production Plan Item,Quantity and Description,Kiasi na Maelezo
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Reference No and Reference Date is mandatory for Bank transaction,Kitabu cha Marejeo na Kumbukumbu ni lazima kwa shughuli za Benki
DocType: Purchase Receipt,Add / Edit Taxes and Charges,Ongeza / Badilisha Taxes na Malipo
DocType: Payment Entry Reference,Supplier Invoice No,Nambari ya ankara ya wasambazaji
DocType: Territory,For reference,Kwa kumbukumbu
DocType: Healthcare Settings,Appointment Confirmation,Uthibitisho wa Uteuzi
DocType: Inpatient Record,HLC-INP-.YYYY.-,HLC-INP -YYYY.-
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot delete Serial No {0}, as it is used in stock transactions","Haiwezi kufuta Serial No {0}, kama inatumiwa katika ushirikiano wa hisa"
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Closing (Cr),Kufungwa (Cr)
DocType: Purchase Invoice,Registered Composition,Muundo uliosajiliwa
apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html,Hello,Sawa
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Move Item,Hoja Item
DocType: Employee Incentive,Incentive Amount,Kiasi cha Mshawishi
,Employee Leave Balance Summary,Muhtasari wa Akiba ya Mfanyikazi
DocType: Serial No,Warranty Period (Days),Kipindi cha udhamini (Siku)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Total Credit/ Debit Amount should be same as linked Journal Entry,Kiwango cha Mikopo / Kiwango cha Debit kinapaswa kuwa sawa na Kuingizwa kwa Journal
DocType: Installation Note Item,Installation Note Item,Kitu cha Kumbuka cha Ufungaji
DocType: Production Plan Item,Pending Qty,Uchina uliotarajiwa
DocType: Budget,Ignore,Puuza
apps/erpnext/erpnext/accounts/party.py,{0} {1} is not active,{0} {1} haifanyi kazi
DocType: Woocommerce Settings,Freight and Forwarding Account,Akaunti ya Usafirishaji na Usambazaji
apps/erpnext/erpnext/config/accounting.py,Setup cheque dimensions for printing,Weka vipimo vipimo vya kuchapisha
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Create Salary Slips,Unda Slips za Mshahara
DocType: Vital Signs,Bloated,Imezuiwa
DocType: Salary Slip,Salary Slip Timesheet,Timesheet ya Mshahara Mshahara
apps/erpnext/erpnext/controllers/buying_controller.py,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Ghala la Wafanyabiashara lazima kwa Receipt ya Ununuzi wa chini ya mkataba
DocType: Item Price,Valid From,Halali Kutoka
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Your rating: ,Ukadiriaji wako:
DocType: Sales Invoice,Total Commission,Jumla ya Tume
DocType: Tax Withholding Account,Tax Withholding Account,Akaunti ya Kuzuia Ushuru
DocType: Pricing Rule,Sales Partner,Mshirika wa Mauzo
apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Mapendekezo yote ya Wasambazaji.
DocType: Buying Settings,Purchase Receipt Required,Receipt ya Ununuzi inahitajika
DocType: Sales Invoice,Rail,Reli
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Gharama halisi
DocType: Item,Website Image,Picha ya Wavuti
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Target warehouse in row {0} must be same as Work Order,Ghala muhimu katika mstari {0} lazima iwe sawa na Kazi ya Kazi
apps/erpnext/erpnext/stock/doctype/item/item.py,Valuation Rate is mandatory if Opening Stock entered,Kiwango cha Vigeo ni lazima ikiwa Stock Inapoingia
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,No records found in the Invoice table,Hakuna kumbukumbu zilizopatikana kwenye meza ya ankara
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Please select Company and Party Type first,Tafadhali chagua Aina ya Kampuni na Chapa kwanza
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,"Already set default in pos profile {0} for user {1}, kindly disabled default","Tayari kuweka default katika profile posho {0} kwa mtumiaji {1}, kwa uzima imefungwa kuwa default"
apps/erpnext/erpnext/config/accounting.py,Financial / accounting year.,Mwaka wa fedha / uhasibu.
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js,Accumulated Values,Maadili yaliyokusanywa
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Sorry, Serial Nos cannot be merged","Samahani, Serial Nos haiwezi kuunganishwa"
DocType: Shopify Settings,Customer Group will set to selected group while syncing customers from Shopify,Kundi la Wateja litaweka kwenye kikundi cha kuchaguliwa wakati wa kusawazisha wateja kutoka Shopify
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Territory is Required in POS Profile,Territory Inahitajika katika POS Profile
DocType: Supplier,Prevent RFQs,Zuia RFQs
DocType: Hub User,Hub User,Mtumiaji wa Hub
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Salary Slip submitted for period from {0} to {1},Slip ya Mshahara imewasilishwa kwa kipindi cha {0} hadi {1}
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Passing Score value should be between 0 and 100,Thamani ya alama ya kupita inapaswa kuwa kati ya 0 na 100
DocType: Loyalty Point Entry Redemption,Redeemed Points,Vipengee Vyepesi
,Lead Id,Weka Id
DocType: C-Form Invoice Detail,Grand Total,Jumla ya Jumla
DocType: Assessment Plan,Course,Kozi
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Section Code,Kanuni ya Sehemu
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Valuation Rate required for Item {0} at row {1},Kiwango cha hesabu inahitajika kwa Bidhaa {0} katika safu {1}
DocType: Timesheet,Payslip,Ilipigwa
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,Pricing Rule {0} is updated,Sheria ya bei {0} imesasishwa
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Half day date should be in between from date and to date,Siku ya nusu ya siku inapaswa kuwa katikati ya tarehe na hadi sasa
DocType: POS Closing Voucher,Expense Amount,Kiasi cha gharama
apps/erpnext/erpnext/public/js/pos/pos.html,Item Cart,Ramani ya Bidhaa
DocType: Quality Action,Resolution,Azimio
DocType: Employee,Personal Bio,Bio ya kibinafsi
DocType: C-Form,IV,IV
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Membership ID,Kitambulisho cha Uanachama
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Receive at Warehouse Entry,Pokea kwa Ingizo la Ghala
apps/erpnext/erpnext/templates/pages/material_request_info.html,Delivered: {0},Imetolewa: {0}
DocType: QuickBooks Migrator,Connected to QuickBooks,Imeunganishwa na QuickBooks
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please identify/create Account (Ledger) for type - {0},Tafadhali tambua / unda Akaunti (Ledger) ya aina - {0}
DocType: Bank Statement Transaction Entry,Payable Account,Akaunti ya kulipa
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,You haven\,Haujawahi
DocType: Payment Entry,Type of Payment,Aina ya Malipo
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date is mandatory,Siku ya Nusu ya Siku ni lazima
DocType: Sales Order,Billing and Delivery Status,Hali ya kulipia na utoaji
DocType: Job Applicant,Resume Attachment,Pitia kiambatisho
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Repeat Customers,Rudia Wateja
DocType: Leave Control Panel,Allocate,Weka
apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variant,Unda Tofauti
DocType: Sales Invoice,Shipping Bill Date,Tarehe ya Bendera ya Utoaji
DocType: Production Plan,Production Plan,Mpango wa Uzalishaji
DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Kufungua Chombo cha Uumbaji wa Invoice
DocType: Salary Component,Round to the Nearest Integer,Kuzunguka kwa Inayo Karibu
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Kurudi kwa Mauzo
DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Weka Uchina katika Shughuli kulingana na Serial No Input
,Total Stock Summary,Jumla ya muhtasari wa hisa
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,"You can only plan for upto {0} vacancies and budget {1} \
				for {2} as per staffing plan {3} for parent company {4}.",Unaweza tu kupanga mipango ya {0} na bajeti {1} \ kwa {2} kama mpango wa wafanyakazi {3} kwa kampuni ya mzazi {4}.
DocType: Announcement,Posted By,Imewekwa By
apps/erpnext/erpnext/controllers/stock_controller.py,Quality Inspection required for Item {0} to submit,Ukaguzi wa Ubora unahitajika kwa Bidhaa {0} kuwasilisha
DocType: Item,Delivered by Supplier (Drop Ship),Imetolewa na Wafanyabiashara (Drop Ship)
DocType: Healthcare Settings,Confirmation Message,Ujumbe wa Uthibitisho
apps/erpnext/erpnext/config/crm.py,Database of potential customers.,Database ya wateja uwezo.
DocType: Authorization Rule,Customer or Item,Wateja au Bidhaa
apps/erpnext/erpnext/config/crm.py,Customer database.,Wateja database.
DocType: Quotation,Quotation To,Nukuu Kwa
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Middle Income,Mapato ya Kati
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Opening (Cr),Kufungua (Cr)
apps/erpnext/erpnext/stock/doctype/item/item.py,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,Kipengee cha Kupima kwa Kipengee cha Bidhaa {0} hawezi kubadilishwa moja kwa moja kwa sababu tayari umefanya shughuli au UOM mwingine. Utahitaji kujenga kipengee kipya cha kutumia UOM tofauti ya UOM.
DocType: Purchase Invoice,Overseas,Nje
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Please set the Company,Tafadhali weka Kampuni
DocType: Share Balance,Share Balance,Shiriki Mizani
DocType: Amazon MWS Settings,AWS Access Key ID,Kitambulisho cha Ufikiaji wa AWS
DocType: Employee Tax Exemption Declaration,Monthly House Rent,Kodi ya Nyumba ya Kila mwezi
apps/erpnext/erpnext/projects/doctype/task/task_list.js,Set as Completed,Weka kama Imekamilika
DocType: Purchase Order Item,Billed Amt,Alilipwa Amt
DocType: Training Result Employee,Training Result Employee,Matokeo ya Mafunzo ya Mfanyakazi
DocType: Warehouse,A logical Warehouse against which stock entries are made.,Ghala la mantiki ambalo vituo vya hisa vinafanywa.
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Principal Amount,Kiasi kikubwa
DocType: Loan Application,Total Payable Interest,Jumla ya Maslahi ya kulipa
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Total Outstanding: {0},Jumla ya Kipaumbele: {0}
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Open Contact,Fungua Mawasiliano
DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Timesheet ya Mauzo ya Mauzo
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference No & Reference Date is required for {0},Tarehe ya Kumbukumbu na Kitabu cha Marejeo inahitajika kwa {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Serial no(s) required for serialized item {0},Hakuna (s) inayohitajika kwa bidhaa iliyosarifishwa {0}
DocType: Payroll Entry,Select Payment Account to make Bank Entry,Chagua Akaunti ya Malipo kwa Kufungua Benki
apps/erpnext/erpnext/config/accounting.py,Opening and Closing,Kufungua na kufunga
DocType: Hotel Settings,Default Invoice Naming Series,Mfululizo wa Majina ya Kutoa Invoice
apps/erpnext/erpnext/utilities/activation.py,"Create Employee records to manage leaves, expense claims and payroll","Unda kumbukumbu za Wafanyakazi kusimamia majani, madai ya gharama na malipo"
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,An error occurred during the update process,Hitilafu ilitokea wakati wa mchakato wa sasisho
DocType: Restaurant Reservation,Restaurant Reservation,Uhifadhi wa Mkahawa
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Your Items,Vitu vyako
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Proposal Writing,Kuandika Proposal
DocType: Payment Entry Deduction,Payment Entry Deduction,Utoaji wa Kuingia kwa Malipo
DocType: Service Level Priority,Service Level Priority,Kipaumbele cha Kiwango cha Huduma
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Wrapping up,Kufunga juu
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Notify Customers via Email,Wajulishe Wateja kupitia Barua pepe
DocType: Item,Batch Number Series,Orodha ya Batch Number
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,Another Sales Person {0} exists with the same Employee id,Mtu mwingine wa Mauzo {0} yupo na id idumu ya mfanyakazi
DocType: Employee Advance,Claimed Amount,Kiasi kilichodaiwa
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.js,Expire Allocation,Kugawanya Mgao
DocType: QuickBooks Migrator,Authorization Settings,Mipangilio ya Mamlaka
DocType: Travel Itinerary,Departure Datetime,Saa ya Tarehe ya Kuondoka
apps/erpnext/erpnext/hub_node/api.py,No items to publish,Hakuna vitu vya kuchapisha
DocType: Customer,CUST-.YYYY.-,CUST -YYYY.-
DocType: Travel Request Costing,Travel Request Costing,Gharama ya Ombi la Kusafiri
apps/erpnext/erpnext/config/healthcare.py,Masters,Masters
DocType: Employee Onboarding,Employee Onboarding Template,Kigezo cha Wafanyakazi Onboarding
DocType: Assessment Plan,Maximum Assessment Score,Makadirio ya Kiwango cha Tathmini
apps/erpnext/erpnext/config/accounting.py,Update Bank Transaction Dates,Sasisha Dates ya Shughuli za Benki
apps/erpnext/erpnext/config/projects.py,Time Tracking,Ufuatiliaji wa Muda
DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DUPLICATE kwa TRANSPORTER
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Row {0}# Paid Amount cannot be greater than requested advance amount,Row {0} # Kipengee kilicholipwa hawezi kuwa kikubwa kuliko kiasi kilichopendekezwa
DocType: Fiscal Year Company,Fiscal Year Company,Kampuni ya Mwaka wa Fedha
DocType: Packing Slip Item,DN Detail,DN Detail
DocType: Training Event,Conference,Mkutano
DocType: Employee Grade,Default Salary Structure,Mfumo wa Mshahara wa Default
DocType: Stock Entry,Send to Warehouse,Tuma kwa Ghala
apps/erpnext/erpnext/hr/report/daily_work_summary_replies/daily_work_summary_replies.py,Replies,Majibu
DocType: Timesheet,Billed,Inauzwa
DocType: Batch,Batch Description,Maelezo ya Bande
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Creating student groups,Kujenga makundi ya wanafunzi
apps/erpnext/erpnext/accounts/utils.py,"Payment Gateway Account not created, please create one manually.","Akaunti ya Gateway ya Malipo haijatengenezwa, tafadhali ingiza moja kwa moja."
DocType: Supplier Scorecard,Per Year,Kwa mwaka
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Not eligible for the admission in this program as per DOB,Haikubaliki kuingia kwenye programu hii kama DOB
DocType: Sales Invoice,Sales Taxes and Charges,Malipo ya Kodi na Malipo
DocType: Supplier Scorecard Period,PU-SSP-.YYYY.-,PU-SSP -YYYY.-
DocType: Vital Signs,Height (In Meter),Urefu (Katika mita)
DocType: Student,Sibling Details,Maelezo ya Kikabila
DocType: Vehicle Service,Vehicle Service,Huduma ya Gari
DocType: Employee,Reason for Resignation,Sababu ya Kuondolewa
DocType: Sales Invoice,Credit Note Issued,Maelezo ya Mikopo imeondolewa
DocType: Task,Weight,Uzito
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Invoice / Maelezo ya Maelezo ya Kuingia
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,{0} bank transaction(s) created,{0} manunuzi ya benki yameundwa
apps/erpnext/erpnext/accounts/utils.py,{0} '{1}' not in Fiscal Year {2},{0} &#39;{1}&#39; si katika Mwaka wa Fedha {2}
DocType: Buying Settings,Settings for Buying Module,Mipangilio ya Ununuzi wa Moduli
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Asset {0} does not belong to company {1},Malipo {0} si ya kampuni {1}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Please enter Purchase Receipt first,Tafadhali ingiza Receipt ya Ununuzi kwanza
DocType: Buying Settings,Supplier Naming By,Wafanyabiashara Wanitaja Na
DocType: Activity Type,Default Costing Rate,Kiwango cha Chaguo cha Kimaadili
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Maintenance Schedule,Ratiba ya Matengenezo
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Kisha Kanuni za Bei zinachaguliwa kwa kuzingatia Wateja, Kikundi cha Wateja, Wilaya, Wasambazaji, Aina ya Wafanyabiashara, Kampeni, Mshiriki wa Mauzo nk."
DocType: Employee Promotion,Employee Promotion Details,Maelezo ya Kukuza Waajiri
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Inventory,Mabadiliko ya Net katika Mali
DocType: Employee,Passport Number,Nambari ya Pasipoti
DocType: Invoice Discounting,Accounts Receivable Credit Account,Akaunti inayopatikana Akaunti ya Mkopo
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian2,Uhusiano na Guardian2
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Manager,Meneja
DocType: Payment Entry,Payment From / To,Malipo Kutoka / Kwa
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,From Fiscal Year,Kutoka Mwaka wa Fedha
apps/erpnext/erpnext/selling/doctype/customer/customer.py,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Mpaka mpya wa mkopo ni chini ya kiasi cha sasa cha sasa kwa wateja. Kizuizi cha mkopo kinapaswa kuwa kikubwa {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please set account in Warehouse {0},Tafadhali weka akaunti katika Warehouse {0}
apps/erpnext/erpnext/controllers/trends.py,'Based On' and 'Group By' can not be same,&#39;Kutoka&#39; na &#39;Kundi Kwa&#39; haiwezi kuwa sawa
DocType: Sales Person,Sales Person Targets,Malengo ya Mtu wa Mauzo
DocType: GSTR 3B Report,December,Desemba
DocType: Work Order Operation,In minutes,Kwa dakika
DocType: Production Plan,"If enabled, then system will create the material even if the raw materials are available","Ikiwa imewezeshwa, basi mfumo utaunda nyenzo hata kama malighafi zinapatikana"
apps/erpnext/erpnext/templates/pages/cart.html,See past quotations,Tazama nukuu zilizopita
DocType: Issue,Resolution Date,Tarehe ya Azimio
DocType: Lab Test Template,Compound,Kipengee
DocType: Opportunity,Probability (%),Uwezekano (%)
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py,Dispatch Notification,Arifa ya Usajili
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Select Property,Chagua Mali
DocType: Course Activity,Course Activity,Somo la kozi
DocType: Student Batch Name,Batch Name,Jina la Kundi
DocType: Fee Validity,Max number of visit,Idadi kubwa ya ziara
DocType: Accounting Dimension Detail,Mandatory For Profit and Loss Account,Lazima kwa Faida na Upotezaji Akaunti
,Hotel Room Occupancy,Kazi ya chumba cha Hoteli
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please set default Cash or Bank account in Mode of Payment {0},Tafadhali weka Akaunti ya Fedha au Benki ya Mkopo katika Mfumo wa Malipo {0}
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Enroll,Ingia
DocType: GST Settings,GST Settings,Mipangilio ya GST
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Currency should be same as Price List Currency: {0},Fedha inapaswa kuwa sawa na Orodha ya Bei Fedha: {0}
DocType: Selling Settings,Customer Naming By,Mteja anayeitwa na
DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,Utaonyesha mwanafunzi kama Neno la Ripoti ya Wanafunzi wa Mwezi kila mwezi
DocType: Depreciation Schedule,Depreciation Amount,Kiwango cha kushuka kwa thamani
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Convert to Group,Badilisha hadi Kikundi
DocType: Activity Cost,Activity Type,Aina ya Shughuli
DocType: Request for Quotation,For individual supplier,Kwa muuzaji binafsi
DocType: BOM Operation,Base Hour Rate(Company Currency),Kiwango cha saa ya msingi (Fedha la Kampuni)
,Qty To Be Billed,Qty Kujazwa
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Kiasi kilichotolewa
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Qty iliyohifadhiwa kwa Uzalishaji: Wingi wa malighafi kutengeneza vitu vya utengenezaji.
DocType: Loyalty Point Entry Redemption,Redemption Date,Tarehe ya ukombozi
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Uuzaji huu wa benki tayari umepatanishwa
DocType: Sales Invoice,Packing List,Orodha ya Ufungashaji
apps/erpnext/erpnext/config/buying.py,Purchase Orders given to Suppliers.,Amri ya Ununuzi iliyotolewa kwa Wauzaji.
DocType: Contract,Contract Template,Kigezo cha Mkataba
DocType: Clinical Procedure Item,Transfer Qty,Nambari ya Uhamisho
DocType: Purchase Invoice Item,Asset Location,Mahali ya Malipo
apps/erpnext/erpnext/projects/report/billing_summary.py, From Date can not be greater than To Date,Kuanzia Tarehe haiwezi kuwa kubwa kuliko Hadi leo
DocType: Tax Rule,Shipping Zipcode,Nambari ya Zipcode
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Publishing,Kuchapisha
DocType: Accounts Settings,Report Settings,Ripoti Mipangilio
DocType: Activity Cost,Projects User,Miradi Mtumiaji
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Consumed,Inatumiwa
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,{0}: {1} not found in Invoice Details table,{0}: {1} haipatikani kwenye meza ya maelezo ya ankara
DocType: Asset,Asset Owner Company,Kampuni ya Mmiliki wa Mali
DocType: Company,Round Off Cost Center,Kituo cha Gharama ya Duru
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Kutembelea kutembelea {0} lazima kufutwa kabla ya kufuta Sheria hii ya Mauzo
apps/erpnext/erpnext/templates/pages/help.html,What do you need help with?,Unahitaji msaada gani?
DocType: Employee Checkin,Shift Start,Anzisha Shift
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Material Transfer,Uhamisho wa Nyenzo
DocType: Cost Center,Cost Center Number,Idadi ya Kituo cha Gharama
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py,Could not find path for ,Haikuweza kupata njia
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Opening (Dr),Ufunguzi (Dk)
DocType: Compensatory Leave Request,Work End Date,Tarehe ya Mwisho wa Kazi
DocType: Loan,Applicant,Mwombaji
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Posting timestamp must be after {0},Kutuma timestamp lazima iwe baada ya {0}
,GST Itemised Purchase Register,GST Kujiandikisha Ununuzi wa Item
apps/erpnext/erpnext/regional/italy/setup.py,Applicable if the company is a limited liability company,Inatumika ikiwa kampuni ni kampuni ya dhima ndogo
DocType: Course Scheduling Tool,Reschedule,Rekebisha
DocType: Item Tax Template,Item Tax Template,Bidhaa ya Kodi ya Kiolezo
DocType: Loan,Total Interest Payable,Jumla ya Maslahi ya Kulipa
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reason for Hold,Sababu ya kushikilia
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Malipo ya Gharama na Malipo
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set at Tax Exemption Reason in Sales Taxes and Charges,Row {0}: Tafadhali weka kwa Sababu ya Msamaha wa Ushuru katika Ushuru na Uuzaji
DocType: Quality Goal Objective,Quality Goal Objective,Lengo la shabaha ya shabaha
DocType: Work Order Operation,Actual Start Time,Muda wa Kuanza
DocType: Purchase Invoice Item,Deferred Expense Account,Akaunti ya Gharama iliyochaguliwa
DocType: BOM Operation,Operation Time,Muda wa Uendeshaji
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Finish,Kumaliza
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Base,Msingi
DocType: Timesheet,Total Billed Hours,Masaa Yote yaliyolipwa
DocType: Pricing Rule Item Group,Pricing Rule Item Group,Kikundi cha Bei ya Bei ya Bei
DocType: Travel Itinerary,Travel To,Safari Kwa
apps/erpnext/erpnext/config/accounting.py,Exchange Rate Revaluation master.,Kubadilisha Mabadiliko ya Viwango vya kubadilishana.
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Write Off Amount,Andika Kiasi
DocType: Leave Block List Allow,Allow User,Ruhusu Mtumiaji
DocType: Journal Entry,Bill No,Bill No
DocType: Company,Gain/Loss Account on Asset Disposal,Akaunti ya Kupoteza / Kupoteza juu ya Upunguzaji wa Mali
DocType: Vehicle Log,Service Details,Maelezo ya Huduma
DocType: Lab Test Template,Grouped,Yameunganishwa
DocType: Selling Settings,Delivery Note Required,Kumbuka Utoaji Inahitajika
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Submitting Salary Slips...,Inawasilisha Slips za Mshahara ...
DocType: Bank Guarantee,Bank Guarantee Number,Nambari ya Dhamana ya Benki
DocType: Assessment Criteria,Assessment Criteria,Vigezo vya Tathmini
DocType: BOM Item,Basic Rate (Company Currency),Kiwango cha Msingi (Fedha la Kampuni)
apps/erpnext/erpnext/accounts/doctype/account/account.py,"While creating account for child Company {0}, parent account {1} not found. Please create the parent account in corresponding COA","Wakati wa kuunda akaunti ya Kampuni ya watoto {0}, akaunti ya wazazi {1} haipatikani. Tafadhali unda akaunti ya mzazi katika COA inayolingana"
apps/erpnext/erpnext/support/doctype/issue/issue.js,Split Issue,Fungua Suala
DocType: Student Attendance,Student Attendance,Mahudhurio ya Wanafunzi
apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,No data to export,Hakuna data ya kuuza nje
DocType: Sales Invoice Timesheet,Time Sheet,Karatasi ya Muda
DocType: Manufacturing Settings,Backflush Raw Materials Based On,Vipande vya Raw vya Backflush Kulingana na
DocType: Sales Invoice,Port Code,Kanuni ya Bandari
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reserve Warehouse,Ghala la Hifadhi
DocType: Lead,Lead is an Organization,Kiongozi ni Shirika
DocType: Guardian Interest,Interest,Hamu
apps/erpnext/erpnext/accounts/doctype/tax_category/tax_category_dashboard.py,Pre Sales,Mauzo ya awali
DocType: Instructor Log,Other Details,Maelezo mengine
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Suplier,Kuinua
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Actual Delivery Date,Tarehe halisi ya Uwasilishaji
DocType: Lab Test,Test Template,Kigezo cha Mtihani
DocType: Restaurant Order Entry Item,Served,Imehudumiwa
apps/erpnext/erpnext/config/non_profit.py,Chapter information.,Maelezo ya sura.
DocType: Account,Accounts,Akaunti
DocType: Vehicle,Odometer Value (Last),Thamani ya Odometer (Mwisho)
apps/erpnext/erpnext/config/buying.py,Templates of supplier scorecard criteria.,Matukio ya vigezo vya scorecard ya wasambazaji.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Marketing,Masoko
DocType: Sales Invoice,Redeem Loyalty Points,Punguza Pole ya Uaminifu
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Entry is already created,Kuingia kwa Malipo tayari kuundwa
DocType: Request for Quotation,Get Suppliers,Pata Wauzaji
DocType: Purchase Receipt Item Supplied,Current Stock,Stock sasa
DocType: Pricing Rule,System will notify to increase or decrease quantity or amount ,Mfumo utaarifu kuongeza au kupungua kwa idadi au kiasi
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} does not linked to Item {2},Mstari # {0}: Malipo {1} haihusishwa na Item {2}
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Preview Salary Slip,Angalia Slip ya Mshahara
apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Unda Timesheet
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Akaunti {0} imeingizwa mara nyingi
DocType: Account,Expenses Included In Valuation,Malipo Pamoja na Valuation
apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Unaweza tu upya kama wanachama wako muda wake ndani ya siku 30
DocType: Shopping Cart Settings,Show Stock Availability,Onyesha Upatikanaji wa hisa
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Weka {0} katika kiwanja cha mali {1} au kampuni {2}
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,As per section 17(5),Kama kwa sehemu ya 17 (5)
DocType: Location,Longitude,Longitude
,Absent Student Report,Ripoti ya Wanafunzi Yasiyo
DocType: Crop,Crop Spacing UOM,Ugawaji wa mazao ya UOM
DocType: Loyalty Program,Single Tier Program,Programu ya Mpango wa Pekee
DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,Chagua tu ikiwa umeweka hati za Mapato ya Mapato ya Fedha
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Address 1,Kutoka kwenye Anwani 1
DocType: Email Digest,Next email will be sent on:,Imefuata barua pepe itatumwa kwenye:
DocType: Supplier Scorecard,Per Week,Kila wiki
apps/erpnext/erpnext/stock/doctype/item/item.py,Item has variants.,Item ina tofauti.
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Total Student,Jumla ya Mwanafunzi
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,Item {0} not found,Kipengee {0} haipatikani
DocType: Bin,Stock Value,Thamani ya Hifadhi
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Duplicate {0} found in the table,Kurudia {0} kupatikana kwenye jedwali
apps/erpnext/erpnext/accounts/doctype/account/account.py,Company {0} does not exist,Kampuni {0} haipo
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} has fee validity till {1},{0} ina uhalali wa ada mpaka {1}
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Tree Type,Aina ya Mti
DocType: Leave Control Panel,Employee Grade (optional),Daraja la Mwajiriwa (hiari)
DocType: Pricing Rule,Apply Rule On Other,Tumia Sheria Nyingine
DocType: BOM Explosion Item,Qty Consumed Per Unit,Uchina hutumiwa kwa kitengo
DocType: Shift Type,Late Entry Grace Period,Marehemu Kuingia kwa kipindi cha Neema
DocType: GST Account,IGST Account,Akaunti ya IGST
DocType: Serial No,Warranty Expiry Date,Tarehe ya Kumalizika ya Udhamini
DocType: Material Request Item,Quantity and Warehouse,Wingi na Ghala
DocType: Sales Invoice,Commission Rate (%),Kiwango cha Tume (%)
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Program,Tafadhali chagua Programu
DocType: Project,Estimated Cost,Gharama zilizohesabiwa
DocType: Supplier Quotation,Link to material requests,Unganisha maombi ya vifaa
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Publish,Kuchapisha
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Aerospace,Mazingira
,Fichier des Ecritures Comptables [FEC],Faili la Maandiko ya Comptables [FEC]
DocType: Journal Entry,Credit Card Entry,Kuingia Kadi ya Mikopo
apps/erpnext/erpnext/config/selling.py,Invoices for Costumers.,Ankara kwa Vivutio.
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,In Value,Kwa Thamani
DocType: Asset Settings,Depreciation Options,Chaguzi za uchafuzi
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Either location or employee must be required,Eneo lolote au mfanyakazi lazima ahitajike
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js,Create Employee,Unda Mfanyikazi
apps/erpnext/erpnext/utilities/transaction_base.py,Invalid Posting Time,Muda usio sahihi wa Kuchapa
DocType: Salary Component,Condition and Formula,Hali na Mfumo
DocType: Lead,Campaign Name,Jina la Kampeni
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Task Completion,Kwenye Kukamilika kwa Kazi
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,There is no leave period in between {0} and {1},Hakuna kipindi cha kuondoka kati ya {0} na {1}
DocType: Fee Validity,Healthcare Practitioner,Daktari wa Afya
DocType: Hotel Room,Capacity,Uwezo
DocType: Travel Request Costing,Expense Type,Aina ya gharama
DocType: Selling Settings,Close Opportunity After Days,Fungua Fursa Baada ya Siku
,Reserved,Imehifadhiwa
DocType: Driver,License Details,Maelezo ya Leseni
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field From Shareholder cannot be blank,Shamba Kutoka kwa Mshirika haiwezi kuwa tupu
DocType: Leave Allocation,Allocation,Ugawaji
DocType: Purchase Order,Supply Raw Materials,Vifaa vya Malighafi
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Structures have been assigned successfully,Miundo imepewa mafanikio
apps/erpnext/erpnext/config/getting_started.py,Create Opening Sales and Purchase Invoices,Unda Uuzaji wa ufunguzi na ankara za ununuzi
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Current Assets,Malipo ya sasa
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,{0} is not a stock Item,{0} si kitu cha hisa
apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html,Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',Tafadhali shiriki maoni yako kwenye mafunzo kwa kubonyeza &#39;Mafunzo ya Maoni&#39; na kisha &#39;Mpya&#39;
DocType: Call Log,Caller Information,Habari ya mpiga simu
DocType: Mode of Payment Account,Default Account,Akaunti ya Akaunti
apps/erpnext/erpnext/stock/doctype/item/item.py,Please select Sample Retention Warehouse in Stock Settings first,Tafadhali chagua Ghala la Wafanyakazi Kuhifadhiwa katika Mipangilio ya Hifadhi kwanza
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,Please select the Multiple Tier Program type for more than one collection rules.,Tafadhali chagua aina ya Programu ya Mipango ya Multiple kwa sheria zaidi ya moja ya ukusanyaji.
DocType: Payment Entry,Received Amount (Company Currency),Kiasi kilichopokelewa (Fedha la Kampuni)
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,Payment Cancelled. Please check your GoCardless Account for more details,Malipo Imepigwa. Tafadhali angalia Akaunti yako ya GoCardless kwa maelezo zaidi
DocType: Work Order,Skip Material Transfer to WIP Warehouse,Skip Uhamisho wa nyenzo kwa Ghala ya WIP
DocType: Contract,N/A,N / A
DocType: Task Type,Task Type,Aina ya Kazi
DocType: Topic,Topic Content,Yaliyomo Mada
DocType: Delivery Settings,Send with Attachment,Tuma na Kiambatisho
DocType: Service Level,Priorities,Vipaumbele
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py,Please select weekly off day,Tafadhali chagua kila wiki siku
DocType: Inpatient Record,O Negative,O Hasi
DocType: Work Order Operation,Planned End Time,Muda wa Mwisho
DocType: POS Profile,Only show Items from these Item Groups,Onyesha tu Vitu kutoka kwa Vikundi vya Bidhaa
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction cannot be converted to ledger,Akaunti na shughuli zilizopo haziwezi kubadilishwa kuwa kiongozi
apps/erpnext/erpnext/config/non_profit.py,Memebership Type Details,Maelezo ya Aina ya Uhifadhi
DocType: Delivery Note,Customer's Purchase Order No,Nambari ya Ununuzi wa Wateja No
DocType: Clinical Procedure,Consume Stock,Tumia Stock
DocType: Budget,Budget Against,Bajeti ya Dhidi
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Lost Reasons,Sababu Zilizopotea
apps/erpnext/erpnext/stock/reorder_item.py,Auto Material Requests Generated,Maombi ya Nyenzo za Auto yanayotokana
DocType: Shift Type,Working hours below which Half Day is marked. (Zero to disable),Kufanya kazi masaa chini ambayo Half Day imewekwa alama. (Zero ya kuzima)
DocType: Job Card,Total Completed Qty,Jumla ya Qty iliyokamilishwa
DocType: HR Settings,Auto Leave Encashment,Auto Acha Shtaka
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js,Lost,Potea
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,You can not enter current voucher in 'Against Journal Entry' column,Huwezi kuingia hati ya sasa katika safu ya &#39;Against Journal Entry&#39;
DocType: Employee Benefit Application Detail,Max Benefit Amount,Kiwango cha Faida Max
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for manufacturing,Imehifadhiwa kwa ajili ya utengenezaji
DocType: Soil Texture,Sand,Mchanga
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Energy,Nishati
DocType: Opportunity,Opportunity From,Fursa Kutoka
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Row {0}: {1} Nambari za nambari zinahitajika kwa Bidhaa {2}. Umetoa {3}.
apps/erpnext/erpnext/controllers/accounts_controller.py,Cannot set quantity less than delivered quantity,Haiwezi kuweka kiasi chini ya wingi uliowasilishwa
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please select a table,Tafadhali chagua meza
DocType: BOM,Website Specifications,Ufafanuzi wa tovuti
apps/erpnext/erpnext/accounts/doctype/account/account.py,Please add the account to root level Company - %s,Tafadhali ongeza akaunti kwa Kampuni ya kiwango cha mizizi -% s
DocType: Content Activity,Content Activity,Shughuli ya yaliyomo
DocType: Special Test Items,Particulars,Maelezo
DocType: Employee Checkin,Employee Checkin,Mfanyakazi Checkin
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0}: From {0} of type {1},{0}: Kutoka {0} ya aina {1}
apps/erpnext/erpnext/config/crm.py,Sends Mails to lead or contact based on a Campaign schedule,Inatuma barua za kuongoza au mawasiliano kwa msingi wa ratiba ya Kampeni
apps/erpnext/erpnext/controllers/selling_controller.py,Row {0}: Conversion Factor is mandatory,Row {0}: Kiini cha Kubadilisha ni lazima
DocType: Student,A+,A +
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Sheria nyingi za Bei zipo na vigezo sawa, tafadhali tatua mgogoro kwa kuwapa kipaumbele. Kanuni za Bei: {0}"
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation Account,Akaunti ya Kukarabati Akaunti
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Min Amt can not be greater than Max Amt,Min Amt haiwezi kuwa kubwa kuliko Max Amt
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Cannot deactivate or cancel BOM as it is linked with other BOMs,Haiwezi kuzima au kufuta BOM kama inavyounganishwa na BOM nyingine
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js,Please select Company and Posting Date to getting entries,Tafadhali chagua tarehe ya Kampuni na Kuajili ili uweze kuingia
DocType: Asset,Maintenance,Matengenezo
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Get from Patient Encounter,Pata kutoka kwa Mkutano wa Wagonjwa
DocType: Subscriber,Subscriber,Msajili
DocType: Item Attribute Value,Item Attribute Value,Thamani ya Thamani ya Bidhaa
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,Currency Exchange must be applicable for Buying or for Selling.,Kubadilisha Fedha lazima iwezekanavyo kwa Ununuzi au kwa Ununuzi.
apps/erpnext/erpnext/hr/doctype/leave_ledger_entry/leave_ledger_entry.py,Only expired allocation can be cancelled,Ugawaji uliomalizika tu ndio unaweza kufutwa
DocType: Item,Maximum sample quantity that can be retained,Upeo wa kiwango cha sampuli ambacho kinaweza kuhifadhiwa
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Row {0} # Item {1} haiwezi kuhamishiwa zaidi ya {2} dhidi ya Ununuzi wa Order {3}
apps/erpnext/erpnext/config/crm.py,Sales campaigns.,Kampeni za mauzo.
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Unknown Caller,Mpiga simu asiyejulikana
DocType: Sales Taxes and Charges Template,"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.

#### Note

The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.

#### Description of Columns

1. Calculation Type: 
    - This can be on **Net Total** (that is the sum of basic amount).
    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
    - **Actual** (as mentioned).
2. Account Head: The Account ledger under which this tax will be booked
3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
4. Description: Description of the tax (that will be printed in invoices / quotes).
5. Rate: Tax rate.
6. Amount: Tax amount.
7. Total: Cumulative total to this point.
8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.","Template ya kodi ya kawaida inayoweza kutumika kwa Shughuli zote za Mauzo. Template hii inaweza kuwa na orodha ya vichwa vya kodi na pia vichwa vingine / kipato cha mapato kama &quot;Shipping&quot;, &quot;Bima&quot;, &quot;Kushikilia&quot; nk #### Kumbuka kiwango cha kodi unachofafanua hapa kitakuwa kiwango cha kodi ya wote ** Vipengele **. Ikiwa kuna ** Vitu ** vilivyo na viwango tofauti, lazima ziongezwe kwenye meza ya ** ya Item ** ** kwenye ** Item ** bwana. #### Maelezo ya nguzo 1. Aina ya mahesabu: - Hii inaweza kuwa kwenye ** Net Jumla ** (hiyo ni jumla ya kiasi cha msingi). - ** Katika Mstari uliopita Mto / Kiasi ** (kwa kodi za malipo au mashtaka). Ikiwa utichagua chaguo hili, kodi itatumika kama asilimia ya safu ya awali (katika meza ya kodi) kiasi au jumla. - ** Halisi ** (kama ilivyoelezwa). 2. Mkurugenzi wa Akaunti: Mwandishi wa Akaunti chini ya kodi hii itafunguliwa 3. Kituo cha Gharama: Ikiwa kodi / malipo ni mapato (kama meli) au gharama zinahitajika kutumiwa kwenye kituo cha gharama. 4. Maelezo: Maelezo ya kodi (ambayo yatachapishwa katika ankara / quotes). 5. Kiwango: kiwango cha kodi. 6. Kiasi: Kiwango cha Ushuru. 7. Jumla: Jumla ya jumla kwa hatua hii. 8. Ingiza Mstari: Ikiwa msingi wa &quot;Mstari uliopita Uliopita&quot; unaweza kuchagua namba ya mstari ambayo itachukuliwa kama msingi kwa hesabu hii (default ni mstari uliopita). 9. Je, kodi hii ni pamoja na Msingi wa Msingi ?: Ikiwa utaangalia hii, inamaanisha kuwa kodi hii haionyeshe chini ya meza ya bidhaa, lakini itaingizwa katika Msingi wa Msingi kwenye meza yako kuu ya bidhaa. Hii ni muhimu ambapo unataka kutoa bei ya gorofa (bei ya pamoja na kodi) kwa wateja."
DocType: Quality Action,Corrective,Marekebisho
DocType: Employee,Bank A/C No.,Benki ya A / C.
DocType: Quality Inspection Reading,Reading 7,Kusoma 7
DocType: Purchase Invoice,UIN Holders,Wamiliki wa UIN
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Partially Ordered,Imeamriwa kwa kikundi
DocType: Lab Test,Lab Test,Mtihani wa Lab
DocType: Student Report Generation Tool,Student Report Generation Tool,Chombo cha Uzazi wa Ripoti ya Mwanafunzi
DocType: Healthcare Schedule Time Slot,Healthcare Schedule Time Slot,Muda wa Ratiba ya Afya
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Name,Jina la Hati
DocType: Expense Claim Detail,Expense Claim Type,Aina ya kudai ya gharama
DocType: Shopping Cart Settings,Default settings for Shopping Cart,Mipangilio ya mipangilio ya Kifaa cha Ununuzi
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Save Item,Hifadhi kipengee
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Expense,Gharama Mpya
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Ignore Existing Ordered Qty,Puuza agizo lililopo la Qty
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Add Timeslots,Ongeza Timeslots
apps/erpnext/erpnext/stock/__init__.py,Please set Account in Warehouse {0} or Default Inventory Account in Company {1},Tafadhali weka Akaunti katika Warehouse {0} au Akaunti ya Inventory Akaunti katika Kampuni {1}
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Asset scrapped via Journal Entry {0},Mali yamepigwa kupitia Entri ya Journal {0}
DocType: Loan,Interest Income Account,Akaunti ya Mapato ya riba
DocType: Bank Transaction,Unreconciled,Haijaridhishwa
DocType: Shift Type,Allow check-out after shift end time (in minutes),Ruhusu kuondoka baada ya muda wa mwisho wa kuhama (kwa dakika)
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Max benefits should be greater than zero to dispense benefits,Faida nyingi zinapaswa kuwa kubwa zaidi kuliko sifuri kutangaza faida
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py,Review Invitation Sent,Kagua Mwaliko uliotumwa
DocType: Shift Assignment,Shift Assignment,Kazi ya Shift
DocType: Employee Transfer Property,Employee Transfer Property,Mali ya Uhamisho wa Wafanyakazi
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field Equity/Liability Account cannot be blank,Akaunti ya Usawa / Dhima ya uwanja haiwezi kuwa wazi
apps/erpnext/erpnext/accounts/doctype/cashier_closing/cashier_closing.py,From Time Should Be Less Than To Time,Kutoka Wakati Unapaswa Kuwa Chini Zaidi ya Muda
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Biotechnology,Bioteknolojia
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Item {0} (Serial No: {1}) cannot be consumed as is reserverd\
						 to fullfill Sales Order {2}.",Kipengee {0} (Serial No: {1}) haiwezi kutumiwa kama vile reserverd \ to Order Sales kamilifu {2}.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Maintenance Expenses,Malipo ya Matengenezo ya Ofisi
,BOM Explorer,BOM Explorer
apps/erpnext/erpnext/utilities/user_progress.py,Go to ,Enda kwa
DocType: Shopify Settings,Update Price from Shopify To ERPNext Price List,Punguza bei kutoka kwa Shopify hadi ERPNext Orodha ya Bei
apps/erpnext/erpnext/config/help.py,Setting up Email Account,Kuweka Akaunti ya Barua pepe
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Please enter Item first,Tafadhali ingiza kipengee kwanza
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Needs Analysis,Uchambuzi wa Mahitaji
DocType: Asset Repair,Downtime,Downtime
DocType: Account,Liability,Dhima
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Kizuizi cha Hesabu haiwezi kuwa kikubwa kuliko Kiasi cha Madai katika Row {0}.
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Academic Term: ,Muda wa Elimu:
DocType: Salary Detail,Do not include in total,Usijumuishe kwa jumla
DocType: Quiz Activity,Quiz Activity,Swali ya Jaribio
DocType: Company,Default Cost of Goods Sold Account,Akaunti ya Kuuza Gharama ya Bidhaa
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Sample quantity {0} cannot be more than received quantity {1},Mfano wa wingi {0} hauwezi kuwa zaidi ya kupokea kiasi {1}
apps/erpnext/erpnext/stock/get_item_details.py,Price List not selected,Orodha ya Bei haichaguliwa
DocType: Employee,Family Background,Familia ya Background
DocType: Request for Quotation Supplier,Send Email,Kutuma barua pepe
DocType: Quality Goal,Weekday,Siku ya wiki
apps/erpnext/erpnext/stock/doctype/item/item.py,Warning: Invalid Attachment {0},Onyo: Sakilili batili {0}
DocType: Item,Max Sample Quantity,Max Mfano Wingi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,No Permission,Hakuna Ruhusa
DocType: Contract Fulfilment Checklist,Contract Fulfilment Checklist,Orodha ya Uthibitishaji wa Mkataba
DocType: Vital Signs,Heart Rate / Pulse,Kiwango cha Moyo / Pulse
DocType: Supplier,Default Bank Account,Akaunti ya Akaunti ya Default
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"To filter based on Party, select Party Type first","Kuchuja kulingana na Chama, chagua Aina ya Chama kwanza"
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,'Update Stock' can not be checked because items are not delivered via {0},&#39;Mwisho Stock&#39; hauwezi kuzingatiwa kwa sababu vitu havijatumwa kupitia {0}
DocType: Vehicle,Acquisition Date,Tarehe ya Ununuzi
apps/erpnext/erpnext/regional/italy/utils.py,Nos,Nasi
DocType: Item,Items with higher weightage will be shown higher,Vitu vinavyo na uzito mkubwa vitaonyeshwa juu
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py,Lab Tests and Vital Signs,Majaribio ya Lab na Ishara za Vital
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Upatanisho wa Benki ya Ufafanuzi
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} must be submitted,Row # {0}: Mali {1} lazima iwasilishwa
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py,No employee found,Hakuna mfanyakazi aliyepatikana
DocType: Supplier Quotation,Stopped,Imesimamishwa
DocType: Item,If subcontracted to a vendor,Ikiwa unatambuliwa kwa muuzaji
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Student Group is already updated.,Kundi la Wanafunzi tayari limehifadhiwa.
apps/erpnext/erpnext/config/projects.py,Project Update.,Mwisho wa Mradi.
DocType: SMS Center,All Customer Contact,Mawasiliano ya Wateja wote
DocType: Location,Tree Details,Maelezo ya Miti
DocType: Marketplace Settings,Registered,Imeandikishwa
DocType: Training Event,Event Status,Hali ya Tukio
DocType: Volunteer,Availability Timeslot,Timeslot ya Upatikanaji
apps/erpnext/erpnext/config/support.py,Support Analytics,Analytics Support
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,"If you have any questions, please get back to us.","Ikiwa una maswali yoyote, tafadhali kurudi kwetu."
DocType: Cash Flow Mapper,Cash Flow Mapper,Cash Flow Mapper
DocType: Item,Website Warehouse,Tovuti ya Warehouse
DocType: Payment Reconciliation,Minimum Invoice Amount,Kiasi cha chini cha ankara
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Kituo cha Gharama {2} si cha Kampuni {3}
apps/erpnext/erpnext/www/lms/program.py,Program {0} does not exist.,Programu {0} haipo.
apps/erpnext/erpnext/utilities/user_progress.py,Upload your letter head (Keep it web friendly as 900px by 100px),Pakia kichwa chako cha barua (Weka mtandao kuwa wavuti kama 900px kwa 100px)
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} cannot be a Group,{0} {1}: Akaunti {2} haiwezi kuwa Kikundi
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Timesheet {0} is already completed or cancelled,Timesheet {0} tayari imekamilika au kufutwa
DocType: QuickBooks Migrator,QuickBooks Migrator,QuickBooks Migrator
apps/erpnext/erpnext/templates/pages/projects.html,No tasks,Hakuna kazi
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Sales Invoice {0} created as paid,Invozi ya Mauzo {0} imeundwa kama kulipwa
DocType: Item Variant Settings,Copy Fields to Variant,Weka Mashamba kwa Tofauti
DocType: Asset,Opening Accumulated Depreciation,Kufungua kushuka kwa thamani
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js,Score must be less than or equal to 5,Score lazima iwe chini au sawa na 5
DocType: Program Enrollment Tool,Program Enrollment Tool,Chombo cha Usajili wa Programu
apps/erpnext/erpnext/config/accounting.py,C-Form records,Rekodi za Fomu za C
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shares already exist,Sehemu tayari zipo
apps/erpnext/erpnext/config/help.py,Customer and Supplier,Wateja na Wasambazaji
DocType: Email Digest,Email Digest Settings,Mipangilio ya Digest ya barua pepe
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Thank you for your business!,Asante kwa biashara yako!
apps/erpnext/erpnext/config/support.py,Support queries from customers.,Maswali ya msaada kutoka kwa wateja.
DocType: Employee Property History,Employee Property History,Historia ya Mali ya Wafanyakazi
apps/erpnext/erpnext/stock/doctype/item/item.py,Variant Based On cannot be changed,Lahaja ya msingi haiwezi kubadilishwa
DocType: Setup Progress Action,Action Doctype,Doctype ya Hatua
DocType: HR Settings,Retirement Age,Umri wa Kustaafu
DocType: Bin,Moving Average Rate,Kusonga Kiwango cha Wastani
DocType: Share Transfer,To Shareholder,Kwa Mshirika
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Bill {1} dated {2},{0} dhidi ya Sheria {1} iliyowekwa {2}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From State,Kutoka Nchi
apps/erpnext/erpnext/utilities/user_progress.py,Setup Institution,Taasisi ya Kuweka
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,Allocating leaves...,Kugawa majani ...
DocType: Program Enrollment,Vehicle/Bus Number,Nambari ya Gari / Bus
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Create New Contact,Unda Mawasiliano Mpya
apps/erpnext/erpnext/education/doctype/course/course.js,Course Schedule,Ratiba ya Kozi
DocType: GSTR 3B Report,GSTR 3B Report,Ripoti ya GSTR 3B
DocType: Request for Quotation Supplier,Quote Status,Hali ya Quote
DocType: GoCardless Settings,Webhooks Secret,Mtandao wa siri
DocType: Maintenance Visit,Completion Status,Hali ya kukamilisha
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Total payments amount can't be greater than {},Jumla ya malipo ya jumla hayawezi kuwa kubwa kuliko {}
DocType: Daily Work Summary Group,Select Users,Chagua Watumiaji
DocType: Hotel Room Pricing Item,Hotel Room Pricing Item,Kituo cha bei ya chumba cha Hoteli
DocType: Loyalty Program Collection,Tier Name,Jina la Msingi
DocType: HR Settings,Enter retirement age in years,Ingiza umri wa kustaafu kwa miaka
DocType: Crop,Target Warehouse,Ghala la Ghala
DocType: Payroll Employee Detail,Payroll Employee Detail,Maelezo ya Waajiri wa Mishahara
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select a warehouse,Tafadhali chagua ghala
DocType: Cheque Print Template,Starting location from left edge,Kuanzia eneo kutoka kwa makali ya kushoto
,Territory Target Variance Based On Item Group,Target Target Tofauti Kulingana na Kikundi cha Bidhaa
DocType: Upload Attendance,Import Attendance,Weka Mahudhurio
apps/erpnext/erpnext/public/js/pos/pos.html,All Item Groups,Vikundi vyote vya Item
DocType: Work Order,Item To Manufacture,Mchapishaji wa Utengenezaji
DocType: Leave Control Panel,Employment Type (optional),Aina ya Ajira (hiari)
DocType: Pricing Rule,Threshold for Suggestion,Kizingiti cha Mapendekezo
apps/erpnext/erpnext/buying/utils.py,{0} {1} status is {2},{0} {1} hali ni {2}
DocType: Water Analysis,Collection Temperature ,Ukusanyaji Joto
DocType: Employee,Provide Email Address registered in company,Kutoa anwani ya barua pepe iliyosajiliwa katika kampuni
DocType: Shopping Cart Settings,Enable Checkout,Wezesha Checkout
apps/erpnext/erpnext/config/help.py,Purchase Order to Payment,Amri ya Malipo ya Ununuzi
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Projected Qty,Uchina uliopangwa
DocType: Sales Invoice,Payment Due Date,Tarehe ya Kutayarisha Malipo
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Reserved Qty: Quantity ordered for sale, but not delivered.","Qty iliyohifadhiwa: Wingi imeamuru kuuzwa, lakini haijafikishwa."
DocType: Drug Prescription,Interval UOM,Muda wa UOM
DocType: Customer,"Reselect, if the chosen address is edited after save","Pitia tena, ikiwa anwani iliyochaguliwa imebadilishwa baada ya kuokoa"
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Subcontract: Raw materials quantity to make subcotracted items.,Qty iliyohifadhiwa kwa Subcontract: Wingi wa malighafi kutengeneza vitu visivyotengwa.
apps/erpnext/erpnext/stock/doctype/item/item.js,Item Variant {0} already exists with same attributes,Tofauti ya kipengee {0} tayari ipo na sifa sawa
DocType: Item,Hub Publishing Details,Maelezo ya Uchapishaji wa Hub
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,'Opening',&#39;Kufungua&#39;
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open To Do,Fungua Kufanya
DocType: Pricing Rule,Mixed Conditions,Masharti ya Mchanganyiko
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Summary Saved,Muhtasari wa wito umehifadhiwa
DocType: Issue,Via Customer Portal,Kupitia Portal ya Wateja
DocType: Employee Tax Exemption Proof Submission Detail,Actual Amount,Kiasi halisi
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,SGST Amount,Kiwango cha SGST
DocType: Lab Test Template,Result Format,Fomu ya matokeo
DocType: Expense Claim,Expenses,Gharama
DocType: Service Level,Support Hours,Saa za Msaada
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Delivery Notes,Vidokezo vya utoaji
DocType: Item Variant Attribute,Item Variant Attribute,Kipengee cha Tofauti cha Tofauti
,Purchase Receipt Trends,Ununuzi Mwelekeo wa Receipt
DocType: Payroll Entry,Bimonthly,Bimonthly
DocType: Vehicle Service,Brake Pad,Padha ya Breki
DocType: Fertilizer,Fertilizer Contents,Mbolea Yaliyomo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Research & Development,Utafiti na Maendeleo
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py,Amount to Bill,Kiasi cha Bill
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Based On Payment Terms,Kulingana na Masharti ya Malipo
apps/erpnext/erpnext/config/settings.py,ERPNext Settings,Mipangilio ya maandishi ya ERP
DocType: Company,Registration Details,Maelezo ya Usajili
apps/erpnext/erpnext/support/doctype/issue/issue.py,Couldn't Set Service Level Agreement {0}.,Haikuweza kuweka Mkataba wa Kiwango cha Huduma {0}.
DocType: Timesheet,Total Billed Amount,Kiasi kilicholipwa
DocType: Item Reorder,Re-Order Qty,Ulipaji Uchina
DocType: Leave Block List Date,Leave Block List Date,Acha Tarehe ya Kuzuia Tarehe
DocType: Quality Feedback Parameter,Quality Feedback Parameter,Kiwango cha Maoni ya Ubora
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM #{0}: Raw material cannot be same as main Item,BOM # {0}: Vifaa vyenye rangi haviwezi kuwa sawa na Bidhaa kuu
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Malipo Yote ya Kuhitajika katika Jedwali la Vipokezi vya Ununuzi lazima lifanane na Jumla ya Kodi na Malipo
DocType: Production Plan Item,"If enabled, system will create the work order for the exploded items against which BOM is available.","Ikiwa itawezeshwa, mfumo utaunda mpangilio wa kazi kwa vitu vilivyolipuka ambayo BOM inapatikana."
DocType: Sales Team,Incentives,Vidokezo
DocType: SMS Log,Requested Numbers,Hesabu zilizoombwa
DocType: Volunteer,Evening,Jioni
DocType: Quiz,Quiz Configuration,Usanidi wa Quiz
DocType: Vital Signs,Normal,Kawaida
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Kuwezesha &#39;Matumizi kwa Ununuzi wa Ununuzi&#39;, kama Kifaa cha Ununuzi kinawezeshwa na kuna lazima iwe na Kanuni moja ya Ushuru kwa Kundi la Ununuzi"
DocType: Sales Invoice Item,Stock Details,Maelezo ya hisa
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Value,Thamani ya Mradi
apps/erpnext/erpnext/config/help.py,Point-of-Sale,Uhakika wa Kuuza
DocType: Fee Schedule,Fee Creation Status,Hali ya Uumbaji wa Mali
apps/erpnext/erpnext/utilities/activation.py,Create Sales Orders to help you plan your work and deliver on-time,Unda Maagizo ya Uuzaji ili kukusaidia kupanga kazi yako na kutoa kwa wakati
DocType: Vehicle Log,Odometer Reading,Kusoma Odometer
apps/erpnext/erpnext/accounts/doctype/account/account.py,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Usawa wa Akaunti tayari kwenye Mikopo, huruhusiwi kuweka &#39;Mizani lazima iwe&#39; kama &#39;Debit&#39;"
DocType: Account,Balance must be,Mizani lazima iwe
,Available Qty,Uchina unaopatikana
DocType: Shopify Settings,Default Warehouse to to create Sales Order and Delivery Note,Ghala la Ghafla ili kujenga Mauzo ya Utaratibu na Utoaji
DocType: Purchase Taxes and Charges,On Previous Row Total,Kwenye Mstari Uliopita
DocType: Purchase Invoice Item,Rejected Qty,Uchina Umekataliwa
DocType: Setup Progress Action,Action Field,Sehemu ya Hatua
DocType: Healthcare Settings,Manage Customer,Dhibiti Wateja
DocType: Amazon MWS Settings,Always synch your products from Amazon MWS before synching the Orders details,Daima kuunganisha bidhaa zako kutoka Amazon MWS kabla ya kuunganisha maelezo ya Amri
DocType: Delivery Trip,Delivery Stops,Utoaji wa Utoaji
DocType: Salary Slip,Working Days,Siku za Kazi
apps/erpnext/erpnext/accounts/deferred_revenue.py,Cannot change Service Stop Date for item in row {0},Haiwezi kubadilisha Tarehe ya Kusitisha Huduma kwa kipengee {0}
DocType: Serial No,Incoming Rate,Kiwango kinachoingia
DocType: Packing Slip,Gross Weight,Uzito wa Pato
DocType: Leave Type,Encashment Threshold Days,Siku ya Kuzuia Uingizaji
,Final Assessment Grades,Tathmini ya Mwisho ya Masomo
apps/erpnext/erpnext/public/js/setup_wizard.js,The name of your company for which you are setting up this system.,Jina la kampuni yako ambayo unaanzisha mfumo huu.
DocType: HR Settings,Include holidays in Total no. of Working Days,Jumuisha likizo katika Jumla ya. ya siku za kazi
apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py,Setup your Institute in ERPNext,Weka Taasisi yako katika ERPNext
DocType: Agriculture Analysis Criteria,Plant Analysis,Uchunguzi wa kupanda
DocType: Task,Timeline,Mda wa saa
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Hold,Weka
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Alternate Item,Nakala mbadala
DocType: Shopify Log,Request Data,Omba Data
DocType: Employee,Date of Joining,Tarehe ya kujiunga
DocType: Naming Series,Update Series,Sasisha Mfululizo
DocType: Supplier Quotation,Is Subcontracted,"Je, unachangamizwa"
DocType: Restaurant Table,Minimum Seating,Kukaa chini
DocType: Item Attribute,Item Attribute Values,Kipengee cha sifa za Maadili
DocType: Examination Result,Examination Result,Matokeo ya Uchunguzi
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Purchase Receipt,Receipt ya Ununuzi
,Received Items To Be Billed,Vipokee Vipokee vya Kulipwa
DocType: Purchase Invoice,Accounting Dimensions,Vipimo vya Uhasibu
,Subcontracted Raw Materials To Be Transferred,Malighafi ya Malighafi Iliyopitishwa Ili kubadilishwa
apps/erpnext/erpnext/config/accounting.py,Currency exchange rate master.,Kiwango cha ubadilishaji wa fedha.
,Sales Person Target Variance Based On Item Group,Lengo la Mtu wa Uuzaji kulingana na Kikundi cha Bidhaa
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Reference Doctype must be one of {0},Doctype ya Kumbukumbu lazima iwe moja ya {0}
apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js,Filter Total Zero Qty,Futa Jumla ya Zero Uchina
DocType: Work Order,Plan material for sub-assemblies,Panga nyenzo kwa makusanyiko ndogo
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} must be active,BOM {0} lazima iwe hai
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,No Items available for transfer,Hakuna Vipengele vinavyopatikana kwa uhamisho
DocType: Employee Boarding Activity,Activity Name,Jina la Shughuli
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Change Release Date,Tarehe ya Toleo la Mabadiliko
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,Umefikia kiasi cha bidhaa <b>{0}</b> na Kwa Wingi <b>{1}</b> haiwezi kuwa tofauti
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Closing (Opening + Total),Kufungwa (Kufungua + Jumla)
DocType: Delivery Settings,Dispatch Notification Attachment,Kusambaza Taarifa ya Sawa
DocType: Payroll Entry,Number Of Employees,Idadi ya Waajiriwa
DocType: Journal Entry,Depreciation Entry,Kuingia kwa kushuka kwa thamani
apps/erpnext/erpnext/selling/report/sales_partner_commission_summary/sales_partner_commission_summary.py,Please select the document type first,Tafadhali chagua aina ya hati kwanza
apps/erpnext/erpnext/stock/doctype/item/item.py,You have to enable auto re-order in Stock Settings to maintain re-order levels.,Lazima uwezeshe kuagiza upya kiotomatiki katika Mipangilio ya Hisa ili kudumisha viwango vya kuagiza upya.
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,Cancel Material Visits {0} before cancelling this Maintenance Visit,Futa Ziara Nyenzo {0} kabla ya kufuta Kutembelea Utunzaji huu
DocType: Pricing Rule,Rate or Discount,Kiwango au Punguzo
apps/erpnext/erpnext/accounts/doctype/bank/bank_dashboard.py,Bank Details,Taarifa za benki
DocType: Vital Signs,One Sided,Mmoja mmoja
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Item {1},Serial Hakuna {0} si ya Bidhaa {1}
DocType: Purchase Order Item Supplied,Required Qty,Uliohitajika Uchina
DocType: Marketplace Settings,Custom Data,Takwimu za Desturi
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with existing transaction can not be converted to ledger.,Maghala na shughuli zilizopo haziwezi kubadilishwa kwenye kiwanja.
DocType: Service Day,Service Day,Siku ya Huduma
apps/erpnext/erpnext/projects/doctype/project/project.py,Project Summary for {0},Muhtasari wa Mradi wa {0}
apps/erpnext/erpnext/hub_node/api.py,Unable to update remote activity,Imeshindwa kusasisha shughuli za mbali
apps/erpnext/erpnext/controllers/buying_controller.py,Serial no is mandatory for the item {0},Hapana ya serial ni lazima kwa kipengee {0}
DocType: Bank Reconciliation,Total Amount,Jumla
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,From Date and To Date lie in different Fiscal Year,Tarehe Tarehe na Tarehe ziko katika Mwaka tofauti wa Fedha
apps/erpnext/erpnext/healthcare/utils.py,The Patient {0} do not have customer refrence to invoice,Mgonjwa {0} hawana rejea ya wateja kwa ankara
DocType: Quality Feedback Template,Quality Feedback Template,Kiolezo cha Maoni ya Ubora
apps/erpnext/erpnext/config/education.py,LMS Activity,Shughuli ya LMS
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Internet Publishing,Kuchapisha mtandao
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Creating {0} Invoice,Kujenga {0} ankara
DocType: Medical Code,Medical Code Standard,Kanuni ya Matibabu ya Kiwango
DocType: Soil Texture,Clay Composition (%),Muundo wa Clay (%)
DocType: Item Group,Item Group Defaults,Kundi la Bidhaa Hifadhi
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js,Please save before assigning task.,Tafadhali salama kabla ya kugawa kazi.
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Balance Value,Thamani ya usawa
DocType: Lab Test,Lab Technician,Mtaalamu wa Lab
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,Sales Price List,Orodha ya Bei ya Mauzo
DocType: Healthcare Settings,"If checked, a customer will be created, mapped to Patient.
Patient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.","Ikiwa imechungwa, mteja atatengenezwa, amechukuliwa kwa Mgonjwa. Invoice za Mgonjwa zitaundwa dhidi ya Wateja hawa. Unaweza pia kuchagua Wateja aliyepo wakati wa kujenga Mgonjwa."
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,Customer isn't enrolled in any Loyalty Program,Wateja hajiandikishwa katika Mpango wowote wa Uaminifu
DocType: Bank Reconciliation,Account Currency,Fedha za Akaunti
DocType: Lab Test,Sample ID,Kitambulisho cha Mfano
apps/erpnext/erpnext/accounts/general_ledger.py,Please mention Round Off Account in Company,Tafadhali tuma Akaunti ya Pande zote katika Kampuni
DocType: Purchase Receipt,Range,Rangi
DocType: Supplier,Default Payable Accounts,Akaunti ya malipo yenye malipo
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} is not active or does not exist,Mfanyakazi {0} haifanyi kazi au haipo
DocType: Fee Structure,Components,Vipengele
DocType: Support Search Source,Search Term Param Name,Jina la Utafutaji wa Jina la Param
DocType: Item Barcode,Item Barcode,Msimbo wa Barcode
DocType: Delivery Trip,In Transit,Katika usafiri
DocType: Woocommerce Settings,Endpoints,Mwisho
DocType: Shopping Cart Settings,Show Configure Button,Onyesha Kitufe cha Usanidi
DocType: Quality Inspection Reading,Reading 6,Kusoma 6
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Cannot {0} {1} {2} without any negative outstanding invoice,Haiwezi {0} {1} {2} bila ankara yoyote mbaya
DocType: Share Transfer,From Folio No,Kutoka No ya Folio
DocType: Purchase Invoice Advance,Purchase Invoice Advance,Ununuzi wa ankara ya awali
DocType: Shift Type,Every Valid Check-in and Check-out,Kila Kuingia Kuingia na Kuangalia
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Credit entry can not be linked with a {1},Row {0}: Uingiaji wa mikopo hauwezi kuunganishwa na {1}
apps/erpnext/erpnext/config/accounting.py,Define budget for a financial year.,Eleza bajeti kwa mwaka wa kifedha.
DocType: Shopify Tax Account,ERPNext Account,Akaunti ya Akaunti ya ERP
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.py,Provide the academic year and set the starting and ending date.,Toa mwaka wa masomo na weka tarehe ya kuanza na kumalizia.
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} is blocked so this transaction cannot proceed,{0} imefungwa hivyo shughuli hii haiwezi kuendelea
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on MR,Hatua kama Bajeti ya Mwezi Yote Iliyopatikana imeongezeka kwa MR
DocType: Employee,Permanent Address Is,Anwani ya Kudumu ni
DocType: Work Order Operation,Operation completed for how many finished goods?,Uendeshaji ulikamilishwa kwa bidhaa ngapi zilizomalizika?
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Healthcare Practitioner {0} not available on {1},Mtaalamu wa Afya {0} haipatikani kwa {1}
DocType: Payment Terms Template,Payment Terms Template,Masharti ya Malipo Kigezo
apps/erpnext/erpnext/public/js/setup_wizard.js,The Brand,Brand
DocType: Employee Tax Exemption Proof Submission,Rented To Date,Ilipangwa hadi Tarehe
DocType: Manufacturing Settings,Allow Multiple Material Consumption,Ruhusu Matumizi ya Nyenzo nyingi
DocType: Employee,Exit Interview Details,Toka Maelezo ya Mahojiano
DocType: Item,Is Purchase Item,Inunuzi ya Bidhaa
DocType: Bank Statement Transaction Invoice Item,Purchase Invoice,Invozi ya Ununuzi
DocType: Manufacturing Settings,Allow multiple Material Consumption against a Work Order,Ruhusu Matumizi Nyenzo nyingi dhidi ya Kazi ya Kazi
DocType: GL Entry,Voucher Detail No,Maelezo ya Voucher No
DocType: Email Digest,New Sales Invoice,Invozi mpya ya Mauzo
DocType: Stock Entry,Total Outgoing Value,Thamani Yote ya Kuondoka
DocType: Healthcare Practitioner,Appointments,Uteuzi
apps/erpnext/erpnext/quality_management/doctype/quality_review/quality_review_list.js,Action Initialised,Imeanzishwa
apps/erpnext/erpnext/public/js/account_tree_grid.js,Opening Date and Closing Date should be within same Fiscal Year,Tarehe ya Ufunguzi na Tarehe ya Kufungwa lazima iwe ndani ya mwaka mmoja wa Fedha
DocType: Lead,Request for Information,Ombi la Taarifa
DocType: Course Activity,Activity Date,Tarehe ya shughuli
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,{} of {},{} ya {}
DocType: Sales Invoice Item,Rate With Margin (Company Currency),Kiwango na Margin (Kampuni ya Fedha)
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Categories,Jamii
apps/erpnext/erpnext/accounts/page/pos/pos.js,Sync Offline Invoices,Sawazisha ankara zisizo kwenye mtandao
DocType: Payment Request,Paid,Ilipwa
DocType: Service Level,Default Priority,Kipaumbele Cha msingi
DocType: Program Fee,Program Fee,Malipo ya Programu
DocType: BOM Update Tool,"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.
It also updates latest price in all the BOMs.","Badilisha BOM fulani katika BOM nyingine zote ambako zinatumiwa. Itasimamia kiungo cha zamani cha BOM, uhakikishe gharama na urekebishe upya &quot;meza ya Bomu ya Mlipuko&quot; kama kwa BOM mpya. Pia inasasisha bei ya hivi karibuni katika BOM zote."
DocType: Employee Skill Map,Employee Skill Map,Ramani ya Ujuzi wa Wafanyakazi
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,The following Work Orders were created:,Amri za Kazi zifuatazo zimeundwa:
DocType: Salary Slip,Total in words,Jumla ya maneno
DocType: Inpatient Record,Discharged,Imetolewa
DocType: Material Request Item,Lead Time Date,Tarehe ya Muda wa Kuongoza
,Employee Advance Summary,Muhtasari wa Mapema wa Waajiriwa
DocType: Asset,Available-for-use Date,Inapatikana kwa tarehe Tarehe
DocType: Guardian,Guardian Name,Jina la Mlinzi
DocType: Cheque Print Template,Has Print Format,Ina Chapisho la Kuchapa
DocType: Support Settings,Get Started Sections,Fungua Sehemu
DocType: Lead,CRM-LEAD-.YYYY.-,MKAZI-MWEZI - YYYY.-
DocType: Invoice Discounting,Sanctioned,Imeteuliwa
,Base Amount,Kiasi cha msingi
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js,Total Contribution Amount: {0},Kiasi cha Ugawaji Jumla: {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Tafadhali taja Serial Hakuna kwa Bidhaa {1}
DocType: Payroll Entry,Salary Slips Submitted,Slips za Mshahara Iliombwa
DocType: Crop Cycle,Crop Cycle,Mzunguko wa Mazao
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Kwa vitu vya &#39;Bidhaa Bundle&#39;, Ghala, Serial No na Batch Hakuna itazingatiwa kutoka kwenye orodha ya &#39;Orodha ya Ufungashaji&#39;. Ikiwa Hakuna Ghala na Batch No ni sawa kwa vitu vyote vya kuingiza kwa bidhaa yoyote ya &#39;Bidhaa Bundle&#39;, maadili haya yanaweza kuingizwa kwenye meza kuu ya Bidhaa, maadili yatakopwa kwenye &#39;Orodha ya Ufungashaji&#39;."
DocType: Amazon MWS Settings,BR,BR
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Place,Kutoka mahali
DocType: Student Admission,Publish on website,Chapisha kwenye tovuti
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Supplier Invoice Date cannot be greater than Posting Date,Tarehe ya Invozi ya Wasambazaji haiwezi kuwa kubwa kuliko Tarehe ya Kuweka
DocType: Installation Note,MAT-INS-.YYYY.-,MAT-INS -YYYY.-
DocType: Subscription,Cancelation Date,Tarehe ya kufuta
DocType: Purchase Invoice Item,Purchase Order Item,Nambari ya Utaratibu wa Ununuzi
DocType: Agriculture Task,Agriculture Task,Kazi ya Kilimo
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Indirect Income,Mapato ya moja kwa moja
DocType: Student Attendance Tool,Student Attendance Tool,Chombo cha Kuhudhuria Wanafunzi
DocType: Restaurant Menu,Price List (Auto created),Orodha ya Bei (Iliundwa kwa Auto)
DocType: Pick List Item,Picked Qty,Aliyemaliza Qty
DocType: Cheque Print Template,Date Settings,Mpangilio wa Tarehe
apps/erpnext/erpnext/education/doctype/question/question.py,A question must have more than one options,Swali lazima liwe na chaguzi zaidi ya moja
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Variance,Tofauti
DocType: Employee Promotion,Employee Promotion Detail,Wafanyakazi wa Kukuza Maelezo
DocType: SMS Center,Total Message(s),Ujumbe Jumla (s)
DocType: Share Balance,Purchased,Inunuliwa
DocType: Item Variant Settings,Rename Attribute Value in Item Attribute.,Fanya Thamani ya Thamani katika Kipengee cha Item.
DocType: Purchase Invoice,Additional Discount Percentage,Asilimia ya Punguzo la ziada
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,View a list of all the help videos,Tazama orodha ya video zote za usaidizi
DocType: Agriculture Analysis Criteria,Soil Texture,Texture ya Udongo
DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,Chagua kichwa cha akaunti cha benki ambapo hundi iliwekwa.
DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Ruhusu mtumiaji kuhariri Kiwango cha Orodha ya Bei katika shughuli
DocType: Pricing Rule,Max Qty,Upeo wa Max
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js,Print Report Card,Kadi ya Ripoti ya Kuchapa
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,"Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \
						Please enter a valid Invoice","Row {0}: ankara {1} ni batili, inaweza kufutwa / haipo. \ Tafadhali ingiza ankara halali"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Row {0}: Malipo dhidi ya Mauzo / Ununuzi Order lazima daima kuwa alama kama mapema
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Chemical,Kemikali
DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Akaunti ya Hifadhi ya Benki / Cash itasasishwa moja kwa moja katika Uingiaji wa Machapisho ya Mshahara wakati hali hii imechaguliwa.
DocType: Quiz,Latest Attempt,Jaribio la hivi karibuni
DocType: Quiz Result,Quiz Result,Matokeo ya Jaribio
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total leaves allocated is mandatory for Leave Type {0},Majani yote yaliyotengwa ni ya lazima kwa Kuacha Aina {0}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Row # {0}: Kiwango hawezi kuwa kikubwa zaidi kuliko kiwango cha kutumika katika {1} {2}
apps/erpnext/erpnext/utilities/user_progress.py,Meter,Mita
DocType: Workstation,Electricity Cost,Gharama za Umeme
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py,Lab testing datetime cannot be before collection datetime,Siku ya tarehe ya kupima Lab haiwezi kuwa kabla ya tarehe ya kukusanya
DocType: Subscription Plan,Cost,Gharama
DocType: HR Settings,Don't send Employee Birthday Reminders,Usitumie Makumbusho ya Siku ya Kuzaliwa
DocType: Expense Claim,Total Advance Amount,Jumla ya Mapendekezo ya Kiasi
DocType: Delivery Stop,Estimated Arrival,Ufikiaji uliotarajiwa
apps/erpnext/erpnext/templates/pages/help.html,See All Articles,Angalia Makala Yote
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Walk In,Ingia ndani
DocType: Item,Inspection Criteria,Vigezo vya ukaguzi
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Transfered,Imehamishwa
DocType: BOM Website Item,BOM Website Item,BOM ya Bidhaa ya Tovuti
apps/erpnext/erpnext/public/js/setup_wizard.js,Upload your letter head and logo. (you can edit them later).,Pakia kichwa chako na alama. (unaweza kuwahariri baadaye).
DocType: Timesheet Detail,Bill,Bill
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,White,Nyeupe
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Invalid Company for Inter Company Transaction.,Kampuni batili ya Uingilianaji wa Kampuni.
DocType: SMS Center,All Lead (Open),Viongozi wote (Ufunguzi)
apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py,You can only select a maximum of one option from the list of check boxes.,Unaweza kuchagua chaguo moja tu kutoka kwenye orodha ya masanduku ya kuangalia.
DocType: Purchase Invoice,Get Advances Paid,Pata Mafanikio ya kulipwa
DocType: Item,Automatically Create New Batch,Unda Batch Mpya kwa moja kwa moja
DocType: Woocommerce Settings,"The user that will be used to create Customers, Items and Sales Orders. This user should have the relevant permissions.","Mtumiaji atakayetumiwa kuunda Wateja, Vitu na Daraja ya Uuzaji. Mtumiaji huyu anapaswa kuwa na ruhusa inayofaa."
DocType: Supplier,Represents Company,Inawakilisha Kampuni
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Make ,Fanya
DocType: Student Admission,Admission Start Date,Tarehe ya Kuanza Kuingia
DocType: Journal Entry,Total Amount in Words,Jumla ya Kiasi kwa Maneno
apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js,New Employee,Mfanyakazi Mpya
apps/erpnext/erpnext/controllers/selling_controller.py,Order Type must be one of {0},Aina ya Utaratibu lazima iwe moja ya {0}
DocType: Lead,Next Contact Date,Tarehe ya Kuwasiliana ijayo
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Opening Qty,Ufunguzi wa Uchina
DocType: Healthcare Settings,Appointment Reminder,Kumbukumbu ya Uteuzi
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please enter Account for Change Amount,Tafadhali ingiza Akaunti ya Kiasi cha Mabadiliko
DocType: Program Enrollment Tool Student,Student Batch Name,Jina la Kundi la Mwanafunzi
DocType: Holiday List,Holiday List Name,Jina la Orodha ya likizo
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Kuingiza Vitu na UOM
DocType: Repayment Schedule,Balance Loan Amount,Kiwango cha Mikopo
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Imeongezwa kwa maelezo
DocType: Communication Medium,Catch All,Chukua Zote
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Ratiba ya Kozi
DocType: Budget,Applicable on Material Request,Inahitajika kwenye Ombi la Nyenzo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Stock Options,Chaguzi za hisa
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,No Items added to cart,Hakuna Vitu vilivyoongezwa kwenye gari
DocType: Journal Entry Account,Expense Claim,Madai ya Madai
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Do you really want to restore this scrapped asset?,"Je, kweli unataka kurejesha mali hii iliyokatwa?"
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Qty for {0},Uchina kwa {0}
DocType: Attendance,Leave Application,Acha Maombi
DocType: Patient,Patient Relation,Uhusiano wa Mgonjwa
DocType: Item,Hub Category to Publish,Jamii ya Hifadhi ya Kuchapisha
DocType: Leave Block List,Leave Block List Dates,Acha Tarehe ya Kuzuia Orodha
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Sales Order {0} has reservation for item {1}, you can
		only deliver reserved {1} against {0}. Serial No {2} cannot
		be delivered","Amri ya Mauzo {0} ina uhifadhi wa kipengee {1}, unaweza kutoa tu iliyohifadhiwa {1} dhidi ya {0}. Serial Hapana {2} haiwezi kutolewa"
DocType: Sales Invoice,Billing Address GSTIN,Anwani ya kulipia GSTIN
DocType: Homepage,Hero Section Based On,Sehemu ya shujaa Kulingana
DocType: Employee Tax Exemption Proof Submission,Total Eligible HRA Exemption,Jumla ya Kutolewa HRA ya Haki
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! A GSTIN must have 15 characters.,GSTIN batili! GSTIN lazima iwe na herufi 15.
DocType: Assessment Plan,Evaluate,Tathmini
DocType: Workstation,Net Hour Rate,Kiwango cha Saa ya Nambari
DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Rejeipt ya Ununuzi wa Gharama
DocType: Supplier Scorecard Period,Criteria,Vigezo
DocType: Packing Slip Item,Packing Slip Item,Ufungashaji wa Slip Item
DocType: Purchase Invoice,Cash/Bank Account,Akaunti ya Fedha / Benki
DocType: Travel Itinerary,Train,Treni
,Delayed Item Report,Imechelewa Ripoti ya jambo
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Eligible ITC,Inastahili ITC
DocType: Healthcare Service Unit,Inpatient Occupancy,Uzoefu wa wagonjwa
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,Publish Your First Items,Chapisha Vitu Vya Kwanza
DocType: Sample Collection,HLC-SC-.YYYY.-,HLC-SC-YYYY.-
DocType: Shift Type,Time after the end of shift during which check-out is considered for attendance.,Wakati baada ya kumalizika kwa mabadiliko ambayo wakati wa kuondoka unazingatiwa kwa mahudhurio.
apps/erpnext/erpnext/public/js/queries.js,Please specify a {0},Tafadhali taja {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Removed items with no change in quantity or value.,Vipengee vilivyoondolewa bila mabadiliko katika wingi au thamani.
DocType: Delivery Note,Delivery To,Utoaji Kwa
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant creation has been queued.,Uumbaji wa viumbe umefungwa.
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py,Work Summary for {0},Muhtasari wa Kazi kwa {0}
DocType: Department,The first Leave Approver in the list will be set as the default Leave Approver.,Msaidizi wa kwanza wa Kuondoka kwenye orodha utawekwa kama Msaidizi wa Kuacha wa Kuacha.
apps/erpnext/erpnext/stock/doctype/item/item.py,Attribute table is mandatory,Toleo la meza ni lazima
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Delayed Days,Siku za kuchelewa
DocType: Production Plan,Get Sales Orders,Pata Maagizo ya Mauzo
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,{0} can not be negative,{0} haiwezi kuwa hasi
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js,Connect to Quickbooks,Unganisha kwenye Quickbooks
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Clear values,Futa maadili
DocType: Training Event,Self-Study,Kujitegemea
DocType: POS Closing Voucher,Period End Date,Tarehe ya Mwisho wa Kipindi
apps/erpnext/erpnext/regional/india/utils.py,Transport Receipt No and Date are mandatory for your chosen Mode of Transport,Risiti ya Usafiri Hapana na Tarehe ni ya lazima kwa Njia yako ya Usafiri uliyochagua
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py,Soil compositions do not add up to 100,Nyimbo za udongo haziongei hadi 100
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Discount,Punguzo
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Row {0}: {1} is required to create the Opening {2} Invoices,Row {0}: {1} inahitajika ili kuunda {2} ankara za Ufunguzi
DocType: Membership,Membership,Uanachama
DocType: Asset,Total Number of Depreciations,Jumla ya Idadi ya Dhamana
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Debit A/C Number,Debit A / C Idadi
DocType: Sales Invoice Item,Rate With Margin,Kiwango cha Kwa Margin
DocType: Purchase Invoice,Is Return (Debit Note),Inarudi (Kumbuka Debit)
DocType: Workstation,Wages,Mishahara
DocType: Asset Maintenance,Maintenance Manager Name,Jina la Meneja wa Matengenezo
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Transactions against the company already exist! ,Manunuzi dhidi ya kampuni tayari yapo!
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Requesting Site,Kuomba Tovuti
DocType: Agriculture Task,Urgent,Haraka
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Fetching records......,Inachukua rekodi ......
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please specify a valid Row ID for row {0} in table {1},Tafadhali taja Kitambulisho cha Row halali kwa mstari {0} katika jedwali {1}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py,Unable to find variable: ,Haiwezi kupata variable:
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select a field to edit from numpad,Tafadhali chagua shamba kuhariri kutoka numpad
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot be a fixed asset item as Stock Ledger is created.,Haiwezi kuwa kitu cha kudumu cha mali kama Stock Ledger imeundwa.
DocType: Subscription Plan,Fixed rate,Kiwango cha usawa
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.js,Admit,Kukubali
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Go to the Desktop and start using ERPNext,Nenda kwenye Desktop na uanze kutumia ERPNext
apps/erpnext/erpnext/templates/pages/order.js,Pay Remaining,Ulipotee
DocType: Purchase Invoice Item,Manufacturer,Mtengenezaji
DocType: Landed Cost Item,Purchase Receipt Item,Ununuzi wa Receipt Item
DocType: Leave Allocation,Total Leaves Encashed,Jumla ya Majani yaliyotetemeka
DocType: POS Profile,Sales Invoice Payment,Malipo ya ankara ya mauzo
DocType: Quality Inspection Template,Quality Inspection Template Name,Jina la Kigezo cha Ukaguzi wa Ubora
DocType: Project,First Email,Barua ya Kwanza
DocType: Company,Exception Budget Approver Role,Mpangilio wa Msaidizi wa Bajeti
DocType: Purchase Invoice,"Once set, this invoice will be on hold till the set date","Mara baada ya kuweka, ankara hii itaendelea hadi tarehe ya kuweka"
DocType: Cashier Closing,POS-CLO-,POS-CLO-
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Selling Amount,Kuuza Kiasi
DocType: Repayment Schedule,Interest Amount,Kiwango cha riba
DocType: Job Card,Time Logs,Magogo ya Wakati
DocType: Sales Invoice,Loyalty Amount,Kiasi cha Uaminifu
DocType: Employee Transfer,Employee Transfer Detail,Maelezo ya Uhamisho wa Waajiri
DocType: Serial No,Creation Document No,Hati ya Uumbaji No
DocType: Location,Location Details,Maelezo ya Eneo
DocType: Share Transfer,Issue,Suala
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter_dashboard.py,Records,Kumbukumbu
DocType: Asset,Scrapped,Imepigwa
DocType: Item,Item Defaults,Ufafanuzi wa Bidhaa
DocType: Cashier Closing,Returns,Inarudi
DocType: Job Card,WIP Warehouse,Ghala la WIP
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} is under maintenance contract upto {1},Serial Hakuna {0} ni chini ya mkataba wa matengenezo hadi {1}
apps/erpnext/erpnext/config/hr.py,Recruitment,Uajiri
DocType: Lead,Organization Name,Jina la Shirika
DocType: Support Settings,Show Latest Forum Posts,Onyesha Ujumbe wa Majadiliano ya hivi karibuni
DocType: Tax Rule,Shipping State,Jimbo la Mtoaji
,Projected Quantity as Source,Wengi uliopangwa kama Chanzo
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Item must be added using 'Get Items from Purchase Receipts' button,Kipengee lazima kiongezwe kwa kutumia &#39;Pata Vitu kutoka kwenye Kitufe cha Ununuzi&#39;
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Delivery Trip,Safari ya Utoaji
DocType: Student,A-,A-
DocType: Share Transfer,Transfer Type,Aina ya Uhamisho
DocType: Pricing Rule,Quantity and Amount,Kiasi na Kiasi
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Sales Expenses,Gharama za Mauzo
DocType: Diagnosis,Diagnosis,Utambuzi
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py,Standard Buying,Ununuzi wa kawaida
DocType: Attendance Request,Explanation,Maelezo
DocType: GL Entry,Against,Dhidi
DocType: Item Default,Sales Defaults,Vipimo vya Mauzo
DocType: Sales Order Item,Work Order Qty,Kazi ya Utoaji Kazi
DocType: Item Default,Default Selling Cost Center,Kituo cha Gharama ya Kuuza Ghali
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Disc,Duru
DocType: Buying Settings,Material Transferred for Subcontract,Nyenzo zimehamishwa kwa Mkataba wa Chini
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Date,Tarehe ya Agizo la Ununuzi
DocType: Email Digest,Purchase Orders Items Overdue,Malipo ya Amri ya Ununuzi
apps/erpnext/erpnext/accounts/page/pos/pos.js,ZIP Code,Namba ya Posta
apps/erpnext/erpnext/controllers/selling_controller.py,Sales Order {0} is {1},Amri ya Mauzo {0} ni {1}
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Select interest income account in loan {0},Chagua akaunti ya mapato ya riba kwa mkopo {0}
DocType: Opportunity,Contact Info,Maelezo ya Mawasiliano
apps/erpnext/erpnext/config/help.py,Making Stock Entries,Kufanya Entries Stock
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py,Cannot promote Employee with status Left,Haiwezi kukuza mfanyakazi na hali ya kushoto
DocType: Packing Slip,Net Weight UOM,Uzito wa Uzito wa Nambari
DocType: Item Default,Default Supplier,Muuzaji wa Default
DocType: Loan,Repayment Schedule,Ratiba ya Ulipaji
DocType: Shipping Rule Condition,Shipping Rule Condition,Hali ya Kanuni ya Utoaji
apps/erpnext/erpnext/hr/doctype/payroll_period/payroll_period.py,End Date can not be less than Start Date,Tarehe ya Mwisho haiwezi kuwa chini ya Tarehe ya Mwanzo
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Invoice can't be made for zero billing hour,Invozi haiwezi kufanywa kwa saa ya kulipa zero
DocType: Company,Date of Commencement,Tarehe ya Kuanza
DocType: Sales Person,Select company name first.,Chagua jina la kampuni kwanza.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Email sent to {0},Barua pepe imetumwa kwa {0}
apps/erpnext/erpnext/config/buying.py,Quotations received from Suppliers.,Nukuu zilizopokea kutoka kwa Wauzaji.
DocType: Quality Goal,January-April-July-October,Januari-Aprili-Julai-Oktoba
apps/erpnext/erpnext/config/manufacturing.py,Replace BOM and update latest price in all BOMs,Badilisha BOM na usasishe bei ya hivi karibuni katika BOM zote
apps/erpnext/erpnext/controllers/selling_controller.py,To {0} | {1} {2},Kwa {0} | {1} {2}
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js,This is a root supplier group and cannot be edited.,Huu ni kikundi cha wasambazaji wa mizizi na hauwezi kuhaririwa.
DocType: Sales Invoice,Driver Name,Jina la dereva
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Average Age,Umri wa Umri
DocType: Education Settings,Attendance Freeze Date,Tarehe ya Kuhudhuria Tarehe
DocType: Payment Request,Inward,Ndani
apps/erpnext/erpnext/utilities/user_progress.py,List a few of your suppliers. They could be organizations or individuals.,Andika orodha ya wachache wa wauzaji wako. Wanaweza kuwa mashirika au watu binafsi.
DocType: Accounting Dimension,Dimension Defaults,Mapungufu ya Vipimo
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Minimum Lead Age (Days),Umri wa Kiongozi wa Chini (Siku)
apps/erpnext/erpnext/assets/report/fixed_asset_register/fixed_asset_register.py,Available For Use Date,Inapatikana Kwa Tarehe ya Matumizi
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,All BOMs,BOM zote
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Create Inter Company Journal Entry,Unda Kiingilio cha Kijarida cha Kampuni
DocType: Company,Parent Company,Kampuni mama
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py,Hotel Rooms of type {0} are unavailable on {1},Vyumba vya aina ya aina {0} hazipatikani kwa {1}
apps/erpnext/erpnext/config/manufacturing.py,Compare BOMs for changes in Raw Materials and Operations,Linganisha BOMs za mabadiliko katika Malighafi na Uendeshaji
apps/erpnext/erpnext/accounts/doctype/bank_transaction/bank_transaction.js,Document {0} successfully uncleared,Hati {0} haijafanikiwa
DocType: Healthcare Practitioner,Default Currency,Fedha ya Default
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Reconcile this account,Patanisha akaunti hii
apps/erpnext/erpnext/controllers/selling_controller.py,Maximum discount for Item {0} is {1}%,Upeo wa juu kwa Bidhaa {0} ni {1}%
DocType: Chart of Accounts Importer,Attach custom Chart of Accounts file,Ambatisha Chati maalum ya faili ya Hesabu
DocType: Asset Movement,From Employee,Kutoka kwa Mfanyakazi
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Import of services,Umuhimu wa huduma
DocType: Driver,Cellphone Number,Nambari ya simu ya mkononi
DocType: Project,Monitor Progress,Kufuatilia Maendeleo
DocType: Pricing Rule Item Code,Pricing Rule Item Code,Code Bei ya Bidhaa ya bei
apps/erpnext/erpnext/controllers/accounts_controller.py,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Tahadhari: Mfumo hautaangalia overbilling tangu kiasi cha Bidhaa {0} katika {1} ni sifuri
DocType: Journal Entry,Make Difference Entry,Fanya Tofauti Kuingia
DocType: Supplier Quotation,Auto Repeat Section,Sehemu ya kurudia kwa urahisi
DocType: Service Level Priority,Response Time,Wakati wa Kujibu
DocType: Upload Attendance,Attendance From Date,Kuhudhuria Tarehe Tarehe
DocType: Appraisal Template Goal,Key Performance Area,Eneo la Ufanisi
DocType: Program Enrollment,Transportation,Usafiri
apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Attribute batili
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} lazima iwasilishwa
apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Kampeni za barua pepe
DocType: Buying Settings,Default Supplier Group,Kikundi cha Wasambazaji cha Default
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Wingi lazima iwe chini au sawa na {0}
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Kiwango cha juu kinafaa kwa sehemu {0} zaidi ya {1}
DocType: Department Approver,Department Approver,Idhini ya Idara
DocType: QuickBooks Migrator,Application Settings,Maombi ya Maombi
DocType: SMS Center,Total Characters,Washirika wa jumla
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Creating Company and Importing Chart of Accounts,Kuunda Kampuni na Chati ya Kuingiza Akaunti
DocType: Employee Advance,Claimed,Alidai
DocType: Crop,Row Spacing,Upeo wa Row
apps/erpnext/erpnext/controllers/buying_controller.py,Please select BOM in BOM field for Item {0},Tafadhali chagua BOM katika uwanja wa BOM kwa Item {0}
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,There isn't any item variant for the selected item,Hakuna kitu chochote cha kipengee cha kipengee kilichochaguliwa
DocType: C-Form Invoice Detail,C-Form Invoice Detail,Maelezo ya Nambari ya Invoice ya Fomu
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Malipo ya Upatanisho wa Malipo
DocType: Clinical Procedure,Procedure Template,Kigezo cha Utaratibu
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Publish Items,Chapisha Vitu
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py,Contribution %,Mchango%
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}","Kwa mujibu wa Mipangilio ya Ununuzi ikiwa Utaratibu wa Ununuzi Unahitajika == &#39;Ndiyo&#39;, kisha kwa Kuunda Invoice ya Ununuzi, mtumiaji anahitaji kuunda Utaratibu wa Ununuzi kwanza kwa kipengee {0}"
,HSN-wise-summary of outward supplies,Sura ya HSN-hekima ya vifaa vya nje
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Nambari za usajili wa Kampuni kwa kumbukumbu yako. Nambari za kodi nk
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To State,Kwa Hali
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Distributor,Wasambazaji
DocType: Asset Finance Book,Asset Finance Book,Kitabu cha Fedha za Mali
DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Ununuzi wa Ununuzi wa Kusafirishwa
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.py,Please setup a default bank account for company {0},Tafadhali sasisha akaunti ya benki ya msingi ya kampuni {0}
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please set 'Apply Additional Discount On',Tafadhali weka &#39;Weka Kutoa Kinga ya ziada&#39;
DocType: Party Tax Withholding Config,Applicable Percent,Asilimia inayofaa
,Ordered Items To Be Billed,Vipengele vya Amri vinavyopigwa
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,From Range has to be less than To Range,Kutoka kwa Range lazima iwe chini ya Kupanga
DocType: Global Defaults,Global Defaults,Ufafanuzi wa Global
apps/erpnext/erpnext/projects/doctype/project/project.py,Project Collaboration Invitation,Mwaliko wa Ushirikiano wa Mradi
DocType: Salary Slip,Deductions,Kupunguza
DocType: Setup Progress Action,Action Name,Jina la Hatua
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,Start Year,Mwaka wa Mwanzo
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.js,Create Loan,Unda Mkopo
DocType: Purchase Invoice,Start date of current invoice's period,Tarehe ya mwanzo wa kipindi cha ankara ya sasa
DocType: Shift Type,Process Attendance After,Mchakato wa Kuhudhuria Baada ya
,IRS 1099,IRS 1099
DocType: Salary Slip,Leave Without Pay,Acha bila Bila Kulipa
DocType: Payment Request,Outward,Nje
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On {0} Creation,Kwenye {0} Ubunifu
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,State/UT Tax,Ushuru wa Jimbo / UT
,Trial Balance for Party,Mizani ya majaribio kwa Chama
,Gross and Net Profit Report,Pato la jumla na faida ya Net
apps/erpnext/erpnext/config/quality_management.py,Tree of Procedures,Mti wa Taratibu
DocType: Lead,Consultant,Mshauri
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Parents Teacher Meeting Attendance,Mwalimu wa Mwalimu Mkutano wa Mahudhurio
DocType: Salary Slip,Earnings,Mapato
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Finished Item {0} must be entered for Manufacture type entry,Kitengo cha mwisho {0} lazima kiingizwe kwa kuingia kwa aina ya Utengenezaji
apps/erpnext/erpnext/config/help.py,Opening Accounting Balance,Kufungua Mizani ya Uhasibu
,GST Sales Register,Jumuiya ya Daftari ya Mauzo
DocType: Sales Invoice Advance,Sales Invoice Advance,Advance ya Mauzo ya Mauzo
apps/erpnext/erpnext/public/js/setup_wizard.js,Select your Domains,Chagua Domains yako
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/sync_product.py,Shopify Supplier,Mtoa Wasambazaji
DocType: Bank Statement Transaction Entry,Payment Invoice Items,Vitu vya ankara za malipo
DocType: Payroll Entry,Employee Details,Maelezo ya Waajiri
DocType: Amazon MWS Settings,CN,CN
DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Mashamba yatakopwa zaidi wakati wa uumbaji.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Row {0}: asset is required for item {1},Safu {0}: mali inahitajika kwa bidhaa {1}
apps/erpnext/erpnext/projects/doctype/task/task.py,'Actual Start Date' can not be greater than 'Actual End Date','Tarehe sahihi ya Kuanza' haiwezi kuwa kubwa zaidi kuliko 'Tarehe ya mwisho ya mwisho'
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Management,Usimamizi
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.js,Show {0},Onyesha {0}
DocType: Cheque Print Template,Payer Settings,Mipangilio ya Payer
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,No pending Material Requests found to link for the given items.,Hakuna Maombi ya Nyenzo yaliyotumiwa yaliyopatikana ili kuunganishwa kwa vitu vyenye.
apps/erpnext/erpnext/public/js/utils/party.js,Select company first,Chagua kampuni kwanza
apps/erpnext/erpnext/accounts/general_ledger.py,Account: <b>{0}</b> is capital Work in progress and can not be updated by Journal Entry,Akaunti: <b>{0}</b> ni mtaji wa Kazi unaendelea na hauwezi kusasishwa na Ingizo la Jarida
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Compare List function takes on list arguments,Linganisha kazi ya Orodha inachukua hoja za orodha
DocType: Item Attribute Value,"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","Hii itaongezwa kwenye Kanuni ya Nambari ya Mchapishaji. Kwa mfano, ikiwa kichwa chako ni &quot;SM&quot;, na msimbo wa kipengee ni &quot;T-SHIRT&quot;, msimbo wa kipengee wa kipengee utakuwa &quot;T-SHIRT-SM&quot;"
DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,Net Pay (kwa maneno) itaonekana baada ya kuokoa Slip ya Mshahara.
DocType: Delivery Note,Is Return,Inarudi
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Caution,Tahadhari
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Import Successful,Ingiza Kufanikiwa
apps/erpnext/erpnext/config/quality_management.py,Goal and Procedure,Lengo na Utaratibu
apps/erpnext/erpnext/agriculture/doctype/disease/disease.py,Start day is greater than end day in task '{0}',Siku ya kuanza ni kubwa kuliko siku ya mwisho katika kazi &#39;{0}&#39;
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Return / Debit Note,Kurudi / Kumbuka Debit
DocType: Price List Country,Price List Country,Orodha ya Bei ya Nchi
DocType: Sales Invoice,Set Source Warehouse,Weka Chapa ya Ghala
DocType: Tally Migration,UOMs,UOM
DocType: Account Subtype,Account Subtype,Subtype ya Akaunti
apps/erpnext/erpnext/stock/utils.py,{0} valid serial nos for Item {1},{0} salama ya serial kwa Bidhaa {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item Code cannot be changed for Serial No.,Msimbo wa kipengee hauwezi kubadilishwa kwa Nambari ya Serial.
DocType: Purchase Invoice Item,UOM Conversion Factor,Kipengele cha Kubadili UOM
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js,Please enter Item Code to get Batch Number,Tafadhali ingiza Msimbo wa Nambari ili kupata Nambari ya Batch
DocType: Loyalty Point Entry,Loyalty Point Entry,Uaminifu wa Kuingia Uhakika
DocType: Employee Checkin,Shift End,Mwisho wa Shift
DocType: Stock Settings,Default Item Group,Kikundi cha Kichwa cha Kichwa
DocType: Job Card Time Log,Time In Mins,Muda Katika Zaka
apps/erpnext/erpnext/config/non_profit.py,Grant information.,Ruhusu habari.
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.js,This action will unlink this account from any external service integrating ERPNext with your bank accounts. It cannot be undone. Are you certain ?,Kitendo hiki kitaondoa akaunti hii kutoka kwa huduma yoyote ya nje inayojumuisha ERPNext na akaunti yako ya benki. Haiwezi kutekelezwa. Je! Una uhakika?
apps/erpnext/erpnext/config/buying.py,Supplier database.,Duka la wauzaji.
DocType: Contract Template,Contract Terms and Conditions,Masharti na Masharti ya Mkataba
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,You cannot restart a Subscription that is not cancelled.,Huwezi kuanzisha upya Usajili ambao haujahairiwa.
DocType: Account,Balance Sheet,Karatasi ya Mizani
DocType: Leave Type,Is Earned Leave,Inapatikana Kuondoka
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Amount,Kiasi cha Agizo la Ununuzi
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Cost Center For Item with Item Code ',Kituo cha Gharama kwa Bidhaa na Msimbo wa Bidhaa &#39;
DocType: Fee Validity,Valid Till,Halali Mpaka
DocType: Student Report Generation Tool,Total Parents Teacher Meeting,Jumla ya Mkutano wa Mwalimu wa Wazazi
apps/erpnext/erpnext/accounts/page/pos/pos.js,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Njia ya Malipo haijasanidiwa. Tafadhali angalia, kama akaunti imewekwa kwenye Mfumo wa Malipo au kwenye POS Profile."
apps/erpnext/erpnext/buying/utils.py,Same item cannot be entered multiple times.,Kitu kimoja hawezi kuingizwa mara nyingi.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Further accounts can be made under Groups, but entries can be made against non-Groups","Akaunti zaidi zinaweza kufanywa chini ya Vikundi, lakini viingilio vinaweza kufanywa dhidi ya wasio Vikundi"
DocType: Call Log,Lead,Cheza
DocType: Email Digest,Payables,Malipo
DocType: Amazon MWS Settings,MWS Auth Token,Kitambulisho cha MWS Auth
DocType: Email Campaign,Email Campaign For ,Kampeni ya barua pepe kwa
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Stock Entry {0} created,Entry Entry {0} imeundwa
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,You don't have enought Loyalty Points to redeem,Huna ushawishi wa Pole ya Uaminifu ili ukomboe
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py,Please set associated account in Tax Withholding Category {0} against Company {1},Tafadhali weka akaunti inayohusishwa katika Jamii ya Kuzuia Ushuru {0} dhidi ya Kampuni {1}
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Rejected Qty can not be entered in Purchase Return,Row # {0}: Nambari iliyokataliwa haiwezi kuingizwa katika Kurudi kwa Ununuzi
apps/erpnext/erpnext/stock/doctype/item/item.js,Changing Customer Group for the selected Customer is not allowed.,Kubadilisha Kundi la Wateja kwa Wateja waliochaguliwa hairuhusiwi.
,Purchase Order Items To Be Billed,Vitu vya Utaratibu wa Ununuzi Ili Kulipwa
DocType: Program Enrollment Tool,Enrollment Details,Maelezo ya Uandikishaji
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot set multiple Item Defaults for a company.,Haiwezi kuweka Vifungo vingi vya Bidhaa kwa kampuni.
DocType: Customer Group,Credit Limits,Upungufu wa Mikopo
DocType: Purchase Invoice Item,Net Rate,Kiwango cha Nambari
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select a customer,Tafadhali chagua mteja
DocType: Leave Policy,Leave Allocations,Acha Ugawaji
DocType: Job Card,Started Time,Saa Iliyoanza
DocType: Purchase Invoice Item,Purchase Invoice Item,Bidhaa ya Invoice ya Ununuzi
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Entries Ledger Entries na GL Entries ni reposted kwa Receipts ya kuchaguliwa Ununuzi
DocType: Student Report Generation Tool,Assessment Terms,Masharti ya Tathmini
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 1,Kipengee 1
DocType: Holiday,Holiday,Sikukuu
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Leave Type is madatory,Acha aina ni madhara
DocType: Support Settings,Close Issue After Days,Funga Suala Baada ya Siku
,Eway Bill,Bunge Bill
apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to add users to Marketplace.,Unahitaji kuwa mtumiaji na Meneja wa Mfumo na majukumu ya Meneja wa Bidhaa ili kuongeza watumiaji kwenye Marketplace.
DocType: Attendance,Early Exit,Toka mapema
DocType: Job Opening,Staffing Plan,Mpango wa Utumishi
apps/erpnext/erpnext/accounts/doctype/sales_invoice/regional/india_list.js,e-Way Bill JSON can only be generated from a submitted document,E-Way Bill JSON inaweza tu kutolewa kutoka hati iliyowasilishwa
apps/erpnext/erpnext/config/hr.py,Employee Tax and Benefits,Kodi ya Wafanyakazi na Faida
DocType: Bank Guarantee,Validity in Days,Uthibitisho katika Siku
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,C-form is not applicable for Invoice: {0},Fomu ya C haina kutumika kwa ankara: {0}
DocType: Certified Consultant,Name of Consultant,Jina la Mshauri
DocType: Payment Reconciliation,Unreconciled Payment Details,Maelezo ya Malipo yasiyotambulika
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py,Member Activity,Shughuli ya Mjumbe
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Count,Hesabu ya Hesabu
DocType: Global Defaults,Current Fiscal Year,Mwaka wa Fedha wa sasa
DocType: Purchase Invoice,Group same items,Jumuisha vitu sawa
DocType: Purchase Invoice,Disable Rounded Total,Lemaza Jumla ya Mviringo
DocType: Marketplace Settings,Sync in Progress,Sawazisha katika Maendeleo
DocType: Department,Parent Department,Idara ya Mzazi
DocType: Loan Application,Repayment Info,Maelezo ya kulipa
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,'Entries' cannot be empty,&#39;Entries&#39; haiwezi kuwa tupu
DocType: Maintenance Team Member,Maintenance Role,Dhamana ya Matengenezo
apps/erpnext/erpnext/utilities/transaction_base.py,Duplicate row {0} with same {1},Mstari wa Duplicate {0} na sawa {1}
DocType: Marketplace Settings,Disable Marketplace,Lemaza mahali pa Marketplace
DocType: Quality Meeting,Minutes,Dakika
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Your Featured Items,Vitu vyako vilivyotambuliwa
,Trial Balance,Mizani ya majaribio
apps/erpnext/erpnext/templates/pages/projects.js,Show Completed,Onyesha imekamilishwa
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Fiscal Year {0} not found,Mwaka wa Fedha {0} haukupatikana
apps/erpnext/erpnext/config/help.py,Setting up Employees,Kuweka Wafanyakazi
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Fanya Uingilio wa Hisa
DocType: Hotel Room Reservation,Hotel Reservation User,User Reservation User
apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Weka Hali
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Tafadhali sasisha safu za nambari za Kuhudhuria kupitia Usanidi&gt; Mfululizo wa hesabu
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Tafadhali chagua kiambatisho kwanza
DocType: Contract,Fulfilment Deadline,Utekelezaji wa Mwisho
apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Karibu na wewe
DocType: Student,O-,O-
DocType: Subscription Settings,Subscription Settings,Mipangilio ya usajili
DocType: Purchase Invoice,Update Auto Repeat Reference,Sasisha Nambari ya Repeat ya Rejea
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Optional Holiday List not set for leave period {0},Orodha ya Likizo ya Hiari haipatikani wakati wa kuondoka {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Research,Utafiti
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Address 2,Kwa Anwani 2
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0}: From time must be less than to time,Safu {0}: Kutoka wakati lazima iwe chini ya wakati
DocType: Maintenance Visit Purpose,Work Done,Kazi Imefanyika
apps/erpnext/erpnext/controllers/item_variant.py,Please specify at least one attribute in the Attributes table,Tafadhali taja angalau sifa moja katika meza ya Tabia
DocType: Announcement,All Students,Wanafunzi wote
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} must be a non-stock item,Kipengee {0} lazima iwe kipengee cha hisa
apps/erpnext/erpnext/stock/doctype/batch/batch.js,View Ledger,Tazama kizuizi
DocType: Cost Center,Lft,Karibu
DocType: Grading Scale,Intervals,Mapumziko
DocType: Bank Statement Transaction Entry,Reconciled Transactions,Shughuli zilizounganishwa
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Earliest,Mapema kabisa
DocType: Crop Cycle,Linked Location,Eneo lililohusishwa
apps/erpnext/erpnext/stock/doctype/item/item.py,"An Item Group exists with same name, please change the item name or rename the item group","Kundi la Bidhaa limekuwa na jina moja, tafadhali ubadilisha jina la kipengee au uunda jina la kundi la bidhaa"
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invocies,Pata ankara
DocType: Designation,Skills,Ujuzi
DocType: Crop Cycle,Less than a year,Chini ya mwaka
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py,Student Mobile No.,Namba ya Mkono ya Mwanafunzi
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Rest Of The World,Mwisho wa Dunia
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,The Item {0} cannot have Batch,Item {0} haiwezi kuwa na Kundi
DocType: Crop,Yield UOM,Uzao UOM
,Budget Variance Report,Ripoti ya Tofauti ya Bajeti
DocType: Salary Slip,Gross Pay,Pato la Pato
DocType: Item,Is Item from Hub,Ni kitu kutoka Hub
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Get Items from Healthcare Services,Pata vitu kutoka Huduma za Huduma za Afya
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: Activity Type is mandatory.,Row {0}: Aina ya Shughuli ni lazima.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Dividends Paid,Mgawanyiko ulipwa
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Accounting Ledger,Ledger ya Uhasibu
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Difference Amount,Tofauti Kiasi
DocType: Purchase Invoice,Reverse Charge,Malipo ya Reverse
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Retained Earnings,Mapato yaliyohifadhiwa
DocType: Job Card,Timing Detail,Maelezo ya Muda
DocType: Purchase Invoice,05-Change in POS,05-Badilisha katika POS
DocType: Vehicle Log,Service Detail,Maelezo ya Huduma
DocType: BOM,Item Description,Maelezo ya maelezo
DocType: Student Sibling,Student Sibling,Kijana wa Kike
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py,Payment Mode,Njia ya Malipo
DocType: Purchase Invoice,Supplied Items,Vitu vinavyopatikana
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please set an active menu for Restaurant {0},Tafadhali weka orodha ya kazi ya Mgahawa {0}
apps/erpnext/erpnext/selling/report/sales_partner_commission_summary/sales_partner_commission_summary.py,Commission Rate %,Kiwango cha Tume%
DocType: Woocommerce Settings,"This warehouse will be used to create Sale Orders. The fallback warehouse is ""Stores"".",Ghala hii itatumika kuunda Maagizo ya Uuzaji. Ghala inayoanguka ni &quot;Duka&quot;.
DocType: Work Order,Qty To Manufacture,Uchina Ili Kufanya
DocType: Email Digest,New Income,Mapato mapya
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Open Lead,Fungua Kiongozi
DocType: Buying Settings,Maintain same rate throughout purchase cycle,Weka kiwango sawa katika mzunguko wa ununuzi
DocType: Opportunity Item,Opportunity Item,Kitu cha Fursa
DocType: Quality Action,Quality Review,Mapitio ya Ubora
,Student and Guardian Contact Details,Mwanafunzi na Mlinzi Maelezo ya Mawasiliano
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge Account,Unganisha Akaunti
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Row {0}: For supplier {0} Email Address is required to send email,Row {0}: Kwa wauzaji {0} Anwani ya barua pepe inahitajika kutuma barua pepe
DocType: Shift Type,Attendance will be marked automatically only after this date.,Mahudhurio yata alama moja kwa moja tu baada ya tarehe hii.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Temporary Opening,Ufunguo wa Muda
,Employee Leave Balance,Mizani ya Waajiriwa
apps/erpnext/erpnext/quality_management/doctype/quality_procedure/quality_procedure_tree.js,New Quality Procedure,Utaratibu Mpya wa Ubora
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Balance for Account {0} must always be {1},Mizani ya Akaunti {0} lazima iwe {1}
DocType: Patient Appointment,More Info,Maelezo zaidi
DocType: Supplier Scorecard,Scorecard Actions,Vitendo vya kadi ya alama
apps/erpnext/erpnext/utilities/user_progress.py,Example: Masters in Computer Science,Mfano: Masters katika Sayansi ya Kompyuta
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,Supplier {0} not found in {1},Muuzaji {0} haipatikani katika {1}
DocType: Purchase Invoice,Rejected Warehouse,Ghala iliyokataliwa
DocType: GL Entry,Against Voucher,Dhidi ya Voucher
DocType: Item Default,Default Buying Cost Center,Kituo cha Gharama cha Ununuzi cha Default
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Payment,Malipo Mpya
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Ili kupata bora kutoka kwa ERPNext, tunapendekeza kwamba utachukua muda na kutazama video hizi za usaidizi."
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,For Default Supplier (optional),Kwa Default Supplier (hiari)
DocType: Supplier Quotation Item,Lead Time in days,Tembea Muda katika siku
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Target ({}),Lengo ({})
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Accounts Payable Summary,Muhtasari wa Kulipa Akaunti
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Not authorized to edit frozen Account {0},Haiidhinishwa kuhariri Akaunti iliyohifadhiwa {0}
DocType: Journal Entry,Get Outstanding Invoices,Pata ankara bora
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Sales Order {0} is not valid,Uagizaji wa Mauzo {0} halali
DocType: Supplier Scorecard,Warn for new Request for Quotations,Tahadhari kwa ombi mpya ya Nukuu
apps/erpnext/erpnext/utilities/activation.py,Purchase orders help you plan and follow up on your purchases,Amri za ununuzi husaidia kupanga na kufuatilia ununuzi wako
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Lab Test Prescriptions,Maagizo ya Majaribio ya Lab
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,"The total Issue / Transfer quantity {0} in Material Request {1}  \
							cannot be greater than requested quantity {2} for Item {3}",Jalada la jumla / Vipimo vya uhamisho {0} katika Maombi ya Vifaa {1} \ hawezi kuwa kubwa zaidi kuliko kiasi kilichoombwa {2} kwa Bidhaa {3}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Small,Ndogo
DocType: Shopify Settings,"If Shopify not contains a customer in Order, then while syncing Orders, the system will consider default customer for order","Ikiwa Shopify haina mteja katika Utaratibu, basi wakati wa kusawazisha Maagizo, mfumo utazingatia mteja default kwa amri"
DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Kufungua Kitufe cha Uumbaji wa Dawa ya Invoice
DocType: Cashier Closing Payments,Cashier Closing Payments,Malipo ya Kufunga Fedha
DocType: Education Settings,Employee Number,Nambari ya Waajiriwa
DocType: Subscription Settings,Cancel Invoice After Grace Period,Futa Invoice Baada ya Kipindi cha Grace
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Case No(s) already in use. Try from Case No {0},Kesi Hakuna (s) tayari kutumika. Jaribu kutoka kwenye Uchunguzi Hapana {0}
DocType: Project,% Completed,Imekamilika
,Invoiced Amount (Exculsive Tax),Kiasi kilichotolewa (kodi ya nje)
DocType: Asset Finance Book,Rate of Depreciation,Kiwango cha Uchakavu
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Serial Numbers,Nambari za serial
apps/erpnext/erpnext/controllers/stock_controller.py,Row {0}: Quality Inspection rejected for item {1},Safu {0}: Ukaguzi wa Ubora uliokataliwa kwa bidhaa {1}
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 2,Kipengee 2
DocType: Pricing Rule,Validate Applied Rule,Thibitisha Sheria iliyotumiwa
DocType: QuickBooks Migrator,Authorization Endpoint,Mwisho wa Hati miliki
DocType: Employee Onboarding,Notify users by email,Waarifu watumiaji kwa barua pepe
DocType: Travel Request,International,Kimataifa
DocType: Training Event,Training Event,Tukio la Mafunzo
DocType: Item,Auto re-order,Rejesha upya
DocType: Attendance,Late Entry,Kuingia kwa Marehemu
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Total Achieved,Jumla imefikia
DocType: Employee,Place of Issue,Pahali pa kupewa
DocType: Promotional Scheme,Promotional Scheme Price Discount,Punguzo la Bei ya Uendelezaji
DocType: Contract,Contract,Mkataba
DocType: GSTR 3B Report,May,Mei
DocType: Plant Analysis,Laboratory Testing Datetime,Wakati wa Tathmini ya Maabara
DocType: Email Digest,Add Quote,Ongeza Nukuu
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,UOM coversion factor required for UOM: {0} in Item: {1},Kipengele cha ufunuo wa UOM kinahitajika kwa UOM: {0} katika Item: {1}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Indirect Expenses,Gharama zisizo sahihi
apps/erpnext/erpnext/controllers/selling_controller.py,Row {0}: Qty is mandatory,Row {0}: Uchina ni lazima
DocType: Agriculture Analysis Criteria,Agriculture,Kilimo
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,Create Sales Order,Unda Utaratibu wa Mauzo
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Accounting Entry for Asset,Kuingia kwa Uhasibu kwa Mali
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Block Invoice,Zima ankara
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js,Quantity to Make,Wingi wa Kufanya
apps/erpnext/erpnext/accounts/page/pos/pos.js,Sync Master Data,Sawa Data ya Mwalimu
DocType: Asset Repair,Repair Cost,Tengeneza Gharama
apps/erpnext/erpnext/utilities/user_progress.py,Your Products or Services,Bidhaa au Huduma zako
DocType: Quality Meeting Table,Under Review,Chini ya Mapitio
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Imeshindwa kuingia
apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Malipo {0} yameundwa
DocType: Special Test Items,Special Test Items,Vipimo vya Mtihani maalum
apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Unahitaji kuwa mtumiaji na Meneja wa Mfumo na Majukumu ya Meneja wa Item kujiandikisha kwenye Soko.
apps/erpnext/erpnext/config/buying.py,Key Reports,Ripoti muhimu
DocType: Bank Statement Transaction Payment Item,Mode of Payment,Hali ya Malipo
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,As per your assigned Salary Structure you cannot apply for benefits,Kwa mujibu wa Mfumo wa Mshahara uliopangwa huwezi kuomba faida
apps/erpnext/erpnext/stock/doctype/item/item.py,Website Image should be a public file or website URL,Image ya tovuti lazima iwe faili ya umma au URL ya tovuti
DocType: Purchase Invoice Item,BOM,BOM
apps/erpnext/erpnext/stock/doctype/item/item.py,Duplicate entry in Manufacturers table,Kuingia marudio katika meza ya Watengenezaji
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js,This is a root item group and cannot be edited.,Hii ni kikundi cha bidhaa cha mizizi na haiwezi kuhaririwa.
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge,Unganisha
DocType: Journal Entry Account,Purchase Order,Amri ya Utunzaji
DocType: Vehicle,Fuel UOM,UOM ya mafuta
DocType: Warehouse,Warehouse Contact Info,Info ya Kuwasiliana na Ghala
DocType: Payment Entry,Write Off Difference Amount,Andika Tofauti Tofauti
DocType: Volunteer,Volunteer Name,Jina la kujitolea
apps/erpnext/erpnext/controllers/accounts_controller.py,Rows with duplicate due dates in other rows were found: {0},Inapanda kwa duplicate tarehe kutokana na safu zingine zilipatikana: {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,"{0}: Employee email not found, hence email not sent","{0}: barua pepe ya mfanyakazi haipatikani, hivyo barua pepe haitumwa"
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,No Salary Structure assigned for Employee {0} on given date {1},Hakuna Mfumo wa Mshahara uliopangwa kwa Mfanyakazi {0} kwenye tarehe iliyotolewa {1}
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule not applicable for country {0},Sheria ya usafirishaji haifai kwa nchi {0}
DocType: Item,Foreign Trade Details,Maelezo ya Biashara ya Nje
,Assessment Plan Status,Hali ya Mpango wa Tathmini
DocType: Email Digest,Annual Income,Mapato ya kila mwaka
DocType: Serial No,Serial No Details,Serial Hakuna Maelezo
DocType: Purchase Invoice Item,Item Tax Rate,Kiwango cha Kodi ya Kodi
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Party Name,Kutoka Jina la Chama
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Net Salary Amount,Kiasi cha Mshahara wa Net
DocType: Pick List,Delivery against Sales Order,Uwasilishaji dhidi ya Agizo la Uuzaji
DocType: Student Group Student,Group Roll Number,Nambari ya Roll ya Kikundi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"For {0}, only credit accounts can be linked against another debit entry","Kwa {0}, akaunti za mikopo tu zinaweza kuunganishwa dhidi ya kuingia mwingine kwa debit"
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Delivery Note {0} is not submitted,Kumbuka Utoaji {0} haujawasilishwa
apps/erpnext/erpnext/stock/get_item_details.py,Item {0} must be a Sub-contracted Item,Kipengee {0} kinafaa kuwa kitu cha Chini
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Capital Equipments,Vifaa vya Capital
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Rule ya bei ni ya kwanza kuchaguliwa kulingana na shamba la &#39;Weka On&#39;, ambayo inaweza kuwa Item, Kikundi cha Bidhaa au Brand."
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Please set the Item Code first,Tafadhali weka Kanuni ya Kwanza
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Aina ya Doc
apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Asilimia ya jumla iliyotengwa kwa timu ya mauzo inapaswa kuwa 100
DocType: Subscription Plan,Billing Interval Count,Muda wa Kipaji cha Hesabu
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Uteuzi na Mkutano wa Wagonjwa
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Thamani haipo
DocType: Employee,Department and Grade,Idara na Daraja
DocType: Antibiotic,Antibiotic,Antibiotic
,Team Updates,Updates ya Timu
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,For Supplier,Kwa Wafanyabiashara
DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Kuweka Aina ya Akaunti husaidia katika kuchagua Akaunti hii katika shughuli.
DocType: Purchase Invoice,Grand Total (Company Currency),Jumla ya Jumla (Kampuni ya Fedha)
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Create Print Format,Unda Format Print
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Created,Ada Iliyoundwa
apps/erpnext/erpnext/utilities/bot.py,Did not find any item called {0},Haikupata kitu kilichoitwa {0}
apps/erpnext/erpnext/stock/report/item_prices/item_prices.js,Items Filter,Futa ya vipengee
DocType: Supplier Scorecard Criteria,Criteria Formula,Mfumo wa Kanuni
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Total Outgoing,Jumla ya Kuondoka
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""",Kunaweza tu kuwa na Kanuni moja ya Rupia ya Usafirishaji na 0 au thamani tupu ya &quot;Ili Thamani&quot;
DocType: Bank Statement Transaction Settings Item,Transaction,Shughuli
DocType: Call Log,Duration,Muda
apps/erpnext/erpnext/controllers/status_updater.py,"For an item {0}, quantity must be positive number","Kwa kipengee {0}, wingi lazima uwe namba nzuri"
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Kumbuka: Kituo hiki cha Gharama ni Kikundi. Haiwezi kufanya maagizo ya uhasibu dhidi ya vikundi.
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Compensatory leave request days not in valid holidays,Siku ya ombi ya kuondoka kwa siku ya malipo sio likizo za halali
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Child warehouse exists for this warehouse. You can not delete this warehouse.,Ghala la watoto lipo kwa ghala hili. Huwezi kufuta ghala hii.
DocType: Item,Website Item Groups,Vikundi vya Bidhaa vya tovuti
DocType: Purchase Invoice,Total (Company Currency),Jumla (Kampuni ya Fedha)
DocType: Daily Work Summary Group,Reminder,Kumbusho
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Accessable Value,Thamani ya kupatikana
apps/erpnext/erpnext/stock/utils.py,Serial number {0} entered more than once,Nambari ya serial {0} imeingia zaidi ya mara moja
DocType: Bank Statement Transaction Invoice Item,Journal Entry,Kuingia kwa Jarida
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From GSTIN,Kutoka GSTIN
DocType: Expense Claim Advance,Unclaimed amount,Kiasi kisichojulikana
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} items in progress,{0} vitu vinaendelea
DocType: Workstation,Workstation Name,Jina la kazi
DocType: Grading Scale Interval,Grade Code,Daraja la Kanuni
DocType: POS Item Group,POS Item Group,Kundi la Bidhaa la POS
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,Email Digest:,Ujumbe wa barua pepe:
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Alternative item must not be same as item code,Kitu mbadala haipaswi kuwa sawa na msimbo wa bidhaa
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} does not belong to Item {1},BOM {0} sio Kipengee {1}
DocType: Promotional Scheme,Product Discount Slabs,Bidhaa Punguzo la bidhaa
DocType: Target Detail,Target Distribution,Usambazaji wa Target
DocType: Purchase Invoice,06-Finalization of Provisional assessment,06-Kukamilisha tathmini ya muda
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Parties and Addresses,Kuingiza Vyama na Anwani
DocType: Salary Slip,Bank Account No.,Akaunti ya Akaunti ya Benki
DocType: Naming Series,This is the number of the last created transaction with this prefix,Huu ndio idadi ya shughuli za mwisho zilizoundwa na kiambishi hiki
DocType: Supplier Scorecard,"Scorecard variables can be used, as well as:
{total_score} (the total score from that period),
{period_number} (the number of periods to present day)
","Vigezo vya kadi ya alama inaweza kutumika, pamoja na: {total_score} (alama ya jumla kutoka kipindi hicho), {period_number} (idadi ya vipindi vinavyowasilisha siku)"
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,Create Purchase Order,Unda Utaratibu wa Ununuzi
DocType: Quality Inspection Reading,Reading 8,Kusoma 8
DocType: Inpatient Record,Discharge Note,Kumbuka Kuondoa
apps/erpnext/erpnext/config/desktop.py,Getting Started,Kuanza
DocType: Purchase Invoice,Taxes and Charges Calculation,Kodi na Malipo ya Hesabu
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Kitabu cha Kushindwa kwa Athari ya Kitabu Kwa moja kwa moja
DocType: BOM Operation,Workstation,Kazi ya kazi
DocType: Request for Quotation Supplier,Request for Quotation Supplier,Ombi la Mtoaji wa Nukuu
DocType: Healthcare Settings,Registration Message,Ujumbe wa Usajili
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Hardware,Vifaa
DocType: Prescription Dosage,Prescription Dosage,Kipimo cha Dawa
DocType: Contract,HR Manager,Meneja wa HR
apps/erpnext/erpnext/accounts/party.py,Please select a Company,Tafadhali chagua Kampuni
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Privilege Leave,Uondoaji wa Hifadhi
DocType: Purchase Invoice,Supplier Invoice Date,Tarehe ya Invoice ya Wasambazaji
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,You need to enable Shopping Cart,Unahitaji kuwezesha Kifaa cha Ununuzi
DocType: Payment Entry,Writeoff,Andika
DocType: Maintenance Visit,MAT-MVS-.YYYY.-,MAT-MVS -YYYY.-
DocType: HR Settings,<b>Example:</b> SAL-{first_name}-{date_of_birth.year} <br>This will generate a password like SAL-Jane-1972,<b>Mfano:</b> SAL- {kwanza_name} - {tarehe_of_birth.year} <br> Hii itatoa nywila kama SAL-Jane-1972
DocType: Stock Settings,Naming Series Prefix,Jina la Msaada wa Kipindi
DocType: Appraisal Template Goal,Appraisal Template Goal,Tathmini ya Lengo la Kigezo
DocType: Salary Component,Earning,Kupata
DocType: Supplier Scorecard,Scoring Criteria,Hifadhi ya Hifadhi
DocType: Purchase Invoice,Party Account Currency,Fedha ya Akaunti ya Chama
DocType: Delivery Trip,Total Estimated Distance,Jumla ya Umbali uliohesabiwa
DocType: Invoice Discounting,Accounts Receivable Unpaid Account,Akaunti zinazopatikana Akaunti isiyolipwa
DocType: Tally Migration,Tally Company,Kampuni ya Tally
apps/erpnext/erpnext/config/manufacturing.py,BOM Browser,BOM Browser
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py,Not allowed to create accounting dimension for {0},Hairuhusiwi kuunda upeo wa uhasibu kwa {0}
apps/erpnext/erpnext/templates/emails/training_event.html,Please update your status for this training event,Tafadhali sasisha hali yako ya tukio hili la mafunzo
DocType: Item Barcode,EAN,EAN
DocType: Purchase Taxes and Charges,Add or Deduct,Ongeza au Deduct
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Overlapping conditions found between:,Hali ya uingiliano hupatikana kati ya:
DocType: Bank Transaction Mapping,Field in Bank Transaction,Shamba katika Biashara ya Benki
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Against Journal Entry {0} is already adjusted against some other voucher,Dhidi ya Kuingia kwa Vitambulisho {0} tayari imebadilishwa dhidi ya hati ya nyingine
,Inactive Sales Items,Vitu vya Uuzaji visivyotumika
DocType: Quality Review,Additional Information,Taarifa za ziada
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Total Order Value,Thamani ya Udhibiti wa Jumla
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Food,Chakula
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 3,Kipindi cha kuzeeka 3
DocType: POS Closing Voucher Details,POS Closing Voucher Details,Maelezo ya Voucher ya Kufungwa
DocType: Bank Account,Is the Default Account,Je! Akaunti Default
DocType: Shopify Log,Shopify Log,Weka Ingia
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,No communication found.,Hakuna mawasiliano yaliyopatikana.
DocType: Inpatient Occupancy,Check In,Angalia
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Create Payment Entry,Unda Wasilisho wa Malipo
DocType: Maintenance Schedule Item,No of Visits,Hakuna ya Ziara
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance Schedule {0} exists against {1},Ratiba ya Matengenezo {0} ipo dhidi ya {1}
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Enrolling student,Kujiandikisha mwanafunzi
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Currency of the Closing Account must be {0},Fedha ya Akaunti ya kufunga lazima {0}
apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py,Sum of points for all goals should be 100. It is {0},Sum ya pointi kwa malengo yote inapaswa kuwa 100. Ni {0}
DocType: Project,Start and End Dates,Anza na Mwisho Dates
DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Masharti ya Ukamilifu wa Mkataba
,Delivered Items To Be Billed,Vitu vilivyopakiwa Kufanywa
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Fungua BOM {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Ghala haiwezi kubadilishwa kwa Nambari ya Serial.
DocType: Authorization Rule,Average Discount,Average Discount
DocType: Pricing Rule,UOM,UOM
DocType: Employee Tax Exemption Declaration,Annual HRA Exemption,Uhuru wa mwaka wa HRA
DocType: Rename Tool,Utilities,Vya kutumia
DocType: POS Profile,Accounting,Uhasibu
DocType: Asset,Purchase Receipt Amount,Ununuzi wa Receipt Kiasi
DocType: Employee Separation,Exit Interview Summary,Toka Muhtasari wa Mahojiano
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select batches for batched item ,Tafadhali chagua vikundi vya kipengee cha kupigwa
DocType: Asset,Depreciation Schedules,Ratiba ya kushuka kwa thamani
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Create Sales Invoice,Unda ankara ya Uuzaji
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Ineligible ITC,ITC isiyoweza kufikiwa
DocType: Task,Dependent Tasks,Kazi za wategemezi
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Following accounts might be selected in GST Settings:,Kufuatia akaunti inaweza kuchaguliwa katika Mipangilio ya GST:
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js,Quantity to Produce,Kiasi cha Kutengeneza
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Application period cannot be outside leave allocation period,Kipindi cha maombi hawezi kuwa nje ya kipindi cha ugawaji wa kuondoka
DocType: Activity Cost,Projects,Miradi
DocType: Payment Request,Transaction Currency,Fedha ya Ushirika
apps/erpnext/erpnext/controllers/buying_controller.py,From {0} | {1} {2},Kutoka {0} | {1} {2}
apps/erpnext/erpnext/public/js/hub/marketplace.js,Some emails are invalid,Baadhi ya barua pepe ni batili
DocType: Work Order Operation,Operation Description,Ufafanuzi wa Uendeshaji
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Haiwezi kubadilisha tarehe ya kuanza kwa mwaka wa fedha na Tarehe ya Mwisho wa Fedha mara Mwaka wa Fedha inapohifadhiwa.
DocType: Quotation,Shopping Cart,Duka la Ununuzi
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Avg Daily Outgoing,Kuondoka Kila siku
DocType: POS Profile,Campaign,Kampeni
DocType: Supplier,Name and Type,Jina na Aina
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Item Reported,Bidhaa Imeripotiwa
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Approval Status must be 'Approved' or 'Rejected',Hali ya kibali lazima iwe &#39;Imeidhinishwa&#39; au &#39;Imekataliwa&#39;
DocType: Healthcare Practitioner,Contacts and Address,Mawasiliano na Anwani
DocType: Shift Type,Determine Check-in and Check-out,Amua Kuingia na Kuangalia
DocType: Salary Structure,Max Benefits (Amount),Faida nyingi (Kiasi)
apps/erpnext/erpnext/templates/includes/cart/cart_items.html,Add notes,Ongeza maelezo
DocType: Purchase Invoice,Contact Person,Kuwasiliana na mtu
apps/erpnext/erpnext/projects/doctype/task/task.py,'Expected Start Date' can not be greater than 'Expected End Date',&#39;Tarehe ya Mwanzo Inatarajiwa&#39; haiwezi kuwa kubwa zaidi kuliko &#39;Tarehe ya Mwisho Inatarajiwa&#39;
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,No data for this period,Hakuna data kwa kipindi hiki
DocType: Course Scheduling Tool,Course End Date,Tarehe ya Mwisho wa Kozi
DocType: Holiday List,Holidays,Likizo
DocType: Sales Order Item,Planned Quantity,Wingi wa Mpango
DocType: Water Analysis,Water Analysis Criteria,Vigezo vya Uchambuzi wa Maji
DocType: Item,Maintain Stock,Weka Stock
DocType: Terms and Conditions,Applicable Modules,Moduli zinazotumika
DocType: Employee,Prefered Email,Barua pepe iliyopendekezwa
DocType: Student Admission,Eligibility and Details,Uhalali na Maelezo
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Included in Gross Profit,Pamoja na Faida ya Jumla
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Fixed Asset,Mabadiliko ya Net katika Mali isiyohamishika
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Reqd Qty,Reqd Kiasi
apps/erpnext/erpnext/controllers/accounts_controller.py,Charge of type 'Actual' in row {0} cannot be included in Item Rate,Malipo ya aina ya &#39;Kweli&#39; katika mstari {0} haiwezi kuingizwa katika Kiwango cha Bidhaa
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Max: {0},Max: {0}
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py,From Datetime,Kutoka wakati wa Tarehe
DocType: Shopify Settings,For Company,Kwa Kampuni
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,"Request for Quotation is disabled to access from portal, for more check portal settings.","Ombi la Nukuu imezimwa ili kufikia kutoka kwenye bandari, kwa mipangilio zaidi ya kuzingatia porta."
DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Scorecard ya Wafanyabiashara Mboresho
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Buying Amount,Kununua Kiasi
DocType: POS Closing Voucher,Modes of Payment,Malipo ya Malipo
DocType: Sales Invoice,Shipping Address Name,Jina la Jina la Mafikisho
apps/erpnext/erpnext/accounts/doctype/account/account.js,Chart of Accounts,Chati ya Akaunti
DocType: Material Request,Terms and Conditions Content,Masharti na Masharti Maudhui
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,There were errors creating Course Schedule,Kulikuwa na hitilafu za kuunda ratiba ya kozi
DocType: Communication Medium,Timeslots,Timeslots
DocType: Department,The first Expense Approver in the list will be set as the default Expense Approver.,Mpangilio wa kwanza wa gharama katika orodha utawekwa kama Msaidizi wa gharama ya chini.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,cannot be greater than 100,haiwezi kuwa zaidi ya 100
apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user other than Administrator with System Manager and Item Manager roles to register on Marketplace.,Unahitaji kuwa mtumiaji mwingine isipokuwa Msimamizi na Meneja wa Mfumo na Majukumu ya Meneja wa Item kujiandikisha kwenye Soko.
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is not a stock Item,Kipengee {0} si kitu cha hisa
DocType: Packing Slip,MAT-PAC-.YYYY.-,MAT-PAC -YYYY.-
DocType: Maintenance Visit,Unscheduled,Haijahamishwa
DocType: Employee,Owned,Imepewa
DocType: Pricing Rule,"Higher the number, higher the priority","Nambari ya juu, juu ya kipaumbele"
,Purchase Invoice Trends,Ununuzi wa Misaada ya ankara
apps/erpnext/erpnext/www/all-products/not_found.html,No products found,Hakuna bidhaa zilizopatikana
DocType: Employee,Better Prospects,Matarajio Bora
DocType: Travel Itinerary,Gluten Free,Bure ya Gluten
DocType: Loyalty Program Collection,Minimum Total Spent,Kima cha chini cha Jumla kilitumika
apps/erpnext/erpnext/stock/doctype/batch/batch.py,"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","Row # {0}: Kikundi {1} kina {2} qty tu. Tafadhali chagua kundi lingine ambalo linapatikana {3} qty au kupasuliwa mstari katika safu nyingi, kutoa / kutolewa kutoka kwa makundi mengi"
DocType: Loyalty Program,Expiry Duration (in days),Muda wa Muda (katika siku)
DocType: Inpatient Record,Discharge Date,Tarehe ya Kuondoa
DocType: Subscription Plan,Price Determination,Uamuzi wa Bei
DocType: Vehicle,License Plate,Bamba la leseni
apps/erpnext/erpnext/hr/doctype/department/department_tree.js,New Department,Idara mpya
DocType: Compensatory Leave Request,Worked On Holiday,Alifanya kazi kwenye likizo
DocType: Appraisal,Goals,Malengo
DocType: Support Settings,Allow Resetting Service Level Agreement,Ruhusu Kurudisha Mkataba wa Kiwango cha Huduma
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Select POS Profile,Chagua Profaili ya POS
DocType: Warranty Claim,Warranty / AMC Status,Waranti / Hali ya AMC
,Accounts Browser,Kivinjari cha Hesabu
DocType: Procedure Prescription,Referral,Rufaa
DocType: Payment Entry Reference,Payment Entry Reference,Kumbukumbu ya Kuingia kwa Malipo
DocType: GL Entry,GL Entry,Uingiaji wa GL
DocType: Support Search Source,Response Options,Chaguo la majibu
DocType: Pricing Rule,Apply Multiple Pricing Rules,Tumia Sheria za Bei nyingi
DocType: HR Settings,Employee Settings,Mipangilio ya Waajiriwa
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.html,Loading Payment System,Inapakia Mfumo wa Malipo
,Batch-Wise Balance History,Historia ya Mizani-Hekima
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,Row # {0}: Haiwezi kuweka Kiwango kama kiasi ni kikubwa kuliko kiasi cha malipo kwa Item {1}.
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Print settings updated in respective print format,Mipangilio ya magazeti imewekwa katika fomu ya kuchapisha husika
DocType: Package Code,Package Code,Kanuni ya pakiti
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Apprentice,Mwanafunzi
DocType: Purchase Invoice,Company GSTIN,Kampuni ya GSTIN
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Negative Quantity is not allowed,Wengi hauna kuruhusiwa
DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges",Maelezo ya kodi ya kodi imetengwa kutoka kwa bwana wa bidhaa kama kamba na kuhifadhiwa kwenye uwanja huu. Iliyotumika kwa Kodi na Malipo
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Employee cannot report to himself.,Mfanyakazi hawezi kujijulisha mwenyewe.
apps/erpnext/erpnext/templates/pages/order.html,Rate:,Kiwango:
DocType: Bank Account,Change this date manually to setup the next synchronization start date,Badilisha tarehe hii kwa mikono ili kuanzisha tarehe inayofuata ya upatanishi
DocType: Leave Type,Max Leaves Allowed,Majani Max Yanaruhusiwa
DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Ikiwa akaunti imehifadhiwa, maingilio yanaruhusiwa watumiaji waliozuiwa."
DocType: Email Digest,Bank Balance,Mizani ya Benki
apps/erpnext/erpnext/controllers/accounts_controller.py,Accounting Entry for {0}: {1} can only be made in currency: {2},Kuingia kwa Uhasibu kwa {0}: {1} inaweza tu kufanywa kwa fedha: {2}
DocType: HR Settings,Leave Approver Mandatory In Leave Application,Acha Msaidizi Wajibu wa Kuacha Maombi
DocType: Job Opening,"Job profile, qualifications required etc.","Profaili ya kazi, sifa zinazohitajika nk."
DocType: Journal Entry Account,Account Balance,Mizani ya Akaunti
apps/erpnext/erpnext/config/accounting.py,Tax Rule for transactions.,Sheria ya Ushuru kwa ajili ya shughuli.
DocType: Rename Tool,Type of document to rename.,Aina ya hati ili kutafsiri tena.
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Resolve error and upload again.,Suluhisha kosa na upakie tena.
DocType: Buying Settings,Over Transfer Allowance (%),Zaidi ya Idhini ya Uhamishaji (%)
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Customer is required against Receivable account {2},{0} {1}: Wateja anatakiwa dhidi ya akaunti ya kupokea {2}
DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Jumla ya Kodi na Malipo (Kampuni ya Fedha)
DocType: Weather,Weather Parameter,Parameter ya hali ya hewa
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js,Show unclosed fiscal year's P&L balances,Onyesha mizani ya P &amp; L isiyopunguzwa mwaka wa fedha
DocType: Item,Asset Naming Series,Mfululizo wa Majina ya Mali
DocType: Appraisal,HR-APR-.YY.-.MM.,HR-APR-.YY.-.MM.
apps/erpnext/erpnext/regional/india/utils.py,House rented dates should be atleast 15 days apart,Nyumba iliyopangwa tarehe inapaswa kuwa na siku 15 mbali
DocType: Clinical Procedure Template,Collection Details,Maelezo ya Ukusanyaji
DocType: POS Profile,Allow Print Before Pay,Ruhusu Chapisha Kabla ya Kulipa
DocType: Linked Soil Texture,Linked Soil Texture,Usanifu wa Mazingira ya Pamoja
DocType: Shipping Rule,Shipping Account,Alama ya Akaunti
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} is inactive,{0} {1}: Akaunti {2} haitumiki
DocType: GSTR 3B Report,March,Machi
DocType: Bank Statement Transaction Entry,Bank Transaction Entries,Shughuli za Uingizaji wa Benki
DocType: Quality Inspection,Readings,Kusoma
DocType: Stock Entry,Total Additional Costs,Jumla ya gharama za ziada
DocType: Quality Action,Quality Action,Kitendo cha Ubora
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,No of Interactions,Hakuna Uingiliano
DocType: BOM,Scrap Material Cost(Company Currency),Gharama za Nyenzo za Nyenzo (Fedha la Kampuni)
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,"Set Start Time and End Time for  \
					Support Day {0} at index {1}.",Weka saa ya Kuanza na Wakati wa Mwisho wa Siku ya Msaada {0} kwenye index {1}.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Sub Assemblies,Assemblies ndogo
DocType: Asset,Asset Name,Jina la Mali
DocType: Employee Boarding Activity,Task Weight,Uzito wa Kazi
DocType: Shipping Rule Condition,To Value,Ili Thamani
DocType: Accounts Settings,Automatically Add Taxes and Charges from Item Tax Template,Ongeza moja kwa moja Ushuru na malipo kutoka kwa Kigeuzo cha Ushuru wa Bidhaa
DocType: Loyalty Program,Loyalty Program Type,Aina ya Programu ya Uaminifu
DocType: Asset Movement,Stock Manager,Meneja wa Stock
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Source warehouse is mandatory for row {0},Ghala la chanzo ni lazima kwa mstari {0}
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,The Payment Term at row {0} is possibly a duplicate.,Muda wa Malipo katika mstari {0} inawezekana kuwa duplicate.
apps/erpnext/erpnext/public/js/setup_wizard.js,Agriculture (beta),Kilimo (beta)
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Packing Slip,Ufungashaji wa Ufungashaji
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Rent,Kodi ya Ofisi
apps/erpnext/erpnext/config/settings.py,Setup SMS gateway settings,Sanidi mipangilio ya uingizaji wa SMS
DocType: Disease,Common Name,Jina la kawaida
DocType: Customer Feedback Template Table,Customer Feedback Template Table,Jedwali la Kiolezo cha Maoni ya Wateja
DocType: Employee Boarding Activity,Employee Boarding Activity,Kazi ya Ufuatiliaji wa Waajiriwa
apps/erpnext/erpnext/public/js/templates/address_list.html,No address added yet.,Hakuna anwani iliyoongezwa bado.
DocType: Workstation Working Hour,Workstation Working Hour,Kazi ya Kazi ya Kazini
DocType: Vital Signs,Blood Pressure,Shinikizo la damu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Analyst,Mchambuzi
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,{0} is not in a valid Payroll Period,{0} sio wakati wa malipo ya halali
DocType: Employee Benefit Application,Max Benefits (Yearly),Faida Max (Kila mwaka)
DocType: Item,Inventory,Uuzaji
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Pakua kama Json
DocType: Item,Sales Details,Maelezo ya Mauzo
DocType: Opportunity,With Items,Na Vitu
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Kampeni &#39;{0}&#39; tayari inapatikana kwa {1} &#39;{2}&#39;
DocType: Asset Maintenance,Maintenance Team,Timu ya Matengenezo
DocType: Homepage Section,"Order in which sections should appear. 0 is first, 1 is second and so on.","Agizo ambayo sehemu zinapaswa kuonekana. 0 ni ya kwanza, 1 ni ya pili na kadhalika."
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,In Qty,Katika Uchina
DocType: Education Settings,Validate Enrolled Course for Students in Student Group,Thibitisha Kozi iliyosajiliwa kwa Wanafunzi katika Kikundi cha Wanafunzi
DocType: Item,Item Attribute,Kipengee cha kipengee
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Government,Serikali
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Expense Claim {0} already exists for the Vehicle Log,Madai ya Madai {0} tayari yupo kwa Ingia ya Gari
DocType: Asset Movement,Source Location,Eneo la Chanzo
apps/erpnext/erpnext/public/js/setup_wizard.js,Institute Name,Jina la Taasisi
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Please enter repayment Amount,Tafadhali ingiza Kiwango cha kulipa
DocType: Shift Type,Working Hours Threshold for Absent,Kufanya kazi masaa ya kizingiti cha kutokuwepo
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,There can be multiple tiered collection factor based on the total spent. But the conversion factor for redemption will always be same for all the tier.,Kunaweza kuwepo kwa sababu nyingi za kukusanya kulingana na jumla ya matumizi. Lakini sababu ya uongofu ya ukombozi daima itakuwa sawa kwa tier yote.
apps/erpnext/erpnext/config/help.py,Item Variants,Tofauti ya Tofauti
apps/erpnext/erpnext/public/js/setup_wizard.js,Services,Huduma
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,BOM 2,BOM 2
DocType: Payment Order,PMO-,PMO-
DocType: HR Settings,Email Salary Slip to Employee,Mshahara wa Salari ya barua pepe kwa Mfanyakazi
DocType: Cost Center,Parent Cost Center,Kituo cha Gharama ya Mzazi
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Create Invoices,Unda ankara
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Select Possible Supplier,Chagua Wasambazaji Inawezekana
DocType: Communication Medium,Communication Medium Type,Aina ya Kati ya Mawasiliano
DocType: Customer,"Select, to make the customer searchable with these fields","Chagua, ili uweze kutafutwa na mteja na mashamba haya"
DocType: Shopify Settings,Import Delivery Notes from Shopify on Shipment,Weka Vidokezo vya Utoaji kutoka Shopify kwenye Uhamisho
apps/erpnext/erpnext/templates/pages/projects.html,Show closed,Onyesha imefungwa
DocType: Issue Priority,Issue Priority,Kipaumbele cha Hoja
DocType: Leave Ledger Entry,Is Leave Without Pay,Anatoka bila Kulipa
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,GSTIN,GSTIN
apps/erpnext/erpnext/stock/doctype/item/item.py,Asset Category is mandatory for Fixed Asset item,Jamii ya Mali ni ya lazima kwa kipengee cha Mali isiyohamishika
DocType: Fee Validity,Fee Validity,Uhalali wa ada
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,No records found in the Payment table,Hakuna kumbukumbu zilizopatikana kwenye meza ya Malipo
apps/erpnext/erpnext/education/utils.py,This {0} conflicts with {1} for {2} {3},Hii {0} inakabiliana na {1} kwa {2} {3}
DocType: Student Attendance Tool,Students HTML,Wanafunzi HTML
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,{0}: {1} must be less than {2},{0}: {1} lazima iwe chini ya {2}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,"Select BOM, Qty and For Warehouse","Chagua BOM, Qty na kwa Ghala"
DocType: GST HSN Code,GST HSN Code,Kanuni ya GST HSN
DocType: Employee External Work History,Total Experience,Uzoefu wa jumla
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open Projects,Fungua Miradi
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Packing Slip(s) cancelled,Kulipishwa kwa Slip (s) kufutwa
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Investing,Mtoko wa Fedha kutoka Uwekezaji
DocType: Program Course,Program Course,Kozi ya Programu
DocType: Healthcare Service Unit,Allow Appointments,Ruhusu Uteuzi
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Freight and Forwarding Charges,Mashtaka ya Mizigo na Usambazaji
DocType: Homepage,Company Tagline for website homepage,Tagline ya kampuni ya homepage ya tovuti
DocType: Item Group,Item Group Name,Jina la Kikundi cha Bidhaa
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,Taken,Kuchukuliwa
DocType: Invoice Discounting,Short Term Loan Account,Akaunti ya mkopo wa muda mfupi
DocType: Student,Date of Leaving,Tarehe ya Kuacha
DocType: Pricing Rule,For Price List,Kwa Orodha ya Bei
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Executive Search,Utafutaji wa Mtendaji
DocType: Employee Advance,HR-EAD-.YYYY.-,HR-EAD -YYYY.-
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Setting defaults,Kuweka desfaults
DocType: Loyalty Program,Auto Opt In (For all customers),Opt Auto In (Kwa wateja wote)
apps/erpnext/erpnext/utilities/activation.py,Create Leads,Unda Mwongozo
DocType: Maintenance Schedule,Schedules,Mipango
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,POS Profile is required to use Point-of-Sale,Profaili ya POS inahitajika kutumia Point-of-Sale
DocType: Cashier Closing,Net Amount,Kiasi cha Nambari
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} has not been submitted so the action cannot be completed,{0} {1} haijawasilishwa hivyo hatua haiwezi kukamilika
DocType: Purchase Order Item Supplied,BOM Detail No,BOM Maelezo ya No
DocType: Landed Cost Voucher,Additional Charges,Malipo ya ziada
DocType: Support Search Source,Result Route Field,Shamba la Njia ya Matokeo
DocType: Supplier,PAN,PAN
DocType: Employee Checkin,Log Type,Aina ya Ingia
DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Kiasi cha Kutoa Kiasi (Kampuni ya Fedha)
DocType: Supplier Scorecard,Supplier Scorecard,Scorecard ya Wasambazaji
DocType: Plant Analysis,Result Datetime,Matokeo ya Tarehe
,Support Hour Distribution,Usambazaji Saa Saa
DocType: Maintenance Visit,Maintenance Visit,Kutembelea Utunzaji
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Close Loan,Funga Mkopo
DocType: Student,Leaving Certificate Number,Kuondoka Nambari ya Cheti
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,"Appointment cancelled, Please review and cancel the invoice {0}","Uteuzi umefutwa, Tafadhali kagua na kufuta ankara {0}"
DocType: Sales Invoice Item,Available Batch Qty at Warehouse,Inapatikana Chini ya Baki katika Ghala
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Update Print Format,Sasisha Format ya Kuchapa
DocType: Bank Account,Is Company Account,Ni Akaunti ya Kampuni
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,Leave Type {0} is not encashable,Toka Aina {0} haipatikani
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Credit limit is already defined for the Company {0},Kikomo cha mkopo tayari kimefafanuliwa kwa Kampuni {0}
DocType: Landed Cost Voucher,Landed Cost Help,Msaada wa Gharama za Utoaji
DocType: Vehicle Log,HR-VLOG-.YYYY.-,HR-VLOG -YYYY.-
DocType: Purchase Invoice,Select Shipping Address,Chagua Anwani ya Meli
DocType: Timesheet Detail,Expected Hrs,Haki zilizotarajiwa
apps/erpnext/erpnext/config/non_profit.py,Memebership Details,Maelezo ya Usajili
DocType: Leave Block List,Block Holidays on important days.,Zima Holidays siku za muhimu.
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Please input all required Result Value(s),Tafadhali ingiza Thamani zote za Thamani zinazohitajika
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Accounts Receivable Summary,Muhtasari wa Akaunti ya Kupokea
DocType: POS Closing Voucher,Linked Invoices,Invosi zilizohusishwa
DocType: Loan,Monthly Repayment Amount,Kiasi cha kulipa kila mwezi
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Opening Invoices,Invoices za Ufunguzi
DocType: Contract,Contract Details,Maelezo ya Mkataba
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please set User ID field in an Employee record to set Employee Role,Tafadhali weka shamba la Kitambulisho cha Mtumiaji katika rekodi ya Wafanyakazi ili kuweka Kazi ya Wafanyakazi
DocType: UOM,UOM Name,Jina la UOM
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Address 1,Ili kufikia 1
DocType: GST HSN Code,HSN Code,Msimbo wa HSN
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py,Contribution Amount,Mchango wa Mchango
DocType: Homepage Section,Section Order,Agizo la Sehemu
DocType: Inpatient Record,Patient Encounter,Mkutano wa Mgonjwa
DocType: Accounts Settings,Shipping Address,Anwani ya kusafirishia
DocType: Stock Reconciliation,This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,Chombo hiki husaidia kuboresha au kurekebisha wingi na hesabu ya hisa katika mfumo. Kwa kawaida hutumiwa kusawazisha maadili ya mfumo na kile ambacho hakipo ipo katika maghala yako.
DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,Katika Maneno itaonekana wakati unapohifadhi Kumbuka Utoaji.
apps/erpnext/erpnext/erpnext_integrations/utils.py,Unverified Webhook Data,Takwimu zisizothibitishwa za Mtandao
DocType: Water Analysis,Container,Chombo
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Please set valid GSTIN No. in Company Address,Tafadhali weka halali GSTIN No katika Anwani ya Kampuni
apps/erpnext/erpnext/education/utils.py,Student {0} - {1} appears Multiple times in row {2} & {3},Mwanafunzi {0} - {1} inaonekana mara nyingi mfululizo {2} &amp; {3}
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Following fields are mandatory to create address:,Sehemu zifuatazo ni lazima kuunda anwani:
DocType: Item Alternative,Two-way,Njia mbili
DocType: Item,Manufacturers,Watengenezaji
apps/erpnext/erpnext/accounts/deferred_revenue.py,Error while processing deferred accounting for {0},Kosa wakati wa kushughulikia uhasibu uliocheleweshwa kwa {0}
,Employee Billing Summary,Muhtasari wa malipo ya mfanyakazi
DocType: Project,Day to Send,Siku ya Kutuma
DocType: Healthcare Settings,Manage Sample Collection,Dhibiti Mkusanyiko wa Mfano
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set the series to be used.,Tafadhali weka mfululizo kutumiwa.
DocType: Patient,Tobacco Past Use,Tabibu Matumizi ya zamani
DocType: Travel Itinerary,Mode of Travel,Njia ya Kusafiri
DocType: Sales Invoice Item,Brand Name,Jina la Brand
DocType: Purchase Receipt,Transporter Details,Maelezo ya Transporter
DocType: Issue,Service Level Agreement Creation,Uundaji wa Mkataba wa Kiwango cha Huduma
apps/erpnext/erpnext/accounts/page/pos/pos.js,Default warehouse is required for selected item,Ghala la msingi linahitajika kwa kipengee kilichochaguliwa
DocType: Quiz,Passing Score,Kupita alama
apps/erpnext/erpnext/utilities/user_progress.py,Box,Sanduku
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Possible Supplier,Wafanyabiashara wawezekana
DocType: Budget,Monthly Distribution,Usambazaji wa kila mwezi
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py,Receiver List is empty. Please create Receiver List,Orodha ya Receiver haina tupu. Tafadhali tengeneza Orodha ya Kupokea
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! The input you've entered doesn't match the GSTIN format for UIN Holders or Non-Resident OIDAR Service Providers,GSTIN batili! Uingizaji ambao umeingia haulingani na fomati ya GSTIN ya Wamiliki wa UIN au Watoa Huduma wa OIDAR wasio Wakazi
apps/erpnext/erpnext/public/js/setup_wizard.js,Healthcare (beta),Huduma ya afya (beta)
DocType: Production Plan Sales Order,Production Plan Sales Order,Mpango wa Mauzo ya Mauzo
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"No active BOM found for item {0}. Delivery by \
						Serial No cannot be ensured",Hakuna BOM ya kazi iliyopatikana kwa kipengee {0}. Utoaji kwa \ Serial Hakuna haiwezi kuhakikisha
DocType: Sales Partner,Sales Partner Target,Lengo la Mshirika wa Mauzo
DocType: Loan Type,Maximum Loan Amount,Kiwango cha Mikopo Kikubwa
DocType: Pricing Rule,Pricing Rule,Kanuni ya bei
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplicate roll idadi kwa mwanafunzi {0}
apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Nambari ya Nyenzo ya Ununuzi wa Utaratibu
DocType: Company,Default Selling Terms,Masharti ya Kuuza Default
DocType: Shopping Cart Settings,Payment Success URL,URL ya Mafanikio ya Malipo
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Returned Item {1} does not exists in {2} {3},Row # {0}: Bidhaa iliyorejeshwa {1} haipo katika {2} {3}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Bank Accounts,Akaunti za Benki
,Bank Reconciliation Statement,Taarifa ya Upatanisho wa Benki
DocType: Patient Encounter,Medical Coding,Coding ya matibabu
DocType: Healthcare Settings,Reminder Message,Ujumbe wa Ukumbusho
DocType: Call Log,Lead Name,Jina la Kiongozi
,POS,POS
DocType: C-Form,III,III
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Prospecting,Matarajio
apps/erpnext/erpnext/config/help.py,Opening Stock Balance,Kufungua Mizani ya Stock
DocType: Asset Category Account,Capital Work In Progress Account,Kazi ya Kitaifa Katika Akaunti ya Maendeleo
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Asset Value Adjustment,Marekebisho ya Thamani ya Mali
DocType: Additional Salary,Payroll Date,Tarehe ya Mishahara
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,{0} must appear only once,{0} lazima ionekane mara moja tu
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py,Leaves Allocated Successfully for {0},Majani yaliyopangwa kwa Mafanikio kwa {0}
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,No Items to pack,Hakuna Vipande vya kuingiza
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Only .csv and .xlsx files are supported currently,Faili za .csv na .xlsx pekee ndizo zinazotumika kwa sasa
DocType: Shipping Rule Condition,From Value,Kutoka kwa Thamani
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Manufacturing Quantity is mandatory,Uzalishaji wa Wingi ni lazima
DocType: Loan,Repayment Method,Njia ya kulipa
DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Ikiwa hunakiliwa, Ukurasa wa Mwanzo utakuwa Kikundi cha Kichwa cha Kichwa cha tovuti"
DocType: Quality Inspection Reading,Reading 4,Kusoma 4
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Pending Quantity,Unasubiri Wingi
apps/erpnext/erpnext/utilities/activation.py,"Students are at the heart of the system, add all your students","Wanafunzi wako katika moyo wa mfumo, waongeze wanafunzi wako wote"
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Member ID,Kitambulisho cha Mwanachama
DocType: Employee Tax Exemption Proof Submission,Monthly Eligible Amount,Kiasi Kilivyotakiwa kila mwezi
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Row # {0}: Tarehe ya kufuta {1} haiwezi kuwa kabla ya Tarehe ya Kuangalia {2}
DocType: Asset Maintenance Task,Certificate Required,Cheti Inahitajika
DocType: Company,Default Holiday List,Orodha ya Likizo ya Default
DocType: Pricing Rule,Supplier Group,Kikundi cha Wasambazaji
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,{0} Digest,{0} Digest
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0}: From Time and To Time of {1} is overlapping with {2},Row {0}: Kutoka wakati na kwa wakati wa {1} linaingiliana na {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Liabilities,Mkopo wa Mkopo
DocType: Purchase Invoice,Supplier Warehouse,Ghala la Wafanyabiashara
DocType: Opportunity,Contact Mobile No,Wasiliana No Simu ya Simu
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Select Company,Chagua Kampuni
,Material Requests for which Supplier Quotations are not created,Maombi ya nyenzo ambayo Nukuu za Wasambazaji haziumbwa
apps/erpnext/erpnext/config/crm.py,"Helps you keep tracks of Contracts based on Supplier, Customer and Employee","Inakusaidia kuweka nyimbo za Mikataba kwa msingi wa Wasambazaji, Wateja na Mfanyakazi"
DocType: Company,Discount Received Account,Akaunti iliyopokea Punguzo
DocType: Student Report Generation Tool,Print Section,Sehemu ya Magazeti
DocType: Staffing Plan Detail,Estimated Cost Per Position,Kiwango cha gharama kwa kila nafasi
DocType: Employee,HR-EMP-,HR-EMP-
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Mtumiaji {0} hana Profaili ya POS ya default. Angalia Default kwa Row {1} kwa Mtumiaji huyu.
DocType: Quality Meeting Minutes,Quality Meeting Minutes,Dakika za Mkutano wa Ubora
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Employee Referral,Kuhamishwa kwa Waajiriwa
DocType: Student Group,Set 0 for no limit,Weka 0 bila kikomo
DocType: Cost Center,rgt,rgt
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,Siku (s) ambayo unaomba kwa ajili ya kuondoka ni likizo. Hauhitaji kuomba kuondoka.
DocType: Customer,Primary Address and Contact Detail,Anwani ya Msingi na Maelezo ya Mawasiliano
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Resend Payment Email,Tuma barua pepe ya malipo
apps/erpnext/erpnext/templates/pages/projects.html,New task,Kazi mpya
DocType: Clinical Procedure,Appointment,Uteuzi
apps/erpnext/erpnext/config/buying.py,Other Reports,Taarifa nyingine
apps/erpnext/erpnext/public/js/setup_wizard.js,Please select at least one domain.,Tafadhali chagua angalau kikoa kimoja.
DocType: Dependent Task,Dependent Task,Kazi ya Kudumu
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Supplies made to UIN holders,Vifaa hutolewa kwa wamiliki wa UIN
DocType: Shopify Settings,Shopify Tax Account,Weka Akaunti ya Ushuru
apps/erpnext/erpnext/stock/doctype/item/item.py,Conversion factor for default Unit of Measure must be 1 in row {0},Sababu ya ubadilishaji kwa chaguo-msingi Kipimo cha Kupima lazima iwe 1 kwenye mstari {0}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Leave of type {0} cannot be longer than {1},Kuondoka kwa aina {0} haiwezi kuwa zaidi kuliko {1}
DocType: Delivery Trip,Optimize Route,Ongeza Njia
DocType: Manufacturing Settings,Try planning operations for X days in advance.,Jaribu kupanga shughuli kwa siku X kabla.
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,"{0} vacancies and {1} budget for {2} already planned for subsidiary companies of {3}. \
				You can only plan for upto {4} vacancies and and budget {5} as per staffing plan {6} for parent company {3}.",{0} nafasi na {1} bajeti ya {2} tayari iliyopangwa kwa kampuni ndogo za {3}. Unaweza tu kupanga mipango ya {4} na bajeti {5} kama mpango wa utumishi {6} kwa kampuni ya mzazi {3}.
DocType: HR Settings,Stop Birthday Reminders,Weka Vikumbusho vya Kuzaliwa
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Please set Default Payroll Payable Account in Company {0},Tafadhali weka Akaunti ya Kulipa ya Payroll ya Kipawa katika Kampuni {0}
DocType: Pricing Rule Brand,Pricing Rule Brand,Bei ya Utawala wa Bei
DocType: Amazon MWS Settings,Get financial breakup of Taxes and charges data by Amazon ,Pata uvunjaji wa kifedha wa Takwimu na mashtaka kwa Amazon
DocType: SMS Center,Receiver List,Orodha ya Kupokea
DocType: Pricing Rule,Rule Description,Maelezo ya Sheria
apps/erpnext/erpnext/accounts/page/pos/pos.js,Search Item,Tafuta kitu
DocType: Program,Allow Self Enroll,Ruhusu Kujiandikisha
DocType: Payment Schedule,Payment Amount,Kiwango cha Malipo
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Siku ya Nusu ya Siku lazima iwe kati ya Kazi Kutoka Tarehe na Tarehe ya Mwisho Kazi
DocType: Healthcare Settings,Healthcare Service Items,Vitu vya Huduma za Afya
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Kiwango kilichotumiwa
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Mabadiliko ya Net katika Fedha
DocType: Assessment Plan,Grading Scale,Kuweka Scale
apps/erpnext/erpnext/stock/doctype/item/item.py,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Kipimo cha Upimaji {0} kiliingizwa zaidi ya mara moja kwenye Jedwali la Kubadilisha Ubadilishaji
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock In Hand,Stock In Hand
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"Please add the remaining benefits {0} to the application as \
				pro-rata component",Tafadhali ongeza faida zilizobaki {0} kwenye programu kama sehemu ya mtumiaji
apps/erpnext/erpnext/regional/italy/utils.py,Please set Fiscal Code for the public administration '%s',Tafadhali weka Nambari ya Fedha kwa utawala wa umma &#39;% s&#39;
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Issued Items,Gharama ya Vitu Vipitishwa
DocType: Healthcare Practitioner,Hospital,Hospitali
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Quantity must not be more than {0},Wingi haipaswi kuwa zaidi ya {0}
DocType: Travel Request Costing,Funded Amount,Kiasi kilichopangwa
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Previous Financial Year is not closed,Mwaka wa Fedha uliopita haujafungwa
DocType: Practitioner Schedule,Practitioner Schedule,Ratiba ya Waalimu
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Age (Days),Umri (Siku)
DocType: Instructor,EDU-INS-.YYYY.-,EDU-INS -YYYY.-
DocType: Additional Salary,Additional Salary,Mshahara wa ziada
DocType: Quotation Item,Quotation Item,Nukuu ya Nukuu
DocType: Customer,Customer POS Id,Idhaa ya POS ya Wateja
apps/erpnext/erpnext/education/utils.py,Student with email {0} does not exist,Mwanafunzi aliye na barua pepe {0} hayupo
DocType: Account,Account Name,Jina la Akaunti
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,From Date cannot be greater than To Date,Kutoka Tarehe haiwezi kuwa kubwa kuliko Tarehe
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} quantity {1} cannot be a fraction,Serial Hapana {0} wingi {1} haiwezi kuwa sehemu
DocType: Pricing Rule,Apply Discount on Rate,Omba punguzo kwenye Viwango
DocType: Tally Migration,Tally Debtors Account,Akaunti ya Wahasibu wa Tally
DocType: Pricing Rule,Promotional Scheme,Mpango wa Uendelezaji
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter Woocommerce Server URL,Tafadhali ingiza URL ya Woocommerce Server
DocType: GSTR 3B Report,September,Septemba
DocType: Purchase Order Item,Supplier Part Number,Nambari ya Sehemu ya Wasambazaji
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Conversion rate cannot be 0 or 1,Kiwango cha uongofu hawezi kuwa 0 au 1
apps/erpnext/erpnext/accounts/page/bank_reconciliation/linked_payment_header.html,Payment Name,Jina la malipo
DocType: Share Balance,To No,Hapana
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py,All the mandatory Task for employee creation hasn't been done yet.,Kazi yote ya lazima ya uumbaji wa wafanyakazi haijafanyika bado.
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} is cancelled or stopped,{0} {1} imefutwa au imesimamishwa
DocType: Accounts Settings,Credit Controller,Mdhibiti wa Mikopo
DocType: Loan,Applicant Type,Aina ya Msaidizi
DocType: Purchase Invoice,03-Deficiency in services,Upungufu wa 03 katika huduma
DocType: Healthcare Settings,Default Medical Code Standard,Kiwango cha Kiwango cha Matibabu cha Kudumu
DocType: Purchase Invoice Item,HSN/SAC,HSN / SAC
DocType: Project Template Task,Project Template Task,Kazi ya Kiolezo cha Mradi
DocType: Accounts Settings,Over Billing Allowance (%),Zaidi ya Idhini ya Bili (%)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Purchase Receipt {0} is not submitted,Receipt ya Ununuzi {0} haijawasilishwa
DocType: Company,Default Payable Account,Akaunti ya malipo yenye malipo
apps/erpnext/erpnext/config/website.py,"Settings for online shopping cart such as shipping rules, price list etc.","Mipangilio ya gari la ununuzi mtandaoni kama sheria za meli, orodha ya bei nk."
DocType: Purchase Receipt,MAT-PRE-.YYYY.-,MAT-PRE-YYYY.-
apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Billed,{0}% Imelipwa
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py,Reserved Qty,Nambari iliyohifadhiwa
DocType: Party Account,Party Account,Akaunti ya Chama
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,Please select Company and Designation,Tafadhali chagua Kampuni na Uteuzi
apps/erpnext/erpnext/config/settings.py,Human Resources,Rasilimali
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Upper Income,Mapato ya Juu
DocType: Item Manufacturer,Item Manufacturer,Bidhaa mtengenezaji
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Create New Lead,Unda Kiongozi Mpya
DocType: BOM Operation,Batch Size,Ukubwa wa Kundi
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Reject,Kataa
DocType: Journal Entry Account,Debit in Company Currency,Debit katika Fedha ya Kampuni
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Import Successfull,Ingiza Mafanikio
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Material Request not created, as quantity for Raw Materials already available.","Ombi la nyenzo halijoundwa, kama idadi ya Malighafi tayari inapatikana."
DocType: BOM Item,BOM Item,Kipengee cha BOM
DocType: Appraisal,For Employee,Kwa Mfanyakazi
DocType: Leave Control Panel,Designation (optional),Uteuzi (hiari)
apps/erpnext/erpnext/stock/stock_ledger.py,"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting / cancelling this entry.","Kiwango cha hesabu haipatikani kwa Bidhaa {0}, ambayo inahitajika kufanya maingizo ya uhasibu kwa {1} {2}. Ikiwa bidhaa hiyo inaendelea kubadilika kama bidhaa ya kiwango cha hesabu sifuri katika {1}, tafadhali taja hiyo kwenye jedwali la {1} la kitu. La sivyo, tafadhali tengeneza ununuzi wa hisa unaoingia kwa bidhaa hiyo au taja kiwango cha hesabu katika rekodi ya kitu, na kisha jaribu kupeleka / kughairi kiingilio hiki."
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Supplier must be debit,Row {0}: Kabla ya Mtoaji lazima awe deni
DocType: Company,Default Values,Maadili ya Maadili
DocType: Certification Application,INR,INR
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Party Addresses,Inashughulikia Kero za Chama
DocType: Woocommerce Settings,Creation User,Mtumiaji wa Uumbaji
DocType: Quality Procedure,Quality Procedure,Utaratibu wa Ubora
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Please check the error log for details about the import errors,Tafadhali angalia logi ya makosa kwa maelezo juu ya makosa ya uingizaji
DocType: Bank Transaction,Reconciled,Kupatanishwa
DocType: Expense Claim,Total Amount Reimbursed,Jumla ya Kizuizi
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py,This is based on logs against this Vehicle. See timeline below for details,Hii inategemea magogo dhidi ya Gari hii. Tazama kalenda ya chini kwa maelezo zaidi
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Payroll date can not be less than employee's joining date,Tarehe ya mishahara haiwezi kuwa chini ya tarehe ya kujiunga na mfanyakazi
DocType: Pick List,Item Locations,Sehemu ya Sehemu
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.py,{0} {1} created,{0} {1} imeundwa
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,"Job Openings for designation {0} already open \
					or hiring completed as per Staffing Plan {1}",Ufunguzi wa Kazi kwa ajili ya uteuzi {0} tayari kufungua \ au kukodisha kukamilika kama kwa Mpangilio wa Utumishi {1}
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,You can publish upto 200 items.,Unaweza kuchapisha vitu hadi 200.
DocType: Vital Signs,Constipated,Imetumiwa
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Against Supplier Invoice {0} dated {1},Dhidi ya Invoice ya Wasambazaji {0} dated {1}
DocType: Customer,Default Price List,Orodha ya Bei ya Hitilafu
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Asset Movement record {0} created,Rekodi ya Movement ya Malipo {0} imeundwa
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Huwezi kufuta Mwaka wa Fedha {0}. Mwaka wa Fedha {0} umewekwa kama default katika Mipangilio ya Global
DocType: Share Transfer,Equity/Liability Account,Akaunti ya Equity / Dhima
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py,A customer with the same name already exists,Mteja mwenye jina sawa tayari yupo
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Hii itawasilisha Slips za Mshahara na kuunda Usajili wa Majarida. Je! Unataka kuendelea?
DocType: Purchase Invoice,Total Net Weight,Jumla ya uzito wa Net
DocType: Purchase Order,Order Confirmation No,Uthibitisho wa Uagizo No
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Net Profit,Faida halisi
DocType: Purchase Invoice,Eligibility For ITC,Ustahiki Kwa ITC
DocType: Student Applicant,EDU-APP-.YYYY.-,EDU-APP-YYYY.-
DocType: Journal Entry,Entry Type,Aina ya Kuingia
,Customer Credit Balance,Mizani ya Mikopo ya Wateja
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Accounts Payable,Mabadiliko ya Nambari ya Akaunti yanapatikana
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Credit limit has been crossed for customer {0} ({1}/{2}),Kizuizi cha mkopo kimevuka kwa wateja {0} ({1} / {2})
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Customer required for 'Customerwise Discount',Wateja wanahitajika kwa &#39;Msaada wa Wateja&#39;
apps/erpnext/erpnext/config/accounting.py,Update bank payment dates with journals.,Sasisha tarehe za malipo ya benki na majarida.
,Billed Qty,Bty Qty
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Pricing,Bei
DocType: Employee,Attendance Device ID (Biometric/RF tag ID),Kitambulisho cha Kiongozi wa Mahudhurio (Kitambulisho cha biometriska / kitambulisho cha RF)
DocType: Quotation,Term Details,Maelezo ya muda
DocType: Item,Over Delivery/Receipt Allowance (%),Idhini ya Zaidi ya Utoaji / risiti (%)
DocType: Employee Incentive,Employee Incentive,Ushawishi wa Waajiriwa
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Cannot enroll more than {0} students for this student group.,Haiwezi kujiandikisha zaidi ya {0} wanafunzi kwa kikundi hiki cha wanafunzi.
apps/erpnext/erpnext/templates/print_formats/includes/total.html,Total (Without Tax),Jumla (bila ya Kodi)
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Lead Count,Hesabu ya Kiongozi
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Stock Available,Stock Inapatikana
DocType: Manufacturing Settings,Capacity Planning For (Days),Mipango ya Uwezo Kwa (Siku)
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py,Procurement,Ununuzi
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,None of the items have any change in quantity or value.,Hakuna vitu vilivyo na mabadiliko yoyote kwa wingi au thamani.
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Program,Sehemu ya lazima - Programu
DocType: Special Test Template,Result Component,Matokeo ya kipengele
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js,Warranty Claim,Madai ya udhamini
,Lead Details,Maelezo ya Kiongozi
DocType: Volunteer,Availability and Skills,Upatikanaji na Ujuzi
DocType: Salary Slip,Loan repayment,Malipo ya kulipia
DocType: Share Transfer,Asset Account,Akaunti ya Mali
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Tarehe mpya ya kutolewa inapaswa kuwa katika siku zijazo
DocType: Purchase Invoice,End date of current invoice's period,Tarehe ya mwisho ya kipindi cha ankara ya sasa
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Tafadhali sasisha Mfumo wa Kumtaja Mfanyikazi katika Rasilimali Watu&gt; Mipangilio ya HR
DocType: Lab Test,Technician Name,Jina la mafundi
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
					Item {0} is added with and without Ensure Delivery by \
					Serial No.",Haiwezi kuhakikisha utoaji wa Serial Hakuna kama \ Item {0} imeongezwa na bila ya Kuhakikisha Utoaji kwa \ Nambari ya Serial
DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Unlink Malipo ya Kuondoa Invoice
DocType: Bank Reconciliation,From Date,Kutoka Tarehe
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},Orodha ya Odometer ya sasa imewekwa inapaswa kuwa kubwa kuliko Odometer ya awali ya Gari {0}
,Purchase Order Items To Be Received or Billed,Vitu vya Agizo la Ununuzi Upate au Kupwa
DocType: Restaurant Reservation,No Show,Hakuna Onyesha
apps/erpnext/erpnext/regional/india/utils.py,You must be a registered supplier to generate e-Way Bill,Lazima uwe muuzaji aliyesajiliwa ili kuunda Muswada wa e-Way
DocType: Shipping Rule Country,Shipping Rule Country,Nchi ya Maagizo ya Utoaji
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Leave and Attendance,Acha na Uhudhuriaji
DocType: Asset,Comprehensive Insurance,Bima kamili
DocType: Maintenance Visit,Partially Completed,Ilikamilishwa kikamilifu
apps/erpnext/erpnext/public/js/event.js,Add Leads,Ongeza Msaidizi
apps/erpnext/erpnext/healthcare/setup.py,Moderate Sensitivity,Sensitivity ya wastani
DocType: Leave Type,Include holidays within leaves as leaves,Jumuisha likizo ndani ya majani kama majani
DocType: Loyalty Program,Redemption,Ukombozi
DocType: Sales Invoice,Packed Items,Vipuri vilivyowekwa
DocType: Tally Migration,Vouchers,Vocha
DocType: Tax Withholding Category,Tax Withholding Rates,Viwango vya Kuzuia Ushuru
DocType: Contract,Contract Period,Kipindi cha Mkataba
apps/erpnext/erpnext/config/support.py,Warranty Claim against Serial No.,Madai ya Udhamini dhidi ya Namba ya Serial.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,'Total',&#39;Jumla&#39;
DocType: Shopping Cart Settings,Enable Shopping Cart,Wezesha Kifaa cha Ununuzi
DocType: Employee,Permanent Address,Anwani ya Kudumu
DocType: Loyalty Program,Collection Tier,Mkusanyiko wa Mkusanyiko
apps/erpnext/erpnext/hr/utils.py,From date can not be less than employee's joining date,Kutoka tarehe haiwezi kuwa chini ya tarehe ya kujiunga na mfanyakazi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"Advance paid against {0} {1} cannot be greater \
						than Grand Total {2}",Advance iliyolipwa dhidi ya {0} {1} haiwezi kuwa kubwa \ kuliko Grand Jumla {2}
DocType: Patient,Medication,Dawa
DocType: Production Plan,Include Non Stock Items,Jumuisha Vipengee Visivyo vya hisa
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select item code,Tafadhali chagua msimbo wa kipengee
DocType: Student Sibling,Studying in Same Institute,Kujifunza katika Taasisi hiyo
DocType: Leave Type,Earned Leave,Kulipwa Kuondoka
apps/erpnext/erpnext/erpnext_integrations/connectors/shopify_connection.py,Tax Account not specified for Shopify Tax {0},Akaunti ya Ushuru haijaainishwa kwa Ushuru wa Shopify {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,The following serial numbers were created: <br> {0},Nambari zifuatazo za serial ziliundwa: <br> {0}
DocType: Employee,Salary Details,Maelezo ya Mshahara
DocType: Territory,Territory Manager,Meneja wa Wilaya
DocType: Packed Item,To Warehouse (Optional),Kwa Ghala (Hiari)
DocType: GST Settings,GST Accounts,Akaunti ya GST
DocType: Payment Entry,Paid Amount (Company Currency),Kiasi kilicholipwa (Fedha la Kampuni)
DocType: Purchase Invoice,Additional Discount,Punguzo la ziada
DocType: Selling Settings,Selling Settings,Kuuza Mipangilio
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Online Auctions,Madaada ya mtandaoni
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please specify either Quantity or Valuation Rate or both,Tafadhali taja ama Wingi au Valuation Rate au wote wawili
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py,Fulfillment,Utekelezaji
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,View in Cart,Angalia katika Kifaa
DocType: Employee Checkin,Shift Actual Start,Mwanzo wa Shift
DocType: Tally Migration,Is Day Book Data Imported,Je! Data ya Kitabu cha Siku imehitajika
,Purchase Order Items To Be Received or Billed1,Vitu vya Agizo la Ununuzi Ili Kupokelewa au Bili1
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Marketing Expenses,Malipo ya Masoko
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.py,{0} units of {1} is not available.,Sehemu za {0} za {1} hazipatikani.
,Item Shortage Report,Ripoti ya uhaba wa habari
DocType: Bank Transaction Payments,Bank Transaction Payments,Malipo ya Manunuzi ya Benki
apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py,Can't create standard criteria. Please rename the criteria,Haiwezi kuunda vigezo vigezo. Tafadhali renama vigezo
apps/erpnext/erpnext/stock/doctype/item/item.js,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Uzito umetajwa, \ nSafadhali kutaja &quot;Uzito UOM&quot; pia"
DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Ombi la Nyenzo lilitumiwa kufanya Usajili huu wa hisa
DocType: Hub User,Hub Password,Hub Password
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Toka Kundi la kozi la Kundi kwa kila Batch
,Sales Partner Target Variance based on Item Group,Malengo ya Washirika wa Uuzaji kulingana na Kikundi cha Bidhaa
apps/erpnext/erpnext/config/support.py,Single unit of an Item.,Kitengo kimoja cha Kipengee.
DocType: Fee Category,Fee Category,Jamii ya ada
DocType: Agriculture Task,Next Business Day,Siku inayofuata ya Biashara
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Allocated Leaves,Alitoa Majani
DocType: Drug Prescription,Dosage by time interval,Kipimo kwa wakati wa muda
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Total Taxable Value,Thamani ya Ushuru Jumla
DocType: Cash Flow Mapper,Section Header,Sehemu ya kichwa
,Student Fee Collection,Ukusanyaji wa Mali ya Wanafunzi
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Appointment Duration (mins),Muda wa Uteuzi (mchana)
DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Fanya Uingizaji wa Uhasibu Kwa Kila Uhamisho wa Stock
DocType: Leave Allocation,Total Leaves Allocated,Majani ya Jumla Yamewekwa
apps/erpnext/erpnext/public/js/setup_wizard.js,Please enter valid Financial Year Start and End Dates,Tafadhali ingiza Msaada wa Mwaka wa Fedha na Mwisho wa Tarehe
DocType: Employee,Date Of Retirement,Tarehe ya Kustaafu
DocType: Upload Attendance,Get Template,Pata Kigezo
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Pick List,Orodha ya Chagua
,Sales Person Commission Summary,Muhtasari wa Tume ya Watu wa Mauzo
DocType: Material Request,Transferred,Imehamishwa
DocType: Vehicle,Doors,Milango
DocType: Healthcare Settings,Collect Fee for Patient Registration,Kukusanya ada kwa Usajili wa Mgonjwa
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Haiwezi kubadilisha sifa baada ya shughuli za hisa. Panga Ncha mpya na uhamishe hisa kwenye Ncha mpya
DocType: Course Assessment Criteria,Weightage,Uzito
DocType: Purchase Invoice,Tax Breakup,Kuvunja kodi
DocType: Employee,Joining Details,Kujiunga Maelezo
DocType: Member,Non Profit Member,Mwanachama asiye na faida
DocType: Email Digest,Bank Credit Balance,Mizani ya Mkopo wa Benki
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,{0} {1}: Kituo cha gharama kinahitajika kwa akaunti ya &#39;Faida na Kupoteza&#39; {2}. Tafadhali weka kituo cha gharama cha chini cha Kampuni.
DocType: Payment Schedule,Payment Term,Muda wa Malipo
apps/erpnext/erpnext/selling/doctype/customer/customer.py,A Customer Group exists with same name please change the Customer name or rename the Customer Group,Kundi la Wateja liko kwa jina moja tafadhali tuma jina la Wateja au uunda jina Kundi la Wateja
DocType: Location,Area,Eneo
apps/erpnext/erpnext/public/js/templates/contact_list.html,New Contact,Mawasiliano mpya
DocType: Company,Company Description,Maelezo ya Kampuni
DocType: Territory,Parent Territory,Eneo la Mzazi
DocType: Purchase Invoice,Place of Supply,Mahali ya Ugavi
DocType: Quality Inspection Reading,Reading 2,Kusoma 2
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Employee {0} already submited an apllication {1} for the payroll period {2},Mfanyakazi {0} tayari amewasilisha apllication {1} kwa muda wa malipo {2}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Material Receipt,Receipt ya nyenzo
DocType: Bank Statement Transaction Entry,Submit/Reconcile Payments,Kuwasilisha / Kulipa Malipo
DocType: Campaign,SAL-CAM-.YYYY.-,SAL-CAM -YYYY.-
DocType: Homepage,Products,Bidhaa
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invoices based on Filters,Pata ankara kulingana na vichungi
DocType: Announcement,Instructor,Mwalimu
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Select Item (optional),Chagua kitu (hiari)
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,The Loyalty Program isn't valid for the selected company,Programu ya Uaminifu haifai kwa kampuni iliyochaguliwa
DocType: Fee Schedule Student Group,Fee Schedule Student Group,Ratiba Ratiba ya Wanafunzi
DocType: Student,AB+,AB +
DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Ikiwa bidhaa hii ina tofauti, basi haiwezi kuchaguliwa katika amri za mauzo nk."
DocType: Products Settings,Hide Variants,Ficha anuwai
DocType: Lead,Next Contact By,Kuwasiliana Nafuatayo
DocType: Compensatory Leave Request,Compensatory Leave Request,Ombi la Kuondoa Rufaa
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Kiasi kinachohitajika kwa Item {0} mfululizo {1}
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Ghala {0} haiwezi kufutwa kama kiasi kilichopo kwa Bidhaa {1}
DocType: Blanket Order,Order Type,Aina ya Utaratibu
,Item-wise Sales Register,Daftari ya Mauzo ya hekima
DocType: Asset,Gross Purchase Amount,Jumla ya Ununuzi wa Pato
apps/erpnext/erpnext/utilities/user_progress.py,Opening Balances,Mizani ya Ufunguzi
DocType: Asset,Depreciation Method,Njia ya kushuka kwa thamani
DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,"Je, kodi hii imejumuishwa katika Msingi Msingi?"
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Total Target,Jumla ya Target
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Perception Analysis,Uchambuzi wa Upimaji
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Integrated Tax,Ushuru uliojumuishwa
DocType: Soil Texture,Sand Composition (%),Mchanga Muundo (%)
DocType: Job Applicant,Applicant for a Job,Mwombaji wa Kazi
DocType: Production Plan Material Request,Production Plan Material Request,Mpango wa Ushauri wa Nyenzo ya Uzalishaji
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Automatic Reconciliation,Upatanisho wa moja kwa moja
DocType: Purchase Invoice,Release Date,Tarehe ya kutolewa
DocType: Stock Reconciliation,Reconciliation JSON,Upatanisho JSON
apps/erpnext/erpnext/accounts/report/financial_statements.html,Too many columns. Export the report and print it using a spreadsheet application.,Safu nyingi za safu. Tuma taarifa na uchapishe kwa kutumia programu ya lahajedwali.
DocType: Purchase Invoice Item,Batch No,Bundi No
DocType: Marketplace Settings,Hub Seller Name,Jina la Muuzaji wa Hub
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Employee Advances,Maendeleo ya Waajiriwa
DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Ruhusu Amri nyingi za Mauzo dhidi ya Utaratibu wa Ununuzi wa Wateja
DocType: Student Group Instructor,Student Group Instructor,Mwalimu wa Kikundi cha Wanafunzi
DocType: Grant Application,Assessment  Mark (Out of 10),Marko ya Tathmini (nje ya 10)
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Mobile No,Guardian2 Simu ya Mkono Hakuna
apps/erpnext/erpnext/setup/doctype/company/company.py,Main,Kuu
DocType: GSTR 3B Report,July,Julai
apps/erpnext/erpnext/controllers/buying_controller.py,Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,Kufuatia item {0} haijawekwa alama kama {1} kipengee. Unaweza kuwawezesha kama kipengee {1} kutoka kwa kichwa chake cha Bidhaa
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant,Tofauti
apps/erpnext/erpnext/controllers/status_updater.py,"For an item {0}, quantity must be negative number","Kwa kipengee {0}, wingi lazima iwe nambari hasi"
DocType: Naming Series,Set prefix for numbering series on your transactions,Weka kiambishi kwa mfululizo wa nambari kwenye shughuli zako
DocType: Employee Attendance Tool,Employees HTML,Waajiri HTML
apps/erpnext/erpnext/stock/doctype/item/item.py,Default BOM ({0}) must be active for this item or its template,BOM ya chaguo-msingi ({0}) lazima iwe kazi kwa kipengee hiki au template yake
DocType: Employee,Leave Encashed?,Je! Uacha Encashed?
DocType: Email Digest,Annual Expenses,Gharama za kila mwaka
DocType: Item,Variants,Tofauti
DocType: SMS Center,Send To,Tuma kwa
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,There is not enough leave balance for Leave Type {0},Hakuna usawa wa kutosha wa kuondoka kwa Aina ya Kuondoka {0}
DocType: Payment Reconciliation Payment,Allocated amount,Ilipunguzwa kiasi
DocType: Sales Team,Contribution to Net Total,Mchango kwa Jumla ya Net
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Manufactured,Imetengenezwa
DocType: Sales Invoice Item,Customer's Item Code,Msimbo wa Bidhaa ya Wateja
DocType: Stock Reconciliation,Stock Reconciliation,Upatanisho wa hisa
DocType: Territory,Territory Name,Jina la Wilaya
DocType: Email Digest,Purchase Orders to Receive,Amri ya Ununuzi Ili Kupokea
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work-in-Progress Warehouse is required before Submit,Ghala ya Maendeleo ya Kazi inahitajika kabla ya Wasilisha
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,You can only have Plans with the same billing cycle in a Subscription,Unaweza tu kuwa na Mipango yenye mzunguko wa bili sawa katika Usajili
DocType: Bank Statement Transaction Settings Item,Mapped Data,Takwimu zilizopangwa
DocType: Purchase Order Item,Warehouse and Reference,Ghala na Kumbukumbu
DocType: Payroll Period Date,Payroll Period Date,Tarehe ya Muda wa Mishahara
DocType: Supplier,Statutory info and other general information about your Supplier,Maelezo ya kisheria na maelezo mengine ya jumla kuhusu Mtoa Wako
DocType: Item,Serial Nos and Batches,Serial Nos na Batches
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py,Student Group Strength,Nguvu ya Kikundi cha Wanafunzi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Against Journal Entry {0} does not have any unmatched {1} entry,Dhidi ya Uingilio wa Jarida {0} haina kiingilio chochote kisicho kulinganishwa {1}
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,"Subsidiary companies have already planned for {1} vacancies at a budget of {2}. \
				Staffing Plan for {0} should allocate more vacancies and budget for {3} than planned for its subsidiary companies",Makampuni ya kampuni ya nyaraka tayari yamepangwa kwa {1} nafasi katika bajeti ya {2}. Mpango wa Utumishi wa {0} unapaswa kutenga nafasi zaidi na bajeti ya {3} kuliko ilivyopangwa kwa kampuni zake ndogo
apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py,Training Events,Mazoezi ya Mafunzo
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Duplicate Serial No entered for Item {0},Duplicate Serial Hakuna aliingia kwa Item {0}
DocType: Quality Review Objective,Quality Review Objective,Lengo la uhakiki wa ubora
apps/erpnext/erpnext/config/crm.py,Track Leads by Lead Source.,Orodha inayoongozwa na Chanzo cha Kiongozi.
DocType: Shipping Rule Condition,A condition for a Shipping Rule,Hali ya Utawala wa Usafirishaji
DocType: Sales Invoice,e-Way Bill No.,Muswada wa e-Way No.
DocType: GSTR 3B Report,JSON Output,Matokeo ya JSON
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please enter ,Tafadhali ingiza
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js,Maintenance Log,Ingia ya Matengenezo
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Please set filter based on Item or Warehouse,Tafadhali weka kichujio kulingana na Bidhaa au Ghala
DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Uzito wavu wa mfuko huu. (mahesabu ya moja kwa moja kama jumla ya uzito wa vitu)
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Discount amount cannot be greater than 100%,Kiasi cha punguzo hawezi kuwa zaidi ya 100%
DocType: Opportunity,CRM-OPP-.YYYY.-,CRM-OPP -YYYY.-
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,"Number of new Cost Center, it will be included in the cost center name as a prefix","Idadi ya Kituo cha Gharama mpya, kitaingizwa katika jina la kituo cha gharama kama kiambishi"
DocType: Sales Order,To Deliver and Bill,Kutoa na Bill
DocType: Student Group,Instructors,Wafundishaji
DocType: GL Entry,Credit Amount in Account Currency,Mikopo Kiasi katika Fedha ya Akaunti
DocType: Stock Entry,Receive at Warehouse,Pokea kwa Ghala
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Accounting Dimension <b>{0}</b> is required for 'Profit and Loss' account {1}.,Vipimo vya Uhasibu <b>{0}</b> inahitajika kwa Akaunti ya &#39;Faida na Hasara&#39; {1}.
DocType: Communication Medium,Voice,Sauti
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} must be submitted,BOM {0} lazima iwasilishwa
apps/erpnext/erpnext/config/accounting.py,Share Management,Shiriki Usimamizi
DocType: Authorization Control,Authorization Control,Kudhibiti Udhibiti
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Row # {0}: Ghala iliyokataliwa ni lazima dhidi ya Kitu kilichokataliwa {1}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Received Stock Entries,Imepokelewa Ingizo la Hisa
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Payment,Malipo
apps/erpnext/erpnext/controllers/stock_controller.py,"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Ghala {0} haihusishwa na akaunti yoyote, tafadhali taja akaunti katika rekodi ya ghala au kuweka akaunti ya hesabu ya msingi kwa kampuni {1}."
apps/erpnext/erpnext/utilities/activation.py,Manage your orders,Dhibiti amri zako
DocType: Work Order Operation,Actual Time and Cost,Muda na Gharama halisi
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Nyenzo ya upeo {0} inaweza kufanywa kwa Bidhaa {1} dhidi ya Mauzo ya Uagizaji {2}
DocType: Amazon MWS Settings,DE,DE
DocType: Crop,Crop Spacing,Upeo wa Mazao
DocType: Budget,Action if Annual Budget Exceeded on PO,Hatua kama Bajeti ya Mwaka imeongezeka kwenye PO
DocType: Issue,Service Level,Kiwango cha Huduma
DocType: Student Leave Application,Student Leave Application,Maombi ya Kuondoka kwa Wanafunzi
DocType: Item,Will also apply for variants,Pia itatumika kwa vipengee
apps/erpnext/erpnext/assets/doctype/asset/asset.py,"Asset cannot be cancelled, as it is already {0}","Mali haziwezi kufutwa, kama tayari {0}"
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} on Half day on {1},Mfanyakazi {0} kwenye siku ya nusu kwenye {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Total working hours should not be greater than max working hours {0},Jumla ya masaa ya kufanya kazi hayapaswi kuwa kubwa kuliko masaa ya kufanya kazi max {0}
DocType: Asset Settings,Disable CWIP Accounting,Lemaza Uhasibu wa CWIP
apps/erpnext/erpnext/templates/pages/task_info.html,On,On
apps/erpnext/erpnext/config/buying.py,Bundle items at time of sale.,Vifungu vya vitu wakati wa kuuza.
DocType: Products Settings,Product Page,Ukurasa wa Bidhaa
DocType: Delivery Settings,Dispatch Settings,Mipangilio ya Dispatch
DocType: Material Request Plan Item,Actual Qty,Uhakika halisi
DocType: Sales Invoice Item,References,Marejeleo
DocType: Quality Inspection Reading,Reading 10,Kusoma 10
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Serial nos {0} does not belongs to the location {1},Serial nos {0} sio ya eneo {1}
DocType: Item,Barcodes,Barcodes
DocType: Hub Tracked Item,Hub Node,Node ya Hub
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,You have entered duplicate items. Please rectify and try again.,Umeingiza vitu vya duplicate. Tafadhali tengeneza na jaribu tena.
DocType: Tally Migration,Is Master Data Imported,Je! Takwimu ya Mwalimu inahitajika
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Associate,Washirika
DocType: Asset Movement,Asset Movement,Mwendo wa Mali
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0} must be submitted,Kazi ya Kazi {0} lazima iwasilishwa
apps/erpnext/erpnext/accounts/page/pos/pos.js,New Cart,New Cart
DocType: Taxable Salary Slab,From Amount,Kutoka kwa Kiasi
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Item {0} is not a serialized Item,Kipengee {0} si Kipengee cha sina
DocType: Leave Type,Encashment,Kuingiza
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.js,Select a company,Chagua kampuni
DocType: Delivery Settings,Delivery Settings,Mipangilio ya utoaji
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js,Fetch Data,Pata data
apps/erpnext/erpnext/hr/doctype/leave_policy/leave_policy.py,Maximum leave allowed in the leave type {0} is {1},Upeo wa kuondoka kuruhusiwa katika aina ya kuondoka {0} ni {1}
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Publish 1 Item,Chapisha Bidhaa 1
DocType: SMS Center,Create Receiver List,Unda Orodha ya Kupokea
DocType: Student Applicant,LMS Only,LMS Tu
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Available-for-use Date should be after purchase date,Tarehe inapatikana-kwa-tarehe inapaswa kuwa baada ya tarehe ya ununuzi
DocType: Vehicle,Wheels,Magurudumu
DocType: Packing Slip,To Package No.,Kwa Package No..
DocType: Patient Relation,Family,Familia
DocType: Invoice Discounting,Invoice Discounting,Upunguzaji wa ankara
DocType: Sales Invoice Item,Deferred Revenue Account,Akaunti ya Revenue iliyochaguliwa
DocType: Production Plan,Material Requests,Maombi ya Nyenzo
DocType: Warranty Claim,Issue Date,Siku ya kutolewa
DocType: Activity Cost,Activity Cost,Shughuli ya Gharama
DocType: Sales Invoice Timesheet,Timesheet Detail,Maelezo ya Timesheet
DocType: Purchase Receipt Item Supplied,Consumed Qty,Uchina uliotumiwa
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Telecommunications,Mawasiliano ya simu
apps/erpnext/erpnext/setup/doctype/company/test_company.py,No Account matched these filters: {},Hakuna Akaunti iliyolingana na vichungi hivi: {}
apps/erpnext/erpnext/accounts/party.py,Billing currency must be equal to either default company's currency or party account currency,Fedha ya kulipia lazima iwe sawa na sarafu au kampuni ya sarafu ya kampuni
DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),Inaonyesha kwamba mfuko ni sehemu ya utoaji huu (Tu Rasimu)
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,Closing Balance,Kufunga Mizani
DocType: Soil Texture,Loam,Loam
apps/erpnext/erpnext/controllers/accounts_controller.py,Row {0}: Due Date cannot be before posting date,Row {0}: Tarehe ya Tuzo haiwezi kuwa kabla ya kutuma tarehe
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Quantity for Item {0} must be less than {1},Wingi wa Bidhaa {0} lazima iwe chini ya {1}
,Sales Invoice Trends,Mwelekeo wa Mauzo ya Invoice
DocType: Leave Application,Apply / Approve Leaves,Tumia / Thibitisha Majani
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,For,Kwa
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Inaweza kutaja safu tu ikiwa aina ya malipo ni &#39;Juu ya Uliopita Mshahara Kiasi&#39; au &#39;Uliopita Row Jumla&#39;
DocType: Sales Order Item,Delivery Warehouse,Ghala la Utoaji
DocType: Leave Type,Earned Leave Frequency,Kulipwa Kuondoka Frequency
apps/erpnext/erpnext/config/accounting.py,Tree of financial Cost Centers.,Mti wa vituo vya gharama za kifedha.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Sub Type,Aina ndogo
DocType: Serial No,Delivery Document No,Nambari ya Hati ya Utoaji
DocType: Sales Order Item,Ensure Delivery Based on Produced Serial No,Hakikisha utoaji kulingana na No ya Serial iliyozalishwa
DocType: Vital Signs,Furry,Furry
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Tafadhali weka &#39;Akaunti ya Kupoteza / Kupoteza kwa Upunguzaji wa Mali&#39; katika Kampuni {0}
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Add to Featured Item,Ongeza kwa Bidhaa Iliyoangaziwa
DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Pata Vitu Kutoka Mapato ya Ununuzi
DocType: Serial No,Creation Date,Tarehe ya Uumbaji
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Target Location is required for the asset {0},Eneo la Target linahitajika kwa mali {0}
DocType: GSTR 3B Report,November,Novemba
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,"Selling must be checked, if Applicable For is selected as {0}","Uuzaji lazima uhakikiwe, ikiwa Inahitajika Kwa kuchaguliwa kama {0}"
DocType: Production Plan Material Request,Material Request Date,Tarehe ya Kuomba Nyenzo
DocType: Purchase Order Item,Supplier Quotation Item,Bidhaa ya Nukuu ya Wasambazaji
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Material Consumption is not set in Manufacturing Settings.,Matumizi ya Nyenzo haijawekwa katika Mipangilio ya Uzalishaji.
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,View all issues from {0},Angalia maswala yote kutoka {0}
DocType: Quality Inspection,MAT-QA-.YYYY.-,MAT-QA -YYYY.-
DocType: Quality Meeting Table,Quality Meeting Table,Jedwali la Mkutano wa Ubora
apps/erpnext/erpnext/templates/pages/help.html,Visit the forums,Tembelea vikao
DocType: Student,Student Mobile Number,Namba ya Simu ya Wanafunzi
DocType: Item,Has Variants,Ina tofauti
DocType: Employee Benefit Claim,Claim Benefit For,Faida ya kudai Kwa
apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Haiwezi kupindua kwa Item {0} katika mstari {1} zaidi ya {2}. Ili kuruhusu kulipia zaidi, tafadhali pangilia kwenye Mipangilio ya Hifadhi"
apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Sasisha jibu
apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Tayari umechagua vitu kutoka {0} {1}
DocType: Monthly Distribution,Name of the Monthly Distribution,Jina la Usambazaji wa Kila mwezi
DocType: Quality Procedure Process,Quality Procedure Process,Utaratibu wa Utaratibu wa Ubora
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Batch ID is mandatory,Kitambulisho cha Batch ni lazima
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.js,Please select Customer first,Tafadhali chagua Mteja kwanza
DocType: Sales Person,Parent Sales Person,Mtu wa Mauzo ya Mzazi
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,No items to be received are overdue,Hakuna vitu vilivyopokelewa vimepungua
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The seller and the buyer cannot be the same,Muuzaji na mnunuzi hawezi kuwa sawa
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,No views yet,Hakuna maoni bado
DocType: Project,Collect Progress,Kusanya Maendeleo
DocType: Delivery Note,MAT-DN-.YYYY.-,MAT-DN -YYYY.-
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Select the program first,Chagua programu kwanza
DocType: Patient Appointment,Patient Age,Umri mgonjwa
apps/erpnext/erpnext/config/help.py,Managing Projects,Miradi ya Kusimamia
DocType: Quiz,Latest Highest Score,Alama ya Juu ya Juu
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial no {0} has been already returned,Serial hakuna {0} imerudi tayari
DocType: Supplier,Supplier of Goods or Services.,Uuzaji wa Bidhaa au Huduma.
DocType: Budget,Fiscal Year,Mwaka wa fedha
DocType: Asset Maintenance Log,Planned,Imepangwa
apps/erpnext/erpnext/hr/utils.py,A {0} exists between {1} and {2} (,{0} ipo kati ya {1} na {2} (
DocType: Vehicle Log,Fuel Price,Bei ya Mafuta
DocType: BOM Explosion Item,Include Item In Manufacturing,Jumuisha Bidhaa katika Viwanda
DocType: Bank Guarantee,Margin Money,Margin Pesa
DocType: Budget,Budget,Bajeti
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Set Open,Weka wazi
apps/erpnext/erpnext/stock/doctype/item/item.py,Fixed Asset Item must be a non-stock item.,Vifaa vya Mali isiyohamishika lazima iwe kipengee cha hisa.
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Bajeti haipatikani dhidi ya {0}, kama sio akaunti ya Mapato au ya gharama"
DocType: Quality Review Table,Achieved,Imetimizwa
DocType: Student Admission,Application Form Route,Njia ya Fomu ya Maombi
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,End Date of Agreement can't be less than today.,Tarehe ya Mwisho ya Mkataba haiwezi kuwa chini ya leo.
apps/erpnext/erpnext/public/js/hub/components/CommentInput.vue,Ctrl + Enter to submit,Ctrl + Ingiza kupeana
DocType: Healthcare Settings,Patient Encounters in valid days,Mkutano wa Wagonjwa katika siku halali
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leave Type {0} cannot be allocated since it is leave without pay,Toka Aina {0} haiwezi kutengwa tangu inatoka bila kulipa
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Row {0}: Kiasi kilichowekwa {1} lazima kiwe chini au kilicho sawa na ankara ya kiasi kikubwa {2}
DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,Katika Maneno itaonekana wakati unapohifadhi ankara ya Mauzo.
DocType: Lead,Follow Up,Fuatilia
apps/erpnext/erpnext/accounts/report/financial_statements.py,Cost Center: {0} does not exist,Kituo cha Gharama: {0} haipo
DocType: Item,Is Sales Item,Ni Bidhaa ya Mauzo
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js,Item Group Tree,Mti wa Kikundi cha Bidhaa
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item {0} is not setup for Serial Nos. Check Item master,Kipengee {0} si kuanzisha kwa Serial Nos. Angalia kipengee cha kitu
DocType: Maintenance Visit,Maintenance Time,Muda wa Matengenezo
,Amount to Deliver,Kiasi cha Kutoa
DocType: Asset,Insurance Start Date,Tarehe ya Kuanza Bima
DocType: Salary Component,Flexible Benefits,Flexible Faida
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Same item has been entered multiple times. {0},Kitu kimoja kimeingizwa mara nyingi. {0}
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,Tarehe ya Kuanza ya Mwisho haiwezi kuwa mapema zaidi kuliko Tarehe ya Mwanzo wa Mwaka wa Mwaka wa Chuo ambao neno hilo linaunganishwa (Mwaka wa Chuo {}). Tafadhali tengeneza tarehe na jaribu tena.
apps/erpnext/erpnext/setup/doctype/company/company.js,There were errors.,Kulikuwa na makosa.
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Pin Code,Nambari ya Bomba
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup defaults,Imeshindwa kuanzisha chaguo-msingi
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Employee {0} has already applied for {1} between {2} and {3} : ,Mfanyakazi {0} tayari ameomba kwa {1} kati ya {2} na {3}:
DocType: Guardian,Guardian Interests,Maslahi ya Guardian
apps/erpnext/erpnext/accounts/doctype/account/account.js,Update Account Name / Number,Sasisha Jina la Akaunti / Nambari
DocType: Naming Series,Current Value,Thamani ya sasa
apps/erpnext/erpnext/controllers/accounts_controller.py,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Miaka kadhaa ya fedha ikopo kwa tarehe {0}. Tafadhali weka kampuni katika Mwaka wa Fedha
DocType: Education Settings,Instructor Records to be created by,Kumbukumbu ya Mwalimu ili kuundwa na
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,{0} created,{0} imeundwa
DocType: GST Account,GST Account,Akaunti ya GST
DocType: Delivery Note Item,Against Sales Order,Dhidi ya Mauzo ya Utaratibu
,Serial No Status,Serial Hakuna Hali
DocType: Payment Entry Reference,Outstanding,Bora
DocType: Supplier,Warn POs,Tahadhari POs
,Daily Timesheet Summary,Muhtasari wa Daily Timesheet
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,"Row {0}: To set {1} periodicity, difference between from and to date \
						must be greater than or equal to {2}","Row {0}: Kuweka {1} mara kwa mara, tofauti kati ya na hadi sasa \ lazima iwe kubwa kuliko au sawa na {2}"
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,This is based on stock movement. See {0} for details,Hii inategemea harakati za hisa. Angalia {0} kwa maelezo
DocType: Pricing Rule,Selling,Kuuza
DocType: Payment Entry,Payment Order Status,Hali ya Agizo la malipo
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} deducted against {2},Kiasi {0} {1} kilichopunguzwa dhidi ya {2}
DocType: Sales Person,Name and Employee ID,Jina na ID ya Waajiriwa
DocType: Promotional Scheme,Promotional Scheme Product Discount,Punguzo la Bidhaa ya Mpango wa Uendelezaji
DocType: Website Item Group,Website Item Group,Website Item Group
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,No salary slip found to submit for the above selected criteria OR salary slip already submitted,Hakuna kuingizwa kwa mshahara kupatikana kwa kuwasilisha kwa vigezo vilivyochaguliwa hapo AU au malipo ya mshahara tayari yamewasilishwa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Duties and Taxes,Kazi na Kodi
DocType: Projects Settings,Projects Settings,Mipangilio ya Miradi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please enter Reference date,Tafadhali ingiza tarehe ya Marejeo
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,{0} payment entries can not be filtered by {1},{0} funguo za kulipa haziwezi kuchujwa na {1}
DocType: Item Website Specification,Table for Item that will be shown in Web Site,Jedwali kwa Item ambayo itaonyeshwa kwenye Tovuti
DocType: Purchase Order Item Supplied,Supplied Qty,Ugavi wa Uchina
DocType: Clinical Procedure,HLC-CPR-.YYYY.-,HLC-CPR -YYYY.-
DocType: Purchase Order Item,Material Request Item,Nakala ya Kuomba Nyenzo
apps/erpnext/erpnext/config/buying.py,Tree of Item Groups.,Mti wa Vikundi vya Bidhaa.
DocType: Production Plan,Total Produced Qty,Uchina uliozalishwa
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,No reviews yet,Hakuna ukaguzi bado
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Cannot refer row number greater than or equal to current row number for this Charge type,Haiwezi kutaja nambari ya mstari zaidi kuliko au sawa na nambari ya mstari wa sasa kwa aina hii ya malipo
DocType: Asset,Sold,Inauzwa
,Item-wise Purchase History,Historia ya Ununuzi wa hekima
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},Tafadhali bonyeza &#39;Weka Ratiba&#39; ya Kuchukua Serial Hakuna Aliongeza kwa Item {0}
DocType: Account,Frozen,Frozen
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Vehicle Type,Aina ya Gari
DocType: Sales Invoice Payment,Base Amount (Company Currency),Kiasi cha Msingi (Fedha la Kampuni)
DocType: Purchase Invoice,Registered Regular,Iliyosajiliwa Mara kwa mara
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Raw Materials,Malighafi
DocType: Payment Reconciliation Payment,Reference Row,Row Reference
DocType: Installation Note,Installation Time,Muda wa Ufungaji
DocType: Sales Invoice,Accounting Details,Maelezo ya Uhasibu
DocType: Shopify Settings,status html,hali html
apps/erpnext/erpnext/setup/doctype/company/company.js,Delete all the Transactions for this Company,Futa Shughuli zote za Kampuni hii
DocType: Designation,Required Skills,Ujuzi Unaohitajika
DocType: Inpatient Record,O Positive,O Chanya
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Investments,Uwekezaji
DocType: Issue,Resolution Details,Maelezo ya Azimio
DocType: Leave Ledger Entry,Transaction Type,Aina ya Ushirikiano
DocType: Item Quality Inspection Parameter,Acceptance Criteria,Vigezo vya Kukubali
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Material Requests in the above table,Tafadhali ingiza Maombi ya Nyenzo katika meza iliyo hapo juu
apps/erpnext/erpnext/hr/doctype/loan/loan.py,No repayments available for Journal Entry,Hakuna malipo ya kutosha kwa Kuingia kwa Journal
DocType: Hub Tracked Item,Image List,Orodha ya Picha
DocType: Item Attribute,Attribute Name,Jina la sifa
DocType: Subscription,Generate Invoice At Beginning Of Period,Kuzalisha Invoice Wakati wa Mwanzo wa Kipindi
DocType: BOM,Show In Website,Onyesha kwenye tovuti
DocType: Loan Application,Total Payable Amount,Kiasi Kilivyoteuliwa
DocType: Task,Expected Time (in hours),Muda Unaotarajiwa (kwa saa)
DocType: Item Reorder,Check in (group),Angalia (kikundi)
DocType: Soil Texture,Silt,Silt
,Qty to Order,Uchina kwa Amri
DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Kichwa cha akaunti chini ya Uwezo au Equity, ambapo Faida / Uvunjaji utawekwa"
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},Rekodi nyingine ya Bajeti &#39;{0}&#39; tayari imesimama dhidi ya {1} &#39;{2}&#39; na akaunti &#39;{3}&#39; kwa mwaka wa fedha {4}
apps/erpnext/erpnext/config/projects.py,Gantt chart of all tasks.,Gantt chati ya kazi zote.
DocType: Opportunity,Mins to First Response,Mafanikio ya Kwanza ya Jibu
DocType: Pricing Rule,Margin Type,Aina ya Margin
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,{0} hours,{0} masaa
DocType: Course,Default Grading Scale,Kiwango cha Kuzingatia chaguo-msingi
DocType: Appraisal,For Employee Name,Kwa Jina la Waajiriwa
DocType: Holiday List,Clear Table,Futa Jedwali
DocType: Woocommerce Settings,Tax Account,Akaunti ya Kodi
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Available slots,Inapatikana
DocType: C-Form Invoice Detail,Invoice No,No ya ankara
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Make Payment,Fanya Malipo
DocType: Room,Room Name,Jina la Chumba
DocType: Prescription Duration,Prescription Duration,Muda wa Dawa
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Kuondoka hakuwezi kutumiwa / kufutwa kabla ya {0}, kama usawa wa kuondoka tayari umepelekwa katika rekodi ya ugawaji wa kuondoka baadaye {1}"
DocType: Activity Cost,Costing Rate,Kiwango cha gharama
apps/erpnext/erpnext/config/selling.py,Customer Addresses And Contacts,Anwani za Wateja Na Mawasiliano
DocType: Homepage Section,Section Cards,Kadi za Sehemu
,Campaign Efficiency,Ufanisi wa Kampeni
DocType: Discussion,Discussion,Majadiliano
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Sales Order Submission,Kwenye Uwasilishaji wa Agizo la Uuzaji
DocType: Bank Transaction,Transaction ID,Kitambulisho cha Shughuli
DocType: Payroll Entry,Deduct Tax For Unsubmitted Tax Exemption Proof,Kutoa Ushuru kwa Uthibitishaji wa Ushuru wa Unsubmitted
DocType: Volunteer,Anytime,Wakati wowote
DocType: Bank Account,Bank Account No,Akaunti ya Akaunti ya Benki
DocType: Employee Tax Exemption Proof Submission,Employee Tax Exemption Proof Submission,Ushuru wa Waajiri wa Ushuru wa Ushahidi
DocType: Patient,Surgical History,Historia ya upasuaji
DocType: Bank Statement Settings Item,Mapped Header,Kichwa cha Mapped
DocType: Employee,Resignation Letter Date,Barua ya Kuondoa Tarehe
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Pricing Rules are further filtered based on quantity.,Kanuni za bei ni zilizochujwa zaidi kulingana na wingi.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Please set the Date Of Joining for employee {0},Tafadhali weka tarehe ya kujiunga na mfanyakazi {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Please enter Difference Account,Tafadhali ingiza Akaunti ya Tofauti
DocType: Inpatient Record,Discharge,Ondoa
DocType: Task,Total Billing Amount (via Time Sheet),Kiasi cha kulipa jumla (kupitia Karatasi ya Muda)
apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js,Create Fee Schedule,Unda Ratiba ya Ada
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Repeat Customer Revenue,Rudia Mapato ya Wateja
DocType: Soil Texture,Silty Clay Loam,Mchoro wa Clay Silly
DocType: Quiz,Enter 0 to waive limit,Ingiza 0 kupunguza kikomo
DocType: Bank Statement Settings,Mapped Items,Vipengee Vipengeke
DocType: Amazon MWS Settings,IT,IT
DocType: Chapter,Chapter,Sura
,Fixed Asset Register,Rejista ya Mali isiyohamishika
apps/erpnext/erpnext/utilities/user_progress.py,Pair,Jozi
DocType: Mode of Payment Account,Default account will be automatically updated in POS Invoice when this mode is selected.,Akaunti ya msingi itasasishwa moja kwa moja katika ankara ya POS wakati hali hii inachaguliwa.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select BOM and Qty for Production,Chagua BOM na Uchina kwa Uzalishaji
DocType: Asset,Depreciation Schedule,Ratiba ya kushuka kwa thamani
DocType: Bank Reconciliation Detail,Against Account,Dhidi ya Akaunti
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Half Day Date should be between From Date and To Date,Tarehe ya Siku ya Nusu inapaswa kuwa kati ya Tarehe na Tarehe
DocType: Maintenance Schedule Detail,Actual Date,Tarehe halisi
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please set the Default Cost Center in {0} company.,Tafadhali weka Kituo cha Ghali cha Default katika {0} kampuni.
apps/erpnext/erpnext/projects/doctype/project/project.py,Daily Project Summary for {0},Muhtasari wa Mradi wa kila siku wa {0}
DocType: Item,Has Batch No,Ina Bande No
apps/erpnext/erpnext/public/js/utils.js,Annual Billing: {0},Ulipaji wa Mwaka: {0}
DocType: Shopify Webhook Detail,Shopify Webhook Detail,Weka Ufafanuzi wa Webhook
apps/erpnext/erpnext/config/accounting.py,Goods and Services Tax (GST India),Malipo na Huduma za Kodi (GST India)
DocType: Delivery Note,Excise Page Number,Nambari ya Ukurasa wa Ushuru
DocType: Asset,Purchase Date,Tarehe ya Ununuzi
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,Could not generate Secret,Haikuweza kuzalisha Siri
DocType: Volunteer,Volunteer Type,Aina ya kujitolea
DocType: Payment Request,ACC-PRQ-.YYYY.-,ACC-PRQ -YYYY.-
DocType: Shift Assignment,Shift Type,Aina ya Shift
DocType: Student,Personal Details,Maelezo ya kibinafsi
apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,Export E-Invoices,Uuzaji wa nje wa barua-pepe
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set 'Asset Depreciation Cost Center' in Company {0},Tafadhali weka &#39;kituo cha gharama ya kushuka kwa thamani ya mali&#39; katika Kampuni {0}
,Maintenance Schedules,Mipango ya Matengenezo
DocType: Pricing Rule,Apply Rule On Brand,Tuma Sheria kwenye Brand
DocType: Task,Actual End Date (via Time Sheet),Tarehe ya mwisho ya mwisho (kupitia Karatasi ya Muda)
apps/erpnext/erpnext/projects/doctype/task/task.py,Cannot close task {0} as its dependant task {1} is not closed.,Haiwezi kufunga kazi {0} kama kazi yake tegemezi {1} haijafungwa.
DocType: Soil Texture,Soil Type,Aina ya Udongo
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} against {2} {3},Kiasi {0} {1} dhidi ya {2} {3}
,Quotation Trends,Mwelekeo wa Nukuu
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Item Group not mentioned in item master for item {0},Kikundi cha kipengee ambacho hakijajwa katika kipengee cha bidhaa kwa kipengee {0}
DocType: GoCardless Mandate,GoCardless Mandate,Hati ya GoCardless
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To account must be a Receivable account,Debit Kwa akaunti lazima iwe akaunti inayoidhinishwa
DocType: Shipping Rule,Shipping Amount,Kiasi cha usafirishaji
DocType: Supplier Scorecard Period,Period Score,Kipindi cha Kipindi
apps/erpnext/erpnext/public/js/event.js,Add Customers,Ongeza Wateja
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Pending Amount,Kiasi kinachosubiri
DocType: Lab Test Template,Special,Maalum
DocType: Loyalty Program,Conversion Factor,Fact Conversion
DocType: Purchase Order,Delivered,Imetolewa
,Vehicle Expenses,Gharama za Gari
DocType: Healthcare Settings,Create Lab Test(s) on Sales Invoice Submit,Unda Majaribio ya Lab (Mawasilisho ya Mauzo)
DocType: Serial No,Invoice Details,Maelezo ya ankara
apps/erpnext/erpnext/regional/india/utils.py,Salary Structure must be submitted before submission of Tax Ememption Declaration,Muundo wa Mshahara lazima uwasilishwe kabla ya kuwasilisha Azimio la Utoaji wa Kodi
DocType: Grant Application,Show on Website,Onyesha kwenye tovuti
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,Start on,Anza
DocType: Hub Tracked Item,Hub Category,Jamii ya Hub
DocType: Purchase Invoice,SEZ,SEZ
DocType: Purchase Receipt,Vehicle Number,Nambari ya Gari
DocType: Loan,Loan Amount,Kiasi cha Mikopo
DocType: Student Report Generation Tool,Add Letterhead,Ongeza kichwa cha barua
DocType: Program Enrollment,Self-Driving Vehicle,Gari ya kujitegemea
DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Washirika wa Scorecard Wamesimama
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Row {0}: Bill of Materials not found for the Item {1},Row {0}: Sheria ya Vifaa haipatikani kwa Bidhaa {1}
DocType: Contract Fulfilment Checklist,Requirement,Mahitaji
DocType: Journal Entry,Accounts Receivable,Akaunti inapatikana
DocType: Quality Goal,Objectives,Malengo
DocType: Travel Itinerary,Meal Preference,Upendeleo wa Chakula
,Supplier-Wise Sales Analytics,Wafanyabiashara-Wiseja Mauzo Analytics
apps/erpnext/erpnext/accounts/doctype/subscription_plan/subscription_plan.py,Billing Interval Count cannot be less than 1,Hesabu ya kipindi cha malipo inaweza kuwa chini ya 1
DocType: Purchase Invoice,Availed ITC Central Tax,Taasisi ya Kati ya ITC iliyopatikana
DocType: Sales Invoice,Company Address Name,Jina la anwani ya kampuni
DocType: Work Order,Use Multi-Level BOM,Tumia BOM Multi Level
DocType: Bank Reconciliation,Include Reconciled Entries,Weka Maingilio Yanayounganishwa
apps/erpnext/erpnext/accounts/doctype/bank_transaction/bank_transaction.py,The total allocated amount ({0}) is greated than the paid amount ({1}).,Jumla ya zilizotengwa ({0}) ni iliyotiwa mafuta kuliko kiwango kilicholipwa ({1}).
DocType: Landed Cost Voucher,Distribute Charges Based On,Shirikisha mishahara ya msingi
DocType: Projects Settings,Timesheets,Timesheets
DocType: HR Settings,HR Settings,Mipangilio ya HR
apps/erpnext/erpnext/config/accounting.py,Accounting Masters,Mabwana wa Uhasibu
DocType: Salary Slip,net pay info,maelezo ya kulipa wavu
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,CESS Amount,CESS Kiasi
DocType: Woocommerce Settings,Enable Sync,Wezesha Sync
DocType: Tax Withholding Rate,Single Transaction Threshold,Kitengo cha Msaada wa Pekee
DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Thamani hii inasasishwa katika Orodha ya Bei ya Mauzo ya Default.
apps/erpnext/erpnext/templates/pages/cart.html,Your cart is Empty,Gari lako ni Tupu
DocType: Email Digest,New Expenses,Gharama mpya
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Cannot Optimize Route as Driver Address is Missing.,Haiwezi Kuboresha Njia kama Anwani ya Dereva inakosekana.
DocType: Shareholder,Shareholder,Mbia
DocType: Purchase Invoice,Additional Discount Amount,Kipengee cha ziada cha Kiasi
DocType: Cash Flow Mapper,Position,Nafasi
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Get Items from Prescriptions,Pata Vitu kutoka kwa Maagizo
DocType: Patient,Patient Details,Maelezo ya Mgonjwa
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Nature Of Supplies,Asili ya Ugavi
DocType: Inpatient Record,B Positive,B Chanya
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of previous claimed\
			amount",Ufikiaji mkubwa wa mfanyakazi {0} unazidi {1} kwa jumla {2} ya kiasi cha awali cha kudai \ kiasi
apps/erpnext/erpnext/buying/report/subcontracted_raw_materials_to_be_transferred/subcontracted_raw_materials_to_be_transferred.py,Transferred Quantity,Wingi uliohamishwa
apps/erpnext/erpnext/controllers/accounts_controller.py,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Row # {0}: Uchina lazima uwe 1, kama kipengee ni mali iliyobaki. Tafadhali tumia mstari wa tofauti kwa qty nyingi."
DocType: Leave Block List Allow,Leave Block List Allow,Acha orodha ya kuzuia Kuruhusu
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbr can not be blank or space,Abbr haiwezi kuwa tupu au nafasi
DocType: Patient Medical Record,Patient Medical Record,Kumbukumbu ya Matibabu Mgonjwa
DocType: Quality Meeting Agenda,Quality Meeting Agenda,Ajenda ya Mkutano wa Ubora
apps/erpnext/erpnext/accounts/doctype/account/account.js,Group to Non-Group,Gundi kwa Wasio Kikundi
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Sports,Michezo
DocType: Leave Control Panel,Employee (optional),Mfanyikazi (hiari)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Material Request {0} submitted.,Ombi la nyenzo {0} limewasilishwa.
DocType: Loan Type,Loan Name,Jina la Mikopo
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Actual,Jumla halisi
DocType: Chart of Accounts Importer,Chart Preview,Hakiki ya Chati
DocType: Attendance,Shift,Shift
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,Enter API key in Google Settings.,Ingiza kitufe cha API katika Mipangilio ya Google.
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js,Create Journal Entry,Unda Uingilio wa Jarida
DocType: Student Siblings,Student Siblings,Ndugu wa Wanafunzi
DocType: Subscription Plan Detail,Subscription Plan Detail,Mpango wa Usajili
DocType: Quality Objective,Unit,Kitengo
apps/erpnext/erpnext/stock/get_item_details.py,Please specify Company,Tafadhali taja Kampuni
,Customer Acquisition and Loyalty,Upatikanaji wa Wateja na Uaminifu
DocType: Issue,Response By Variance,Kujibu kwa Tofauti
DocType: Asset Maintenance Task,Maintenance Task,Kazi ya Matengenezo
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Please set B2C Limit in GST Settings.,Tafadhali weka Mpaka wa B2C katika Mipangilio ya GST.
DocType: Marketplace Settings,Marketplace Settings,Mipangilio ya Marketplace
DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,Ghala ambapo unashikilia vitu vya kukataliwa
apps/erpnext/erpnext/public/js/hub/pages/Publish.vue,Publish {0} Items,Chapisha Vipengee {0}
apps/erpnext/erpnext/setup/utils.py,Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Haiwezi kupata kiwango cha ubadilishaji kwa {0} kwa {1} kwa tarehe muhimu {2}. Tafadhali tengeneza rekodi ya Fedha ya Fedha kwa mkono
DocType: POS Profile,Price List,Orodha ya bei
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} sasa ni Mwaka wa Fedha wa kawaida. Tafadhali rasha upya kivinjari chako ili mabadiliko yaweke.
apps/erpnext/erpnext/projects/doctype/task/task.js,Expense Claims,Madai ya gharama
DocType: Issue,Support,Msaada
DocType: Employee Tax Exemption Declaration,Total Exemption Amount,Kiasi cha jumla cha malipo
DocType: Content Question,Question Link,Kiunga cha Swali
,BOM Search,Utafutaji wa BOM
DocType: Accounting Dimension Detail,Mandatory For Balance Sheet,Lazima kwa Karatasi ya Mizani
DocType: Project,Total Consumed Material Cost  (via Stock Entry),Jumla ya Gharama za Nyenzo Zilizotumiwa (kupitia Uingiaji wa hisa)
DocType: Subscription,Subscription Period,Kipindi cha Usajili
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js,To Date cannot be less than From Date,Tarehe haiwezi kuwa chini ya Tarehe Kutoka Tarehe
,Delayed Order Report,Kuchelewa Ripoti ya
DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Chapisha &quot;Katika Hifadhi&quot; au &quot;Sio katika Hifadhi&quot; kwenye Hifadhi kulingana na hisa zilizopo katika ghala hii.
DocType: Vehicle,Fuel Type,Aina ya mafuta
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Tafadhali taja fedha katika Kampuni
DocType: Workstation,Wages per hour,Mshahara kwa saa
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Sanidi {0}
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Usawa wa hisa katika Batch {0} utakuwa hasi {1} kwa Bidhaa {2} kwenye Ghala {3}
apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Ufuatiliaji wa Nyenzo zifuatayo umefufuliwa kwa moja kwa moja kulingana na ngazi ya re-order ya Item
apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Akaunti {0} ni batili. Fedha ya Akaunti lazima iwe {1}
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py,From Date {0} cannot be after employee's relieving Date {1},Kutoka tarehe {0} haiwezi kuwa baada ya Tarehe ya kuondokana na mfanyakazi {1}
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,Create Payment Entries,Unda Wasilisho wa Malipo
DocType: Supplier,Is Internal Supplier,Ni wauzaji wa ndani
DocType: Employee,Create User Permission,Unda Ruhusa ya Mtumiaji
DocType: Employee Benefit Claim,Employee Benefit Claim,Madai ya Utumishi wa Wafanyakazi
DocType: Healthcare Settings,Remind Before,Kumkumbusha Kabla
apps/erpnext/erpnext/buying/utils.py,UOM Conversion factor is required in row {0},Kipengele cha kubadilisha UOM kinahitajika katika mstari {0}
DocType: Production Plan Item,material_request_item,vifaa_request_item
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Row # {0}: Aina ya Kumbukumbu ya Kumbukumbu lazima iwe moja ya Uagizaji wa Mauzo, Invoice ya Mauzo au Ingiza Jarida"
DocType: Loyalty Program,1 Loyalty Points = How much base currency?,1 Uaminifu Pointi = Fedha ya msingi kiasi gani?
DocType: Salary Component,Deduction,Utoaji
DocType: Item,Retain Sample,Weka Mfano
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: From Time and To Time is mandatory.,Row {0}: Kutoka wakati na muda ni lazima.
DocType: Stock Reconciliation Item,Amount Difference,Tofauti tofauti
apps/erpnext/erpnext/public/js/hub/pages/Buying.vue,This page keeps track of items you want to buy from sellers.,Ukurasa huu unaangalia vitu unachotaka kununua kutoka kwa wauzaji.
apps/erpnext/erpnext/stock/get_item_details.py,Item Price added for {0} in Price List {1},Item Bei imeongezwa kwa {0} katika Orodha ya Bei {1}
DocType: Delivery Stop,Order Information,Maelezo ya Uagizaji
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js,Please enter Employee Id of this sales person,Tafadhali ingiza Id Idhini ya mtu huyu wa mauzo
DocType: Territory,Classification of Customers by region,Uainishaji wa Wateja kwa kanda
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,In Production,Katika Uzalishaji
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Difference Amount must be zero,Tofauti Kiasi lazima iwe sifuri
DocType: Project,Gross Margin,Margin ya Pato
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0} applicable after {1} working days,{0} inatumika baada ya {1} siku za kazi
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Please enter Production Item first,Tafadhali ingiza Bidhaa ya Uzalishaji kwanza
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Calculated Bank Statement balance,Usawa wa Taarifa ya Benki
DocType: Normal Test Template,Normal Test Template,Kigezo cha Mtihani wa kawaida
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,disabled user,mtumiaji mlemavu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Quotation,Nukuu
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Cannot set a received RFQ to No Quote,Haiwezi kuweka RFQ iliyopokea kwa No Quote
DocType: Salary Slip,Total Deduction,Utoaji Jumla
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Select an account to print in account currency,Chagua akaunti ili uchapishe katika sarafu ya akaunti
DocType: BOM,Transfer Material Against,Transfer nyenzo dhidi
,Production Analytics,Uchambuzi wa Uzalishaji
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py,This is based on transactions against this Patient. See timeline below for details,Hii inategemea shughuli za Mgonjwa. Tazama kalenda ya chini kwa maelezo zaidi
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.py,Loan Start Date and Loan Period are mandatory to save the Invoice Discounting,Tarehe ya Kuanza mkopo na Kipindi cha Mkopo ni lazima ili kuokoa Upunguzaji wa ankara
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Cost Updated,Gharama ya Kusasishwa
apps/erpnext/erpnext/regional/india/utils.py,Vehicle Type is required if Mode of Transport is Road,Aina ya Gari inahitajika ikiwa Njia ya Usafiri ni Barabara
DocType: Inpatient Record,Date of Birth,Tarehe ya kuzaliwa
DocType: Quality Action,Resolutions,Maazimio
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Item {0} has already been returned,Kipengee {0} kimerejea
DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Mwaka wa Fedha ** inawakilisha Mwaka wa Fedha. Entries zote za uhasibu na shughuli nyingine kubwa zinapatikana dhidi ya ** Mwaka wa Fedha **.
DocType: Opportunity,Customer / Lead Address,Anwani ya Wateja / Kiongozi
DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Kuweka Scorecard Setup
DocType: Customer Credit Limit,Customer Credit Limit,Kikomo cha Mkopo wa Wateja
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Assessment Plan Name,Jina la Mpango wa Tathmini
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year_dashboard.py,Target Details,Maelezo ya Lengo
apps/erpnext/erpnext/regional/italy/setup.py,"Applicable if the company is SpA, SApA or SRL","Inatumika ikiwa kampuni ni SpA, SApA au SRL"
DocType: Work Order Operation,Work Order Operation,Kazi ya Kazi ya Kazi
apps/erpnext/erpnext/stock/doctype/item/item.py,Warning: Invalid SSL certificate on attachment {0},Onyo: Cheti cha SSL batili kwenye kiambatisho {0}
apps/erpnext/erpnext/regional/italy/setup.py,Set this if the customer is a Public Administration company.,Weka hii ikiwa mteja ni kampuni ya Utawala wa Umma.
apps/erpnext/erpnext/utilities/activation.py,"Leads help you get business, add all your contacts and more as your leads","Inaongoza kukusaidia kupata biashara, ongeza anwani zako zote na zaidi kama inaongoza yako"
DocType: Work Order Operation,Actual Operation Time,Saa halisi ya Uendeshaji
DocType: Authorization Rule,Applicable To (User),Inafaa kwa (Mtumiaji)
DocType: Purchase Taxes and Charges,Deduct,Deduct
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Job Description,Maelezo ya Kazi
DocType: Student Applicant,Applied,Imewekwa
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Details of Outward Supplies and inward supplies liable to reverse charge,Maelezo ya Ugavi wa nje na vifaa vya ndani vina jukumu la kubadili malipo
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Re-open,Fungua tena
DocType: Sales Invoice Item,Qty as per Stock UOM,Uchina kama kwa hisa ya UOM
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Name,Jina la Guardian2
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Root Company,Kampuni ya Mizizi
DocType: Attendance,Attendance Request,Ombi la Kuhudhuria
DocType: Purchase Invoice,02-Post Sale Discount,02-Chapisha Kuuza Discount
DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Weka Orodha ya Kampeni za Mauzo. Weka wimbo wa Waongoza, Nukuu, Mauzo ya Mauzo nk kutoka Kampeni ili kupima Kurudi kwenye Uwekezaji."
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,You can't redeem Loyalty Points having more value than the Grand Total.,Huwezi kukomboa Pointi ya Uaminifu yenye thamani zaidi kuliko Jumla ya Jumla.
DocType: Department Approver,Approver,Msaidizi
apps/erpnext/erpnext/selling/report/pending_so_items_for_purchase_request/pending_so_items_for_purchase_request.py,SO Qty,Uchina huo
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field To Shareholder cannot be blank,Shamba Kwa Mshirika hauwezi kuwa tupu
DocType: Guardian,Work Address,Anwani ya Kazi
DocType: Appraisal,Calculate Total Score,Pata jumla ya alama
DocType: Employee,Health Insurance,Bima ya Afya
DocType: Asset Repair,Manufacturing Manager,Meneja wa Uzalishaji
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} is under warranty upto {1},Serial Hapana {0} ni chini ya udhamini upto {1}
DocType: Plant Analysis Criteria,Minimum Permissible Value,Thamani ya chini ya idhini
apps/erpnext/erpnext/education/doctype/guardian/guardian.py,User {0} already exists,Mtumiaji {0} tayari yupo
apps/erpnext/erpnext/hooks.py,Shipments,Upelekaji
DocType: Payment Entry,Total Allocated Amount (Company Currency),Kiasi kilichopangwa (Kampuni ya Fedha)
DocType: Purchase Order Item,To be delivered to customer,Ili kupelekwa kwa wateja
DocType: BOM,Scrap Material Cost,Gharama za Nyenzo za Nyenzo
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to any Warehouse,Serial Hakuna {0} sio Ghala lolote
DocType: Grant Application,Email Notification Sent,Arifa ya barua pepe imetumwa
DocType: Purchase Invoice,In Words (Company Currency),Katika Maneno (Fedha la Kampuni)
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.py,Company is manadatory for company account,Kampuni ni manadatory kwa akaunti ya kampuni
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,"Item Code, warehouse, quantity are required on row","Msimbo wa kipengee, ghala, wingi unahitajika kwenye mstari"
DocType: Bank Guarantee,Supplier,Mtoa huduma
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,Get From,Pata Kutoka
apps/erpnext/erpnext/hr/doctype/department/department.js,This is a root department and cannot be edited.,Hii ni idara ya mizizi na haiwezi kuhaririwa.
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js,Show Payment Details,Onyesha Maelezo ya Malipo
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,Duration in Days,Muda katika Siku
DocType: C-Form,Quarter,Quarter
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Miscellaneous Expenses,Malipo tofauti
DocType: Global Defaults,Default Company,Kampuni ya Kichwa
DocType: Company,Transactions Annual History,Historia ya Historia ya Shughuli
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Bank account '{0}' has been synchronized,Akaunti ya benki &#39;{0}&#39; imesawazishwa
apps/erpnext/erpnext/controllers/stock_controller.py,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Akaunti au Tofauti akaunti ni lazima kwa Item {0} kama inathiri thamani ya jumla ya hisa
DocType: Bank,Bank Name,Jina la Benki
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Leave the field empty to make purchase orders for all suppliers,Acha shamba bila tupu ili uamuru amri za ununuzi kwa wauzaji wote
DocType: Healthcare Practitioner,Inpatient Visit Charge Item,Kichwa cha Msajili wa Ziara ya Wagonjwa
DocType: Vital Signs,Fluid,Fluid
DocType: Leave Application,Total Leave Days,Siku zote za kuondoka
DocType: Email Digest,Note: Email will not be sent to disabled users,Kumbuka: Barua pepe haitatumwa kwa watumiaji walemavu
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Number of Interaction,Idadi ya Mahusiano
DocType: GSTR 3B Report,February,Februari
apps/erpnext/erpnext/stock/doctype/item/item.js,Item Variant Settings,Mipangilio ya Mchapishaji ya Bidhaa
apps/erpnext/erpnext/public/js/account_tree_grid.js,Select Company...,Chagua Kampuni ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,{0} is mandatory for Item {1},{0} ni lazima kwa Bidhaa {1}
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Item {0}: {1} qty produced, ","Bidhaa {0}: {1} qty zinazozalishwa,"
DocType: Payroll Entry,Fortnightly,Usiku wa jioni
DocType: Currency Exchange,From Currency,Kutoka kwa Fedha
DocType: Vital Signs,Weight (In Kilogram),Uzito (Kilogramu)
DocType: Chapter,"chapters/chapter_name
leave blank automatically set after saving chapter.",sura / sura_nameacha kuondoka tupu bila malipo baada ya kuhifadhi sura.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Please set GST Accounts in GST Settings,Tafadhali weka Akaunti za GST katika Mipangilio ya GST
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Type of Business,Aina ya Biashara
DocType: Sales Invoice,Consumer,Mtumiaji
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Tafadhali chagua Kiwango kilichopakiwa, Aina ya Invoice na Nambari ya Invoice katika safu moja"
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of New Purchase,Gharama ya Ununuzi Mpya
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Sales Order required for Item {0},Utaratibu wa Mauzo unahitajika kwa Bidhaa {0}
DocType: Grant Application,Grant Description,Maelezo ya Ruzuku
DocType: Purchase Invoice Item,Rate (Company Currency),Kiwango (Fedha la Kampuni)
DocType: Student Guardian,Others,Wengine
DocType: Subscription,Discounts,Punguzo
DocType: Bank Transaction,Unallocated Amount,Kiasi kilichowekwa
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,Tafadhali itawezesha Kuhitajika kwenye Utaratibu wa Ununuzi na unaofaa kwenye gharama halisi ya kusajili
apps/erpnext/erpnext/templates/includes/product_page.js,Cannot find a matching Item. Please select some other value for {0}.,Haiwezi kupata kitu kinachofanana. Tafadhali chagua thamani nyingine ya {0}.
DocType: POS Profile,Taxes and Charges,Kodi na Malipo
DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Bidhaa au Huduma inayotunuliwa, kuuzwa au kuhifadhiwa katika hisa."
apps/erpnext/erpnext/hr/page/team_updates/team_updates.js,No more updates,Hakuna updates tena
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Haiwezi kuchagua aina ya malipo kama &#39;Juu ya Mda mrefu wa Mshahara&#39; au &#39;Kwenye Mstari Uliopita&#39; kwa mstari wa kwanza
DocType: Purchase Order,PUR-ORD-.YYYY.-,PUR-ORD -YYYY.-
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py,This covers all scorecards tied to this Setup,Hii inashughulikia alama zote za alama zilizowekwa kwenye Setup hii
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py,Child Item should not be a Product Bundle. Please remove item `{0}` and save,Item ya Watoto haipaswi kuwa Bundle ya Bidhaa. Tafadhali ondoa kitu `{0}` na uhifadhi
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Banking,Banking
apps/erpnext/erpnext/utilities/activation.py,Add Timesheets,Ongeza Nyakati za Nyakati
DocType: Vehicle Service,Service Item,Kitu cha Huduma
DocType: Bank Guarantee,Bank Guarantee,Dhamana ya Benki
DocType: Payment Request,Transaction Details,Maelezo ya Shughuli
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule' to get schedule,Tafadhali bonyeza &#39;Generate Schedule&#39; ili kupata ratiba
DocType: Item,"Purchase, Replenishment Details","Ununuzi, Maelezo ya kumaliza tena"
DocType: Products Settings,Enable Field Filters,Washa vichungi vya Shamba
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot be Purchase Item also",&quot;Bidhaa Iliyopewa na Wateja&quot; haiwezi kuwa Bidhaa ya Ununuzi pia
DocType: Blanket Order Item,Ordered Quantity,Amri ya Amri
apps/erpnext/erpnext/public/js/setup_wizard.js,"e.g. ""Build tools for builders""",km &quot;Kujenga zana kwa wajenzi&quot;
DocType: Grading Scale,Grading Scale Intervals,Kuweka vipindi vya Scale
apps/erpnext/erpnext/regional/india/utils.py,Invalid {0}! The check digit validation has failed. ,Batili {0}! Uthibitisho wa nambari ya kuangalia umeshindwa.
DocType: Item Default,Purchase Defaults,Ununuzi wa Dharura
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again","Haikuweza kuunda Kipaji cha Mikopo kwa moja kwa moja, tafadhali usifute &#39;Ishara ya Mikopo ya Ishara&#39; na uwasilishe tena"
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Added to Featured Items,Imeongezwa kwa Vitu Vilionyangaziwa
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py,Profit for the year,Faida kwa mwaka
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Kuingia kwa Akaunti ya {2} inaweza tu kufanywa kwa fedha: {3}
DocType: Fee Schedule,In Process,Katika Mchakato
DocType: Authorization Rule,Itemwise Discount,Kutoa Pesa
apps/erpnext/erpnext/config/accounting.py,Tree of financial accounts.,Mti wa akaunti za kifedha.
DocType: Cash Flow Mapping,Cash Flow Mapping,Mapato ya Mapato ya Fedha
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Sales Order {1},{0} dhidi ya Uagizaji wa Mauzo {1}
DocType: Account,Fixed Asset,Mali isiyohamishika
DocType: Amazon MWS Settings,After Date,Baada ya Tarehe
apps/erpnext/erpnext/config/help.py,Serialized Inventory,Mali isiyohamishika
,Department Analytics,Idara ya Uchambuzi
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Email not found in default contact,Barua pepe haipatikani kwa kuwasiliana na wakati wote
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,Generate Secret,Kuzalisha siri
DocType: Question,Question,Swali
DocType: Loan,Account Info,Maelezo ya Akaunti
DocType: Activity Type,Default Billing Rate,Kiwango cha kulipa chaguo-msingi
DocType: Fees,Include Payment,Jumuisha Malipo
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,{0} Student Groups created.,{0} Vikundi vya Wanafunzi viliundwa.
DocType: Sales Invoice,Total Billing Amount,Kiwango cha Jumla cha kulipia
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py,Program in the Fee Structure and Student Group {0} are different.,Mpango katika muundo wa ada na kikundi cha wanafunzi {0} ni tofauti.
DocType: Bank Statement Transaction Entry,Receivable Account,Akaunti ya Kupokea
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,Valid From Date must be lesser than Valid Upto Date.,Tarehe Kutoka Tarehe lazima iwe ndogo zaidi kuliko Tarehe ya Halali ya Upto.
DocType: Employee Skill,Evaluation Date,Tarehe ya Tathmini
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} is already {2},Row # {0}: Malipo {1} tayari {2}
DocType: Quotation Item,Stock Balance,Mizani ya hisa
apps/erpnext/erpnext/config/help.py,Sales Order to Payment,Mauzo ya Malipo ya Malipo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,CEO,Mkurugenzi Mtendaji
DocType: Purchase Invoice,With Payment of Tax,Kwa Malipo ya Kodi
DocType: Expense Claim Detail,Expense Claim Detail,Tumia maelezo ya dai
apps/erpnext/erpnext/education/utils.py,You are not allowed to enroll for this course,Hairuhusiwi kujiandikisha kwa kozi hii
DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,FINDA KWA MFASHAJI
DocType: Exchange Rate Revaluation Account,New Balance In Base Currency,Mizani mpya katika Fedha ya Msingi
DocType: Location,Is Container,"Je, kuna Chombo"
DocType: Crop Cycle,This will be day 1 of the crop cycle,Hii itakuwa siku 1 ya mzunguko wa mazao
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please select correct account,Tafadhali chagua akaunti sahihi
DocType: Salary Structure Assignment,Salary Structure Assignment,Mgawo wa Mfumo wa Mshahara
DocType: Purchase Invoice Item,Weight UOM,Uzito UOM
apps/erpnext/erpnext/config/accounting.py,List of available Shareholders with folio numbers,Orodha ya Washiriki waliopatikana na namba za folio
DocType: Salary Structure Employee,Salary Structure Employee,Mshirika wa Mshahara
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Show Variant Attributes,Onyesha sifa za Tofauti
DocType: Student,Blood Group,Kikundi cha Damu
DocType: Purchase Invoice Item,Page Break,Uvunjaji wa Ukurasa
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,The payment gateway account in plan {0} is different from the payment gateway account in this payment request,Akaunti ya mlango wa malipo katika mpango {0} ni tofauti na akaunti ya mlango wa malipo katika ombi hili la malipo
DocType: Course,Course Name,Jina la kozi
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py,No Tax Withholding data found for the current Fiscal Year.,Hakuna data ya Kuzuia Ushuru iliyopatikana kwa Mwaka wa Fedha wa sasa.
DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,Watumiaji ambao wanaweza kupitisha maombi ya kuondoka kwa mfanyakazi maalum
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Equipments,Vifaa vya ofisi
DocType: Pricing Rule,Qty,Uchina
DocType: Fiscal Year,Companies,Makampuni
DocType: Supplier Scorecard,Scoring Setup,Kuweka Kuweka
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Electronics,Electoniki
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Debit ({0}),Debit ({0})
DocType: BOM,Allow Same Item Multiple Times,Ruhusu Item Sawa Mara nyingi
DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Ongeza Ombi la Nyenzo wakati hisa inakaribia ngazi ya kurejesha tena
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Full-time,Wakati wote
DocType: Payroll Entry,Employees,Wafanyakazi
DocType: Question,Single Correct Answer,Jibu Moja Sahihi
DocType: C-Form,Received Date,Tarehe iliyopokea
DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Ikiwa umeunda template ya kiwango katika Kigezo cha Mauzo na Chaguzi, chagua moja na bofya kwenye kitufe kilicho chini."
DocType: BOM Scrap Item,Basic Amount (Company Currency),Kiasi cha Msingi (Fedha la Kampuni)
DocType: Student,Guardians,Walinzi
apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html,Payment Confirmation,Uthibitishaji wa Malipo
apps/erpnext/erpnext/regional/india/utils.py,Unsupported GST Category for e-Way Bill JSON generation,Jamii ya GST isiyosaidiwa kwa kizazi cha E-Way Bill JSON
DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,Bei haitaonyeshwa kama Orodha ya Bei haijawekwa
DocType: Material Request Item,Received Quantity,Idadi iliyopokea
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,To Date must be greater than From Date,Hadi Tarehe lazima iwe kubwa kuliko Tarehe
DocType: Stock Entry,Total Incoming Value,Thamani ya Ingizo Yote
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To is required,Debit To inahitajika
DocType: Clinical Procedure,Inpatient Record,Rekodi ya wagonjwa
apps/erpnext/erpnext/utilities/activation.py,"Timesheets help keep track of time, cost and billing for activites done by your team","Timesheets kusaidia kuweka wimbo wa muda, gharama na bili kwa activites kufanyika kwa timu yako"
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,Purchase Price List,Orodha ya Bei ya Ununuzi
DocType: Communication Medium Timeslot,Employee Group,Kikundi cha Wafanyakazi
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Date of Transaction,Tarehe ya Shughuli
apps/erpnext/erpnext/config/buying.py,Templates of supplier scorecard variables.,Matukio ya vigezo vya scorecard za wasambazaji.
DocType: Job Offer Term,Offer Term,Muda wa Kutoa
DocType: Asset,Quality Manager,Meneja wa Ubora
DocType: Job Applicant,Job Opening,Kufungua kazi
DocType: Employee,Default Shift,Shift ya Chaguo
DocType: Payment Reconciliation,Payment Reconciliation,Upatanisho wa Malipo
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select Incharge Person's name,Tafadhali chagua jina la Incharge Person
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Technology,Teknolojia
apps/erpnext/erpnext/public/js/utils.js,Total Unpaid: {0},Jumla isiyolipwa: {0}
DocType: BOM Website Operation,BOM Website Operation,Huduma ya tovuti ya BOM
DocType: Bank Statement Transaction Payment Item,outstanding_amount,bora_amount
DocType: Supplier Scorecard,Supplier Score,Score ya Wasambazaji
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js,Schedule Admission,Ratiba ya Kuingia
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Total Payment Request amount cannot be greater than {0} amount,Kiasi cha Ombi la Malipo yote haliwezi kuwa kubwa kuliko kiwango cha {0}
DocType: Tax Withholding Rate,Cumulative Transaction Threshold,Msaada wa Mipango ya Kuongezeka
DocType: Promotional Scheme Price Discount,Discount Type,Aina ya Punguzo
DocType: Purchase Invoice Item,Is Free Item,Ni Bure Bidhaa
DocType: Buying Settings,Percentage you are allowed to transfer more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to transfer 110 units.,Asilimia unaruhusiwa kuhamisha zaidi dhidi ya idadi iliyoamriwa. Kwa mfano: Ikiwa umeamuru vitengo 100. na Idhini yako ni 10% basi unaruhusiwa kuhamisha vitengo 110.
DocType: Supplier,Warn RFQs,Thibitisha RFQs
apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Explore,Futa
DocType: BOM,Conversion Rate,Kiwango cha Kubadilisha
apps/erpnext/erpnext/www/all-products/index.html,Product Search,Utafutaji wa Bidhaa
,Bank Remittance,Marekebisho ya Benki
DocType: Cashier Closing,To Time,Kwa Muda
DocType: Invoice Discounting,Loan End Date,Tarehe ya Mwisho wa Mkopo
apps/erpnext/erpnext/hr/utils.py,) for {0},) kwa {0}
DocType: Authorization Rule,Approving Role (above authorized value),Idhini ya Kupitisha (juu ya thamani iliyoidhinishwa)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Credit To account must be a Payable account,Mikopo Kwa akaunti lazima iwe akaunti ya kulipwa
DocType: Loan,Total Amount Paid,Jumla ya Malipo
DocType: Asset,Insurance End Date,Tarehe ya Mwisho wa Bima
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Please select Student Admission which is mandatory for the paid student applicant,Tafadhali chagua Uingizaji wa Mwanafunzi ambao ni lazima kwa mwombaji aliyepwa msamaha
DocType: Pick List,STO-PICK-.YYYY.-,STO-PICK-.YYYY--
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,Budget List,Orodha ya Bajeti
DocType: Campaign,Campaign Schedules,Ratiba za Kampeni
DocType: Job Card Time Log,Completed Qty,Uliokamilika Uchina
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"For {0}, only debit accounts can be linked against another credit entry","Kwa {0}, akaunti za debit tu zinaweza kuunganishwa dhidi ya kuingizwa kwa mkopo mwingine"
DocType: Manufacturing Settings,Allow Overtime,Ruhusu muda wa ziada
DocType: Training Event Employee,Training Event Employee,Mafunzo ya Tukio la Mfanyakazi
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Sampuli za Upeo - {0} zinaweza kuhifadhiwa kwa Batch {1} na Bidhaa {2}.
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Add Time Slots,Ongeza Muda wa Muda
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} Serial Hesabu inahitajika kwa Bidhaa {1}. Umetoa {2}.
DocType: Stock Reconciliation Item,Current Valuation Rate,Kiwango cha Thamani ya sasa
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Number of root accounts cannot be less than 4,Idadi ya akaunti za mizizi haiwezi kuwa chini ya 4
DocType: Training Event,Advance,Mapema
apps/erpnext/erpnext/config/integrations.py,GoCardless payment gateway settings,Mipangilio ya njia ya malipo ya GoCardless
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Exchange Gain/Loss,Kubadilisha / Kupoteza
DocType: Opportunity,Lost Reason,Sababu iliyopotea
DocType: Amazon MWS Settings,Enable Amazon,Wezesha Amazon
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Account {1} does not belong to company {2},Row # {0}: Akaunti {1} si ya kampuni {2}
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Unable to find DocType {0},Haikuweza kupata DocType {0}
apps/erpnext/erpnext/public/js/templates/address_list.html,New Address,Anwani mpya
DocType: Quality Inspection,Sample Size,Ukubwa wa Mfano
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Please enter Receipt Document,Tafadhali ingiza Hati ya Receipt
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,All items have already been invoiced,Vitu vyote tayari vinatumiwa
apps/erpnext/erpnext/hr/report/employee_leave_balance_summary/employee_leave_balance_summary.py,Leaves Taken,Majani Imechukuliwa
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Please specify a valid 'From Case No.',Tafadhali onyesha halali &#39;Kutoka Halali Nambari&#39;
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,Further cost centers can be made under Groups but entries can be made against non-Groups,Vituo vya gharama zaidi vinaweza kufanywa chini ya Vikundi lakini viingilio vinaweza kufanywa dhidi ya wasio Vikundi
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total allocated leaves are more days than maximum allocation of {0} leave type for employee {1} in the period,Majani yote yaliyotengwa ni siku zaidi kuliko ugawaji wa kiwango cha {0} aina ya kuondoka kwa mfanyakazi {1} katika kipindi
DocType: Branch,Branch,Tawi
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Other outward supplies(Nil rated,Exempted)","Vifaa vingine vya nje (Nilikadiriwa, Imesamehewa)"
DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
DocType: Delivery Trip,Fulfillment User,Utimizaji Mtumiaji
apps/erpnext/erpnext/config/settings.py,Printing and Branding,Uchapishaji na Kubandika
DocType: Company,Total Monthly Sales,Jumla ya Mauzo ya Mwezi
DocType: Course Activity,Enrollment,Uandikishaji
DocType: Payment Request,Subscription Plans,Mipango ya Usajili
DocType: Agriculture Analysis Criteria,Weather,Hali ya hewa
DocType: Bin,Actual Quantity,Kiasi halisi
DocType: Shipping Rule,example: Next Day Shipping,mfano: Utoaji wa siku inayofuata
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} not found,Serial Hapana {0} haipatikani
DocType: Fee Schedule Program,Fee Schedule Program,Mpango wa ratiba ya ada
DocType: Fee Schedule Program,Student Batch,Kundi la Wanafunzi
DocType: Pricing Rule,Advanced Settings,Mipangilio ya hali ya juu
DocType: Supplier Scorecard Scoring Standing,Min Grade,Daraja la Kidogo
DocType: Healthcare Service Unit Type,Healthcare Service Unit Type,Aina ya Huduma ya Huduma ya Afya
DocType: Training Event Employee,Feedback Submitted,Maoni yaliwasilishwa
apps/erpnext/erpnext/projects/doctype/project/project.py,You have been invited to collaborate on the project: {0},Umealikwa kushirikiana kwenye mradi: {0}
DocType: Supplier Group,Parent Supplier Group,Kundi la Wauzaji wa Mzazi
DocType: Email Digest,Purchase Orders to Bill,Amri ya Ununuzi kwa Bill
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,Accumulated Values in Group Company,Maadili yaliyokusanywa katika Kundi la Kampuni
DocType: Leave Block List Date,Block Date,Weka Tarehe
DocType: Item,You can use any valid Bootstrap 4 markup in this field. It will be shown on your Item Page.,Unaweza kutumia alama yoyote halali ya Bootstrap 4 kwenye uwanja huu. Itaonyeshwa kwenye Ukurasa wako wa Bidhaa.
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Outward taxable supplies(other than zero rated, nil rated and exempted","Vifaa vya ushuru vya nje (zaidi ya sifuri zilizokadiriwa, havikadiriwa na kutolewa msamaha)"
DocType: Crop,Crop,Mazao
DocType: Purchase Receipt,Supplier Delivery Note,Kumbuka Utoaji wa Wasambazaji
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,Apply Now,Tumia Sasa
DocType: Employee Tax Exemption Proof Submission Detail,Type of Proof,Aina ya Uthibitisho
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html,Actual Qty {0} / Waiting Qty {1},Uhakika halisi {0} / Kiwango cha kusubiri {1}
DocType: Purchase Invoice,E-commerce GSTIN,E-commerce GSTIN
DocType: Sales Order,Not Delivered,Haikutolewa
,Bank Clearance Summary,Muhtasari wa Muhtasari wa Benki
apps/erpnext/erpnext/config/settings.py,"Create and manage daily, weekly and monthly email digests.","Unda na udhibiti majaribio ya barua pepe kila siku, kila wiki na kila mwezi."
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_dashboard.py,This is based on transactions against this Sales Person. See timeline below for details,Hii inategemea shughuli za Mtu wa Mauzo. Tazama kalenda ya chini kwa maelezo zaidi
DocType: Appraisal Goal,Appraisal Goal,Lengo la Kutathmini
DocType: Stock Reconciliation Item,Current Amount,Kiwango cha sasa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Buildings,Majengo
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,Leaves has been granted sucessfully,Majani imetolewa kwa ufanisi
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_transaction_row.html,New Invoice,Ankara mpya
DocType: Products Settings,Enable Attribute Filters,Washa vichungi vya Sifa
DocType: Fee Schedule,Fee Structure,Mfumo wa Mali
DocType: Timesheet Detail,Costing Amount,Kiwango cha gharama
DocType: Student Admission Program,Application Fee,Malipo ya Maombi
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Tuma Slip ya Mshahara
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Inashikilia
apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Qustion lazima iwe na chaguzi angalau moja sahihi
DocType: Account,Inter Company Account,Akaunti ya Kampuni ya Inter
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Ingiza katika Bonde
DocType: Sales Partner,Address & Contacts,Anwani na Mawasiliano
DocType: SMS Log,Sender Name,Jina la Sender
DocType: Vital Signs,Very Hyper,Hyper sana
DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Vigezo vya Uchambuzi wa Kilimo
DocType: HR Settings,Leave Approval Notification Template,Acha Kigezo cha Arifa Idhini
DocType: POS Profile,[Select],[Chagua]
DocType: Staffing Plan Detail,Number Of Positions,Idadi ya Vyeo
DocType: Vital Signs,Blood Pressure (diastolic),Shinikizo la damu (diastoli)
DocType: SMS Log,Sent To,Imepelekwa
DocType: Agriculture Task,Holiday Management,Usimamizi wa Likizo
DocType: Payment Request,Make Sales Invoice,Fanya ankara ya Mauzo
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Softwares,Softwares
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Next Contact Date cannot be in the past,Tarehe ya Kuwasiliana inayofuata haiwezi kuwa katika siku za nyuma
DocType: Company,For Reference Only.,Kwa Kumbukumbu Tu.
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select Batch No,Chagua Batch No
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Invalid {0}: {1},Halafu {0}: {1}
,GSTR-1,GSTR-1
DocType: Fee Validity,Reference Inv,Mwaliko wa Kumbukumbu
DocType: Sales Invoice Advance,Advance Amount,Kiwango cha awali
DocType: Manufacturing Settings,Capacity Planning,Mipango ya Uwezo
DocType: Supplier Quotation,Rounding Adjustment (Company Currency,Marekebisho ya Upangaji (Kampuni ya Fedha
DocType: Asset,Policy number,Nambari ya sera
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,'From Date' is required,&#39;Tarehe Tarehe&#39; inahitajika
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Assign to Employees,Wape Waajiriwa
DocType: Bank Transaction,Reference Number,Nambari ya Kumbukumbu
DocType: Employee,New Workplace,Sehemu Mpya ya Kazi
DocType: Retention Bonus,Retention Bonus,Bonus ya kuhifadhiwa
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Material Consumption,Matumizi ya Nyenzo
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js,Set as Closed,Weka kama Imefungwa
apps/erpnext/erpnext/stock/get_item_details.py,No Item with Barcode {0},Hakuna kitu na Barcode {0}
DocType: Normal Test Items,Require Result Value,Thamani ya Thamani ya Uhitaji
DocType: Purchase Invoice,Pricing Rules,Sheria za Bei
DocType: Item,Show a slideshow at the top of the page,Onyesha slideshow juu ya ukurasa
DocType: Tax Withholding Rate,Tax Withholding Rate,Kiwango cha Kuzuia Ushuru
DocType: Pricing Rule,Max Amt,Max Amt
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Boms,Boms
apps/erpnext/erpnext/stock/doctype/item/item.py,Stores,Maduka
DocType: Project Type,Projects Manager,Meneja wa Miradi
DocType: Serial No,Delivery Time,Muda wa Utoaji
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Based On,Kuzeeka kwa Msingi
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Appointment cancelled,Uteuzi umefutwa
DocType: Item,End of Life,Mwisho wa Uzima
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Travel,Safari
DocType: Student Report Generation Tool,Include All Assessment Group,Jumuisha Kundi Jaribio Lote
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,No active or default Salary Structure found for employee {0} for the given dates,Hakuna muundo wa Mshahara wa Mshahara au wa Mteja uliopatikana kwa mfanyakazi {0} kwa tarehe zilizopewa
DocType: Leave Block List,Allow Users,Ruhusu Watumiaji
DocType: Purchase Order,Customer Mobile No,Nambari ya Simu ya Wateja
DocType: Leave Type,Calculated in days,Imehesabiwa kwa siku
DocType: Call Log,Received By,Imepokelewa na
DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Maelezo ya Kigezo cha Mapangilio ya Fedha
apps/erpnext/erpnext/config/non_profit.py,Loan Management,Usimamizi wa Mikopo
DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Fuatilia Mapato na gharama tofauti kwa vipimo vya bidhaa au mgawanyiko.
DocType: Rename Tool,Rename Tool,Badilisha jina
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Update Cost,Sasisha Gharama
DocType: Item Reorder,Item Reorder,Kipengee Upya
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,GSTR3B-Form,GSTR3B-Fomu
DocType: Sales Invoice,Mode of Transport,Njia ya Usafiri
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Show Salary Slip,Onyesha Slip ya Mshahara
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Transfer Material,Nyenzo za Uhamisho
DocType: Fees,Send Payment Request,Tuma Ombi la Malipo
DocType: Travel Request,Any other details,Maelezo mengine yoyote
DocType: Water Analysis,Origin,Mwanzo
apps/erpnext/erpnext/controllers/status_updater.py,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Hati hii imepungua kwa {0} {1} kwa kipengee {4}. Je! Unafanya mwingine {3} dhidi ya sawa {2}?
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please set recurring after saving,Tafadhali kuweka mara kwa mara baada ya kuokoa
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Select change amount account,Chagua akaunti ya kubadilisha kiasi
DocType: Purchase Invoice,Price List Currency,Orodha ya Bei ya Fedha
DocType: Naming Series,User must always select,Mtumiaji lazima ague daima
DocType: Stock Settings,Allow Negative Stock,Ruhusu Stock mbaya
DocType: Installation Note,Installation Note,Maelezo ya Ufungaji
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.js,Show Warehouse-wise Stock,Onyesha Hifadhi ya busara ya Ghala
DocType: Soil Texture,Clay,Clay
DocType: Course Topic,Topic,Mada
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Financing,Mtoko wa Fedha kutoka Fedha
DocType: Budget Account,Budget Account,Akaunti ya Bajeti
DocType: Quality Inspection,Verified By,Imehakikishwa na
DocType: Travel Request,Name of Organizer,Jina la Mhariri
apps/erpnext/erpnext/setup/doctype/company/company.py,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Haiwezi kubadilisha sarafu ya msingi ya kampuni, kwa sababu kuna shughuli zilizopo. Shughuli zinapaswa kufutwa ili kubadilisha sarafu ya default."
DocType: Cash Flow Mapping,Is Income Tax Liability,"Je, ni kodi ya kodi?"
DocType: Grading Scale Interval,Grade Description,Maelezo ya Daraja
DocType: Clinical Procedure,Is Invoiced,Inauzwa
apps/erpnext/erpnext/setup/doctype/company/company.js,Create Tax Template,Unda Kiolezo cha Ushuru
DocType: Stock Entry,Purchase Receipt No,Ununuzi wa Receipt No
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Earnest Money,Fedha za Kulipwa
DocType: Sales Invoice, Shipping Bill Number,Nambari ya Bili ya Utoaji
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Create Salary Slip,Unda Slip ya Mshahara
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Traceability,Ufuatiliaji
DocType: Asset Maintenance Log,Actions performed,Vitendo vilifanyika
DocType: Cash Flow Mapper,Section Leader,Kiongozi wa sehemu
DocType: Sales Invoice,Transport Receipt No,Rejeipt ya Usafiri
DocType: Quiz Activity,Pass,Pita
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Please add the account to root level Company - ,Tafadhali ongeza akaunti kwa Kampuni ya kiwango -
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Source of Funds (Liabilities),Chanzo cha Mfuko (Madeni)
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Source and Target Location cannot be same,Eneo la Chanzo na Target haliwezi kuwa sawa
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Wingi katika mstari {0} ({1}) lazima iwe sawa na wingi wa viwandani {2}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Difference Account must be a Asset/Liability type account, since this Stock Entry is an Opening Entry","Akaunti ya Tofauti lazima iwe akaunti ya Aina ya Mali / Dhima, kwa kuwa Kiingilio hiki cha Hisa ni Ufunguo wa Ufunguzi"
DocType: Supplier Scorecard Scoring Standing,Employee,Mfanyakazi
DocType: Bank Guarantee,Fixed Deposit Number,Nambari ya Amana zisizohamishika
DocType: Asset Repair,Failure Date,Tarehe ya Kushindwa
DocType: Support Search Source,Result Title Field,Kichwa cha Kichwa cha Kichwa
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Summary,Muhtasari wa simu
DocType: Sample Collection,Collected Time,Wakati uliokusanywa
DocType: Employee Skill Map,Employee Skills,Ujuzi wa Mfanyikazi
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,Fuel Expense,Gharama ya Mafuta
DocType: Company,Sales Monthly History,Historia ya Mwezi ya Mauzo
apps/erpnext/erpnext/regional/italy/utils.py,Please set at least one row in the Taxes and Charges Table,Tafadhali weka angalau safu moja katika Jedwali la Ushuru na ada
DocType: Asset Maintenance Task,Next Due Date,Tarehe ya Kuondolewa Inayofuata
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Batch,Chagua Batch
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is fully billed,{0} {1} imekamilika kikamilifu
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Vital Signs,Vital Ishara
DocType: Payment Entry,Payment Deductions or Loss,Upunguzaji wa Malipo au Kupoteza
DocType: Soil Analysis,Soil Analysis Criterias,Siri za Uchambuzi wa Udongo
apps/erpnext/erpnext/config/settings.py,Standard contract terms for Sales or Purchase.,Kanuni za mkataba wa Standard kwa Mauzo au Ununuzi.
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Rows Removed in {0},Safu zimeondolewa katika {0}
DocType: Shift Type,Begin check-in before shift start time (in minutes),Anza kuingia kabla ya kuanza saa (saa.)
DocType: BOM Item,Item operation,Item operesheni
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Voucher,Jumuisha kwa Voucher
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Are you sure you want to cancel this appointment?,Una uhakika unataka kufuta miadi hii?
DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,Pakiti ya bei ya chumba cha Hoteli
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Sales Pipeline,Bomba la Mauzo
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Please set default account in Salary Component {0},Tafadhali weka akaunti ya msingi katika Kipengele cha Mshahara {0}
apps/erpnext/erpnext/templates/form_grid/material_request_grid.html,Required On,Inahitajika
DocType: Rename Tool,File to Rename,Funga Kurejesha tena
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please select BOM for Item in Row {0},Tafadhali chagua BOM kwa Bidhaa katika Row {0}
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Fetch Subscription Updates,Pata Updates za Usajili
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py,Account {0} does not match with Company {1} in Mode of Account: {2},Akaunti {0} hailingani na Kampuni {1} katika Mode ya Akaunti: {2}
apps/erpnext/erpnext/controllers/buying_controller.py,Specified BOM {0} does not exist for Item {1},BOM iliyojulikana {0} haipo kwa Bidhaa {1}
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Course: ,Kozi:
DocType: Soil Texture,Sandy Loam,Sandy Loam
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Ratiba ya Matengenezo {0} lazima iondoliwe kabla ya kufuta Sheria hii ya Mauzo
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py,Student LMS Activity,Shughuli ya Wanafunzi wa LMS
DocType: POS Profile,Applicable for Users,Inatumika kwa Watumiaji
DocType: Supplier Quotation,PUR-SQTN-.YYYY.-,PUR-SQTN -YYYY.-
apps/erpnext/erpnext/projects/doctype/project/project.js,Set Project and all Tasks to status {0}?,Weka Mradi na Kazi zote kwa hadhi {0}?
DocType: Purchase Invoice,Set Advances and Allocate (FIFO),Weka Maendeleo na Ugawa (FIFO)
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,No Work Orders created,Hakuna Amri za Kazi zilizoundwa
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Slip of employee {0} already created for this period,Kulipwa kwa mshahara wa mfanyakazi {0} tayari kuundwa kwa kipindi hiki
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Pharmaceutical,Madawa
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,You can only submit Leave Encashment for a valid encashment amount,Unaweza tu kuwasilisha Uingizaji wa Fedha kwa kiasi cha uingizaji wa halali
apps/erpnext/erpnext/public/js/hub/pages/SellerItems.vue,Items by ,Vitu na
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Purchased Items,Gharama ya Vitu Vilivyotunzwa
DocType: Employee Separation,Employee Separation Template,Kigezo cha Utunzaji wa Waajiriwa
DocType: Selling Settings,Sales Order Required,Amri ya Mauzo Inahitajika
apps/erpnext/erpnext/public/js/hub/marketplace.js,Become a Seller,Kuwa Muzaji
,Procurement Tracker,Ununuzi wa Tracker
DocType: Purchase Invoice,Credit To,Mikopo Kwa
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Reversed,ITC Imebadilishwa
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid authentication error,Makosa ya uthibitisho wa pesa
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Active Leads / Customers,Msaidizi wa Active / Wateja
DocType: Delivery Settings,Leave blank to use the standard Delivery Note format,Acha tupu ili utumie muundo wa Kumbuka utoaji wa kawaida
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Fiscal Year End Date should be one year after Fiscal Year Start Date,Tarehe ya Kumalizia Mwaka wa Fedha inapaswa kuwa mwaka mmoja baada ya Tarehe ya Kuanza ya Mwaka wa Fedha
DocType: Employee Education,Post Graduate,Chapisha Chuo
DocType: Quality Meeting,Agenda,Ajenda
DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Ratiba ya Matengenezo ya Daraja
DocType: Supplier Scorecard,Warn for new Purchase Orders,Tahadhari kwa Amri mpya ya Ununuzi
DocType: Quality Inspection Reading,Reading 9,Kusoma 9
apps/erpnext/erpnext/config/integrations.py,Connect your Exotel Account to ERPNext and track call logs,Unganisha Akaunti yako ya Exotel kwa ERPNext na ufuatilia magogo ya simu
DocType: Supplier,Is Frozen,Ni Frozen
DocType: Tally Migration,Processed Files,Faili zilizosindika
apps/erpnext/erpnext/stock/utils.py,Group node warehouse is not allowed to select for transactions,Ghala la node ya kikundi hairuhusiwi kuchagua kwa shughuli
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Accounting Dimension <b>{0}</b> is required for 'Balance Sheet' account {1}.,Vipimo vya Uhasibu <b>{0}</b> inahitajika kwa akaunti ya &#39;Mizani ya Karatasi&#39; {1}.
DocType: Buying Settings,Buying Settings,Mipangilio ya kununua
DocType: Stock Entry Detail,BOM No. for a Finished Good Item,BOM No kwa Nakala Iliyopangwa Nzuri
DocType: Upload Attendance,Attendance To Date,Kuhudhuria Tarehe
DocType: Request for Quotation Supplier,No Quote,Hakuna Nukuu
DocType: Support Search Source,Post Title Key,Kitufe cha Kichwa cha Chapisho
DocType: Issue,Issue Split From,Suala Gawanya Kutoka
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Job Card,Kwa Kadi ya Kazi
DocType: Warranty Claim,Raised By,Iliyotolewa na
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Prescriptions,Maagizo
DocType: Payment Gateway Account,Payment Account,Akaunti ya Malipo
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Please specify Company to proceed,Tafadhali taja Kampuni ili kuendelea
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Accounts Receivable,Mabadiliko ya Nambari katika Akaunti ya Kukubalika
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Compensatory Off,Off Compensation
DocType: Job Applicant,Accepted,Imekubaliwa
DocType: POS Closing Voucher,Sales Invoices Summary,Muhtasari wa Mauzo ya Mauzo
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Party Name,Kwa Jina la Chama
DocType: Grant Application,Organization,Shirika
DocType: BOM Update Tool,BOM Update Tool,Chombo cha Mwisho cha BOM
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Party,Kikundi na Chama
DocType: SG Creation Tool Course,Student Group Name,Jina la Kikundi cha Wanafunzi
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js,Show exploded view,Onyesha maoni yaliyopuka
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Creating Fees,Kujenga ada
apps/erpnext/erpnext/setup/doctype/company/company.js,Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,Tafadhali hakikisha unataka kufuta shughuli zote za kampuni hii. Data yako bwana itabaki kama ilivyo. Hatua hii haiwezi kufutwa.
apps/erpnext/erpnext/templates/pages/product_search.html,Search Results,Matokeo ya Utafutaji
DocType: Homepage Section,Number of Columns,Idadi ya safuwima
DocType: Room,Room Number,Idadi ya Chumba
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Price not found for item {0} in price list {1},Bei haipatikani kwa bidhaa {0} kwenye orodha ya bei {1}
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Requestor,Mwombaji
apps/erpnext/erpnext/utilities/transaction_base.py,Invalid reference {0} {1},Kumbukumbu batili {0} {1}
apps/erpnext/erpnext/config/buying.py,Rules for applying different promotional schemes.,Sheria za kutumia miradi tofauti ya uendelezaji.
DocType: Shipping Rule,Shipping Rule Label,Lebo ya Rule ya Utoaji
DocType: Journal Entry Account,Payroll Entry,Kuingia kwa Mishahara
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,View Fees Records,Angalia Kumbukumbu za Malipo
apps/erpnext/erpnext/public/js/conf.js,User Forum,Forum Forum
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Raw Materials cannot be blank.,Malighafi haziwezi kuwa tupu.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row #{0} (Payment Table): Amount must be negative,Row # {0} (Jedwali la Malipo): Kiasi lazima iwe hasi
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,"Could not update stock, invoice contains drop shipping item.","Haikuweza kusasisha hisa, ankara ina bidhaa ya kusafirisha kushuka."
DocType: Contract,Fulfilment Status,Hali ya Utekelezaji
DocType: Lab Test Sample,Lab Test Sample,Mfano wa Mtihani wa Lab
DocType: Item Variant Settings,Allow Rename Attribute Value,Ruhusu Unda Thamani ya Thamani
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Quick Journal Entry,Quick Journal Entry
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Amount,Kiasi cha malipo ya Baadaye
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,You can not change rate if BOM mentioned agianst any item,Huwezi kubadili kiwango kama BOM imetajwa agianst kitu chochote
DocType: Restaurant,Invoice Series Prefix,Msaada wa Mfululizo wa Invoice
DocType: Employee,Previous Work Experience,Uzoefu wa Kazi uliopita
apps/erpnext/erpnext/accounts/doctype/account/account.js,Update Account Number / Name,Sasisha Nambari ya Akaunti / Jina
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Assign Salary Structure,Shirikisha Mfumo wa Mshahara
DocType: Support Settings,Response Key List,Orodha ya Muhimu ya Jibu
DocType: Job Card,For Quantity,Kwa Wingi
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Planned Qty for Item {0} at row {1},Tafadhali ingiza Kiini kilichopangwa kwa Bidhaa {0} kwenye safu {1}
DocType: Support Search Source,API,API
DocType: Support Search Source,Result Preview Field,Msimbo wa Mtazamo wa Matokeo
DocType: Item Price,Packing Unit,Kitengo cha Ufungashaji
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} haijawasilishwa
DocType: Subscription,Trialling,Inakuja
DocType: Sales Invoice Item,Deferred Revenue,Mapato yaliyotengwa
DocType: Bank Account,GL Account,Akaunti ya GL
DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Akaunti ya Fedha itatumika kwa uundaji wa ankara za Mauzo
DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Kutoa Kundi Kundi
DocType: Member,Membership Expiry Date,Tarehe ya Kumalizika kwa Uanachama
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,{0} must be negative in return document,{0} lazima iwe hasi katika hati ya kurudi
DocType: Employee Tax Exemption Proof Submission,Submission Date,Tarehe ya Uwasilishaji
,Minutes to First Response for Issues,Dakika kwa Maswali ya kwanza ya Masuala
DocType: Purchase Invoice,Terms and Conditions1,Masharti na Masharti1
apps/erpnext/erpnext/public/js/setup_wizard.js,The name of the institute for which you are setting up this system.,Jina la taasisi ambayo unaanzisha mfumo huu.
DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Uingizaji wa uhasibu umehifadhiwa hadi tarehe hii, hakuna mtu anaweza kufanya / kurekebisha kuingia isipokuwa jukumu lililoelezwa hapo chini."
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js,Latest price updated in all BOMs,Bei ya hivi karibuni imesasishwa katika BOM zote
DocType: Project User,Project Status,Hali ya Mradi
DocType: UOM,Check this to disallow fractions. (for Nos),Angalia hii ili kupinga marufuku. (kwa Nos)
DocType: Student Admission Program,Naming Series (for Student Applicant),Mfululizo wa majina (kwa Msaidizi wa Mwanafunzi)
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py,Bonus Payment Date cannot be a past date,Tarehe ya Malipo ya Bonus haiwezi kuwa tarehe iliyopita
DocType: Travel Request,Copy of Invitation/Announcement,Nakala ya Mwaliko / Matangazo
DocType: Practitioner Service Unit Schedule,Practitioner Service Unit Schedule,Ratiba ya Kitengo cha Utumishi
DocType: Sales Invoice,Transporter Name,Jina la Transporter
DocType: Authorization Rule,Authorized Value,Thamani iliyoidhinishwa
DocType: BOM,Show Operations,Onyesha Kazi
,Minutes to First Response for Opportunity,Dakika ya Kwanza ya Majibu ya Fursa
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Absent,Jumla ya Ukosefu
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item or Warehouse for row {0} does not match Material Request,Kipengee au Ghala la mstari {0} hailingani na Maombi ya Nyenzo
apps/erpnext/erpnext/hr/report/loan_repayment/loan_repayment.py,Payable Amount,Kiasi kinacholipwa
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Unit of Measure,Kitengo cha Kupima
DocType: Fiscal Year,Year End Date,Tarehe ya Mwisho wa Mwaka
DocType: Task Depends On,Task Depends On,Kazi inategemea
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Opportunity,Fursa
DocType: Options,Option,Chaguo
apps/erpnext/erpnext/accounts/general_ledger.py,You can't create accounting entries in the closed accounting period {0},Hauwezi kuunda viingizo vya uhasibu katika kipindi cha uhasibu kilichofungwa {0}
DocType: Operation,Default Workstation,Kituo cha Kazi cha Kazi
DocType: Payment Entry,Deductions or Loss,Kupoteza au kupoteza
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is closed,{0} {1} imefungwa
DocType: Email Digest,How frequently?,Ni mara ngapi?
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Total Collected: {0},Jumla Imekusanywa: {0}
DocType: Purchase Receipt,Get Current Stock,Pata Stock Current
DocType: Purchase Invoice,ineligible,halali
apps/erpnext/erpnext/config/manufacturing.py,Tree of Bill of Materials,Mti wa Matayarisho ya Vifaa
DocType: BOM,Exploded Items,Vitu vilivyolipuka
DocType: Student,Joining Date,Tarehe ya Kujiunga
,Employees working on a holiday,Wafanyakazi wanaofanya kazi likizo
,TDS Computation Summary,Muhtasari wa Hesabu ya TDS
DocType: Share Balance,Current State,Hali ya sasa
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Present,Andika Sasa
DocType: Share Transfer,From Shareholder,Kutoka kwa Mshirika
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Greater Than Amount,Kubwa kuliko Kiasi
DocType: Project,% Complete Method,Njia kamili
apps/erpnext/erpnext/healthcare/setup.py,Drug,Madawa
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance start date can not be before delivery date for Serial No {0},Tarehe ya kuanza ya matengenezo haiwezi kuwa kabla ya tarehe ya kujifungua kwa Serial No {0}
DocType: Work Order,Actual End Date,Tarehe ya mwisho ya mwisho
DocType: Cash Flow Mapping,Is Finance Cost Adjustment,"Je, mabadiliko ya Gharama za Fedha"
DocType: BOM,Operating Cost (Company Currency),Gharama za Uendeshaji (Fedha la Kampuni)
DocType: Authorization Rule,Applicable To (Role),Inafaa kwa (Mgawo)
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Pending Leaves,Majani yaliyoyasubiri
DocType: BOM Update Tool,Replace BOM,Badilisha BOM
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Code {0} already exist,Kanuni {0} tayari iko
DocType: Patient Encounter,Procedures,Taratibu
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Sales orders are not available for production,Maagizo ya mauzo haipatikani kwa uzalishaji
DocType: Asset Movement,Purpose,Kusudi
DocType: Company,Fixed Asset Depreciation Settings,Mipangilio ya Malipo ya Kushuka kwa Mali
DocType: Item,Will also apply for variants unless overrridden,Pia itatumika kwa vipengee isipokuwa imeingizwa
DocType: Purchase Invoice,Advances,Maendeleo
DocType: HR Settings,Hiring Settings,Mipangilio ya Kuajiri
DocType: Work Order,Manufacture against Material Request,Tengeneza dhidi ya Nyenzo ya Nyenzo
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Assessment Group: ,Kundi la Tathmini:
DocType: Item Reorder,Request for,Ombi la
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Approving User cannot be same as user the rule is Applicable To,Kupitisha Mtumiaji hawezi kuwa sawa na mtumiaji utawala unaofaa
DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Kiwango cha msingi (kama kwa Stock UOM)
DocType: SMS Log,No of Requested SMS,Hakuna ya SMS iliyoombwa
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Leave Without Pay does not match with approved Leave Application records,Acha bila ya kulipa hailingani na kumbukumbu za Maombi ya Kuondoka
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Next Steps,Hatua Zingine
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Saved Items,Vitu vilivyohifadhiwa
DocType: Travel Request,Domestic,Ndani
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Please supply the specified items at the best possible rates,Tafadhali usambaze vitu maalum kwa viwango bora zaidi
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,Employee Transfer cannot be submitted before Transfer Date ,Uhamisho wa Wafanyabiashara hauwezi kufungwa kabla ya Tarehe ya Uhamisho
DocType: Certification Application,USD,USD
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Remaining Balance,Kudumisha Mizani
DocType: Selling Settings,Auto close Opportunity after 15 days,Funga karibu na fursa baada ya siku 15
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Amri za Ununuzi hayaruhusiwi kwa {0} kutokana na msimamo wa alama ya {1}.
apps/erpnext/erpnext/stock/doctype/item/item.py,Barcode {0} is not a valid {1} code,Barcode {0} sio sahihi {1} kificho
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,End Year,Mwisho wa Mwaka
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot/Lead %,Quot / Kiongozi%
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Contract End Date must be greater than Date of Joining,Tarehe ya Mwisho wa Mkataba lazima iwe kubwa kuliko Tarehe ya Kujiunga
DocType: Sales Invoice,Driver,Dereva
DocType: Vital Signs,Nutrition Values,Maadili ya lishe
DocType: Lab Test Template,Is billable,Ni billable
DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,Washirika wa tatu / muuzaji / wakala wa tume / mshirika / wauzaji ambaye anauza bidhaa za kampuni kwa tume.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Purchase Order {1},{0} dhidi ya Utaratibu wa Ununuzi {1}
DocType: Patient,Patient Demographics,Idadi ya Watu wa Magonjwa
DocType: Task,Actual Start Date (via Time Sheet),Tarehe ya Kuanza Kuanza (kupitia Karatasi ya Muda)
apps/erpnext/erpnext/portal/doctype/homepage/homepage.py,This is an example website auto-generated from ERPNext,Hii ni tovuti ya mfano iliyozalishwa kutoka ERPNext
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 1,Kipindi cha kuzeeka 1
DocType: Shopify Settings,Enable Shopify,Wezesha Shopify
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total claimed amount,Jumla ya kiasi cha mapema haiwezi kuwa kubwa zaidi kuliko jumla ya kiasi kilichodaiwa
DocType: Purchase Taxes and Charges Template,"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.

#### Note

The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.

#### Description of Columns

1. Calculation Type: 
    - This can be on **Net Total** (that is the sum of basic amount).
    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
    - **Actual** (as mentioned).
2. Account Head: The Account ledger under which this tax will be booked
3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
4. Description: Description of the tax (that will be printed in invoices / quotes).
5. Rate: Tax rate.
6. Amount: Tax amount.
7. Total: Cumulative total to this point.
8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.
10. Add or Deduct: Whether you want to add or deduct the tax.","Template ya kodi ya kawaida ambayo inaweza kutumika kwa Shughuli zote za Ununuzi. Template hii inaweza kuwa na orodha ya vichwa vya kodi na pia majukumu mengine kama &quot;Shipping&quot;, &quot;Bima&quot;, &quot;Kushikilia&quot; nk #### Kumbuka kiwango cha kodi unachofafanua hapa kitakuwa kiwango cha kodi ya kila kitu * *. Ikiwa kuna ** Vitu ** vilivyo na viwango tofauti, lazima ziongezwe kwenye meza ya ** ya Item ** ** kwenye ** Item ** bwana. #### Maelezo ya nguzo 1. Aina ya mahesabu: - Hii inaweza kuwa kwenye ** Net Jumla ** (hiyo ni jumla ya kiasi cha msingi). - ** Katika Mstari uliopita Mto / Kiasi ** (kwa kodi za malipo au mashtaka). Ikiwa utichagua chaguo hili, kodi itatumika kama asilimia ya safu ya awali (katika meza ya kodi) kiasi au jumla. - ** Halisi ** (kama ilivyoelezwa). 2. Mkurugenzi wa Akaunti: Mwandishi wa Akaunti chini ya kodi hii itafunguliwa 3. Kituo cha Gharama: Ikiwa kodi / malipo ni mapato (kama meli) au gharama zinahitajika kutumiwa kwenye kituo cha gharama. 4. Maelezo: Maelezo ya kodi (ambayo yatachapishwa katika ankara / quotes). 5. Kiwango: kiwango cha kodi. 6. Kiasi: Kiwango cha Ushuru. 7. Jumla: Jumla ya jumla kwa hatua hii. 8. Ingiza Mstari: Ikiwa msingi wa &quot;Mstari uliopita Uliopita&quot; unaweza kuchagua namba ya mstari ambayo itachukuliwa kama msingi kwa hesabu hii (default ni mstari uliopita). 9. Fikiria kodi au malipo kwa: Katika kifungu hiki unaweza kutaja ikiwa kodi / malipo ni kwa ajili ya hesabu tu (sio sehemu ya jumla) au kwa jumla (haina kuongeza thamani kwa bidhaa) au kwa wote. 10. Ongeza au Deduct: Ikiwa unataka kuongeza au kupunguza kodi."
DocType: Homepage,Homepage,Homepage
DocType: Grant Application,Grant Application Details ,Ruhusu Maelezo ya Maombi
DocType: Employee Separation,Employee Separation,Ugawaji wa Waajiriwa
DocType: BOM Item,Original Item,Nakala ya awali
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Date,Tarehe ya Hati
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py,Fee Records Created - {0},Kumbukumbu za ada zilizoundwa - {0}
DocType: Asset Category Account,Asset Category Account,Akaunti ya Jamii ya Mali
apps/erpnext/erpnext/controllers/item_variant.py,The value {0} is already assigned to an exisiting Item {2}.,Thamani {0} tayari imepewa kipengee cha kuuza nje {2}.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row #{0} (Payment Table): Amount must be positive,Row # {0} (Jedwali la Malipo): Kiasi kinachofaa
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Cannot produce more Item {0} than Sales Order quantity {1},Haiwezi kuzalisha kipengee zaidi {0} kuliko kiasi cha Mauzo ya Mauzo {1}
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Nothing is included in gross,Hakuna kilichojumuishwa katika jumla
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill already exists for this document,Mswada wa e-Way tayari uko kwa hati hii
apps/erpnext/erpnext/stock/doctype/item/item.js,Select Attribute Values,Chagua Maadili ya Tabia
DocType: Purchase Invoice,Reason For Issuing document,Sababu ya Kuondoa hati
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Stock Entry {0} is not submitted,Uingiaji wa hisa {0} haujawasilishwa
DocType: Payment Reconciliation,Bank / Cash Account,Akaunti ya Benki / Cash
DocType: Bank Transaction,ACC-BTN-.YYYY.-,ACC-BTN-.YYYY--
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Next Contact By cannot be same as the Lead Email Address,Kuwasiliana Nafuatayo hawezi kuwa sawa na Anwani ya barua pepe
DocType: Tax Rule,Billing City,Mji wa kulipia
apps/erpnext/erpnext/regional/italy/setup.py,Applicable if the company is an Individual or a Proprietorship,Inatumika ikiwa kampuni ni ya Mtu binafsi au Proprietorship
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,Log Type is required for check-ins falling in the shift: {0}.,Aina ya logi inahitajika kwa anguko linaloanguka kwenye mabadiliko: {0}.
DocType: Asset,Manual,Mwongozo
DocType: Tally Migration,Is Master Data Processed,Takwimu za Mwalimu zinasindika
DocType: Salary Component Account,Salary Component Account,Akaunti ya Mshahara wa Mshahara
DocType: Global Defaults,Hide Currency Symbol,Ficha Symbol ya Fedha
apps/erpnext/erpnext/config/non_profit.py,Donor information.,Maelezo ya wafadhili.
apps/erpnext/erpnext/config/accounting.py,"e.g. Bank, Cash, Credit Card","mfano Benki, Fedha, Kadi ya Mikopo"
DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Kupumzika kwa shinikizo la damu kwa mtu mzima ni takribani 120 mmHg systolic, na 80 mmHg diastolic, iliyofupishwa &quot;120/80 mmHg&quot;"
DocType: Journal Entry,Credit Note,Maelezo ya Mikopo
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Finished Good Item Code,Imekamilika Nambari ya Bidhaa nzuri
apps/erpnext/erpnext/config/desktop.py,Quality,Ubora
DocType: Projects Settings,Ignore Employee Time Overlap,Puuza Muda wa Waajiriwa
DocType: Warranty Claim,Service Address,Anwani ya Huduma
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Master Data,Ingiza Takwimu za Mwalimu
DocType: Asset Maintenance Task,Calibration,Calibration
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} is a company holiday,{0} ni likizo ya kampuni
apps/erpnext/erpnext/projects/report/billing_summary.py,Billable Hours,Masaa yanayoweza kulipwa
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Status Notification,Acha Arifa ya Hali
DocType: Patient Appointment,Procedure Prescription,Utaratibu wa Dawa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Furnitures and Fixtures,Furnitures na Marekebisho
DocType: Travel Request,Travel Type,Aina ya Kusafiri
DocType: Purchase Invoice Item,Manufacture,Tengeneza
DocType: Blanket Order,MFG-BLR-.YYYY.-,MFG-BLR -YYYY.-
apps/erpnext/erpnext/utilities/user_progress.py,Setup Company,Kampuni ya Kuweka
,Lab Test Report,Ripoti ya Mtihani wa Lab
DocType: Employee Benefit Application,Employee Benefit Application,Maombi ya Faida ya Wafanyakazi
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.py,Row({0}): {1} is already discounted in {2},Njia ({0}): {1} tayari imepunguzwa katika {2}
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Additional Salary Component Exists.,Vidokezo vya Sehemu ya Mshahara.
DocType: Purchase Invoice,Unregistered,Iliyosajiliwa
DocType: Student Applicant,Application Date,Tarehe ya Maombi
DocType: Salary Component,Amount based on formula,Kiasi kilichowekwa kwenye formula
DocType: Purchase Invoice,Currency and Price List,Orodha ya Fedha na Bei
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Create Maintenance Visit,Unda Ziara ya Matengenezo
DocType: Opportunity,Customer / Lead Name,Wateja / Jina la Kiongozi
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Clearance Date not mentioned,Tarehe ya kufuta haijajwajwa
DocType: Payroll Period,Taxable Salary Slabs,Slabs Salary zilizolipwa
apps/erpnext/erpnext/config/manufacturing.py,Production,Uzalishaji
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! The input you've entered doesn't match the format of GSTIN.,GSTIN batili! Uingizaji ambao umeingia haulingani na muundo wa GSTIN.
DocType: Guardian,Occupation,Kazi
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Quantity must be less than quantity {0},Kwa Wingi lazima iwe chini ya wingi {0}
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Row {0}:Start Date must be before End Date,Row {0}: tarehe ya mwanzo lazima iwe kabla ya tarehe ya mwisho
DocType: Salary Component,Max Benefit Amount (Yearly),Kiasi cha Faida nyingi (Kila mwaka)
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,TDS Rate %,Kiwango cha TDS%
DocType: Crop,Planting Area,Eneo la Kupanda
apps/erpnext/erpnext/controllers/trends.py,Total(Qty),Jumla (Uchina)
DocType: Installation Note Item,Installed Qty,Uchina uliowekwa
apps/erpnext/erpnext/utilities/user_progress.py,You added ,Uliongeza
,Product Bundle Balance,Mizani ya Sehemu ya Bidhaa
DocType: Purchase Taxes and Charges,Parenttype,Mzazi
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Central Tax,Ushuru wa kati
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js,Training Result,Matokeo ya Mafunzo
DocType: Purchase Invoice,Is Paid,Ni kulipwa
DocType: Salary Structure,Total Earning,Jumla ya Kupata
DocType: Purchase Receipt,Time at which materials were received,Wakati ambapo vifaa vilipokelewa
DocType: Products Settings,Products per Page,Bidhaa kwa Ukurasa
DocType: Stock Ledger Entry,Outgoing Rate,Kiwango cha Kuondoka
apps/erpnext/erpnext/controllers/accounts_controller.py, or ,au
apps/erpnext/erpnext/public/js/purchase_trends_filters.js,Billing Date,Tarehe ya bili
apps/erpnext/erpnext/accounts/utils.py,Allocated amount cannot be negative,Kiasi kilichowekwa haziwezi kuwa hasi
DocType: Sales Order,Billing Status,Hali ya kulipia
apps/erpnext/erpnext/public/js/conf.js,Report an Issue,Ripoti Suala
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"If you {0} {1} quantities of the item <b>{2}</b>, the scheme <b>{3}</b>
			will be applied on the item.","Ikiwa {0} {1} idadi ya bidhaa <b>{2}</b> , mpango <b>{3}</b> utatumika kwenye bidhaa hiyo."
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Utility Expenses,Malipo ya matumizi
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,90-Above,90-juu
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Row # {0}: Kuingia kwa Machapishaji {1} hawana akaunti {2} au tayari kuendana na chaguo jingine
DocType: Supplier Scorecard Criteria,Criteria Weight,Vigezo vya uzito
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Account: {0} is not permitted under Payment Entry,Akaunti: {0} hairuhusiwi chini ya malipo ya Malipo
DocType: Production Plan,Ignore Existing Projected Quantity,Puuza Kiwango Kilichohesabiwa cha Kutarajiwa
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Approval Notification,Acha Arifa ya Idhini
DocType: Buying Settings,Default Buying Price List,Orodha ya Bei ya Kichuuzi
DocType: Payroll Entry,Salary Slip Based on Timesheet,Kulipwa kwa Mshahara Kulingana na Timesheet
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Buying Rate,Kiwango cha kununua
apps/erpnext/erpnext/controllers/buying_controller.py,Row {0}: Enter location for the asset item {1},Row {0}: Ingiza mahali kwa kipengee cha mali {1}
DocType: Employee Checkin,Attendance Marked,Mahudhurio Alionyesha
DocType: Request for Quotation,PUR-RFQ-.YYYY.-,PUR-RFQ -YYYY.-
apps/erpnext/erpnext/public/js/hub/pages/Seller.vue,About the Company,Kuhusu Kampuni
apps/erpnext/erpnext/config/settings.py,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Weka Maadili ya Hifadhi kama Kampuni, Fedha, Sasa Fedha ya Sasa, nk."
DocType: Payment Entry,Payment Type,Aina ya malipo
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,Tafadhali chagua Batch kwa Bidhaa {0}. Haiwezi kupata kundi moja linalotimiza mahitaji haya
DocType: Asset Maintenance Log,ACC-AML-.YYYY.-,ACC-AML -YYYY.-
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,No gain or loss in the exchange rate,Hakuna faida au kupoteza kwa kiwango cha ubadilishaji
DocType: Leave Control Panel,Select Employees,Chagua Waajiriwa
DocType: Shopify Settings,Sales Invoice Series,Misaada ya Mauzo ya Mauzo
DocType: Bank Reconciliation,To Date,Mpaka leo
DocType: Opportunity,Potential Sales Deal,Uwezekano wa Mauzo ya Mauzo
DocType: Complaint,Complaints,Malalamiko
DocType: Employee Tax Exemption Declaration,Employee Tax Exemption Declaration,Azimio la Ushuru wa Ushuru wa Wafanyakazi
DocType: Payment Entry,Cheque/Reference Date,Tazama / Tarehe ya Marejeo
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,No Items with Bill of Materials.,Hakuna Vitu na Muswada wa Vifaa.
apps/erpnext/erpnext/portal/doctype/homepage/homepage.js,Customize Homepage Sections,Binafsisha Sehemu za Ukurasa
DocType: Purchase Invoice,Total Taxes and Charges,Jumla ya Kodi na Malipo
DocType: Payment Entry,Company Bank Account,Akaunti ya Benki ya Kampuni
DocType: Employee,Emergency Contact,Mawasiliano ya dharura
DocType: Bank Reconciliation Detail,Payment Entry,Kuingia kwa Malipo
,sales-browser,kivinjari cha mauzo
apps/erpnext/erpnext/accounts/doctype/account/account.js,Ledger,Ledger
DocType: Drug Prescription,Drug Code,Msimbo wa Dawa
DocType: Target Detail,Target  Amount,Kiwango cha Target
apps/erpnext/erpnext/education/utils.py,Quiz {0} does not exist,Jaribio {0} halipo
DocType: POS Profile,Print Format for Online,Funga muundo wa mtandaoni
DocType: Shopping Cart Settings,Shopping Cart Settings,Mipangilio ya Cart Shopping
DocType: Journal Entry,Accounting Entries,Uingizaji wa Uhasibu
DocType: Job Card Time Log,Job Card Time Log,Kadi ya Kazi wakati wa Log
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Ikiwa Rule ya bei iliyochaguliwa imefanywa kwa &#39;Kiwango&#39;, itatawala Orodha ya Bei. Kiwango cha Rule ya bei ni kiwango cha mwisho, kwa hiyo hakuna punguzo zaidi linapaswa kutumiwa. Kwa hiyo, katika shughuli kama Maagizo ya Mauzo, Utaratibu wa Ununuzi nk, itafutwa kwenye uwanja wa &#39;Kiwango&#39;, badala ya shamba la &quot;Orodha ya Thamani.&quot;"
DocType: Journal Entry,Paid Loan,Mikopo iliyolipwa
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Duplicate Entry. Please check Authorization Rule {0},Kuingia kwa Duplicate. Tafadhali angalia Sheria ya Uidhinishaji {0}
DocType: Journal Entry Account,Reference Due Date,Tarehe ya Kutokana na Kumbukumbu
DocType: Purchase Order,Ref SQ,Ref SQ
DocType: Issue,Resolution By,Azimio Na
DocType: Leave Type,Applicable After (Working Days),Baada ya Kazi (Siku za Kazi)
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Receipt document must be submitted,Hati ya Receipt inapaswa kuwasilishwa
DocType: Purchase Invoice Item,Received Qty,Imepokea Uchina
DocType: Stock Entry Detail,Serial No / Batch,Serial No / Batch
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Not Paid and Not Delivered,Hailipatikani na Haijaokolewa
DocType: Product Bundle,Parent Item,Item ya Mzazi
DocType: Account,Account Type,Aina ya Akaunti
DocType: Shopify Settings,Webhooks Details,Maelezo ya wavuti
apps/erpnext/erpnext/templates/pages/projects.html,No time sheets,Hakuna karatasi za wakati
DocType: GoCardless Mandate,GoCardless Customer,Wateja wa GoCardless
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leave Type {0} cannot be carry-forwarded,Acha Aina {0} haiwezi kubeba
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Ratiba ya Matengenezo haijazalishwa kwa vitu vyote. Tafadhali bonyeza &#39;Generate Schedule&#39;
,To Produce,Kuzalisha
DocType: Leave Encashment,Payroll,Mishahara
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Kwa mstari {0} katika {1}. Ili ni pamoja na {2} katika kiwango cha kipengee, safu {3} lazima ziingizwe pia"
DocType: Healthcare Service Unit,Parent Service Unit,Kitengo cha Utumishi wa Mzazi
DocType: Packing Slip,Identification of the package for the delivery (for print),Utambulisho wa mfuko wa utoaji (kwa kuchapishwa)
apps/erpnext/erpnext/support/doctype/issue/issue.js,Service Level Agreement was reset.,Mkataba wa Kiwango cha Huduma uliwekwa tena.
DocType: Bin,Reserved Quantity,Waliohifadhiwa Wingi
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Please enter valid email address,Tafadhali ingiza anwani ya barua pepe halali
DocType: Volunteer Skill,Volunteer Skill,Ujuzi wa Kujitolea
DocType: Bank Reconciliation,Include POS Transactions,Jumuisha Shughuli za POS
DocType: Quality Action,Corrective/Preventive,Kurekebisha / kuzuia
DocType: Purchase Invoice,Inter Company Invoice Reference,Kumbukumbu ya Invoice ya Kampuni ya Inter
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select an item in the cart,Tafadhali chagua kipengee kwenye gari
DocType: Landed Cost Voucher,Purchase Receipt Items,Ununuzi wa Receipt Items
apps/erpnext/erpnext/regional/italy/utils.py,Please set Tax ID for the customer '%s',Tafadhali weka kitambulisho cha Ushuru kwa wateja &#39;% s&#39;
apps/erpnext/erpnext/config/help.py,Customizing Forms,Fomu za Customizing
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Arrear,Nyuma
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Depreciation Amount during the period,Upungufu Kiasi wakati wa kipindi
DocType: Sales Invoice,Is Return (Credit Note),Inarudi (Maelezo ya Mikopo)
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Start Job,Anza Ayubu
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Serial no is required for the asset {0},Hapana ya serial inahitajika kwa mali {0}
DocType: Leave Control Panel,Allocate Leaves,Gawanya Majani
apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py,Disabled template must not be default template,Template ya ulemavu haipaswi kuwa template default
DocType: Pricing Rule,Price or Product Discount,Bei au Punguzo la Bidhaa
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,For row {0}: Enter planned qty,Kwa mstari {0}: Ingiza qty iliyopangwa
DocType: Account,Income Account,Akaunti ya Mapato
DocType: Payment Request,Amount in customer's currency,Kiasi cha fedha za wateja
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Delivery,Utoaji
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Assigning Structures...,Kugawa Miundo ...
DocType: Stock Reconciliation Item,Current Qty,Uchina wa sasa
DocType: Restaurant Menu,Restaurant Menu,Mkahawa wa Menyu
apps/erpnext/erpnext/public/js/event.js,Add Suppliers,Ongeza Wauzaji
DocType: Sales Invoice,ACC-SINV-.YYYY.-,ACC-SINV -YYYY.-
DocType: Loyalty Program,Help Section,Sehemu ya Usaidizi
apps/erpnext/erpnext/www/all-products/index.html,Prev,Kabla
DocType: Appraisal Goal,Key Responsibility Area,Eneo la Ujibu wa Ufunguo
DocType: Delivery Trip,Distance UOM,Umbali wa UOM
apps/erpnext/erpnext/utilities/activation.py,"Student Batches help you track attendance, assessments and fees for students","Majaribio ya Wanafunzi husaidia kufuatilia mahudhurio, tathmini na ada kwa wanafunzi"
DocType: Payment Entry,Total Allocated Amount,Kiasi kilichopangwa
apps/erpnext/erpnext/setup/doctype/company/company.py,Set default inventory account for perpetual inventory,Weka akaunti ya hesabu ya msingi kwa hesabu ya daima
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot deliver Serial No {0} of item {1} as it is reserved to \
												fullfill Sales Order {2}",Haiwezi kutoa Serial Hakuna {0} ya kipengee {1} kama imehifadhiwa kwa \ fullfill Sales Order {2}
DocType: Material Request Plan Item,Material Request Type,Aina ya Uomba wa Nyenzo
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js,Send Grant Review Email,Tuma Email Review Review
apps/erpnext/erpnext/accounts/page/pos/pos.js,"LocalStorage is full, did not save","Mitaa ya Mitaa imejaa, haikuhifadhi"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row {0}: UOM Conversion Factor is mandatory,Row {0}: Kipengele cha kubadilisha UOM ni lazima
DocType: Employee Benefit Claim,Claim Date,Tarehe ya kudai
apps/erpnext/erpnext/utilities/user_progress.py,Room Capacity,Uwezo wa Chumba
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field Asset Account cannot be blank,Akaunti ya Mali ya uwanja haiwezi kuwa wazi
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Already record exists for the item {0},Tayari rekodi ipo kwa kipengee {0}
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Ref,Ref
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,You will lose records of previously generated invoices. Are you sure you want to restart this subscription?,Utapoteza rekodi za ankara zinazozalishwa hapo awali. Una uhakika unataka kuanzisha upya usajili huu?
DocType: Lab Test,LP-,LP-
DocType: Healthcare Settings,Registration Fee,Malipo ya Usajili
DocType: Loyalty Program Collection,Loyalty Program Collection,Mkusanyiko wa Programu ya Uaminifu
DocType: Stock Entry Detail,Subcontracted Item,Kipengee kilichochaguliwa
apps/erpnext/erpnext/education/__init__.py,Student {0} does not belong to group {1},Mwanafunzi {0} sio kikundi {1}
DocType: Budget,Cost Center,Kituo cha Gharama
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Voucher #,Voucher #
DocType: Tax Rule,Shipping Country,Nchi ya Meli
DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Ficha Ideni ya Kodi ya Wateja kutoka kwa Mauzo ya Mauzo
DocType: Upload Attendance,Upload HTML,Weka HTML
DocType: Employee,Relieving Date,Tarehe ya Kuondoa
DocType: Purchase Invoice,Total Quantity,Jumla ya Wingi
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Sheria ya bei ni kufuta Orodha ya Bei / kufafanua asilimia ya discount, kulingana na vigezo vingine."
apps/erpnext/erpnext/support/doctype/issue/issue.py,Service Level Agreement has been changed to {0}.,Mkataba wa Kiwango cha Huduma umebadilishwa kuwa {0}.
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Ghala inaweza tu kubadilishwa kupitia Stock Entry / Delivery Kumbuka / Ununuzi Receipt
DocType: Employee Education,Class / Percentage,Hatari / Asilimia
DocType: Shopify Settings,Shopify Settings,Weka Mipangilio
DocType: Amazon MWS Settings,Market Place ID,ID ya Mahali ya Soko
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Head of Marketing and Sales,Mkuu wa Masoko na Mauzo
DocType: Video,Vimeo,Vimeo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Income Tax,Kodi ya mapato
DocType: HR Settings,Check Vacancies On Job Offer Creation,Angalia nafasi za kazi kwenye uumbaji wa kazi ya kazi
apps/erpnext/erpnext/utilities/user_progress.py,Go to Letterheads,Nenda kwenye Barua
DocType: Subscription,Cancel At End Of Period,Futa Wakati wa Mwisho
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Property already added,Mali tayari imeongezwa
DocType: Item Supplier,Item Supplier,Muuzaji wa Bidhaa
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please enter Item Code to get batch no,Tafadhali ingiza Msimbo wa Nambari ili kupata bat
apps/erpnext/erpnext/public/js/utils.js,Loyalty Points: {0},Vidokezo vya Uaminifu: {0}
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js,Please select a value for {0} quotation_to {1},Tafadhali chagua thamani ya {0} quotation_to {1}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,No Items selected for transfer,Hakuna Vichaguliwa kwa uhamisho
apps/erpnext/erpnext/config/buying.py,All Addresses.,Anwani zote.
DocType: Company,Stock Settings,Mipangilio ya hisa
apps/erpnext/erpnext/accounts/doctype/account/account.py,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Kuunganisha inawezekana tu kama mali zifuatazo zimefanana katika kumbukumbu zote mbili. Ni Kikundi, Aina ya Mizizi, Kampuni"
DocType: Vehicle,Electric,Umeme
DocType: Task,% Progress,Maendeleo
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Gain/Loss on Asset Disposal,Kupata / Kupoteza kwa Upunguzaji wa Mali
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js,"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",Msaidizi wa Mwanafunzi tu na hali &quot;Imeidhinishwa&quot; itachaguliwa katika meza hapa chini.
DocType: Tax Withholding Category,Rates,Viwango
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py,Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,Nambari ya Akaunti kwa akaunti {0} haipatikani. <br> Tafadhali kuanzisha Chati yako ya Akaunti kwa usahihi.
DocType: Task,Depends on Tasks,Inategemea Kazi
apps/erpnext/erpnext/config/crm.py,Manage Customer Group Tree.,Dhibiti mti wa Wateja wa Wateja.
DocType: Normal Test Items,Result Value,Thamani ya matokeo
DocType: Hotel Room,Hotels,Hoteli
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,New Cost Center Name,Jina la Kituo cha Gharama Mpya
DocType: Leave Control Panel,Leave Control Panel,Acha Jopo la Kudhibiti
DocType: Project,Task Completion,Kukamilisha Kazi
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,Not in Stock,Sio katika Hifadhi
DocType: Volunteer,Volunteer Skills,Ujuzi wa Kujitolea
DocType: Additional Salary,HR User,Mtumiaji wa HR
DocType: Bank Guarantee,Reference Document Name,Jina la Kumbukumbu la Kumbukumbu
DocType: Purchase Invoice,Taxes and Charges Deducted,Kodi na Malipo zimefutwa
DocType: Support Settings,Issues,Mambo
DocType: Loyalty Program,Loyalty Program Name,Jina la Programu ya Uaminifu
apps/erpnext/erpnext/controllers/status_updater.py,Status must be one of {0},Hali lazima iwe moja ya {0}
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Reminder to update GSTIN Sent,Kumbusho ya kurekebisha GSTIN Iliyotumwa
DocType: Discounted Invoice,Debit To,Debit To
DocType: Restaurant Menu Item,Restaurant Menu Item,Menyu ya Menyu ya Mgahawa
DocType: Delivery Note,Required only for sample item.,Inahitajika tu kwa bidhaa ya sampuli.
DocType: Stock Ledger Entry,Actual Qty After Transaction,Uhakika halisi baada ya Shughuli
,Pending SO Items For Purchase Request,Inasubiri vitu vya SO Kwa Ununuzi wa Ombi
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,Student Admissions,Uingizaji wa Wanafunzi
DocType: Supplier,Billing Currency,Fedha ya kulipia
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Extra Large,Ziada kubwa
DocType: Loan,Loan Application,Maombi ya Mikopo
DocType: Crop,Scientific Name,Jina la Sayansi
DocType: Healthcare Service Unit,Service Unit Type,Aina ya Huduma ya Huduma
DocType: Bank Account,Branch Code,Kanuni ya Tawi
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Leaves,Jumla ya Majani
DocType: Customer,"Reselect, if the chosen contact is edited after save","Pitia tena, ikiwa mteule aliyechaguliwa amehaririwa baada ya kuokoa"
DocType: Quality Procedure,Parent Procedure,Utaratibu wa Mzazi
DocType: Patient Encounter,In print,Ili kuchapishwa
DocType: Accounting Dimension,Accounting Dimension,Vipimo vya Uhasibu
,Profit and Loss Statement,Taarifa ya Faida na Kupoteza
DocType: Bank Reconciliation Detail,Cheque Number,Angalia Nambari
apps/erpnext/erpnext/healthcare/utils.py,The item referenced by {0} - {1} is already invoiced,Kipengee kilichorejelewa na {0} - {1} tayari kinarejeshwa
,Sales Browser,Kivinjari cha Mauzo
DocType: Journal Entry,Total Credit,Jumla ya Mikopo
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Warning: Another {0} # {1} exists against stock entry {2},Onyo: Nyingine {0} # {1} ipo dhidi ya kuingia kwa hisa {2}
apps/erpnext/erpnext/utilities/user_progress_utils.py,Local,Mitaa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Loans and Advances (Assets),Mikopo na Maendeleo (Mali)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Debtors,Wadaiwa
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Large,Kubwa
DocType: Bank Statement Settings,Bank Statement Settings,Mipangilio ya Taarifa ya Benki
DocType: Shopify Settings,Customer Settings,Mazingira ya Wateja
DocType: Homepage Featured Product,Homepage Featured Product,Bidhaa ya Matukio ya Ukurasa
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,View Orders,Angalia Amri
DocType: Marketplace Settings,Marketplace URL (to hide and update label),URL ya sokoni (kuficha na kusafirisha studio)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,All Assessment Groups,Makundi yote ya Tathmini
apps/erpnext/erpnext/regional/india/utils.py,{} is required to generate e-Way Bill JSON,{} inahitajika kutengeneza E-Way Bill JSON
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js,New Warehouse Name,Jina jipya la ghala
DocType: Shopify Settings,App Type,Aina ya App
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py,Total {0} ({1}),Jumla {0} ({1})
DocType: C-Form Invoice Detail,Territory,Nchi
DocType: Pricing Rule,Apply Rule On Item Code,Tumia Nambari ya Bidhaa
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Tafadhali angalia hakuna wa ziara zinazohitajika
DocType: Stock Settings,Default Valuation Method,Njia ya Hifadhi ya Kimaadili
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Malipo
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Onyesha Kiasi Kikubwa
apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Mwisho unaendelea. Inaweza kuchukua muda.
DocType: Production Plan Item,Produced Qty,Uchina uliotayarishwa
DocType: Vehicle Log,Fuel Qty,Uchina wa mafuta
DocType: Stock Entry,Target Warehouse Name,Jina la Ghala la Taraka
DocType: Work Order Operation,Planned Start Time,Muda wa Kuanza
DocType: Course,Assessment,Tathmini
DocType: Payment Entry Reference,Allocated,Imewekwa
apps/erpnext/erpnext/config/accounting.py,Close Balance Sheet and book Profit or Loss.,Funga Karatasi ya Mizani na Kitabu Faida au Kupoteza.
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,ERPNext could not find any matching payment entry,ERPNext haikuweza kupata kiingilio chochote cha malipo kinacholingana
DocType: Student Applicant,Application Status,Hali ya Maombi
DocType: Additional Salary,Salary Component Type,Aina ya Mshahara wa Mshahara
DocType: Sensitivity Test Items,Sensitivity Test Items,Vipimo vya Mtihani wa Sensiti
DocType: Website Attribute,Website Attribute,Sifa ya Wavuti
DocType: Project Update,Project Update,Mwisho wa Mradi
DocType: Fees,Fees,Malipo
DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Taja Kiwango cha Kubadilika kubadilisha fedha moja hadi nyingine
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Quotation {0} is cancelled,Nukuu {0} imefutwa
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Total Outstanding Amount,Jumla ya Kiasi Kikubwa
DocType: Sales Partner,Targets,Malengo
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js,Please register the SIREN number in the company information file,Tafadhali kujiandikisha namba ya SIREN katika faili ya habari ya kampuni
DocType: Quality Action Table,Responsible,Kuwajibika
DocType: Email Digest,Sales Orders to Bill,Maagizo ya Mauzo kwa Bill
DocType: Price List,Price List Master,Orodha ya Bei Mwalimu
DocType: GST Account,CESS Account,Akaunti ya CESS
DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,Shughuli zote za Mauzo zinaweza kutambulishwa dhidi ya watu wengi wa Mauzo ** ili uweze kuweka na kufuatilia malengo.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Link to Material Request,Unganisha Ombi la Nyenzo
DocType: Quiz,Score out of 100,Alama ya 100
apps/erpnext/erpnext/templates/pages/help.html,Forum Activity,Shughuli ya Vikao
DocType: Quiz,Grading Basis,Msingi wa Kuandaa
apps/erpnext/erpnext/selling/report/pending_so_items_for_purchase_request/pending_so_items_for_purchase_request.py,S.O. No.,SO Hapana.
DocType: Bank Statement Transaction Settings Item,Bank Statement Transaction Settings Item,Taarifa ya Benki ya Mipangilio ya Transaction
apps/erpnext/erpnext/hr/utils.py,To date can not greater than employee's relieving date,Hadi sasa haiwezi kuu kuliko tarehe ya kuondokana na mfanyakazi
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Please create Customer from Lead {0},Tafadhali tengeneza Wateja kutoka Kiongozi {0}
apps/erpnext/erpnext/healthcare/page/patient_history/patient_history.html,Select Patient,Chagua Mgonjwa
DocType: Price List,Applicable for Countries,Inahitajika kwa Nchi
DocType: Supplier Scorecard Scoring Variable,Parameter Name,Jina la Kipimo
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Tu Acha Maombi na hali &#39;Imeidhinishwa&#39; na &#39;Imekataliwa&#39; inaweza kuwasilishwa
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py,Creating Dimensions...,Inaunda vipimo ...
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Student Group Name is mandatory in row {0},Jina la Kikundi cha Wanafunzi ni lazima katika mstari {0}
DocType: Homepage,Products to be shown on website homepage,Bidhaa zinazoonyeshwa kwenye ukurasa wa nyumbani wa tovuti
DocType: HR Settings,Password Policy,Sera ya nywila
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js,This is a root customer group and cannot be edited.,Huu ni kikundi cha wateja wa mizizi na hauwezi kuhaririwa.
DocType: Student,AB-,AB-
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Total completed qty must be greater than zero,Jumla ya qty iliyokamilishwa lazima iwe kubwa kuliko sifuri
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on PO,Hatua kama Bajeti ya kila mwezi iliyokusanywa imeongezeka kwenye PO
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Place,Kuweka
DocType: Stock Entry,Stock Entry (Outward GIT),Kiingilio cha Hisa (nje GIT)
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation,Kiwango cha Kubadilishana
DocType: POS Profile,Ignore Pricing Rule,Piga Sheria ya bei
DocType: Employee Education,Graduate,Hitimu
DocType: Leave Block List,Block Days,Weka Siku
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,"Shipping Address does not have country, which is required for this Shipping Rule","Anwani ya Mafikisho haina nchi, ambayo inahitajika kwa Utawala huu wa Usafirishaji"
DocType: Journal Entry,Excise Entry,Entry Entry
DocType: Bank,Bank Transaction Mapping,Ramani ya Ununuzi wa Benki
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Onyo: Mauzo ya Mauzo {0} tayari yamepo kinyume cha Uguuzi wa Wateja {1}
DocType: Terms and Conditions,"Standard Terms and Conditions that can be added to Sales and Purchases.

Examples:

1. Validity of the offer.
1. Payment Terms (In Advance, On Credit, part advance etc).
1. What is extra (or payable by the Customer).
1. Safety / usage warning.
1. Warranty if any.
1. Returns Policy.
1. Terms of shipping, if applicable.
1. Ways of addressing disputes, indemnity, liability, etc.
1. Address and Contact of your Company.","Masharti na Masharti ya kawaida ambayo yanaweza kuongezwa kwa Mauzo na Ununuzi. Mifano: 1. Uthibitisho wa utoaji. Masharti ya Malipo (Katika Advance, Kwa Mikopo, sehemu ya mapema nk). 1. Ni nini ziada (au kulipwa na Wateja). 1. Usalama / onyo la matumizi. 1. dhamana kama yoyote. 1. Inarudi Sera. 1. Masharti ya usafirishaji, ikiwa yanafaa. 1. Njia za kukabiliana na migogoro, malipo, dhima, nk 1. Anwani na Mawasiliano ya Kampuni yako."
DocType: Homepage Section,Section Based On,Sehemu Kulingana na
DocType: Issue,Issue Type,Aina ya Suala
DocType: Attendance,Leave Type,Acha Aina
DocType: Purchase Invoice,Supplier Invoice Details,Maelezo ya Invoice ya Wasambazaji
DocType: Agriculture Task,Ignore holidays,Puuza sikukuu
apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Akaunti ya gharama na tofauti ({0}) lazima iwe akaunti ya &#39;Faida au Kupoteza&#39;
DocType: Stock Entry Detail,Stock Entry Child,Mtoto wa Kuingia
DocType: Project,Copied From,Ilikosa Kutoka
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Invoice already created for all billing hours,Dawa tayari imeundwa kwa masaa yote ya kulipa
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Name error: {0},Jina la kosa: {0}
DocType: Healthcare Service Unit Type,Item Details,Maelezo ya kipengee
DocType: Cash Flow Mapping,Is Finance Cost,Ni Gharama za Fedha
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance for employee {0} is already marked,Mahudhurio ya mfanyakazi {0} tayari amewekwa alama
DocType: Packing Slip,If more than one package of the same type (for print),Ikiwa zaidi ya mfuko mmoja wa aina moja (kwa kuchapishwa)
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please set default customer in Restaurant Settings,Tafadhali weka mteja default katika Mipangilio ya Mkahawa
,Salary Register,Daftari ya Mshahara
DocType: Company,Default warehouse for Sales Return,Ghala la Default la Kurudi kwa Uuzaji
DocType: Pick List,Parent Warehouse,Ghala la Mzazi
DocType: Subscription,Net Total,Jumla ya Net
apps/erpnext/erpnext/stock/doctype/batch/batch.py,"Set item's shelf life in days, to set expiry based on manufacturing date plus shelf-life.","Weka maisha ya rafu ya bidhaa kwa siku, kuweka kumalizika kwa msingi wa tarehe ya utengenezaji pamoja na maisha ya rafu."
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Default BOM not found for Item {0} and Project {1},BOM ya kutosha haipatikani kwa Item {0} na Mradi {1}
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set the Mode of Payment in Payment Schedule,Njia {0}: Tafadhali seti Njia ya Malipo katika Ratiba ya Malipo
apps/erpnext/erpnext/config/non_profit.py,Define various loan types,Eleza aina mbalimbali za mkopo
DocType: Bin,FCFS Rate,Kiwango cha FCFS
DocType: Bank Statement Transaction Invoice Item,Outstanding Amount,Kiasi Kikubwa
apps/erpnext/erpnext/templates/generators/bom.html,Time(in mins),Muda (kwa mchana)
DocType: Task,Working,Kufanya kazi
DocType: Stock Ledger Entry,Stock Queue (FIFO),Taa ya Hifadhi (FIFO)
DocType: Homepage Section,Section HTML,Sehemu ya HTML
apps/erpnext/erpnext/public/js/setup_wizard.js,Financial Year,Mwaka wa Fedha
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,{0} does not belong to Company {1},{0} sio Kampuni {1}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Could not solve criteria score function for {0}. Make sure the formula is valid.,Haikuweza kutatua kazi ya alama ya alama kwa {0}. Hakikisha fomu hiyo halali.
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost as on,Gharama kama
DocType: Healthcare Settings,Out Patient Settings,Nje Mipangilio ya Mgonjwa
DocType: Account,Round Off,Pande zote
DocType: Service Level Priority,Resolution Time,Wakati wa Azimio
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Quantity must be positive,Wingi lazima uwe na chanya
DocType: Job Card,Requested Qty,Uliotakiwa Uchina
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The fields From Shareholder and To Shareholder cannot be blank,Mashamba Kutoka kwa Mshirika na Mshirika hawezi kuwa tupu
DocType: Cashier Closing,Cashier Closing,Kufungua Fedha
DocType: Tax Rule,Use for Shopping Cart,Tumia kwa Ununuzi wa Ununuzi
DocType: Homepage,Homepage Slideshow,Slideshow ya ukurasa
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Serial Numbers,Chagua Nambari za Serial
DocType: BOM Item,Scrap %,Vipande%
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,"Charges will be distributed proportionately based on item qty or amount, as per your selection","Malipo yatasambazwa kulingana na bidhaa qty au kiasi, kulingana na uteuzi wako"
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Create Supplier Quotation,Unda Nukuu ya Mtoaji
DocType: Travel Request,Require Full Funding,Inahitaji Fedha Kamili
DocType: Maintenance Visit,Purposes,Malengo
DocType: Stock Entry,MAT-STE-.YYYY.-,MAT-STE -YYYY.-
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Atleast one item should be entered with negative quantity in return document,Atleast kitu kimoja kinapaswa kuingizwa kwa kiasi kikubwa katika hati ya kurudi
DocType: Shift Type,Grace Period Settings For Auto Attendance,Mipangilio ya kipindi cha Neema kwa Kuhudhuria Moja kwa moja
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Uendeshaji {0} kwa muda mrefu kuliko masaa yoyote ya kazi iliyopo katika kituo cha kazi {1}, uvunja operesheni katika shughuli nyingi"
DocType: Membership,Membership Status,Hali ya Uanachama
DocType: Travel Itinerary,Lodging Required,Makao Inahitajika
DocType: Promotional Scheme,Price Discount Slabs,Bei za Punguzo la Bei
DocType: Stock Reconciliation Item,Current Serial No,Sifa ya Sasa Hapana
DocType: Employee,Attendance and Leave Details,Mahudhurio na Maelezo ya Kuondoka
,BOM Comparison Tool,Chombo cha kulinganisha cha BOM
,Requested,Aliomba
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,No Remarks,Hakuna Maneno
DocType: Asset,In Maintenance,Katika Matengenezo
DocType: Amazon MWS Settings,Click this button to pull your Sales Order data from Amazon MWS.,Bonyeza kifungo hiki ili kuvuta data yako ya Mauzo ya Order kutoka Amazon MWS.
DocType: Vital Signs,Abdomen,Tumbo
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,No outstanding invoices require exchange rate revaluation,Hakuna ankara bora zinahitaji ukaguzi wa kiwango cha ubadilishaji
DocType: Purchase Invoice,Overdue,Kuondolewa
DocType: Account,Stock Received But Not Billed,Stock imepata lakini haijatibiwa
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root Account must be a group,Akaunti ya mizizi lazima iwe kikundi
DocType: Drug Prescription,Drug Prescription,Dawa ya Dawa
DocType: Service Level,Support and Resolution,Msaada na Azimio
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Free item code is not selected,Nambari ya bidhaa ya bure haijachaguliwa
DocType: Loan,Repaid/Closed,Kulipwa / Kufungwa
DocType: Amazon MWS Settings,CA,CA
DocType: Item,Total Projected Qty,Jumla ya Uchina uliopangwa
DocType: Monthly Distribution,Distribution Name,Jina la Usambazaji
DocType: Chart of Accounts Importer,Chart Tree,Mti wa Chati
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Include UOM,Jumuisha UOM
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Material Request No,Ombi la Vifaa La
DocType: Service Level Agreement,Default Service Level Agreement,Mkataba wa Kiwango cha Huduma ya Chaguzi
DocType: SG Creation Tool Course,Course Code,Msimbo wa Kozi
apps/erpnext/erpnext/hr/utils.py,More than one selection for {0} not allowed,Zaidi ya chaguo moja kwa {0} hairuhusiwi
DocType: Pick List,Qty of raw materials will be decided based on the qty of the Finished Goods Item,Qty ya malighafi itaamuliwa kwa kuzingatia qty ya Bidhaa iliyokamilishwa Bidhaa
DocType: Location,Parent Location,Eneo la Mzazi
DocType: POS Settings,Use POS in Offline Mode,Tumia POS katika Hali ya Nje
apps/erpnext/erpnext/support/doctype/issue/issue.py,Priority has been changed to {0}.,Kipaumbele kimebadilishwa kuwa {0}.
apps/erpnext/erpnext/accounts/page/pos/pos.js,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2},{0} ni lazima. Kumbukumbu ya Kubadilisha Fedha Labda haikuundwa kwa {1} kwa {2}
DocType: Quotation,Rate at which customer's currency is converted to company's base currency,Kiwango cha sarafu ya mteja ni chaguo la sarafu ya kampuni
DocType: Purchase Invoice Item,Net Rate (Company Currency),Kiwango cha Net (Kampuni ya Fedha)
DocType: Salary Detail,Condition and Formula Help,Hali na Msaada Msaada
apps/erpnext/erpnext/config/crm.py,Manage Territory Tree.,Dhibiti Miti ya Wilaya.
apps/erpnext/erpnext/config/getting_started.py,Import Chart Of Accounts from CSV / Excel files,Ingiza Chati ya Hesabu kutoka faili za CSV / Excel
DocType: Patient Service Unit,Patient Service Unit,Unit Service Service
DocType: Bank Statement Transaction Invoice Item,Sales Invoice,Invozi ya Mauzo
DocType: Journal Entry Account,Party Balance,Mizani ya Chama
DocType: Cash Flow Mapper,Section Subtotal,Subtotal Sehemu
apps/erpnext/erpnext/accounts/page/pos/pos.js,Please select Apply Discount On,Tafadhali chagua Weka Kutoa Discount On
DocType: Stock Settings,Sample Retention Warehouse,Mfano wa Kuhifadhi Ghala
DocType: Company,Default Receivable Account,Akaunti ya Akaunti ya Kupokea
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Projected Quantity Formula,Njia Iliyotarajiwa ya Wingi
DocType: Sales Invoice,Deemed Export,Exported kuagizwa
DocType: Pick List,Material Transfer for Manufacture,Uhamisho wa Nyenzo kwa Utengenezaji
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Discount Percentage can be applied either against a Price List or for all Price List.,Asilimia ya Punguzo inaweza kutumika ama dhidi ya orodha ya bei au orodha zote za bei.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Accounting Entry for Stock,Kuingia kwa Uhasibu kwa Stock
DocType: Lab Test,LabTest Approver,Msaidizi wa LabTest
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py,You have already assessed for the assessment criteria {}.,Tayari umehakikishia vigezo vya tathmini {}.
DocType: Vehicle Service,Engine Oil,Mafuta ya injini
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Orders Created: {0},Amri ya Kazi Iliundwa: {0}
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,Please set an email id for the Lead {0},Tafadhali weka kitambulisho cha barua pepe kwa Kiongozi {0}
DocType: Sales Invoice,Sales Team1,Timu ya Mauzo1
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} does not exist,Kipengee {0} haipo
DocType: Sales Invoice,Customer Address,Anwani ya Wateja
DocType: Loan,Loan Details,Maelezo ya Mikopo
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup post company fixtures,Imeshindwa kuanzisha safu za kampuni za posta
DocType: Company,Default Inventory Account,Akaunti ya Akaunti ya Default
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The folio numbers are not matching,Nambari za folio hazifananishi
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Request for {0},Ombi la Malipo kwa {0}
DocType: Item Barcode,Barcode Type,Aina ya Barcode
DocType: Antibiotic,Antibiotic Name,Jina la Antibiotic
apps/erpnext/erpnext/config/buying.py,Supplier Group master.,Kikundi cha Wasambazaji.
DocType: Healthcare Service Unit,Occupancy Status,Hali ya Makazi
DocType: Purchase Invoice,Apply Additional Discount On,Weka Kutoa Discount On
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Type...,Chagua Aina ...
apps/erpnext/erpnext/templates/pages/help.html,Your tickets,Tiketi zako
DocType: Account,Root Type,Aina ya mizizi
DocType: Item,FIFO,FIFO
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Close the POS,Funga POS
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Cannot return more than {1} for Item {2},Row # {0}: Haiwezi kurudi zaidi ya {1} kwa Bidhaa {2}
DocType: Item Group,Show this slideshow at the top of the page,Onyesha slideshow hii juu ya ukurasa
DocType: BOM,Item UOM,Kipengee cha UOM
DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Kiwango cha Ushuru Baada ya Kiasi cha Fedha (Fedha la Kampuni)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Target warehouse is mandatory for row {0},Ghala inayolenga ni lazima kwa mstari {0}
apps/erpnext/erpnext/config/retail.py,Retail Operations,Uendeshaji wa Uuzaji
DocType: Cheque Print Template,Primary Settings,Mipangilio ya msingi
DocType: Attendance Request,Work From Home,Kazi Kutoka Nyumbani
DocType: Purchase Invoice,Select Supplier Address,Chagua Anwani ya Wasambazaji
apps/erpnext/erpnext/public/js/event.js,Add Employees,Ongeza Waajiriwa
DocType: Purchase Invoice Item,Quality Inspection,Ukaguzi wa Ubora
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Extra Small,Kinga ndogo
DocType: Company,Standard Template,Kigezo cha Kigezo
DocType: Training Event,Theory,Nadharia
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Warning: Material Requested Qty is less than Minimum Order Qty,Onyo: Nyenzo Nambari Iliyoombwa ni chini ya Upeo wa chini wa Uagizaji
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Account {0} is frozen,Akaunti {0} imehifadhiwa
DocType: Quiz Question,Quiz Question,Swali la Jaribio
DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Shirika la Kisheria / Subsidiary na Chart tofauti ya Akaunti ya Shirika.
DocType: Payment Request,Mute Email,Tuma barua pepe
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,"Food, Beverage & Tobacco","Chakula, Beverage &amp; Tobacco"
DocType: Account,Account Number,Idadi ya Akaunti
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Can only make payment against unbilled {0},Inaweza tu kulipa malipo dhidi ya unbilled {0}
DocType: Call Log,Missed,Imekosa
apps/erpnext/erpnext/controllers/selling_controller.py,Commission rate cannot be greater than 100,Kiwango cha Tume haiwezi kuwa zaidi ya 100
apps/erpnext/erpnext/stock/doctype/item_manufacturer/item_manufacturer.py,Duplicate entry against the item code {0} and manufacturer {1},Ingizo maradufu dhidi ya nambari ya bidhaa {0} na mtengenezaji {1}
DocType: Sales Invoice,Allocate Advances Automatically (FIFO),Shirikisha Maendeleo kwa moja kwa moja (FIFO)
DocType: Volunteer,Volunteer,Kujitolea
DocType: Buying Settings,Subcontract,Usikilize
apps/erpnext/erpnext/public/js/utils/party.js,Please enter {0} first,Tafadhali ingiza {0} kwanza
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py,No replies from,Hakuna majibu kutoka
DocType: Work Order Operation,Actual End Time,Wakati wa mwisho wa mwisho
DocType: Production Plan,Download Materials Required,Weka Vifaa Vipengee
DocType: Purchase Invoice Item,Manufacturer Part Number,Nambari ya Sehemu ya Mtengenezaji
DocType: Taxable Salary Slab,Taxable Salary Slab,Kisasa cha Mshahara
DocType: Work Order Operation,Estimated Time and Cost,Muda na Gharama zilizohesabiwa
apps/erpnext/erpnext/controllers/stock_controller.py,Quality Inspection: {0} is not submitted for the item: {1} in row {2},Ukaguzi wa Ubora: {0} haujawasilishwa kwa kipengee: {1} kwa safu {2}
DocType: Bin,Bin,Bin
DocType: Bank Transaction,Bank Transaction,Uuzaji wa benki
DocType: Crop,Crop Name,Jina la Mazao
apps/erpnext/erpnext/hub_node/api.py,Only users with {0} role can register on Marketplace,Watumiaji tu walio na jukumu la {0} wanaweza kujiandikisha kwenye Soko
DocType: SMS Log,No of Sent SMS,Hakuna SMS iliyotumwa
DocType: Leave Application,HR-LAP-.YYYY.-,HR-LAP -YYYY.-
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py,Appointments and Encounters,Uteuzi na Mkutano
DocType: Antibiotic,Healthcare Administrator,Msimamizi wa Afya
apps/erpnext/erpnext/utilities/user_progress.py,Set a Target,Weka Lengo
DocType: Dosage Strength,Dosage Strength,Nguvu ya Kipimo
DocType: Healthcare Practitioner,Inpatient Visit Charge,Msaada wa Ziara ya Wagonjwa
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,Published Items,Vitu vilivyochapishwa
DocType: Account,Expense Account,Akaunti ya gharama
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Software,Programu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Colour,Rangi
DocType: Assessment Plan Criteria,Assessment Plan Criteria,Vigezo vya Mpango wa Tathmini
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Shughuli
DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Zuia Maagizo ya Ununuzi
apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Inapotosha
DocType: Email Campaign,Scheduled,Imepangwa
DocType: Shift Type,Working Hours Calculation Based On,Kufanya kazi Mahesabu kwa msingi wa
apps/erpnext/erpnext/config/buying.py,Request for quotation.,Ombi la nukuu.
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js,"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle","Tafadhali chagua Kitu ambacho &quot;Je, Kitu cha Hifadhi&quot; ni &quot;Hapana&quot; na &quot;Je, Ni Kitu cha Mauzo&quot; ni &quot;Ndiyo&quot; na hakuna Bundi la Bidhaa"
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js,Select Customer,Chagua Wateja
DocType: Student Log,Academic,Elimu
DocType: Patient,Personal and Social History,Historia ya kibinafsi na ya kijamii
apps/erpnext/erpnext/education/doctype/guardian/guardian.py,User {0} created,Mtumiaji {0} ameundwa
DocType: Fee Schedule,Fee Breakup for each student,Kulipwa kwa kila mwanafunzi
apps/erpnext/erpnext/controllers/accounts_controller.py,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Jumla ya mapema ({0}) dhidi ya Amri {1} haiwezi kuwa kubwa kuliko Jumla ya Jumla ({2})
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Code,Badilisha Kanuni
DocType: Purchase Invoice Item,Valuation Rate,Kiwango cha Thamani
apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Unda anuwai
DocType: Vehicle,Diesel,Dizeli
apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Orodha ya Bei Fedha isiyochaguliwa
DocType: Purchase Invoice,Availed ITC Cess,Imepata ITC Cess
,Student Monthly Attendance Sheet,Karatasi ya Wahudumu wa Mwezi kila mwezi
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Sheria ya usafirishaji inatumika tu kwa Kuuza
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Upungufu wa Row {0}: Tarehe ya Utoaji wa Dhamana haiwezi kuwa kabla ya Tarehe ya Ununuzi
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Start Date,Tarehe ya Kuanza Mradi
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Until,Mpaka
DocType: Rename Tool,Rename Log,Rejesha Ingia
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,Student Group or Course Schedule is mandatory,Kundi la Wanafunzi au Ratiba ya Kozi ni lazima
DocType: Maintenance Visit Purpose,Against Document No,Dhidi ya Nambari ya Hati
DocType: BOM,Scrap,Vipande
apps/erpnext/erpnext/utilities/user_progress.py,Go to Instructors,Nenda kwa Walimu
apps/erpnext/erpnext/config/selling.py,Manage Sales Partners.,Dhibiti Washirika wa Mauzo.
DocType: Quality Inspection,Inspection Type,Aina ya Ukaguzi
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,All bank transactions have been created,Uuzaji wote wa benki umeundwa
DocType: Fee Validity,Visited yet,Alirudi bado
apps/erpnext/erpnext/public/js/hub/pages/FeaturedItems.vue,You can Feature upto 8 items.,Unaweza Kuangazia vitu 8.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with existing transaction can not be converted to group.,Maghala na shughuli zilizopo haziwezi kubadilishwa kuwa kikundi.
DocType: Assessment Result Tool,Result HTML,Matokeo ya HTML
DocType: Selling Settings,How often should project and company be updated based on Sales Transactions.,Ni mara ngapi mradi na kampuni zinasasishwa kulingana na Shughuli za Mauzo.
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,Expires On,Inamalizika
apps/erpnext/erpnext/utilities/user_progress.py,Add Students,Ongeza Wanafunzi
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js,Please select {0},Tafadhali chagua {0}
DocType: C-Form,C-Form No,Fomu ya Fomu ya C
DocType: Delivery Stop,Distance,Umbali
apps/erpnext/erpnext/utilities/user_progress.py,List your products or services that you buy or sell.,Andika orodha ya bidhaa au huduma zako unazouza au kuuza.
DocType: Water Analysis,Storage Temperature,Joto la Uhifadhi
DocType: Sales Order,SAL-ORD-.YYYY.-,SAL-ORD -YYYY.-
DocType: Employee Attendance Tool,Unmarked Attendance,Uhudhurio usiojulikana
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Creating Payment Entries......,Kujenga Entries Payment ......
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Researcher,Mtafiti
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Plaid public token error,Makosa ya ishara ya umma
DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Chombo cha Uandikishaji wa Programu Mwanafunzi
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py,Start date should be less than end date for task {0},Tarehe ya kuanza lazima iwe chini ya tarehe ya mwisho ya kazi {0}
,Consolidated Financial Statement,Taarifa ya Fedha ya Pamoja
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py,Name or Email is mandatory,Jina au barua pepe ni lazima
DocType: Instructor,Instructor Log,Ingia ya Mkufunzi
DocType: Clinical Procedure,Clinical Procedure,Utaratibu wa Kliniki
DocType: Shopify Settings,Delivery Note Series,Mfululizo wa Kumbuka utoaji
DocType: Purchase Order Item,Returned Qty,Nambari ya Kurudi
DocType: Student,Exit,Utgång
DocType: Communication Medium,Communication Medium,Mawasiliano Kati
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root Type is mandatory,Aina ya mizizi ni lazima
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to install presets,Imeshindwa kufunga presets
DocType: Healthcare Service Unit Type,UOM Conversion in Hours,Kubadilisha UOM kwa Masaa
DocType: Contract,Signee Details,Maelezo ya Signee
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.","{0} kwa sasa ina {1} Wafanyabiashara Scorecard amesimama, na RFQs kwa muuzaji huyu inapaswa kutolewa."
DocType: Certified Consultant,Non Profit Manager,Meneja Msaada
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} created,Serial Hapana {0} imeundwa
DocType: Homepage,Company Description for website homepage,Maelezo ya Kampuni kwa homepage tovuti
DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Kwa urahisi wa wateja, kanuni hizi zinaweza kutumiwa katika fomu za kuchapisha kama Invoices na Vidokezo vya Utoaji"
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py,Suplier Name,Jina la Juu
apps/erpnext/erpnext/accounts/report/financial_statements.py,Could not retrieve information for {0}.,Haikuweza kupata maelezo ya {0}.
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py,Opening Entry Journal,Journal ya Kuingia ya Kuingia
DocType: Contract,Fulfilment Terms,Masharti ya Utekelezaji
DocType: Sales Invoice,Time Sheet List,Orodha ya Karatasi ya Muda
DocType: Employee,You can enter any date manually,Unaweza kuingia tarehe yoyote kwa mkono
DocType: Healthcare Settings,Result Printed,Matokeo yaliyochapishwa
DocType: Asset Category Account,Depreciation Expense Account,Akaunti ya gharama ya kushuka kwa thamani
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Probationary Period,Muda wa majaribio
DocType: Purchase Taxes and Charges Template,Is Inter State,Ni Jimbo la Kati
apps/erpnext/erpnext/config/hr.py,Shift Management,Usimamizi wa Shift
DocType: Customer Group,Only leaf nodes are allowed in transaction,Node tu za majani zinaruhusiwa katika shughuli
DocType: Project,Total Costing Amount (via Timesheets),Kiwango cha jumla cha gharama (kupitia Timesheets)
DocType: Department,Expense Approver,Msaidizi wa gharama
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Row {0}: Upendeleo dhidi ya Wateja lazima uwe mkopo
DocType: Quality Meeting,Quality Meeting,Mkutano wa Ubora
apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Siyo Kikundi kwa Kundi
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Tafadhali weka Mfululizo wa Jina la {0} kupitia Kusanidi&gt; Mipangilio&gt; Mfululizo wa Kumtaja
DocType: Employee,ERPNext User,ERPNext User
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Kundi ni lazima katika mstari {0}
DocType: Company,Default Buying Terms,Masharti ya Kununua chaguo msingi
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Ununuzi wa Receipt Item Inayolewa
DocType: Amazon MWS Settings,Enable Scheduled Synch,Wezesha Synch iliyopangwa
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py,To Datetime,Ili Ufikiaji
apps/erpnext/erpnext/config/crm.py,Logs for maintaining sms delivery status,Ingia kwa kudumisha hali ya utoaji wa SMS
DocType: Accounts Settings,Make Payment via Journal Entry,Fanya Malipo kupitia Ingia ya Machapisho
apps/erpnext/erpnext/controllers/item_variant.py,Please do not create more than 500 items at a time,Tafadhali usijenge vitu zaidi ya 500 kwa wakati mmoja
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Printed On,Kuchapishwa
DocType: Clinical Procedure Template,Clinical Procedure Template,Kigezo cha Utaratibu wa Kliniki
DocType: Item,Inspection Required before Delivery,Ukaguzi unahitajika kabla ya Utoaji
apps/erpnext/erpnext/config/education.py,Content Masters,Mabwana wa Yaliyomo
DocType: Item,Inspection Required before Purchase,Ukaguzi unahitajika kabla ya Ununuzi
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Pending Activities,Shughuli zinazosubiri
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js,Create Lab Test,Unda Jaribio la Lab
DocType: Patient Appointment,Reminded,Alikumbushwa
DocType: Homepage Section,Cards,Kadi
apps/erpnext/erpnext/public/js/setup_wizard.js,View Chart of Accounts,Angalia Chati ya Akaunti
DocType: Chapter Member,Chapter Member,Mjumbe wa Sura
DocType: Material Request Plan Item,Minimum Order Quantity,Kiwango cha chini cha utaratibu
apps/erpnext/erpnext/public/js/setup_wizard.js,Your Organization,Shirika lako
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,"Skipping Leave Allocation for the following employees, as Leave Allocation records already exists against them. {0}","Kukimbia Kuondoa Ugawaji kwa wafanyakazi wafuatayo, kama kuacha rekodi za Ugawaji tayari zipo juu yao. {0}"
DocType: Fee Component,Fees Category,Ada ya Jamii
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please enter relieving date.,Tafadhali ingiza tarehe ya kufuta.
apps/erpnext/erpnext/controllers/trends.py,Amt,Am
DocType: Travel Request,"Details of Sponsor (Name, Location)","Maelezo ya Msaidizi (Jina, Mahali)"
DocType: Supplier Scorecard,Notify Employee,Wajulishe Waajiriwa
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Enter value betweeen {0} and {1},Ingiza betwe kumi na moja {0} na {1}
DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,Ingiza jina la kampeni ikiwa chanzo cha uchunguzi ni kampeni
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Newspaper Publishers,Waandishi wa gazeti
apps/erpnext/erpnext/hr/utils.py,Future dates not allowed,Tarehe za baadaye haziruhusiwi
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Expected Delivery Date should be after Sales Order Date,Tarehe ya utoaji inayotarajiwa inapaswa kuwa baada ya Tarehe ya Kuagiza Mauzo
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Reorder Level,Reorder Level
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Chart Of Accounts Template,Chati ya Kigezo cha Akaunti
DocType: Attendance,Attendance Date,Tarehe ya Kuhudhuria
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Update stock must be enable for the purchase invoice {0},Sasisha hisa lazima ziwezeshe kwa ankara ya ununuzi {0}
apps/erpnext/erpnext/stock/get_item_details.py,Item Price updated for {0} in Price List {1},Item Bei iliyosasishwa kwa {0} katika Orodha ya Bei {1}
,DATEV,DATEV
DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Uvunjaji wa mshahara kulingana na Kupata na Kupunguza.
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with child nodes cannot be converted to ledger,Akaunti yenye nodes za mtoto haiwezi kubadilishwa kwenye kiongozi
DocType: Purchase Invoice Item,Accepted Warehouse,Ghala iliyokubaliwa
DocType: Bank Reconciliation Detail,Posting Date,Tarehe ya Kuchapisha
DocType: Item,Valuation Method,Njia ya Hesabu
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,One customer can be part of only single Loyalty Program.,Mteja mmoja anaweza kuwa sehemu ya Programu ya Uaminifu pekee.
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Half Day,Mark Half Day
DocType: Sales Invoice,Sales Team,Timu ya Mauzo
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Duplicate entry,Kuingia mara kwa mara
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the name of the Beneficiary before submittting.,Ingiza jina la Msaidizi kabla ya kuwasilisha.
DocType: Program Enrollment Tool,Get Students,Pata Wanafunzi
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Bank Data mapper doesn't exist,Programu ya data ya Benki haipo
DocType: Serial No,Under Warranty,Chini ya udhamini
DocType: Homepage Section,Number of columns for this section. 3 cards will be shown per row if you select 3 columns.,Idadi ya safuwima za sehemu hii. Kadi 3 zitaonyeshwa kwa safu moja ikiwa utachagua safu tatu.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,[Error],[Hitilafu]
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Reconcile Entries,Kupatanisha Viingilio
DocType: Sales Order,In Words will be visible once you save the Sales Order.,Katika Maneno itaonekana wakati unapohifadhi Amri ya Mauzo.
,Employee Birthday,Kuzaliwa kwa Waajiriwa
apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py,Please select Completion Date for Completed Repair,Tafadhali chagua tarehe ya kukamilisha ya kukamilika kukamilika
DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Chombo cha Uhudhuriaji wa Wanafunzi
apps/erpnext/erpnext/controllers/status_updater.py,Limit Crossed,Upeo umevuka
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js,Scheduled Upto,Imepangwa Upto
apps/erpnext/erpnext/hr/doctype/shift_type/shift_type.js,Attendance has been marked as per employee check-ins,Mahudhurio yamewekwa alama kwa kila ukaguzi wa wafanyikazi
DocType: Woocommerce Settings,Secret,Siri
DocType: Plaid Settings,Plaid Secret,Siri iliyowekwa wazi
DocType: Company,Date of Establishment,Tarehe ya Uanzishwaji
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Venture Capital,Capital Venture
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Jina la kitaaluma na &#39;Mwaka wa Mwaka&#39; &#39;{0} na&#39; Jina la Muda &#39;{1} tayari lipo. Tafadhali tengeneza safu hizi na jaribu tena.
apps/erpnext/erpnext/stock/doctype/item/item.py,"As there are existing transactions against item {0}, you can not change the value of {1}","Kama kuna shughuli zilizopo dhidi ya kipengee {0}, huwezi kubadilisha thamani ya {1}"
DocType: UOM,Must be Whole Number,Inapaswa kuwa Nambari Yote
DocType: Campaign Email Schedule,Send After (days),Tuma Baada ya (siku)
DocType: Leave Control Panel,New Leaves Allocated (In Days),Majani mapya yaliyowekwa (Katika Siku)
DocType: Purchase Invoice,Invoice Copy,Nakala ya ankara
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,Serial No {0} does not exist,Serial Hakuna {0} haipo
DocType: Sales Invoice Item,Customer Warehouse (Optional),Ghala la Wateja (Hiari)
DocType: Blanket Order Item,Blanket Order Item,Kipengee cha Order ya Kikiti
DocType: Pricing Rule,Discount Percentage,Asilimia ya Punguzo
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for sub contracting,Imehifadhiwa kwa kuambukizwa ndogo
DocType: Payment Reconciliation Invoice,Invoice Number,Nambari ya ankara
DocType: Shopping Cart Settings,Orders,Amri
DocType: Travel Request,Event Details,Maelezo ya Tukio
DocType: Department,Leave Approver,Acha Msaidizi
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select a batch,Tafadhali chagua batch
DocType: Sales Invoice,Redemption Cost Center,Kituo cha Gharama ya Ukombozi
DocType: QuickBooks Migrator,Scope,Upeo
DocType: Assessment Group,Assessment Group Name,Jina la Kundi la Tathmini
DocType: Manufacturing Settings,Material Transferred for Manufacture,Nyenzo Iliyohamishwa kwa Utengenezaji
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Add to Details,Ongeza maelezo
DocType: Travel Itinerary,Taxi,Teksi
DocType: Shopify Settings,Last Sync Datetime,Mwisho wa Tarehe ya Ulinganisho
DocType: Landed Cost Item,Receipt Document Type,Aina ya Hati ya Rekodi
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Proposal/Price Quote,Pendekezo / Punguzo la Bei
DocType: Antibiotic,Healthcare,Huduma ya afya
DocType: Target Detail,Target Detail,Maelezo ya Target
apps/erpnext/erpnext/stock/doctype/item/item.js,Single Variant,Tofauti moja
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,All Jobs,Kazi zote
DocType: Sales Order,% of materials billed against this Sales Order,% ya vifaa vilivyotokana na Utaratibu huu wa Mauzo
DocType: Program Enrollment,Mode of Transportation,Njia ya Usafiri
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"From a supplier under composition scheme, Exempt and Nil rated","Kutoka kwa muuzaji chini ya mpango wa utungaji, Msamaha na Nil uliyokadiriwa"
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js,Period Closing Entry,Uingiaji wa Kipindi cha Kipindi
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Department...,Chagua Idara ...
DocType: Pricing Rule,Free Item,Bidhaa Bure
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Suppliies made to Composition Taxable Persons,Vifaa vilivyoundwa kwa muundo wa watu wanaopaswa kuwa na Kodi
apps/erpnext/erpnext/regional/india/utils.py,Distance cannot be greater than 4000 kms,Umbali hauwezi kuwa mkubwa kuliko kilomita 4000
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cost Center with existing transactions can not be converted to group,Kituo cha Gharama na shughuli zilizopo haziwezi kubadilishwa kuwa kikundi
DocType: QuickBooks Migrator,Authorization URL,URL ya idhini
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} {2} {3},Kiasi {0} {1} {2} {3}
DocType: Account,Depreciation,Kushuka kwa thamani
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The number of shares and the share numbers are inconsistent,Idadi ya hisa na nambari za kushiriki si sawa
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Supplier(s),Wasambazaji (s)
DocType: Employee Attendance Tool,Employee Attendance Tool,Chombo cha Kuhudhuria Waajiriwa
DocType: Guardian Student,Guardian Student,Mwanafunzi wa Guardian
DocType: Supplier,Credit Limit,Kizuizi cha Mikopo
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Avg. Selling Price List Rate,Mg. Orodha ya Bei ya Kuuza
DocType: Loyalty Program Collection,Collection Factor (=1 LP),Factor ya Ukusanyaji (= 1 LP)
DocType: Additional Salary,Salary Component,Kipengele cha Mshahara
apps/erpnext/erpnext/accounts/utils.py,Payment Entries {0} are un-linked,Maingizo ya Malipo {0} hayajaunganishwa
DocType: GL Entry,Voucher No,Voucher No
,Lead Owner Efficiency,Ufanisi wa Mmiliki wa Uongozi
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Workday {0} has been repeated.,Siku ya kazi {0} imerudiwa.
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"You can claim only an amount of {0}, the rest amount {1} should be in the application \
				as pro-rata component","Unaweza kudai tu kiasi cha {0}, kiasi cha kupumzika {1} kinapaswa kuwa katika programu \ kama sehemu ya pro-rata"
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Employee A/C Number,Mfanyikazi A / C Idadi
DocType: Amazon MWS Settings,Customer Type,Aina ya Wateja
DocType: Compensatory Leave Request,Leave Allocation,Acha Ugawaji
DocType: Payment Request,Recipient Message And Payment Details,Ujumbe wa mpokeaji na maelezo ya malipo
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Please select a Delivery Note,Tafadhali chagua Ujumbe wa Uwasilishaji
DocType: Support Search Source,Source DocType,DocType ya Chanzo
apps/erpnext/erpnext/templates/pages/help.html,Open a new ticket,Fungua tiketi mpya
DocType: Training Event,Trainer Email,Barua ya Mkufunzi
DocType: Sales Invoice,Transporter,Transporter
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Day Book Data,Ingiza Takwimu ya Kitabu cha Siku
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Priority {0} has been repeated.,Kipaumbele {0} kimerudiwa.
DocType: Restaurant Reservation,No of People,Hakuna Watu
apps/erpnext/erpnext/config/buying.py,Template of terms or contract.,Kigezo cha maneno au mkataba.
DocType: Bank Account,Address and Contact,Anwani na Mawasiliano
DocType: Vital Signs,Hyper,Hyper
DocType: Cheque Print Template,Is Account Payable,Ni Malipo ya Akaunti
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Stock cannot be updated against Purchase Receipt {0},Hifadhi haiwezi kurekebishwa dhidi ya Receipt ya Ununuzi {0}
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.js,Create Delivery Trip,Unda safari ya Uwasilishaji
DocType: Support Settings,Auto close Issue after 7 days,Funga karibu na Suala baada ya siku 7
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Kuondoka hakuwezi kutengwa kabla ya {0}, kama usawa wa kuondoka tayari umebeba katika rekodi ya ugawaji wa kuondoka baadaye {1}"
apps/erpnext/erpnext/accounts/party.py,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Kumbuka: Kutokana / Tarehe ya Marejeo inazidi siku za mikopo za mteja zilizoruhusiwa na {0} siku (s)
DocType: Program Enrollment Tool,Student Applicant,Mwombaji wa Mwanafunzi
DocType: Hub Tracked Item,Hub Tracked Item,Kitengo cha Ufuatiliaji wa Hub
DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,KIFUNA KWA RECIPIENT
DocType: Asset Category Account,Accumulated Depreciation Account,Akaunti ya Kushuka kwa Uzito
DocType: Certified Consultant,Discuss ID,Jadili ID
DocType: Stock Settings,Freeze Stock Entries,Fungua Entries za Stock
DocType: Program Enrollment,Boarding Student,Kuogelea Mwanafunzi
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Please enable Applicable on Booking Actual Expenses,Tafadhali itawezesha kuhitajika kwenye gharama halisi ya kusajili
DocType: Asset Finance Book,Expected Value After Useful Life,Thamani Inayotarajiwa Baada ya Maisha ya Muhimu
DocType: Item,Reorder level based on Warehouse,Weka upya ngazi kulingana na Ghala
DocType: Activity Cost,Billing Rate,Kiwango cha kulipia
,Qty to Deliver,Uchina Ili Kuokoa
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Create Disbursement Entry,Unda Uingilio wa Malipo
DocType: Amazon MWS Settings,Amazon will synch data updated after this date,Amazon itasanisha data iliyosasishwa baada ya tarehe hii
,Stock Analytics,Analytics ya hisa
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Operations cannot be left blank,Kazi haiwezi kushoto tupu
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Select a Default Priority.,Chagua Kipaumbele Cha msingi.
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py,Lab Test(s) ,Mtihani wa Lab
DocType: Maintenance Visit Purpose,Against Document Detail No,Dhidi ya Detail Document No
apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Ufuta hauruhusiwi kwa nchi {0}
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Aina ya Chama ni lazima
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","Kwa kadi ya kazi {0}, unaweza tu kutengeneza &#39;Transfer ya Nyenzo kwa kuingia kwa aina ya Uuzaji&#39;"
DocType: Quality Inspection,Outgoing,Inatoka
DocType: Customer Feedback Table,Customer Feedback Table,Meza ya Maoni ya Wateja
apps/erpnext/erpnext/config/support.py,Service Level Agreement.,Mkataba wa Kiwango cha Huduma.
DocType: Material Request,Requested For,Aliomba
DocType: Quotation Item,Against Doctype,Dhidi ya Doctype
apps/erpnext/erpnext/controllers/selling_controller.py,{0} {1} is cancelled or closed,{0} {1} imefutwa au imefungwa
DocType: Asset,Calculate Depreciation,Tathmini ya kushuka kwa thamani
DocType: Delivery Note,Track this Delivery Note against any Project,Fuatilia Kumbuka hii ya utoaji dhidi ya Mradi wowote
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Investing,Fedha Nasi kutoka Uwekezaji
DocType: Purchase Invoice,Import Of Capital Goods,Umuhimu wa Bidhaa za Mitaji
DocType: Work Order,Work-in-Progress Warehouse,Ghala ya Maendeleo ya Kazi
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Asset {0} must be submitted,Malipo {0} yanapaswa kuwasilishwa
DocType: Fee Schedule Program,Total Students,Jumla ya Wanafunzi
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,Attendance Record {0} exists against Student {1},Rekodi ya Mahudhurio {0} ipo dhidi ya Mwanafunzi {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference #{0} dated {1},Rejea # {0} dated {1}
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Depreciation Eliminated due to disposal of assets,Kushuka kwa thamani kumetolewa kutokana na uondoaji wa mali
DocType: Employee Transfer,New Employee ID,Kitambulisho cha Waajiriwa Mpya
DocType: Loan,Member,Mwanachama
DocType: Work Order Item,Work Order Item,Jedwali la Kazi ya Kazi
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js,Show Opening Entries,Onyesha Viingilio vya Ufunguzi
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.js,Unlink external integrations,Ondoa unganisho la nje
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Choose a corresponding payment,Chagua malipo yanayolingana
DocType: Pricing Rule,Item Code,Msimbo wa kipengee
DocType: Student,EDU-STU-.YYYY.-,EDU-STU -YYYY.-
DocType: Serial No,Warranty / AMC Details,Maelezo ya udhamini / AMC
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Select students manually for the Activity based Group,Chagua wanafunzi kwa kikundi kwa Kundi la Shughuli
DocType: Journal Entry,User Remark,Remark ya Mtumiaji
DocType: Travel Itinerary,Non Diary,Haija Diary
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py,Cannot create Retention Bonus for left Employees,Haiwezi kuunda Bonus ya kuhifadhiwa kwa Waajiri wa kushoto
DocType: Lead,Market Segment,Sehemu ya Soko
DocType: Agriculture Analysis Criteria,Agriculture Manager,Meneja wa Kilimo
DocType: Supplier Scorecard Period,Variables,Vigezo
DocType: Employee Internal Work History,Employee Internal Work History,Mfanyakazi wa Historia ya Kazi ya Kazi
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Closing (Dr),Kufungwa (Dk)
DocType: Cheque Print Template,Cheque Size,Angalia Ukubwa
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} not in stock,Serial Hakuna {0} sio katika hisa
apps/erpnext/erpnext/config/accounting.py,Tax template for selling transactions.,Template ya kodi kwa kuuza shughuli.
DocType: Sales Invoice,Write Off Outstanding Amount,Andika Off Kiasi Bora
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py,Account {0} does not match with Company {1},Akaunti {0} haifanani na Kampuni {1}
DocType: Education Settings,Current Academic Year,Mwaka wa Mafunzo ya Sasa
DocType: Stock Settings,Default Stock UOM,Ufafanuzi wa hisa Uliopita
DocType: Asset,Number of Depreciations Booked,Idadi ya kushuka kwa thamani iliyopangwa
apps/erpnext/erpnext/public/js/pos/pos.html,Qty Total,Uchina Jumla
DocType: Landed Cost Item,Receipt Document,Hati ya Receipt
DocType: Employee Education,School/University,Shule / Chuo Kikuu
DocType: Sales Invoice Item,Available Qty at Warehouse,Uchina Inapatikana katika Ghala
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Billed Amount,Ulipa kiasi
DocType: Share Transfer,(including),(ikiwa ni pamoja na)
DocType: Quality Review Table,Yes/No,Ndio la
DocType: Asset,Double Declining Balance,Mizani miwili ya kupungua
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Closed order cannot be cancelled. Unclose to cancel.,Utaratibu wa kufungwa hauwezi kufutwa. Fungua kufuta.
DocType: Amazon MWS Settings,Synch Products,Bidhaa za Synch
DocType: Loyalty Point Entry,Loyalty Program,Programu ya Uaminifu
DocType: Student Guardian,Father,Baba
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,Support Tickets,Tiketi za Msaada
apps/erpnext/erpnext/controllers/accounts_controller.py,'Update Stock' cannot be checked for fixed asset sale,Mwisho Stock &#39;hauwezi kuchunguziwa kwa uuzaji wa mali fasta
DocType: Bank Reconciliation,Bank Reconciliation,Upatanisho wa Benki
DocType: Attendance,On Leave,Kuondoka
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Get Updates,Pata Marekebisho
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Akaunti {2} sio ya Kampuni {3}
apps/erpnext/erpnext/stock/doctype/item/item.js,Select at least one value from each of the attributes.,Chagua angalau thamani moja kutoka kwa kila sifa.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Material Request {0} is cancelled or stopped,Ombi la Vifaa {0} limefutwa au kusimamishwa
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Dispatch State,Jimbo la Mgawanyiko
apps/erpnext/erpnext/config/help.py,Leave Management,Acha Usimamizi
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Groups,Vikundi
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Account,Kundi na Akaunti
DocType: Purchase Invoice,Hold Invoice,Weka ankara
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Please select Employee,Tafadhali chagua Mfanyakazi
DocType: Sales Order,Fully Delivered,Kutolewa kikamilifu
DocType: Promotional Scheme Price Discount,Min Amount,Kiasi cha chini
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Lower Income,Mapato ya chini
DocType: Restaurant Order Entry,Current Order,Utaratibu wa sasa
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Number of serial nos and quantity must be the same,Idadi ya namba za serial na kiasi lazima ziwe sawa
DocType: Delivery Trip,Driver Address,Anwani ya Dereva
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Source and target warehouse cannot be same for row {0},Chanzo na ghala la lengo haliwezi kuwa sawa kwa mstari {0}
DocType: Account,Asset Received But Not Billed,Mali zimepokea lakini hazipatikani
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Athari ya tofauti lazima iwe akaunti ya aina ya Asset / Dhima, tangu hii Upatanisho wa Stock ni Ufungashaji wa Ufunguzi"
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Disbursed Amount cannot be greater than Loan Amount {0},Kiasi kilichopotea hawezi kuwa kikubwa kuliko Kiasi cha Mikopo {0}
apps/erpnext/erpnext/utilities/user_progress.py,Go to Programs,Nenda kwenye Programu
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Row {0} # Kiasi kilichowekwa {1} haiwezi kuwa kikubwa kuliko kiasi kisichojulikana {2}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Purchase Order number required for Item {0},Nambari ya Order ya Ununuzi inahitajika kwa Bidhaa {0}
DocType: Leave Allocation,Carry Forwarded Leaves,Chukua majani yaliyosafishwa
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,'From Date' must be after 'To Date',&#39;Tarehe Tarehe&#39; lazima iwe baada ya &#39;Tarehe&#39;
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.js,No Staffing Plans found for this Designation,Hakuna Mpango wa Utumishi uliopatikana kwa Uteuzi huu
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Batch {0} of Item {1} is disabled.,Kipengee {0} cha Item {1} kilimezimwa.
DocType: Leave Policy Detail,Annual Allocation,Ugawaji wa Mwaka
DocType: Travel Request,Address of Organizer,Anwani ya Mhariri
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Healthcare Practitioner...,Chagua Mtendaji wa Afya ...
DocType: Employee Boarding Activity,Applicable in the case of Employee Onboarding,Inafaa katika kesi ya Waajiri Onboarding
apps/erpnext/erpnext/config/accounting.py,Tax template for item tax rates.,Kiolezo cha ushuru cha viwango vya ushuru wa bidhaa.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry_list.js,Goods Transferred,Bidhaa zinahamishwa
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Cannot change status as student {0} is linked with student application {1},Haiwezi kubadilisha hali kama mwanafunzi {0} imeunganishwa na programu ya mwanafunzi {1}
DocType: Asset,Fully Depreciated,Kikamilifu imepungua
DocType: Item Barcode,UPC-A,UPC-A
,Stock Projected Qty,Uchina Uliopangwa
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Customer {0} does not belong to project {1},Wateja {0} sio mradi {1}
DocType: Employee Attendance Tool,Marked Attendance HTML,Kuhudhuria alama HTML
apps/erpnext/erpnext/utilities/activation.py,"Quotations are proposals, bids you have sent to your customers","Nukuu ni mapendekezo, zabuni ambazo umetuma kwa wateja wako"
DocType: Sales Invoice,Customer's Purchase Order,Amri ya Ununuzi wa Wateja
DocType: Clinical Procedure,Patient,Mgonjwa
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Bypass credit check at Sales Order ,Kagua hundi ya mikopo kwa Order Order
DocType: Employee Onboarding Activity,Employee Onboarding Activity,Kazi ya Onboarding Shughuli
DocType: Location,Check if it is a hydroponic unit,Angalia kama ni sehemu ya hydroponic
DocType: Pick List Item,Serial No and Batch,Serial Hakuna na Batch
DocType: Warranty Claim,From Company,Kutoka kwa Kampuni
DocType: GSTR 3B Report,January,Januari
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py,Sum of Scores of Assessment Criteria needs to be {0}.,Muhtasari wa Mipango ya Tathmini inahitaji kuwa {0}.
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please set Number of Depreciations Booked,Tafadhali weka Idadi ya Dhamana iliyopangwa
DocType: Supplier Scorecard Period,Calculations,Mahesabu
apps/erpnext/erpnext/public/js/stock_analytics.js,Value or Qty,Thamani au Uchina
DocType: Payment Terms Template,Payment Terms,Masharti ya Malipo
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Productions Orders cannot be raised for:,Amri za Uzalishaji haziwezi kuinuliwa kwa:
DocType: Quality Meeting Minutes,Minute,Dakika
DocType: Purchase Invoice,Purchase Taxes and Charges,Malipo na Malipo ya Ununuzi
DocType: Chapter,Meetup Embed HTML,Kukutana Embed HTML
DocType: Asset,Insured value,Thamani ya Bima
apps/erpnext/erpnext/utilities/user_progress.py,Go to Suppliers,Nenda kwa Wauzaji
DocType: POS Closing Voucher Taxes,POS Closing Voucher Taxes,Malipo ya Voucher ya Kufungwa ya POS
,Qty to Receive,Uchina Ili Kupokea
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,"Start and end dates not in a valid Payroll Period, cannot calculate {0}.","Tarehe za mwanzo na za mwisho sio wakati wa malipo ya halali, hauwezi kuhesabu {0}."
DocType: Leave Block List,Leave Block List Allowed,Acha orodha ya kuzuia Inaruhusiwa
DocType: Grading Scale Interval,Grading Scale Interval,Kuweka Kiwango cha Muda
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Expense Claim for Vehicle Log {0},Madai ya Madai ya Ingia ya Gari {0}
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Punguzo (%) kwenye Orodha ya Bei Kiwango na Margin
DocType: Healthcare Service Unit Type,Rate / UOM,Kiwango / UOM
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py,All Warehouses,Wilaya zote
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,No {0} found for Inter Company Transactions.,Hakuna {0} kupatikana kwa Shughuli za Inter Company.
DocType: Travel Itinerary,Rented Car,Imesajiliwa Gari
apps/erpnext/erpnext/public/js/hub/components/profile_dialog.js,About your Company,Kuhusu Kampuni yako
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Show Stock Ageing Data,Onyesha data ya uzee wa hisa
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Credit To account must be a Balance Sheet account,Mikopo Kwa akaunti lazima iwe Hesabu ya Hesabu ya Hesabu
DocType: Donor,Donor,Msaidizi
DocType: Global Defaults,Disable In Words,Zimaza Maneno
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Quotation {0} not of type {1},Nukuu {0} si ya aina {1}
DocType: Maintenance Schedule Item,Maintenance Schedule Item,Ratiba ya Ratiba ya Matengenezo
DocType: Sales Order,%  Delivered,Imetolewa
apps/erpnext/erpnext/education/doctype/fees/fees.js,Please set the Email ID for the Student to send the Payment Request,Tafadhali weka Kitambulisho cha Barua pepe kwa Mwanafunzi ili kutuma Ombi la Malipo
DocType: Skill,Skill Name,Ujuzi Jina
DocType: Patient,Medical History,Historia ya Matibabu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Bank Overdraft Account,Akaunti ya Overdraft ya Benki
DocType: Patient,Patient ID,Kitambulisho cha Mgonjwa
DocType: Practitioner Schedule,Schedule Name,Jina la Ratiba
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.py,Please enter GSTIN and state for the Company Address {0},Tafadhali ingiza GSTIN na eleza anwani ya Kampuni {0}
DocType: Currency Exchange,For Buying,Kwa Ununuzi
apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Juu ya Uwasilishaji wa Agizo la Ununuzi
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Ongeza Wauzaji Wote
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Mstari # {0}: Kiasi kilichowekwa hawezi kuwa kikubwa zaidi kuliko kiasi kikubwa.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Mteja&gt; Kikundi cha Wateja&gt; Wilaya
DocType: Tally Migration,Parties,Vyama
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Tafuta BOM
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Mikopo ya Salama
DocType: Purchase Invoice,Edit Posting Date and Time,Badilisha Tarehe ya Kuchapisha na Muda
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Tafadhali weka Akaunti ya Depreciation kuhusiana na Kundi la Malipo {0} au Kampuni {1}
DocType: Lab Test Groups,Normal Range,Rangi ya kawaida
DocType: Call Log,Call Duration in seconds,Piga simu muda katika sekunde
DocType: Academic Term,Academic Year,Mwaka wa Elimu
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Available Selling,Inapatikana Kuuza
DocType: Loyalty Point Entry Redemption,Loyalty Point Entry Redemption,Ukombozi wa Kuingia Uhalali wa Uaminifu
apps/erpnext/erpnext/config/accounting.py,Cost Center and Budgeting,Kituo cha Gharama na Bajeti
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Opening Balance Equity,Kufungua Mizani Equity
DocType: Campaign Email Schedule,CRM,CRM
apps/erpnext/erpnext/regional/italy/utils.py,Please set the Payment Schedule,Tafadhali weka Ratiba ya Malipo
DocType: Pick List,Items under this warehouse will be suggested,Vitu vilivyo chini ya ghala hili vitapendekezwa
DocType: Purchase Invoice,N,N
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Remaining,Inakaa
DocType: Appraisal,Appraisal,Tathmini
DocType: Loan,Loan Account,Akaunti ya Mkopo
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Valid from and valid upto fields are mandatory for the cumulative,Sahihi kutoka kwa uwanja halali wa upto ni lazima kwa hesabu
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.py,"For item {0} at row {1}, count of serial numbers does not match with the picked quantity","Kwa bidhaa {0} kwa safu {1}, hesabu ya nambari za serial hailingani na wingi uliochukuliwa"
DocType: Purchase Invoice,GST Details,Maelezo ya GST
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,This is based on transactions against this Healthcare Practitioner.,Hii inategemea shughuli dhidi ya Daktari wa Huduma hii ya Afya.
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Email sent to supplier {0},Barua pepe imetumwa kwa muuzaji {0}
DocType: Item,Default Sales Unit of Measure,Kipengee cha Mauzo cha Kiwango cha Mauzo
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Academic Year: ,Mwaka wa Chuo Kikuu:
DocType: Inpatient Record,Admission Schedule Date,Ratiba ya Ratiba ya Uingizaji
DocType: Subscription,Past Due Date,Tarehe ya Uliopita
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Usiruhusu kuweka kitu mbadala kwa kipengee {0}
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Tarehe inarudiwa
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Ishara iliyoidhinishwa
apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Tafadhali wasanidi Mfumo wa Kumtaja Mtaalam katika Elimu&gt; Mipangilio ya elimu
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),ITC Inapatikana (A) - (B)
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Unda ada
DocType: Project,Total Purchase Cost (via Purchase Invoice),Gharama ya Jumla ya Ununuzi (kupitia Invoice ya Ununuzi)
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Select Quantity,Chagua Wingi
DocType: Loyalty Point Entry,Loyalty Points,Pole ya Uaminifu
DocType: Customs Tariff Number,Customs Tariff Number,Nambari ya Ushuru wa Forodha
DocType: Employee Tax Exemption Proof Submission Detail,Maximum Exemption Amount,Kiwango cha juu cha Msamaha
DocType: Products Settings,Item Fields,Sehemu za Sehemu
DocType: Patient Appointment,Patient Appointment,Uteuzi wa Mgonjwa
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Approving Role cannot be same as role the rule is Applicable To,Idhini ya kupitisha haiwezi kuwa sawa na jukumu utawala unaofaa
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Unsubscribe from this Email Digest,Ondoa kutoka kwa Ujumbe huu wa Barua pepe
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Get Suppliers By,Pata Wauzaji
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,{0} not found for Item {1},{0} haipatikani kwa Bidhaa {1}
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Value must be between {0} and {1},Thamani lazima iwe kati ya {0} na {1}
apps/erpnext/erpnext/utilities/user_progress.py,Go to Courses,Nenda kwa Kozi
DocType: Accounts Settings,Show Inclusive Tax In Print,Onyesha kodi ya umoja katika kuchapisha
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,"Bank Account, From Date and To Date are Mandatory","Akaunti ya Benki, Kutoka Tarehe na Tarehe ni lazima"
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Message Sent,Ujumbe uliotumwa
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with child nodes cannot be set as ledger,Akaunti yenye nodes za watoto haiwezi kuweka kama kiongozi
DocType: C-Form,II,II
apps/erpnext/erpnext/assets/report/fixed_asset_register/fixed_asset_register.py,Vendor Name,Jina la muuzaji
DocType: Quiz Result,Wrong,Mbaya
DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Kiwango ambacho sarafu ya orodha ya Bei inabadilishwa kwa sarafu ya msingi ya mteja
DocType: Purchase Invoice Item,Net Amount (Company Currency),Kiasi cha Fedha (Kampuni ya Fedha)
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Jumla ya kiasi cha mapema haiwezi kuwa kubwa zaidi kuliko kiasi cha jumla kilichowekwa
DocType: Salary Slip,Hour Rate,Kiwango cha Saa
apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Washa Agizo la Kuunda upya kiotomatiki
DocType: Stock Settings,Item Naming By,Kipengele kinachojulikana
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Another Period Closing Entry {0} has been made after {1},Muda mwingine wa Kuingia Ufungashaji {0} umefanywa baada ya {1}
DocType: Work Order,Material Transferred for Manufacturing,Nyenzo Iliyohamishwa kwa Uzalishaji
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Account {0} does not exists,Akaunti {0} haipo
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Select Loyalty Program,Chagua Programu ya Uaminifu
DocType: Project,Project Type,Aina ya Mradi
apps/erpnext/erpnext/projects/doctype/task/task.py,Child Task exists for this Task. You can not delete this Task.,Kazi ya Watoto ipo kwa Kazi hii. Huwezi kufuta Kazi hii.
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,Either target qty or target amount is mandatory.,Vipi lengo la qty au kiasi lengo ni lazima.
apps/erpnext/erpnext/config/projects.py,Cost of various activities,Gharama ya shughuli mbalimbali
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Kuweka Matukio kwa {0}, kwa kuwa Mfanyikazi amefungwa kwa Watu chini ya Mauzo hawana ID ya Mtumiaji {1}"
DocType: Timesheet,Billing Details,Maelezo ya kulipia
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Source and target warehouse must be different,Chanzo na lengo la ghala lazima iwe tofauti
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,Payment Failed. Please check your GoCardless Account for more details,Malipo Imeshindwa. Tafadhali angalia Akaunti yako ya GoCardless kwa maelezo zaidi
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Not allowed to update stock transactions older than {0},Hairuhusiwi kusasisha ushirikiano wa hisa zaidi kuliko {0}
DocType: BOM,Inspection Required,Ukaguzi unahitajika
DocType: Purchase Invoice Item,PR Detail,Maelezo ya PR
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the Bank Guarantee Number before submittting.,Ingiza Nambari ya Dhamana ya Benki kabla ya kuwasilisha.
DocType: Driving License Category,Class,Darasa
DocType: Sales Order,Fully Billed,Imejazwa kikamilifu
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work Order cannot be raised against a Item Template,Kazi ya Kazi haiwezi kuinuliwa dhidi ya Kigezo cha Bidhaa
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Buying,Sheria ya usafirishaji inatumika tu kwa Ununuzi
DocType: Vital Signs,BMI,BMI
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Cash In Hand,Fedha Katika Mkono
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Delivery warehouse required for stock item {0},Ghala la utoaji inahitajika kwa kipengee cha hisa {0}
DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Uzito mkubwa wa mfuko. Kawaida uzito wa uzito + uzito wa vifaa vya uzito. (kwa kuchapishwa)
DocType: Assessment Plan,Program,Programu
DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Watumiaji wenye jukumu hili wanaruhusiwa kuweka akaunti zilizohifadhiwa na kujenga / kurekebisha entries za uhasibu dhidi ya akaunti zilizohifadhiwa
DocType: Plaid Settings,Plaid Environment,Mazingira ya Taa
,Project Billing Summary,Muhtasari wa Bili ya Mradi
DocType: Vital Signs,Cuts,Kupunguzwa
DocType: Serial No,Is Cancelled,Imeondolewa
DocType: Student Group,Group Based On,Kundi la msingi
DocType: Journal Entry,Bill Date,Tarehe ya Bili
DocType: Healthcare Settings,Laboratory SMS Alerts,Tahadhari SMS za Maabara
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,"Service Item,Type,frequency and expense amount are required","Kitu cha Huduma, Aina, frequency na gharama zinahitajika"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Hata kama kuna Kanuni nyingi za bei na kipaumbele cha juu, basi kufuatia vipaumbele vya ndani vinatumika:"
DocType: Plant Analysis Criteria,Plant Analysis Criteria,Vigezo vya Uchambuzi wa Kupanda
DocType: Cheque Print Template,Cheque Height,Angalia Urefu
DocType: Supplier,Supplier Details,Maelezo ya Wasambazaji
DocType: Setup Progress,Setup Progress,Maendeleo ya Kuweka
DocType: Expense Claim,Approval Status,Hali ya kibali
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,From value must be less than to value in row {0},Kutoka thamani lazima iwe chini kuliko ya thamani katika mstari {0}
DocType: Program,Intro Video,Video ya Intro
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Wire Transfer,Uhamisho wa Wire
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,From Date must be before To Date,Kutoka Tarehe lazima iwe kabla ya Tarehe
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Check all,Angalia yote
,Issued Items Against Work Order,Vitu vinavyochaguliwa dhidi ya kazi
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.js,Vacancies cannot be lower than the current openings,Nafasi haziwezi kuwa chini kuliko fursa za sasa
,BOM Stock Calculated,BOM Stock Imebainishwa
DocType: Vehicle Log,Invoice Ref,Invoice Ref
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Non-GST outward supplies,Vifaa visivyo vya GST
DocType: Company,Default Income Account,Akaunti ya Mapato ya Default
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Patient History,Historia ya mgonjwa
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Unclosed Fiscal Years Profit / Loss (Credit),Mikopo ya Mali isiyofunguliwa Faida / Kupoteza (Mikopo)
DocType: Sales Invoice,Time Sheets,Karatasi za Muda
DocType: Healthcare Service Unit Type,Change In Item,Badilisha katika Item
DocType: Payment Gateway Account,Default Payment Request Message,Ujumbe wa Ombi wa Ulipaji wa Pesa
DocType: Retention Bonus,Bonus Amount,Bonasi Kiasi
DocType: Item Group,Check this if you want to show in website,Angalia hii ikiwa unataka kuonyesha kwenye tovuti
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Balance ({0}),Mizani ({0})
DocType: Loyalty Point Entry,Redeem Against,Komboa Dhidi
apps/erpnext/erpnext/config/accounting.py,Banking and Payments,Benki na Malipo
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter API Consumer Key,Tafadhali ingiza Nambari ya Watumiaji wa API
DocType: Issue,Service Level Agreement Fulfilled,Mkataba wa Kiwango cha Huduma Imekamilika
,Welcome to ERPNext,Karibu kwenye ERPNext
apps/erpnext/erpnext/config/crm.py,Lead to Quotation,Cheza kwa Nukuu
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Email Reminders will be sent to all parties with email contacts,Vikumbusho vya barua pepe vitapelekwa kwa pande zote na mawasiliano ya barua pepe
DocType: Project,Twice Daily,Mara mbili kwa siku
DocType: Inpatient Record,A Negative,Hasi
apps/erpnext/erpnext/templates/includes/product_list.js,Nothing more to show.,Hakuna zaidi ya kuonyesha.
DocType: Lead,From Customer,Kutoka kwa Wateja
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Calls,Wito
apps/erpnext/erpnext/utilities/user_progress.py,A Product,Bidhaa
DocType: Employee Tax Exemption Declaration,Declarations,Maazimio
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Batches,Vita
DocType: Article,LMS User,Mtumiaji wa LMS
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Place Of Supply (State/UT),Mahali pa Ugavi (Jimbo / UT)
DocType: Purchase Order Item Supplied,Stock UOM,UOM ya hisa
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Purchase Order {0} is not submitted,Amri ya Ununuzi {0} haijawasilishwa
DocType: Account,Expenses Included In Asset Valuation,Malipo Yaliyo pamoja na Hesabu ya Mali
DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Aina ya kumbukumbu ya kawaida kwa mtu mzima ni pumzi 16 / dakika 16 (RCP 2012)
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Set Response Time and Resolution for Priority {0} at index {1}.,Weka wakati wa Majibu na Azimio la Kipaumbele {0} katika index {1}.
DocType: Customs Tariff Number,Tariff Number,Nambari ya Tari
DocType: Work Order Item,Available Qty at WIP Warehouse,Uchina Inapatikana katika WIP Ghala
apps/erpnext/erpnext/stock/doctype/item/item.js,Projected,Imepangwa
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Warehouse {1},Serial Hakuna {0} si ya Ghala {1}
apps/erpnext/erpnext/controllers/status_updater.py,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Kumbuka: Mfumo hautaangalia zaidi utoaji na utoaji wa ziada kwa Bidhaa {0} kama kiasi au kiasi ni 0
DocType: Issue,Opening Date,Tarehe ya Ufunguzi
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Please save the patient first,Tafadhali salama mgonjwa kwanza
apps/erpnext/erpnext/education/api.py,Attendance has been marked successfully.,Mahudhurio yamewekwa kwa mafanikio.
DocType: Program Enrollment,Public Transport,Usafiri wa Umma
DocType: Sales Invoice,GST Vehicle Type,GST Aina ya Gari
DocType: Soil Texture,Silt Composition (%),Silt Muundo (%)
DocType: Journal Entry,Remark,Remark
DocType: Healthcare Settings,Avoid Confirmation,Epuka uthibitisho
DocType: Bank Account,Integration Details,Maelezo ya Ujumuishaji
DocType: Purchase Receipt Item,Rate and Amount,Kiwango na Kiasi
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Account Type for {0} must be {1},Aina ya Akaunti ya {0} lazima iwe {1}
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Cannot Calculate Arrival Time as Driver Address is Missing.,Huwezi kuhesabu Wakati wa Kufika kwani Anwani ya Dereva inakosekana.
DocType: Education Settings,Current Academic Term,Kipindi cha sasa cha elimu
apps/erpnext/erpnext/public/js/controllers/transaction.js,Row #{0}: Item added,Njia # {0}: Bidhaa imeongezwa
DocType: Sales Order,Not Billed,Si Billed
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Both Warehouse must belong to same Company,Ghala zote mbili lazima ziwe na Kampuni moja
DocType: Employee Grade,Default Leave Policy,Sera ya Kuacha ya Kuondoka
DocType: Shopify Settings,Shop URL,Duka la URL
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,The selected payment entry should be linked with a debtor bank transaction,Kiingilio cha malipo kilichochaguliwa kinapaswa kuhusishwa na shughuli ya benki ya mdaiwa
apps/erpnext/erpnext/public/js/templates/contact_list.html,No contacts added yet.,Hakuna anwani zilizoongezwa bado.
DocType: Communication Medium Timeslot,Communication Medium Timeslot,Mawasiliano Timeslot ya kati
DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Kiwango cha Voucher ya Gharama
,Item Balance (Simple),Mizani ya Bidhaa (Rahisi)
apps/erpnext/erpnext/config/accounting.py,Bills raised by Suppliers.,Miradi iliyotolewa na Wauzaji.
DocType: POS Profile,Write Off Account,Andika Akaunti
DocType: Patient Appointment,Get prescribed procedures,Pata taratibu zilizowekwa
DocType: Sales Invoice,Redemption Account,Akaunti ya Ukombozi
apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.js,First add items in the Item Locations table,Kwanza ongeza vitu kwenye jedwali la Sehemu ya Bidhaa
DocType: Pricing Rule,Discount Amount,Kiasi cha Punguzo
DocType: Pricing Rule,Period Settings,Mipangilio ya kipindi
DocType: Purchase Invoice,Return Against Purchase Invoice,Rudi dhidi ya ankara ya ununuzi
DocType: Item,Warranty Period (in days),Kipindi cha udhamini (katika siku)
DocType: Shift Type,Enable Entry Grace Period,Wezesha kipindi cha Neema cha Kuingia
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian1,Uhusiano na Guardian1
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},Tafadhali chagua BOM dhidi ya kipengee {0}
DocType: Shopping Cart Settings,Show Stock Quantity,Onyesha Stock Wingi
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Fedha Nacho kutoka kwa Uendeshaji
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Njia # {0}: Hali lazima iwe {1} kwa Toleo la ankara {2}
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Item 4
DocType: Student Admission,Admission End Date,Tarehe ya Mwisho ya Kuingia
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Kwenye mkataba
DocType: Journal Entry Account,Journal Entry Account,Akaunti ya Kuingia kwa Kawaida
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js,Student Group,Kikundi cha Wanafunzi
DocType: Shopping Cart Settings,Quotation Series,Mfululizo wa Nukuu
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py,"An item exists with same name ({0}), please change the item group name or rename the item","Kipengee kinacho na jina moja ({0}), tafadhali soma jina la kikundi cha bidhaa au uunda jina tena"
DocType: Soil Analysis Criteria,Soil Analysis Criteria,Vigezo vya Uchambuzi wa Udongo
DocType: Pricing Rule Detail,Pricing Rule Detail,Maelezo ya Utawala wa Bei
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create BOM,Unda BOM
DocType: Pricing Rule,Apply Rule On Item Group,Tumia ombi kwa Kikundi cha Bidhaa
apps/erpnext/erpnext/accounts/page/pos/pos.js,Please select customer,Tafadhali chagua mteja
DocType: Employee Tax Exemption Declaration,Total Declared Amount,Kiasi Kilichoangaziwa
DocType: C-Form,I,Mimi
DocType: Company,Asset Depreciation Cost Center,Kituo cha gharama ya kushuka kwa thamani ya mali
DocType: Production Plan Sales Order,Sales Order Date,Tarehe ya Utaratibu wa Mauzo
DocType: Sales Invoice Item,Delivered Qty,Utoaji Uchina
DocType: Assessment Plan,Assessment Plan,Mpango wa Tathmini
DocType: Travel Request,Fully Sponsored,Inasaidiwa kikamilifu
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Rejea Kuingia kwa Jarida
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Unda Kadi ya Kazi
DocType: Quality Procedure Process,Process Description,Maelezo ya Mchakato
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Mteja {0} ameundwa.
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Hivi sasa hakuna hisa zinazopatikana katika ghala lolote
,Payment Period Based On Invoice Date,Kipindi cha Malipo Kulingana na tarehe ya ankara
DocType: Sample Collection,No. of print,Hapana ya kuchapishwa
apps/erpnext/erpnext/education/doctype/question/question.py,No correct answer is set for {0},Hakuna jibu sahihi ambalo limewekwa kwa {0}
DocType: Issue,Response By,Jibu Na
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Birthday Reminder,Kikumbusho cha Kuzaliwa
DocType: Chart of Accounts Importer,Chart Of Accounts Importer,Chati Ya kuingiza Akaunti
DocType: Hotel Room Reservation Item,Hotel Room Reservation Item,Kitabu cha Uhifadhi wa Chumba cha Hoteli
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Missing Currency Exchange Rates for {0},Viwango vya Kubadilisha Fedha Hazipo kwa {0}
DocType: Employee Health Insurance,Health Insurance Name,Jina la Bima ya Afya
DocType: Assessment Plan,Examiner,Mkaguzi
DocType: Student,Siblings,Ndugu
DocType: Journal Entry,Stock Entry,Entry Entry
DocType: Payment Entry,Payment References,Marejeo ya Malipo
DocType: Subscription Plan,"Number of intervals for the interval field e.g if Interval is 'Days' and Billing Interval Count is 3, invoices will be generated every 3 days","Idadi ya vipindi kwa uwanja wa kipindi cha mfano kama Ikiwa Muingizo ni &#39;Siku&#39; na Muda wa Kipaji cha Hesabu ni 3, ankara zitazalishwa kila siku 3"
DocType: Clinical Procedure Template,Allow Stock Consumption,Ruhusu matumizi ya hisa
DocType: Asset,Insurance Details,Maelezo ya Bima
DocType: Account,Payable,Inalipwa
DocType: Share Balance,Share Type,Shiriki Aina
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Please enter Repayment Periods,Tafadhali ingiza Kipindi cha Malipo
apps/erpnext/erpnext/shopping_cart/cart.py,Debtors ({0}),Wadaiwa ({0})
DocType: Pricing Rule,Margin,Margin
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,New Customers,Wateja wapya
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Gross Profit %,Faida Pato%
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Appointment {0} and Sales Invoice {1} cancelled,Uteuzi {0} na Invoice ya Mauzo {1} kufutwa
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Opportunities by lead source,Fursa na chanzo cha kuongoza
DocType: Appraisal Goal,Weightage (%),Uzito (%)
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Change POS Profile,Badilisha Profaili ya POS
DocType: Bank Reconciliation Detail,Clearance Date,Tarehe ya kufuta
DocType: Delivery Settings,Dispatch Notification Template,Kigezo cha Arifa ya Msaada
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Assessment Report,Ripoti ya Tathmini
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Get Employees,Pata Wafanyakazi
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Add your review,Ongeza ukaguzi wako
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Gross Purchase Amount is mandatory,Thamani ya Ununuzi wa Pato ni lazima
apps/erpnext/erpnext/setup/doctype/company/company.js,Company name not same,Jina la kampuni si sawa
DocType: Lead,Address Desc,Anwani Desc
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party is mandatory,Chama ni lazima
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.py,Please set account heads in GST Settings for Compnay {0},Tafadhali weka vichwa vya akaunti katika mipangilio ya GST ya Compnay {0}
DocType: Course Topic,Topic Name,Jina la Mada
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Approval Notification in HR Settings.,Tafadhali weka template default kwa Acha Acha idhini katika Mipangilio ya HR.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Atleast one of the Selling or Buying must be selected,Atleast moja ya Mauzo au Ununuzi lazima ichaguliwe
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Select an employee to get the employee advance.,Chagua mfanyakazi ili aendelee mfanyakazi.
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Please select a valid Date,Tafadhali chagua Tarehe halali
apps/erpnext/erpnext/public/js/setup_wizard.js,Select the nature of your business.,Chagua asili ya biashara yako.
DocType: Lab Test Template,"Single for results which require only a single input, result UOM and normal value 
<br>
Compound for results which require multiple input fields with corresponding event names, result UOMs and normal values
<br>
Descriptive for tests which have multiple result components and corresponding result entry fields. 
<br>
Grouped for test templates which are a group of other test templates.
<br>
No Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.","Mmoja kwa matokeo ambayo yanahitaji pembejeo moja tu, UOM ya matokeo na thamani ya kawaida <br> Kipengee cha matokeo ambayo yanahitaji mashamba mengi ya uingizaji na majina yanayohusiana na tukio, UOM matokeo na maadili ya kawaida <br> Maelezo ya vipimo vina vipengele vingi vya matokeo na mashamba husika ya kuingia. <br> Imejumuishwa kwa templates za mtihani ambazo ni kundi la templates nyingine za mtihani. <br> Hakuna matokeo ya vipimo bila matokeo. Pia, hakuna Jaribio la Lab linaloundwa. mfano. Majaribio ya chini ya matokeo yaliyounganishwa."
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Duplicate entry in References {1} {2},Mstari # {0}: Kuingia kwa Duplicate katika Marejeleo {1} {2}
apps/erpnext/erpnext/config/manufacturing.py,Where manufacturing operations are carried.,Ambapo shughuli za utengenezaji zinafanywa.
apps/erpnext/erpnext/education/doctype/instructor/instructor.js,As Examiner,Kama Mchunguzi
DocType: Company,Default Expense Claim Payable Account,Ada ya Madai ya Malipo ya Kulipa Kutoka
DocType: Appointment Type,Default Duration,Muda wa Muda
DocType: BOM Explosion Item,Source Warehouse,Ghala la Chanzo
DocType: Installation Note,Installation Date,Tarehe ya Usanidi
apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js,Share Ledger,Shirikisha Ledger
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} does not belong to company {2},Row # {0}: Malipo {1} si ya kampuni {2}
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Sales Invoice {0} created,Invoice ya Mauzo {0} imeundwa
DocType: Employee,Confirmation Date,Tarehe ya uthibitisho
DocType: Inpatient Occupancy,Check Out,Angalia
DocType: C-Form,Total Invoiced Amount,Kiasi kilichopakiwa
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Min Qty can not be greater than Max Qty,Min Qty haiwezi kuwa kubwa kuliko Max Qty
DocType: Soil Texture,Silty Clay,Clay Cly
DocType: Account,Accumulated Depreciation,Kushuka kwa thamani
DocType: Supplier Scorecard Scoring Standing,Standing Name,Jina lililosimama
DocType: Stock Entry,Customer or Supplier Details,Maelezo ya Wateja au Wafanyabiashara
DocType: Payment Entry,ACC-PAY-.YYYY.-,ACC-PAY -YYYY.-
DocType: Asset Value Adjustment,Current Asset Value,Thamani ya sasa ya Mali
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM recursion: {0} cannot be parent or child of {1},Kurudiwa kwa BOM: {0} haiwezi kuwa mzazi au mtoto wa {1}
DocType: QuickBooks Migrator,Quickbooks Company ID,Kitambulisho cha kampuni ya Quickbooks
DocType: Travel Request,Travel Funding,Fedha za kusafiri
DocType: Employee Skill,Proficiency,Ustadi
DocType: Loan Application,Required by Date,Inahitajika kwa Tarehe
DocType: Crop Cycle,A link to all the Locations in which the Crop is growing,Kiungo kwa Maeneo yote ambayo Mazao yanakua
DocType: Lead,Lead Owner,Mmiliki wa Kiongozi
DocType: Production Plan,Sales Orders Detail,Maagizo ya Mauzo ya Maelezo
DocType: Bin,Requested Quantity,Waliombwa Wingi
DocType: Pricing Rule,Party Information,Habari ya Chama
DocType: Fees,EDU-FEE-.YYYY.-,EDU-FEE -YYYY.-
DocType: Patient,Marital Status,Hali ya ndoa
DocType: Stock Settings,Auto Material Request,Ombi la Nyenzo za Auto
DocType: Woocommerce Settings,API consumer secret,Siri ya watumiaji wa API
DocType: Delivery Note Item,Available Batch Qty at From Warehouse,Inapatikana Chini ya Baki Kutoka Kwenye Ghala
,Received Qty Amount,Amepokea Kiasi cha Qty
DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Pato la Pato la Jumla - Utoaji Jumla - Ulipaji wa Mikopo
DocType: Bank Account,Last Integration Date,Tarehe ya mwisho ya Ujumuishaji
DocType: Expense Claim,Expense Taxes and Charges,Ushuru wa gharama na ada
DocType: Bank Account,IBAN,IBAN
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Current BOM and New BOM can not be same,BOM ya sasa na BOM Mpya haiwezi kuwa sawa
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py,Salary Slip ID,Kitambulisho cha Mshahara wa Mshahara
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date Of Retirement must be greater than Date of Joining,Tarehe ya Kustaafu lazima iwe kubwa kuliko Tarehe ya kujiunga
apps/erpnext/erpnext/stock/doctype/item/item.js,Multiple Variants,Vipengele vingi
DocType: Sales Invoice,Against Income Account,Dhidi ya Akaunti ya Mapato
apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Delivered,{0}% Ametolewa
DocType: Subscription,Trial Period Start Date,Tarehe ya Kuanza Tarehe
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Kipengee {0}: Iliyoagizwa qty {1} haiwezi kuwa chini ya amri ya chini qty {2} (iliyoelezwa katika Item).
DocType: Certification Application,Certified,Inathibitishwa
DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Asilimia ya Usambazaji wa Kila mwezi
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Party can only be one of ,Chama kinaweza kuwa moja tu
apps/erpnext/erpnext/regional/india/utils.py,Please mention Basic and HRA component in Company,Tafadhali taja sehemu ya Msingi na HRA katika Kampuni
DocType: Daily Work Summary Group User,Daily Work Summary Group User,Muhtasari wa Kazi ya Kila siku ya Mtumiaji
DocType: Territory,Territory Targets,Malengo ya Wilaya
DocType: Soil Analysis,Ca/Mg,Ca / Mg
DocType: Sales Invoice,Transporter Info,Info Transporter
apps/erpnext/erpnext/accounts/utils.py,Please set default {0} in Company {1},Tafadhali teua default {0} katika Kampuni {1}
DocType: Cheque Print Template,Starting position from top edge,Kuanzia nafasi kutoka kwenye makali ya juu
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Same supplier has been entered multiple times,Muuzaji sawa ameingizwa mara nyingi
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py,Gross Profit / Loss,Faida ya Pato / Kupoteza
,Warehouse wise Item Balance Age and Value,Ghala la hekima jambo la kupima Umri na Thamani
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Achieved ({}),Imefikiwa ({})
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Nambari ya Utaratibu wa Ununuzi Inayotolewa
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Name cannot be Company,Jina la Kampuni hawezi kuwa Kampuni
apps/erpnext/erpnext/support/doctype/issue/issue.py,{0} parameter is invalid,{0} paramu sio sahihi
apps/erpnext/erpnext/config/settings.py,Letter Heads for print templates.,Viongozi wa Barua kwa templates za kuchapisha.
apps/erpnext/erpnext/config/settings.py,Titles for print templates e.g. Proforma Invoice.,Majina ya nyaraka za uchapishaji mfano Msajili wa Proforma.
DocType: Program Enrollment,Walking,Kutembea
DocType: Student Guardian,Student Guardian,Mlezi wa Mwanafunzi
DocType: Member,Member Name,Jina la Mwanachama
DocType: Stock Settings,Use Naming Series,Tumia Mfululizo wa Kumwita
apps/erpnext/erpnext/quality_management/doctype/quality_review/quality_review_list.js,No Action,Hakuna Kitendo
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Valuation type charges can not marked as Inclusive,Malipo ya aina ya thamani haipatikani kama Kuunganisha
DocType: POS Profile,Update Stock,Sasisha Stock
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,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 tofauti kwa vitu itasababisha kutosa (Jumla) thamani ya uzito wa Nambari. Hakikisha kwamba Uzito wa Net wa kila kitu ni katika UOM sawa.
DocType: Certification Application,Payment Details,Maelezo ya Malipo
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,Kiwango cha BOM
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Kusoma Faili Iliyopakiwa
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Hifadhi ya Kazi iliyozuiwa haiwezi kufutwa, Fungua kwa kwanza kufuta"
DocType: Asset,Journal Entry for Scrap,Jarida la Kuingia kwa Scrap
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Tafadhali puta vitu kutoka kwa Kumbuka Utoaji
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Row {0}: chagua kituo cha kazi dhidi ya uendeshaji {1}
apps/erpnext/erpnext/accounts/utils.py,Journal Entries {0} are un-linked,Wasifu wa Jarida {0} hawajaunganishwa
apps/erpnext/erpnext/accounts/utils.py,{0} Number {1} already used in account {2},{0} Nambari {1} tayari kutumika katika akaunti {2}
apps/erpnext/erpnext/config/crm.py,"Record of all communications of type email, phone, chat, visit, etc.","Rekodi ya mawasiliano yote ya aina ya barua pepe, simu, kuzungumza, kutembelea, nk."
DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Wafanyakazi wa Scorecard Ufungaji Msimamo
DocType: Manufacturer,Manufacturers used in Items,Wazalishaji hutumiwa katika Vitu
apps/erpnext/erpnext/accounts/general_ledger.py,Please mention Round Off Cost Center in Company,Tafadhali tuta Kituo cha Gharama ya Duru ya Kundi katika Kampuni
DocType: Purchase Invoice,Terms,Masharti
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Select Days,Chagua Siku
DocType: Academic Term,Term Name,Jina la Muda
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set the correct code on Mode of Payment {1},Safu {0}: Tafadhali seti nambari sahihi kwenye Njia ya Malipo {1}
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Credit ({0}),Mikopo ({0})
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Creating Salary Slips...,Kujenga Slips za Mshahara ...
apps/erpnext/erpnext/hr/doctype/department/department.js,You cannot edit root node.,Huwezi kubadilisha node ya mizizi.
DocType: Buying Settings,Purchase Order Required,Utaratibu wa Ununuzi Unahitajika
apps/erpnext/erpnext/public/js/projects/timer.js,Timer,Muda
,Item-wise Sales History,Historia Mauzo ya hekima
DocType: Expense Claim,Total Sanctioned Amount,Jumla ya Kizuizi
,Purchase Analytics,Uchambuzi wa Ununuzi
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Total flexible benefit component amount {0} should not be less than max benefits {1},Jumla ya sehemu ya faida inayoweza kubadilika {0} haipaswi kuwa chini ya faida max {1}
DocType: Sales Invoice Item,Delivery Note Item,Nambari ya Kumbuka ya Utoaji
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Current invoice {0} is missing,Invoice ya sasa {0} haipo
DocType: Asset Maintenance Log,Task,Kazi
DocType: Purchase Taxes and Charges,Reference Row #,Mstari wa Kumbukumbu #
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Batch number is mandatory for Item {0},Nambari ya kundi ni lazima kwa Bidhaa {0}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js,This is a root sales person and cannot be edited.,Huu ni mtu wa mauzo ya mizizi na hauwezi kuhaririwa.
DocType: Salary Component,"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Ikiwa imechaguliwa, thamani iliyotajwa au kuhesabiwa katika sehemu hii haitachangia mapato au punguzo. Hata hivyo, thamani ni inaweza kutajwa na vipengele vingine vinavyoweza kuongezwa au kupunguzwa."
,Stock Ledger,Ledger ya hisa
DocType: Company,Exchange Gain / Loss Account,Pata Akaunti ya Kupoteza / Kupoteza
DocType: Amazon MWS Settings,MWS Credentials,Vidokezo vya MWS
apps/erpnext/erpnext/config/selling.py,Blanket Orders from Costumers.,Agizo la Blanket kutoka kwa Mavigo.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Purpose must be one of {0},Lengo lazima iwe moja ya {0}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Fill the form and save it,Jaza fomu na uihifadhi
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Community Forum,Jumuiya ya Jumuiya
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Actual qty in stock,Kweli qty katika hisa
DocType: Homepage,"URL for ""All Products""",URL ya &quot;Bidhaa Zote&quot;
DocType: Leave Application,Leave Balance Before Application,Kuondoa Msaada Kabla ya Maombi
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Send SMS,Tuma SMS
DocType: Supplier Scorecard Criteria,Max Score,Max Score
DocType: Cheque Print Template,Width of amount in word,Upana wa kiasi kwa neno
DocType: Purchase Order,Get Items from Open Material Requests,Pata Vitu kutoka kwa Maombi ya Vifaa vya Ufunguzi
DocType: Hotel Room Amenity,Billable,Inafaa
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Ordered Qty: Quantity ordered for purchase, but not received.","Qty Iliyopangwa: Wingi umeamuru kwa ununuzi, lakini haujapokelewa."
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Chart of Accounts and Parties,Kusindika Chati ya Hesabu na Vyama
DocType: Lab Test Template,Standard Selling Rate,Kiwango cha Uuzaji wa Standard
DocType: Account,Rate at which this tax is applied,Kiwango ambacho kodi hii inatumiwa
DocType: Cash Flow Mapper,Section Name,Jina la Sehemu
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Reorder Qty,Rekebisha Uchina
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Upungufu Row {0}: Thamani inayotarajiwa baada ya maisha muhimu lazima iwe kubwa kuliko au sawa na {1}
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,Current Job Openings,Open Job sasa
DocType: Company,Stock Adjustment Account,Akaunti ya Marekebisho ya Hifadhi
apps/erpnext/erpnext/public/js/payment/pos_payment.html,Write Off,Andika
apps/erpnext/erpnext/quality_management/doctype/quality_procedure/quality_procedure.py,{0} already has a Parent Procedure {1}.,{0} tayari ina Utaratibu wa Mzazi {1}.
DocType: Healthcare Service Unit,Allow Overlap,Ruhusu Kuingiliana
DocType: Timesheet Detail,Operation ID,Kitambulisho cha Uendeshaji
DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","Kitambulisho cha mtumiaji wa mfumo (kuingia). Ikiwa imewekwa, itakuwa default kwa aina zote HR."
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Enter depreciation details,Ingiza maelezo ya kushuka kwa thamani
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,{0}: From {1},{0}: Kutoka {1}
DocType: Bank Transaction Mapping,Column in Bank File,Safu wima katika Faili ya Benki
apps/erpnext/erpnext/education/doctype/student_leave_application/student_leave_application.py,Leave application {0} already exists against the student {1},Acha programu {0} tayari ipo dhidi ya mwanafunzi {1}
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Imesababishwa kwa uboreshaji wa bei ya hivi karibuni katika Bila zote za Vifaa. Inaweza kuchukua dakika chache.
DocType: Pick List,Get Item Locations,Pata Sehemu za Bidhaa
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Jina la Akaunti mpya. Kumbuka: Tafadhali usijenge akaunti kwa Wateja na Wauzaji
DocType: POS Profile,Display Items In Stock,Vipengele vya Kuonyesha Katika Hifadhi
apps/erpnext/erpnext/config/settings.py,Country wise default Address Templates,Nchi za hekima za Hitilafu za Hitilafu za Nchi
DocType: Payment Order,Payment Order Reference,Kumbukumbu ya Utaratibu wa Malipo
DocType: Water Analysis,Appearance,Mwonekano
DocType: HR Settings,Leave Status Notification Template,Acha Template ya Arifa ya Hali
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Avg. Buying Price List Rate,Mg. Kununua orodha ya bei ya bei
DocType: Sales Order Item,Supplier delivers to Customer,Wasambazaji hutoa kwa Wateja
apps/erpnext/erpnext/config/non_profit.py,Member information.,Maelezo ya wanachama.
DocType: Identification Document Type,Identification Document Type,Aina ya Nyaraka ya Utambulisho
apps/erpnext/erpnext/utilities/bot.py,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Fomu / Bidhaa / {0}) haipo nje ya hisa
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Asset Maintenance,Matengenezo ya Mali
,Sales Payment Summary,Muhtasari wa Malipo ya Mauzo
DocType: Restaurant,Restaurant,Mgahawa
DocType: Woocommerce Settings,API consumer key,Muhimu wa watumiaji wa API
apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;Tarehe&#39; inahitajika
apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Kutokana / Tarehe ya Kumbukumbu haiwezi kuwa baada ya {0}
apps/erpnext/erpnext/config/settings.py,Data Import and Export,Kuingiza Data na Kuagiza
DocType: Bank Account,Account Details,Maelezo ya Akaunti
DocType: Crop,Materials Required,Vifaa vinahitajika
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Hakuna wanafunzi waliopatikana
DocType: Employee Tax Exemption Declaration,Monthly HRA Exemption,Msaada wa kila mwezi wa HRA
DocType: Clinical Procedure,Medical Department,Idara ya Matibabu
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Early Exits,Jumla ya Kutoka mapema
DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Scorecard ya Wafanyabiashara Hatua za Kipazo
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,Invoice Posting Date,Tarehe ya Kuagiza Invozi
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Sell,Nunua
DocType: Purchase Invoice,Rounded Total,Imejaa Jumla
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Slots for {0} are not added to the schedule,Inafaa kwa {0} haijaongezwa kwenye ratiba
DocType: Product Bundle,List items that form the package.,Andika vitu vinavyounda mfuko.
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Not permitted. Please disable the Test Template,Hairuhusiwi. Tafadhali afya Kigezo cha Mtihani
DocType: Sales Invoice,Distance (in km),Umbali (katika km)
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py,Percentage Allocation should be equal to 100%,Asilimia ya Ugawaji lazima iwe sawa na 100%
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select Posting Date before selecting Party,Tafadhali chagua Tarehe ya Kuweka kabla ya kuchagua Chama
apps/erpnext/erpnext/config/accounting.py,Payment Terms based on conditions,Masharti ya malipo kulingana na masharti
DocType: Program Enrollment,School House,Shule ya Shule
DocType: Serial No,Out of AMC,Nje ya AMC
DocType: Opportunity,Opportunity Amount,Fursa Kiasi
apps/erpnext/erpnext/public/js/hub/Sidebar.vue,Your Profile,Profaili yako
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Idadi ya kushuka kwa thamani iliyotengenezwa haiwezi kuwa kubwa zaidi kuliko Jumla ya Idadi ya Dhamana
DocType: Purchase Order,Order Confirmation Date,Tarehe ya uthibitisho wa amri
DocType: Driver,HR-DRI-.YYYY.-,HR-DRI -YYYY.-
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py,All Products,Bidhaa zote
DocType: Employee Transfer,Employee Transfer Details,Maelezo ya Uhamisho wa Waajiri
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Please contact to the user who have Sales Master Manager {0} role,Tafadhali wasiliana na mtumiaji aliye na jukumu la Meneja Mauzo {0}
DocType: Company,Default Cash Account,Akaunti ya Fedha ya Default
DocType: Issue,Ongoing,Inaendelea
apps/erpnext/erpnext/config/accounting.py,Company (not Customer or Supplier) master.,Kampuni (si Wateja au Wafanyabiashara) Mwalimu.
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py,This is based on the attendance of this Student,Hii inategemea mahudhurio ya Mwanafunzi
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,No Students in,Hakuna Wanafunzi
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Add more items or open full form,Ongeza vitu vingine au kufungua fomu kamili
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Vidokezo vya utoaji {0} lazima kufutwa kabla ya kufuta Sheria hii ya Mauzo
apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Nenda kwa Watumiaji
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Kiasi kilicholipwa + Andika Kiasi hawezi kuwa kubwa zaidi kuliko Jumla ya Jumla
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} si Nambari ya Batch halali ya Bidhaa {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Kumbuka: Hakuna usawa wa kutosha wa kuondoka kwa Aina ya Kuondoka {0}
DocType: Task,Task Description,Maelezo ya Kazi
DocType: Training Event,Seminar,Semina
DocType: Program Enrollment Fee,Program Enrollment Fee,Malipo ya Usajili wa Programu
DocType: Item,Supplier Items,Vifaa vya Wasambazaji
DocType: Material Request,MAT-MR-.YYYY.-,MAT-MR -YYYY.-
DocType: Opportunity,Opportunity Type,Aina ya Fursa
DocType: Asset Movement,To Employee,Kwa mfanyakazi
DocType: Employee Transfer,New Company,Kampuni mpya
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py,Transactions can only be deleted by the creator of the Company,Shughuli zinaweza tu kufutwa na Muumba wa Kampuni
apps/erpnext/erpnext/accounts/general_ledger.py,Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Nambari isiyo sahihi ya Entries General Ledger zilizopatikana. Huenda umechagua Akaunti mbaya katika shughuli.
DocType: Employee,Prefered Contact Email,Kuwasiliana na Email
DocType: Cheque Print Template,Cheque Width,Angalia Upana
DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Thibitisha Bei ya Kuuza kwa Bidhaa juu ya Kiwango cha Ununuzi au Kiwango cha Vigezo
DocType: Fee Schedule,Fee Schedule,Ratiba ya ada
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Column Labels : ,Lebo za safu:
DocType: Bank Transaction,Settled,Tulia
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Disbursement Date cannot be after Loan Repayment Start Date,Tarehe ya Marejesho haiwezi kuwa baada ya Tarehe ya Marejesho ya Mkopo
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Cess,Cess
DocType: Quality Feedback,Parameters,Viwanja
DocType: Company,Create Chart Of Accounts Based On,Unda Chati ya Hesabu za Akaunti
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date of Birth cannot be greater than today.,Tarehe ya kuzaliwa haiwezi kuwa kubwa kuliko leo.
,Stock Ageing,Kuzaa hisa
DocType: Travel Request,"Partially Sponsored, Require Partial Funding","Inasaidiwa kikamilifu, Inahitaji Fedha ya Fedha"
apps/erpnext/erpnext/education/doctype/student/student.py,Student {0} exist against student applicant {1},Mwanafunzi {0} iko juu ya mwombaji wa mwanafunzi {1}
DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Marekebisho ya Upangaji (Kampuni ya Fedha)
apps/erpnext/erpnext/projects/doctype/task/task.js,Timesheet,Timesheet
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Batch: ,Kundi:
DocType: Volunteer,Afternoon,Saa ya asubuhi
DocType: Loyalty Program,Loyalty Program Help,Msaada wa Programu ya Uaminifu
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} '{1}' is disabled,{0} &#39;{1}&#39; imezimwa
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js,Set as Open,Weka kama Fungua
DocType: Cheque Print Template,Scanned Cheque,Angalia Angalia
DocType: Timesheet,Total Billable Amount,Kiasi cha Jumla cha Billable
DocType: Customer,Credit Limit and Payment Terms,Masharti ya Mikopo na Malipo
DocType: Loyalty Program,Collection Rules,Kanuni za Ukusanyaji
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 3,Kipengee 3
apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js,Order Entry,Kuingia kwa Amri
DocType: Purchase Order,Customer Contact Email,Anwani ya Mawasiliano ya Wateja
DocType: Warranty Claim,Item and Warranty Details,Maelezo na maelezo ya dhamana
DocType: Chapter,Chapter Members,Wanachama wa Sura
DocType: Sales Team,Contribution (%),Mchango (%)
apps/erpnext/erpnext/controllers/accounts_controller.py,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Kumbuka: Uingiaji wa Malipo hautaundwa tangu &#39;Akaunti ya Fedha au Benki&#39; haijainishwa
DocType: Clinical Procedure,Nursing User,Mtumiaji wa Uuguzi
DocType: Employee Benefit Application,Payroll Period,Kipindi cha Mishahara
DocType: Plant Analysis,Plant Analysis Criterias,Criteria za Uchambuzi wa Kupanda
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Batch {1},Serial Hakuna {0} si ya Kundi {1}
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Your email address...,Anwani yako ya barua ...
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Responsibilities,Majukumu
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Validity period of this quotation has ended.,Kipindi cha uhalali wa nukuu hii imekwisha.
DocType: Expense Claim Account,Expense Claim Account,Akaunti ya dai ya gharama
DocType: Account,Capital Work in Progress,Kazi ya Kitaifa katika Maendeleo
DocType: Accounts Settings,Allow Stale Exchange Rates,Ruhusu Viwango vya Exchange za Stale
DocType: Sales Person,Sales Person Name,Jina la Mtu wa Mauzo
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,Please enter atleast 1 invoice in the table,Tafadhali ingiza ankara 1 kwenye meza
apps/erpnext/erpnext/utilities/user_progress.py,Add Users,Ongeza Watumiaji
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py,No Lab Test created,Hakuna Jaribio la Lab limeundwa
DocType: POS Item Group,Item Group,Kundi la Bidhaa
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Student Group: ,Kikundi cha Wanafunzi:
DocType: Depreciation Schedule,Finance Book Id,Id ya Kitabu cha Fedha
DocType: Item,Safety Stock,Usalama wa Hifadhi
DocType: Healthcare Settings,Healthcare Settings,Mipangilio ya afya
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Total Allocated Leaves,Jumla ya Majani yaliyowekwa
apps/erpnext/erpnext/projects/doctype/task/task.py,Progress % for a task cannot be more than 100.,Maendeleo% ya kazi haiwezi kuwa zaidi ya 100.
DocType: Stock Reconciliation Item,Before reconciliation,Kabla ya upatanisho
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,To {0},Kwa {0}
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Kodi na Malipo Aliongeza (Fedha za Kampuni)
apps/erpnext/erpnext/accounts/doctype/item_tax_template/item_tax_template.py,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Rangi ya Kodi ya Ushuru {0} lazima iwe na akaunti ya aina ya kodi au mapato au gharama au malipo
DocType: Sales Order,Partly Billed,Sehemu ya Billed
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} must be a Fixed Asset Item,Kipengee {0} kinafaa kuwa kipengee cha Mali isiyohamishika
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,HSN,HSN
DocType: Item,Default BOM,BOM ya default
DocType: Project,Total Billed Amount (via Sales Invoices),Kiasi kilicholipwa (kwa njia ya Mauzo ya Mauzo)
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Debit Note Amount,Takwimu ya Kumbuka ya Debit
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,"There are inconsistencies between the rate, no of shares and the amount calculated","Kuna kutofautiana kati ya kiwango, hakuna ya hisa na kiasi kilichohesabiwa"
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,You are not present all day(s) between compensatory leave request days,Hukopo siku zote (s) kati ya siku za ombi za malipo ya kuondoka
apps/erpnext/erpnext/setup/doctype/company/company.js,Please re-type company name to confirm,Tafadhali rejesha jina la kampuni ili kuthibitisha
DocType: Journal Entry,Printing Settings,Mipangilio ya uchapishaji
DocType: Payment Order,Payment Order Type,Aina ya Agizo la malipo
DocType: Employee Advance,Advance Account,Akaunti ya Awali
DocType: Job Offer,Job Offer Terms,Masharti ya Kutoa Kazi
DocType: Sales Invoice,Include Payment (POS),Jumuisha Malipo (POS)
DocType: Shopify Settings,eg: frappe.myshopify.com,kwa mfano: frappe.myshopify.com
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement tracking is not enabled.,Ufuatiliaji wa Mkataba wa Kiwango cha Huduma haujawashwa.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Total Debit must be equal to Total Credit. The difference is {0},Jumla ya Debit lazima iwe sawa na Jumla ya Mikopo. Tofauti ni {0}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Automotive,Magari
DocType: Vehicle,Insurance Company,Kampuni ya Bima
DocType: Asset Category Account,Fixed Asset Account,Akaunti ya Mali isiyohamishika
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Variable,Inaweza kubadilika
apps/erpnext/erpnext/regional/italy/utils.py,"Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}","Usafirishaji wa mapato ni ya lazima, kwa fadhili kuweka serikali ya fedha katika kampuni {0}"
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js,From Delivery Note,Kutoka Kumbuka Utoaji
DocType: Chapter,Members,Wanachama
DocType: Student,Student Email Address,Anwani ya barua pepe ya wanafunzi
DocType: Item,Hub Warehouse,Warehouse Hub
DocType: Cashier Closing,From Time,Kutoka wakati
DocType: Hotel Settings,Hotel Settings,Mipangilio ya Hoteli
apps/erpnext/erpnext/public/js/pos/pos_bill_item.html,In Stock: ,Katika Stock:
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Investment Banking,Benki ya Uwekezaji
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Cash or Bank Account is mandatory for making payment entry,Akaunti au Akaunti ya Benki ni lazima kwa kuingia malipo
DocType: Education Settings,LMS Settings,Mipangilio ya LMS
DocType: Company,Discount Allowed Account,Akaunti iliyoruhusiwa Discount
DocType: Loyalty Program,Multiple Tier Program,Mpango wa Mipango Mingi
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Address,Anwani ya Wanafunzi
DocType: Purchase Invoice,Price List Exchange Rate,Orodha ya Badilishaji ya Bei
apps/erpnext/erpnext/patches/v11_0/rename_supplier_type_to_supplier_group.py,All Supplier Groups,Vikundi vyote vya Wasambazaji
DocType: Employee Boarding Activity,Required for Employee Creation,Inahitajika kwa Uumbaji wa Waajiriwa
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account Number {0} already used in account {1},Nambari ya Akaunti {0} tayari kutumika katika akaunti {1}
DocType: GoCardless Mandate,Mandate,Mamlaka
DocType: Hotel Room Reservation,Booked,Imeandaliwa
DocType: Detected Disease,Tasks Created,Kazi Iliundwa
DocType: Purchase Invoice Item,Rate,Kiwango
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Intern,Ndani
DocType: Delivery Stop,Address Name,Jina la Anwani
DocType: Stock Entry,From BOM,Kutoka BOM
DocType: Assessment Code,Assessment Code,Kanuni ya Tathmini
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Basic,Msingi
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock transactions before {0} are frozen,Ushirikiano wa hisa kabla ya {0} ni waliohifadhiwa
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule',Tafadhali bonyeza &#39;Generate Schedule&#39;
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference No is mandatory if you entered Reference Date,Hakuna kumbukumbu ni lazima ikiwa umeingia Tarehe ya Kumbukumbu
DocType: Bank Reconciliation Detail,Payment Document,Hati ya Malipo
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py,Error evaluating the criteria formula,Hitilafu ya kutathmini fomu ya vigezo
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date of Joining must be greater than Date of Birth,Tarehe ya kujiunga lazima iwe kubwa zaidi kuliko tarehe ya kuzaliwa
DocType: Subscription,Plans,Mipango
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,Opening Balance,Ufunguzi Mizani
DocType: Salary Slip,Salary Structure,Mshahara wa Mshahara
DocType: Account,Bank,Benki
DocType: Job Card,Job Started,Kazi Ilianza
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Airline,Ndege
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Issue Material,Matatizo ya Matatizo
apps/erpnext/erpnext/config/integrations.py,Connect Shopify with ERPNext,Unganisha Dukaify na ERPNext
DocType: Production Plan,For Warehouse,Kwa Ghala
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,Delivery Notes {0} updated,Vidokezo vya Utoaji {0} updated
DocType: Employee,Offer Date,Tarehe ya Kutoa
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Quotations,Nukuu
DocType: Purchase Order,Inter Company Order Reference,Rejea ya Agizo la Kampuni
apps/erpnext/erpnext/accounts/page/pos/pos.js,You are in offline mode. You will not be able to reload until you have network.,Wewe uko katika hali ya mkondo. Hutaweza kupakia upya mpaka una mtandao.
apps/erpnext/erpnext/public/js/controllers/transaction.js,Row #{0}: Qty increased by 1,Njia # {0}: Qty iliongezeka kwa 1
DocType: Account,Include in gross,Jumuisha katika jumla
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js,Grant,Ruhusu
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,No Student Groups created.,Hakuna Vikundi vya Wanafunzi vilivyoundwa.
DocType: Purchase Invoice Item,Serial No,Serial No
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Monthly Repayment Amount cannot be greater than Loan Amount,Kiwango cha Ushuru wa kila mwezi hawezi kuwa kubwa kuliko Kiwango cha Mikopo
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please enter Maintaince Details first,Tafadhali ingiza maelezo ya Duka la kwanza
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Row # {0}: Tarehe ya Utoaji Inayotarajiwa haiwezi kuwa kabla ya Tarehe ya Utunzaji wa Ununuzi
DocType: Purchase Invoice,Print Language,Panga Lugha
DocType: Salary Slip,Total Working Hours,Jumla ya Masaa ya Kazi
DocType: Sales Invoice,Customer PO Details,Mteja PO Maelezo
apps/erpnext/erpnext/education/utils.py,You are not enrolled in program {0},Haujaandikishwa katika mpango {0}
DocType: Stock Entry,Including items for sub assemblies,Ikijumuisha vitu kwa makusanyiko ndogo
DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Akaunti ya Ufunguzi wa Muda
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry_list.js,Goods In Transit,Bidhaa katika Usafiri
apps/erpnext/erpnext/accounts/page/pos/pos.js,Enter value must be positive,Ingiza thamani lazima iwe nzuri
DocType: Asset,Finance Books,Vitabu vya Fedha
DocType: Employee Tax Exemption Declaration Category,Employee Tax Exemption Declaration Category,Azimio la Ushuru wa Ushuru wa Jamii
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py,All Territories,Wilaya zote
DocType: Lost Reason Detail,Lost Reason Detail,Maelezo Iliyopotea
apps/erpnext/erpnext/hr/utils.py,Please set leave policy for employee {0} in Employee / Grade record,Tafadhali weka sera ya kuondoka kwa mfanyakazi {0} katika rekodi ya Wafanyakazi / Daraja
apps/erpnext/erpnext/public/js/controllers/transaction.js,Invalid Blanket Order for the selected Customer and Item,Amri ya batili ya batili kwa Wateja waliochaguliwa na Bidhaa
apps/erpnext/erpnext/projects/doctype/task/task_tree.js,Add Multiple Tasks,Ongeza Kazi nyingi
DocType: Purchase Invoice,Items,Vitu
apps/erpnext/erpnext/crm/doctype/contract/contract.py,End Date cannot be before Start Date.,Tarehe ya Mwisho haiwezi kuwa kabla ya Tarehe ya Mwanzo.
apps/erpnext/erpnext/education/doctype/course_enrollment/course_enrollment.py,Student is already enrolled.,Mwanafunzi tayari amejiandikisha.
DocType: Fiscal Year,Year Name,Jina la Mwaka
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,There are more holidays than working days this month.,Kuna sikukuu zaidi kuliko siku za kazi mwezi huu.
apps/erpnext/erpnext/controllers/buying_controller.py,Following items {0} are not marked as {1} item. You can enable them as {1} item from its Item master,Vipengele vifuatavyo {0} hazijainishwa kama kipengee {1}. Unaweza kuwawezesha kama kipengee {1} kutoka kwa kichwa chake cha Bidhaa
DocType: Production Plan Item,Product Bundle Item,Bidhaa ya Bundle Item
DocType: Sales Partner,Sales Partner Name,Jina la Mshirika wa Mauzo
apps/erpnext/erpnext/hooks.py,Request for Quotations,Ombi la Nukuu
DocType: Payment Reconciliation,Maximum Invoice Amount,Kiasi cha Invoice Kiasi
apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() failed for empty IBAN,BankAccount.validate_iban () ilishindwa kwa IBAN tupu
DocType: Normal Test Items,Normal Test Items,Vipimo vya kawaida vya Mtihani
DocType: QuickBooks Migrator,Company Settings,Mipangilio ya Kampuni
DocType: Additional Salary,Overwrite Salary Structure Amount,Weka Kiwango cha Mshahara wa Mshahara
DocType: Leave Ledger Entry,Leaves,Majani
DocType: Student Language,Student Language,Lugha ya Wanafunzi
DocType: Cash Flow Mapping,Is Working Capital,"Je, ni Capital Capital"
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js,Submit Proof,Peana Ushibitisho
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order/Quot %,Order / Quot%
apps/erpnext/erpnext/config/healthcare.py,Record Patient Vitals,Rekodi Vitals Mgonjwa
DocType: Fee Schedule,Institution,Taasisi
DocType: Asset,Partially Depreciated,Ulimwenguni ulipoteza
DocType: Issue,Opening Time,Wakati wa Ufunguzi
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,From and To dates required,Kutoka na Ili tarehe inahitajika
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Securities & Commodity Exchanges,Usalama &amp; Mchanganyiko wa Bidhaa
apps/erpnext/erpnext/templates/pages/search_help.py,Docs Search,Utafutaji wa Hati
apps/erpnext/erpnext/stock/doctype/item/item.py,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Kitengo cha Mchapishaji cha Mchapishaji &#39;{0}&#39; lazima iwe sawa na katika Kigezo &#39;{1}&#39;
DocType: Shipping Rule,Calculate Based On,Tumia Mahesabu
DocType: Contract,Unfulfilled,Haijajazwa
DocType: Delivery Note Item,From Warehouse,Kutoka kwa Ghala
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,No employees for the mentioned criteria,Hakuna wafanyakazi kwa vigezo vilivyotajwa
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,No Items with Bill of Materials to Manufacture,Hakuna Vipengee Vipengee vya Vifaa vya Kutengeneza
DocType: Shopify Settings,Default Customer,Wateja wa Mteja
DocType: Sales Stage,Stage Name,Jina la hatua
apps/erpnext/erpnext/config/getting_started.py,Data Import and Settings,Umuhimu wa data na Mipangilio
DocType: Warranty Claim,SER-WRN-.YYYY.-,SER-WRN -YYYY.-
DocType: Assessment Plan,Supervisor Name,Jina la Msimamizi
DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,Usihakikishe ikiwa uteuzi umeundwa kwa siku ile ile
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Ship To State,Ship To State
DocType: Program Enrollment Course,Program Enrollment Course,Kozi ya Usajili wa Programu
DocType: Invoice Discounting,Bank Charges,Malipo ya Benki
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner.py,User {0} is already assigned to Healthcare Practitioner {1},Mtumiaji {0} tayari amepewa Daktari wa Afya {1}
DocType: Purchase Taxes and Charges,Valuation and Total,Kiwango na Jumla
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Negotiation/Review,Majadiliano / Mapitio
DocType: Leave Encashment,Encashment Amount,Kiasi cha fedha
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py,Scorecards,Makaratasi ya alama
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Expired Batches,Batches za muda mrefu
DocType: Employee,This will restrict user access to other employee records,Hii itawazuia mtumiaji kupata rekodi nyingine za mfanyakazi
DocType: Tax Rule,Shipping City,Mji wa Mtoaji
apps/erpnext/erpnext/regional/india/utils.py,GST HSN Code does not exist for one or more items,Nambari ya GST HSN haipo kwa bidhaa moja au zaidi
DocType: Quality Procedure Table,Step,Hatua
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Variance ({}),Tofauti ({})
DocType: Purchase Invoice,Import Of Service,Umuhimu wa Huduma
DocType: Education Settings,LMS Title,Kichwa cha LMS
DocType: Sales Invoice,Ship,Meli
DocType: Staffing Plan Detail,Current Openings,Mafunguo ya sasa
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Operations,Mtoko wa Fedha kutoka Uendeshaji
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,CGST Amount,Kiwango cha CGST
apps/erpnext/erpnext/utilities/activation.py,Create Student,Unda Mwanafunzi
DocType: Purchase Invoice,Shipping Rule,Sheria ya Utoaji
DocType: Patient Relation,Spouse,Mwenzi wako
DocType: Lab Test Groups,Add Test,Ongeza Mtihani
DocType: Manufacturer,Limited to 12 characters,Imepunguzwa kwa wahusika 12
DocType: Journal Entry,Print Heading,Chapisha kichwa
DocType: Quality Action Table,Quality Action Table,Jedwali La hatua ya Ubora
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Total cannot be zero,Jumla haiwezi kuwa sifuri
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,'Days Since Last Order' must be greater than or equal to zero,&#39;Siku Tangu Mwisho Order&#39; lazima iwe kubwa kuliko au sawa na sifuri
DocType: Plant Analysis Criteria,Maximum Permissible Value,Upeo wa Thamani Inaruhusiwa
DocType: Journal Entry Account,Employee Advance,Waajiri wa Mapema
DocType: Payroll Entry,Payroll Frequency,Frequency Frequency
DocType: Plaid Settings,Plaid Client ID,Kitambulisho cha Mteja
DocType: Lab Test Template,Sensitivity,Sensitivity
DocType: Plaid Settings,Plaid Settings,Mipangilio ya Paa
apps/erpnext/erpnext/erpnext_integrations/doctype/amazon_mws_settings/amazon_methods.py,Sync has been temporarily disabled because maximum retries have been exceeded,Usawazishaji umezimwa kwa muda kwa sababu majaribio ya kiwango cha juu yamepitiwa
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Raw Material,Malighafi
DocType: Leave Application,Follow via Email,Fuata kupitia barua pepe
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Plants and Machineries,Mimea na Machineries
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Kiwango cha Ushuru Baada ya Kiasi Kikubwa
DocType: Patient,Inpatient Status,Hali ya wagonjwa
DocType: Asset Finance Book,In Percentage,Katika Asilimia
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Selected Price List should have buying and selling fields checked.,Orodha ya Bei iliyochaguliwa inapaswa kuwa na ununuzi na kuuza mashamba yaliyochungwa.
apps/erpnext/erpnext/controllers/buying_controller.py,Please enter Reqd by Date,Tafadhali ingiza Reqd kwa Tarehe
DocType: Payment Entry,Internal Transfer,Uhamisho wa Ndani
DocType: Asset Maintenance,Maintenance Tasks,Kazi za Matengenezo
apps/erpnext/erpnext/setup/doctype/territory/territory.py,Either target qty or target amount is mandatory,Vipi lengo la qty au kiasi lengo ni lazima
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Please select Posting Date first,Tafadhali chagua Tarehe ya Kuweka kwanza
apps/erpnext/erpnext/public/js/account_tree_grid.js,Opening Date should be before Closing Date,Tarehe ya Ufunguzi lazima iwe kabla ya Tarehe ya Kufungwa
DocType: Travel Itinerary,Flight,Ndege
apps/erpnext/erpnext/public/js/hub/pages/NotFound.vue,Back to home,Rudi nyumbani
DocType: Leave Control Panel,Carry Forward,Endelea mbele
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cost Center with existing transactions can not be converted to ledger,Kituo cha Gharama na shughuli zilizopo haziwezi kugeuzwa kuwa kiongozi
DocType: Budget,Applicable on booking actual expenses,Inatumika kwa gharama halisi za malipo
DocType: Department,Days for which Holidays are blocked for this department.,Siku ambazo Likizo zimezuiwa kwa idara hii.
DocType: Amazon MWS Settings,ERPNext Integrations,ERPNext Integrations
DocType: Crop Cycle,Detected Disease,Magonjwa yaliyoambukizwa
,Produced,Iliyotayarishwa
DocType: Issue,Raised By (Email),Iliyotolewa na (Barua pepe)
DocType: Issue,Service Level Agreement,Mkataba wa Kiwango cha Huduma
DocType: Training Event,Trainer Name,Jina la Mkufunzi
DocType: Mode of Payment,General,Mkuu
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication,Mawasiliano ya Mwisho
,TDS Payable Monthly,TDS kulipwa kila mwezi
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Iliyotokana na nafasi ya kuchukua nafasi ya BOM. Inaweza kuchukua dakika chache.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Haiwezi kufuta wakati kiwanja ni kwa &#39;Valuation&#39; au &#39;Valuation na Jumla&#39;
apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Malipo ya Jumla
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serial Nos Inahitajika kwa Bidhaa Serialized {0}
apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Malipo ya mechi na ankara
DocType: Payment Entry,Get Outstanding Invoice,Pata ankara bora
DocType: Journal Entry,Bank Entry,Kuingia kwa Benki
apps/erpnext/erpnext/stock/doctype/item/item.py,Updating Variants...,Inasasisha anuwai ...
DocType: Authorization Rule,Applicable To (Designation),Inafaa Kwa (Uteuzi)
,Profitability Analysis,Uchambuzi wa Faida
DocType: Fees,Student Email,Barua ya Wanafunzi
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Disburse Loan,Kukopa Mkopo
DocType: Supplier,Prevent POs,Zuia POs
DocType: Patient,"Allergies, Medical and Surgical History","Vita, Matibabu na Historia ya Upasuaji"
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Add to Cart,Ongeza kwenye Cart
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js,Group By,Kikundi Kwa
apps/erpnext/erpnext/config/accounting.py,Enable / disable currencies.,Wezesha / afya ya fedha.
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Could not submit some Salary Slips,Haikuweza kuwasilisha Slips za Mshahara
DocType: Project Template,Project Template,Kiolezo cha Mradi
DocType: Exchange Rate Revaluation,Get Entries,Pata Maingilio
DocType: Production Plan,Get Material Request,Pata Ombi la Nyenzo
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Postal Expenses,Malipo ya posta
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html,Sales Summary,Muhtasari wa Mauzo
apps/erpnext/erpnext/controllers/trends.py,Total(Amt),Jumla (Amt)
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please identify/create Account (Group) for type - {0},Tafadhali tambua / unda Akaunti (Kikundi) cha aina - {0}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Entertainment & Leisure,Burudani &amp; Burudani
,Item Variant Details,Maelezo ya Toleo la Tofauti
DocType: Quality Inspection,Item Serial No,Kitu cha Serial No
DocType: Payment Request,Is a Subscription,Ni Usajili
apps/erpnext/erpnext/utilities/activation.py,Create Employee Records,Unda Kumbukumbu ya Wafanyakazi
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Present,Jumla ya Sasa
DocType: Work Order,MFG-WO-.YYYY.-,MFG-WO-YYYY.-
DocType: Drug Prescription,Hour,Saa
DocType: Restaurant Order Entry,Last Sales Invoice,Hati ya Mwisho ya Mauzo
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select Qty against item {0},Tafadhali chagua Uchina dhidi ya bidhaa {0}
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Latest Age,Umri wa hivi karibuni
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Transfer Material to Supplier,Transfer Nyenzo kwa Wasambazaji
apps/erpnext/erpnext/hr/report/loan_repayment/loan_repayment.py,EMI,EMI
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Serial Mpya Hapana haiwezi kuwa na Ghala. Ghala lazima liwekewe na Entry Entry au Receipt ya Ununuzi
DocType: Lead,Lead Type,Aina ya Kiongozi
apps/erpnext/erpnext/utilities/activation.py,Create Quotation,Unda Nukuu
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,You are not authorized to approve leaves on Block Dates,Huna mamlaka ya kupitisha majani kwenye Tarehe ya Kuzuia
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} Request for {1},{0} Ombi la {1}
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,All these items have already been invoiced,Vipengee hivi vyote tayari vinatumiwa
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,No outstanding invoices found for the {0} {1} which qualify the filters you have specified.,Hakuna ankara bora inayopatikana ya {0} {1} inayostahili vichungi ambavyo umeelezea.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Set New Release Date,Weka tarehe mpya ya kutolewa
DocType: Company,Monthly Sales Target,Lengo la Mauzo ya Mwezi
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,No outstanding invoices found,Hakuna ankara bora inayopatikana
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py,Can be approved by {0},Inaweza kupitishwa na {0}
DocType: Hotel Room,Hotel Room Type,Aina ya Chumba cha Hoteli
DocType: Customer,Account Manager,Meneja akaunti
DocType: Issue,Resolution By Variance,Azimio Na Tofauti
DocType: Leave Allocation,Leave Period,Acha Period
DocType: Item,Default Material Request Type,Aina ya Ombi la Ufafanuzi wa Matumizi
DocType: Supplier Scorecard,Evaluation Period,Kipimo cha Tathmini
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js,Unknown,Haijulikani
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Order not created,Kazi ya Kazi haijatengenezwa
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"An amount of {0} already claimed for the component {1},\
						 set the amount equal or greater than {2}","Kiasi cha {0} tayari kilidai kwa sehemu {1}, \ kuweka kiasi sawa au zaidi kuliko {2}"
DocType: Shipping Rule,Shipping Rule Conditions,Masharti ya Kanuni za Uhamisho
DocType: Salary Slip Loan,Salary Slip Loan,Mikopo ya Slip ya Mshahara
DocType: BOM Update Tool,The new BOM after replacement,BOM mpya baada ya kubadilishwa
,Point of Sale,Uhakika wa Uuzaji
DocType: Payment Entry,Received Amount,Kiasi kilichopokea
DocType: Patient,Widow,Mjane
DocType: GST Settings,GSTIN Email Sent On,Barua ya GSTIN Imepelekwa
DocType: Program Enrollment,Pick/Drop by Guardian,Chagua / Kuacha na Mlezi
DocType: Bank Account,SWIFT number,Nambari ya SWIFT
DocType: Payment Entry,Party Name,Jina la Chama
DocType: POS Closing Voucher,Total Collected Amount,Kiasi Kilichokusanywa
DocType: Employee Benefit Application,Benefits Applied,Faida zilizofanywa
DocType: Crop,Planting UOM,Kupanda UOM
DocType: Account,Tax,Kodi
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py,Not Marked,Haijulikani
DocType: Service Level Priority,Response Time Period,Kipindi cha Wakati wa Kujibu
DocType: Contract,Signed,Iliingia
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Opening Invoices Summary,Kufungua Muhtasari wa ankara
DocType: Member,NPO-MEM-.YYYY.-,NPO-MEM-YYYY.-
DocType: Education Settings,Education Manager,Meneja wa Elimu
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inter-State Supplies,Ugavi wa Jimbo la Kimataifa
DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Urefu wa chini kati ya kila mmea katika shamba kwa ukuaji bora
DocType: Quality Inspection,Report Date,Tarehe ya Ripoti
DocType: BOM,Routing,Kurudi
DocType: Serial No,Asset Details,Maelezo ya Mali
DocType: Employee Tax Exemption Declaration Category,Declared Amount,Kiwango kilichotangazwa
DocType: Bank Statement Transaction Payment Item,Invoices,Invoices
DocType: Water Analysis,Type of Sample,Aina ya Mfano
DocType: Batch,Source Document Name,Jina la Hati ya Chanzo
DocType: Production Plan,Get Raw Materials For Production,Pata Malighafi Kwa Uzalishaji
DocType: Job Opening,Job Title,Jina la kazi
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Malipo ya baadaye Ref
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
					have been quoted. Updating the RFQ quote status.","{0} inaonyesha kuwa {1} haitoi quotation, lakini vitu vyote vimeukuliwa. Inasasisha hali ya quote ya RFQ."
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Sampuli za Upeo - {0} tayari zimehifadhiwa kwa Batch {1} na Item {2} katika Kipande {3}.
DocType: Manufacturing Settings,Update BOM Cost Automatically,Sasisha Gharama ya BOM Moja kwa moja
DocType: Lab Test,Test Name,Jina la mtihani
DocType: Healthcare Settings,Clinical Procedure Consumable Item,Utaratibu wa Kliniki Itakayotumika
apps/erpnext/erpnext/utilities/activation.py,Create Users,Unda Watumiaji
apps/erpnext/erpnext/utilities/user_progress.py,Gram,Gramu
DocType: Employee Tax Exemption Category,Max Exemption Amount,Kiasi cha Msamaha wa Max
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py,Subscriptions,Usajili
DocType: Quality Review Table,Objective,Lengo
DocType: Supplier Scorecard,Per Month,Kwa mwezi
DocType: Education Settings,Make Academic Term Mandatory,Fanya muda wa kitaaluma wa lazima
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Quantity to Manufacture must be greater than 0.,Wingi wa Utengenezaji lazima uwe mkubwa kuliko 0.
apps/erpnext/erpnext/config/crm.py,Visit report for maintenance call.,Tembelea ripoti ya simu ya matengenezo.
DocType: Stock Entry,Update Rate and Availability,Sasisha Kiwango na Upatikanaji
DocType: Stock Settings,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.,Asilimia unaruhusiwa kupokea au kutoa zaidi dhidi ya kiasi kilichoamriwa. Kwa mfano: Ikiwa umeamuru vitengo 100. na Ruzuku lako ni 10% basi unaruhusiwa kupokea vitengo 110.
DocType: Shopping Cart Settings,Show Contact Us Button,Onyesha Wasiliana Nasi Kifungo
DocType: Loyalty Program,Customer Group,Kundi la Wateja
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch ID (Optional),Kitambulisho kipya cha chaguo (Hiari)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Expense account is mandatory for item {0},Akaunti ya gharama ni lazima kwa kipengee {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Release date must be in the future,Tarehe ya kutolewa lazima iwe katika siku zijazo
DocType: BOM,Website Description,Website Description
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Equity,Mabadiliko ya Net katika Equity
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py,Not permitted. Please disable the Service Unit Type,Hairuhusiwi. Tafadhali afya Aina ya Huduma ya Huduma
apps/erpnext/erpnext/crm/doctype/lead/lead.py,"Email Address must be unique, already exists for {0}","Anwani ya barua pepe inapaswa kuwa ya kipekee, tayari ipo kwa {0}"
DocType: Serial No,AMC Expiry Date,Tarehe ya Kumalizika ya AMC
DocType: Asset,Receipt,Receipt
,Sales Register,Daftari ya Mauzo
DocType: Daily Work Summary Group,Send Emails At,Tuma Barua pepe Kwa
DocType: Quotation Lost Reason,Quotation Lost Reason,Sababu iliyopoteza Nukuu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/regional/india_list.js,Generate e-Way Bill JSON,Tengeneza muswada wa e-Way JSON
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Transaction reference no {0} dated {1},Rejea ya usafirishaji hakuna {0} dated {1}
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js,There is nothing to edit.,Hakuna kitu cha kuhariri.
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Form View,Tazama Fomu
DocType: HR Settings,Expense Approver Mandatory In Expense Claim,Mpangilio wa gharama unaohitajika katika dai ya gharama
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Summary for this month and pending activities,Muhtasari wa mwezi huu na shughuli zinazosubiri
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,Please set Unrealized Exchange Gain/Loss Account in Company {0},Tafadhali weka Akaunti ya Kushindwa Kuchangia / Kupoteza kwa Kampuni {0}
apps/erpnext/erpnext/utilities/user_progress.py,"Add users to your organization, other than yourself.","Ongeza watumiaji kwenye shirika lako, isipokuwa wewe mwenyewe."
DocType: Customer Group,Customer Group Name,Jina la Kundi la Wateja
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row {0}: Quantity not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Safu {0}: Wingi haipatikani kwa {4} katika ghala {1} wakati wa kutuma wa kuingia ({2} {3})
apps/erpnext/erpnext/public/js/pos/pos.html,No Customers yet!,Hakuna Wateja bado!
DocType: Quality Procedure Process,Link existing Quality Procedure.,Unganisha Utaratibu wa Ubora uliopo.
apps/erpnext/erpnext/config/hr.py,Loans,Mikopo
DocType: Healthcare Service Unit,Healthcare Service Unit,Kitengo cha Utumishi wa Afya
,Customer-wise Item Price,Bei ya vitu vya busara ya Wateja
apps/erpnext/erpnext/public/js/financial_statements.js,Cash Flow Statement,Taarifa ya Flow Flow
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,No material request created,Hakuna ombi la nyenzo lililoundwa
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.py,Loan Amount cannot exceed Maximum Loan Amount of {0},Kiasi cha Mkopo hawezi kuzidi Kiwango cha Mikopo ya Upeo wa {0}
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,License,Leseni
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please remove this Invoice {0} from C-Form {1},Tafadhali ondoa hii ankara {0} kutoka C-Fomu {1}
DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,Tafadhali chagua Kuendeleza ikiwa unataka pia kuweka usawa wa mwaka uliopita wa fedha hadi mwaka huu wa fedha
DocType: GL Entry,Against Voucher Type,Dhidi ya Aina ya Voucher
DocType: Healthcare Practitioner,Phone (R),Simu (R)
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Invalid {0} for Inter Company Transaction.,Sio sahihi {0} kwa Ununuzi wa Kampuni ya.
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Time slots added,Muda wa muda umeongezwa
DocType: Products Settings,Attributes,Sifa
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Enable Template,Wezesha Kigezo
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please enter Write Off Account,Tafadhali ingiza Akaunti ya Kuandika Akaunti
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Last Order Date,Tarehe ya mwisho ya tarehe
DocType: Accounts Settings,Unlink Advance Payment on Cancelation of Order,Ondoa Malipo ya Malipo kabla ya Kufuta Agizo
DocType: Salary Component,Is Payable,Inalipwa
DocType: Inpatient Record,B Negative,B mbaya
DocType: Pricing Rule,Price Discount Scheme,Mpango wa Punguzo la Bei
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Maintenance Status has to be Cancelled or Completed to Submit,Hali ya Matengenezo inapaswa kufutwa au Imekamilika Kuwasilisha
DocType: Amazon MWS Settings,US,Marekani
DocType: Holiday List,Add Weekly Holidays,Ongeza Holidays za wiki
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Report Item,Ripoti Jambo
DocType: Staffing Plan Detail,Vacancies,Vifungu
DocType: Hotel Room,Hotel Room,Chumba cha hoteli
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} does not belongs to company {1},Akaunti {0} sio ya kampuni {1}
DocType: Homepage Section,Use this field to render any custom HTML in the section.,Tumia uwanja huu kutoa HTML yoyote maalum katika sehemu hiyo.
DocType: Leave Type,Rounding,Kupiga kura
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Serial Numbers in row {0} does not match with Delivery Note,Nambari za Serial katika mstari {0} haifani na Kumbuka Utoaji
DocType: Employee Benefit Application,Dispensed Amount (Pro-rated),Kiasi kilicholipwa (Pro-rated)
DocType: Student,Guardian Details,Maelezo ya Guardian
DocType: C-Form,C-Form,Fomu ya C
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! First 2 digits of GSTIN should match with State number {0}.,GSTIN batili! Nambari 2 za kwanza za GSTIN zinapaswa kufanana na Nambari ya Jimbo {0}.
DocType: Agriculture Task,Start Day,Siku ya Mwanzo
DocType: Vehicle,Chassis No,Chassis No
DocType: Payment Entry,Initiated,Ilianzishwa
DocType: Production Plan Item,Planned Start Date,Tarehe ya Kuanza Iliyopangwa
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Please select a BOM,Tafadhali chagua BOM
DocType: Purchase Invoice,Availed ITC Integrated Tax,Taasisi iliyoingizwa ya ITC iliyopatikana
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Create Repayment Entry,Unda Kuingia kwa Kurudisha
DocType: Purchase Order Item,Blanket Order Rate,Kiwango cha Mpangilio wa Kibatili
,Customer Ledger Summary,Muhtasari wa Mteja wa Wateja
apps/erpnext/erpnext/hooks.py,Certification,Vyeti
DocType: Bank Guarantee,Clauses and Conditions,Makala na Masharti
DocType: Serial No,Creation Document Type,Aina ya Hati ya Uumbaji
DocType: Amazon MWS Settings,ES,ES
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invoices,Pata ankara
DocType: Leave Allocation,New Leaves Allocated,Majani mapya yamewekwa
apps/erpnext/erpnext/controllers/trends.py,Project-wise data is not available for Quotation,Data ya busara ya mradi haipatikani kwa Nukuu
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,End on,Mwisho
DocType: Project,Expected End Date,Tarehe ya Mwisho Inayotarajiwa
DocType: Budget Account,Budget Amount,Kiasi cha Bajeti
DocType: Donor,Donor Name,Jina la Msaidizi
DocType: Journal Entry,Inter Company Journal Entry Reference,Kitambulisho cha Kuingiza Ingia ya Kampuni ya Inter
DocType: Course,Topics,Mada
DocType: Tally Migration,Is Day Book Data Processed,Je! Idadi ya Kitabu cha Mchana Inasindika
DocType: Appraisal Template,Appraisal Template Title,Kitambulisho cha Kigezo cha Kigezo
apps/erpnext/erpnext/utilities/user_progress_utils.py,Commercial,Biashara
DocType: Patient,Alcohol Current Use,Pombe Sasa Matumizi
DocType: Employee Tax Exemption Proof Submission,House Rent Payment Amount,Kiwango cha Malipo ya Kodi ya Nyumba
DocType: Student Admission Program,Student Admission Program,Mpango wa Uingizaji wa Wanafunzi
DocType: Employee Tax Exemption Sub Category,Tax Exemption Category,Jamii ya Uhuru wa Kodi
DocType: Payment Entry,Account Paid To,Akaunti Ililipwa
DocType: Subscription Settings,Grace Period,Kipindi cha Neema
DocType: Item Alternative,Alternative Item Name,Jina la Mchapishaji
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py,Parent Item {0} must not be a Stock Item,Item ya Mzazi {0} haipaswi kuwa Item ya Hifadhi
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.js,Cannot create a Delivery Trip from Draft documents.,Huwezi kuunda Safari ya Uwasilishaji kutoka kwa Hati za rasimu.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Website Listing,Orodha ya tovuti
apps/erpnext/erpnext/config/buying.py,All Products or Services.,Bidhaa zote au Huduma.
DocType: Email Digest,Open Quotations,Fungua Nukuu
apps/erpnext/erpnext/www/all-products/item_row.html,More Details,Maelezo zaidi
DocType: Supplier Quotation,Supplier Address,Anwani ya Wasambazaji
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} Bajeti ya Akaunti {1} dhidi ya {2} {3} ni {4}. Itazidisha {5}
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,This feature is under development...,Sehemu hii iko chini ya maendeleo ...
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Creating bank entries...,Kuunda maingizo ya benki ...
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Out Qty,Nje ya Uchina
apps/erpnext/erpnext/buying/doctype/supplier/supplier.py,Series is mandatory,Mfululizo ni lazima
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Financial Services,Huduma za Fedha
DocType: Student Sibling,Student ID,Kitambulisho cha Mwanafunzi
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Quantity must be greater than zero,Kwa Wingi lazima uwe mkubwa kuliko sifuri
apps/erpnext/erpnext/config/projects.py,Types of activities for Time Logs,Aina ya shughuli za Kumbukumbu za Muda
DocType: Opening Invoice Creation Tool,Sales,Mauzo
DocType: Stock Entry Detail,Basic Amount,Kiasi cha Msingi
DocType: Training Event,Exam,Mtihani
DocType: Email Campaign,Email Campaign,Kampeni ya barua pepe
apps/erpnext/erpnext/public/js/hub/hub_call.js,Marketplace Error,Hitilafu ya sokoni
DocType: Complaint,Complaint,Malalamiko
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Warehouse required for stock Item {0},Ghala inayotakiwa kwa kipengee cha hisa {0}
DocType: Leave Allocation,Unused leaves,Majani yasiyotumika
apps/erpnext/erpnext/patches/v11_0/create_department_records_for_each_company.py,All Departments,Idara zote
DocType: Healthcare Service Unit,Vacant,Yakosa
DocType: Patient,Alcohol Past Use,Pombe Matumizi ya Kale
DocType: Fertilizer Content,Fertilizer Content,Maudhui ya Mbolea
apps/erpnext/erpnext/public/js/hub/pages/Seller.vue,No description,Hakuna maelezo
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Cr,Cr
DocType: Tax Rule,Billing State,Hali ya kulipia
DocType: Quality Goal,Monitoring Frequency,Ufuatiliaji wa Mara kwa mara
DocType: Share Transfer,Transfer,Uhamisho
DocType: Quality Action,Quality Feedback,Maoni ya Ubora
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Work Order {0} must be cancelled before cancelling this Sales Order,Kazi ya Kazi {0} lazima iondoliwe kabla ya kufuta Sheria hii ya Mauzo
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Fetch exploded BOM (including sub-assemblies),Pata BOM ilipungua (ikiwa ni pamoja na mikutano ndogo)
DocType: Authorization Rule,Applicable To (Employee),Inafaa kwa (Mfanyakazi)
apps/erpnext/erpnext/controllers/accounts_controller.py,Due Date is mandatory,Tarehe ya Kutokana ni ya lazima
apps/erpnext/erpnext/controllers/accounts_controller.py,Cannot set quantity less than received quantity,Haiwezi kuweka kiasi chini ya wingi uliopokelewa
apps/erpnext/erpnext/controllers/item_variant.py,Increment for Attribute {0} cannot be 0,Uingizaji wa Kushikilia {0} hauwezi kuwa 0
DocType: Employee Benefit Claim,Benefit Type and Amount,Aina ya Faida na Kiasi
DocType: Delivery Stop,Visited,Walitembelewa
apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py,Rooms Booked,Vyumba vimeandikwa
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Ends On date cannot be before Next Contact Date.,Mwisho wa tarehe haiwezi kuwa kabla ya Tarehe ya Mawasiliano ya Ijayo.
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Batch Entries,Viingilio vya Batch
DocType: Journal Entry,Pay To / Recd From,Kulipa / Recd Kutoka
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Unpublish Item,Sichapishe Bidhaa
DocType: Naming Series,Setup Series,Mipangilio ya kuanzisha
DocType: Payment Reconciliation,To Invoice Date,Kwa tarehe ya ankara
DocType: Bank Account,Contact HTML,Wasiliana HTML
DocType: Support Settings,Support Portal,Portal ya Usaidizi
apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py,Registration fee can not be Zero,Halafu ya usajili haiwezi kuwa Zero
DocType: Disease,Treatment Period,Kipindi cha Matibabu
DocType: Travel Itinerary,Travel Itinerary,Safari ya Safari
apps/erpnext/erpnext/education/api.py,Result already Submitted,Matokeo yaliyotolewa tayari
apps/erpnext/erpnext/controllers/buying_controller.py,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Ghala iliyohifadhiwa ni lazima kwa Bidhaa {0} katika Vifaa vya Raw zinazotolewa
,Inactive Customers,Wateja wasio na kazi
DocType: Student Admission Program,Maximum Age,Umri wa Umri
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Please wait 3 days before resending the reminder.,Tafadhali subiri siku 3 kabla ya kurekebisha kukumbusha.
DocType: Landed Cost Voucher,Purchase Receipts,Receipts ya Ununuzi
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,"Upload a bank statement, link or reconcile a bank account","Sasisha taarifa ya benki, unganisha au upatanishe akaunti ya benki"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,How Pricing Rule is applied?,"Je, Sheria ya Pesa inatumikaje?"
DocType: Stock Entry,Delivery Note No,Kumbuka Utoaji No
DocType: Cheque Print Template,Message to show,Ujumbe wa kuonyesha
apps/erpnext/erpnext/public/js/setup_wizard.js,Retail,Uuzaji
DocType: Student Attendance,Absent,Haipo
DocType: Staffing Plan,Staffing Plan Detail,Mpangilio wa Mpango wa Utumishi
DocType: Employee Promotion,Promotion Date,Tarehe ya Kukuza
apps/erpnext/erpnext/hr/doctype/leave_ledger_entry/leave_ledger_entry.py,Leave allocation %s is linked with leave application %s,Ugawaji wa likizo% s umeunganishwa na maombi ya likizo% s
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Product Bundle,Bundle ya Bidhaa
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Haikuweza kupata alama kuanzia {0}. Unahitaji kuwa na alama zilizosimama zinazofunika 0 hadi 100
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Invalid reference {1},Row {0}: kumbukumbu isiyo sahihi {1}
apps/erpnext/erpnext/assets/doctype/location/location_tree.js,New Location,Eneo Jipya
DocType: Purchase Invoice,Purchase Taxes and Charges Template,Kiguli cha Malipo na Chaguzi
DocType: Additional Salary,Date on which this component is applied,Tarehe ambayo sehemu hii inatumika
DocType: Subscription,Current Invoice Start Date,Sasa Tarehe ya Kuanza Anza
DocType: Designation Skill,Designation Skill,Ujuzi wa Uteuzi
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Import of goods,Umuhimu wa bidhaa
DocType: Timesheet,TS-,TS-
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Either debit or credit amount is required for {2},{0} {1}: Kiwango cha deni au kiasi cha mkopo kinahitajika kwa {2}
DocType: GL Entry,Remarks,Maelezo
DocType: Support Settings,Track Service Level Agreement,Fuatilia Mkataba wa Kiwango cha Huduma
DocType: Hotel Room Amenity,Hotel Room Amenity,Ushauri wa chumba cha Hoteli
DocType: Budget,Action if Annual Budget Exceeded on MR,Hatua kama Bajeti ya Mwaka imeongezeka kwa MR
DocType: Course Enrollment,Course Enrollment,Uandikishaji wa kozi
DocType: Payment Entry,Account Paid From,Akaunti Ililipwa Kutoka
DocType: Purchase Order Item Supplied,Raw Material Item Code,Msimbo wa Nakala ya Nyenzo
DocType: Task,Parent Task,Kazi ya Mzazi
DocType: Project,From Template,Kutoka kwa Kiolezo
DocType: Journal Entry,Write Off Based On,Andika Msaada
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Print and Stationery,Chapisha na vifaa
DocType: Stock Settings,Show Barcode Field,Onyesha uwanja wa barcode
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Send Supplier Emails,Tuma barua pepe za Wasambazaji
DocType: Asset Movement,ACC-ASM-.YYYY.-,ACC-ASM-.YYYY--
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Mshahara tayari umeongezwa kwa muda kati ya {0} na {1}, Kuacha kipindi cha maombi hawezi kuwa kati ya tarehe hii ya tarehe."
DocType: Fiscal Year,Auto Created,Auto Iliyoundwa
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py,Submit this to create the Employee record,Tuma hii ili kuunda rekodi ya Wafanyakazi
DocType: Item Default,Item Default,Item Default
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Intra-State Supplies,Ugavi wa Jimbo la ndani
DocType: Chapter Member,Leave Reason,Acha Sababu
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.py,IBAN is not valid,IBAN sio halali
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Invoice {0} no longer exists,Invoice {0} haipo tena
DocType: Guardian Interest,Guardian Interest,Maslahi ya Guardian
DocType: Volunteer,Availability,Upatikanaji
apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.py,Leave application is linked with leave allocations {0}. Leave application cannot be set as leave without pay,Maombi ya kuondoka yanaunganishwa na mgao wa likizo {0}. Maombi ya kuondoka hayawezi kuwekwa kama likizo bila malipo
apps/erpnext/erpnext/config/retail.py,Setup default values for POS Invoices,Weka maadili ya msingi ya POS ankara
DocType: Employee Training,Training,Mafunzo
DocType: Project,Time to send,Muda wa kutuma
apps/erpnext/erpnext/public/js/hub/pages/Selling.vue,This page keeps track of your items in which buyers have showed some interest.,Ukurasa huu unafuatilia vitu vyako ambamo wanunuzi wameonyesha kupendezwa.
DocType: Timesheet,Employee Detail,Maelezo ya Waajiriwa
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.py,Set warehouse for Procedure {0} ,Weka ghala kwa Utaratibu {0}
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Email ID,Guardian1 Barua ya barua pepe
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Error: {0} is mandatory field,Kosa: {0} ni uwanja wa lazima
DocType: Lab Prescription,Test Code,Kanuni ya mtihani
apps/erpnext/erpnext/config/website.py,Settings for website homepage,Mipangilio ya ukurasa wa nyumbani wa wavuti
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} imeshikilia hadi {1}
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQs haziruhusiwi kwa {0} kutokana na msimamo wa alama ya {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Majani yaliyotumika
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Je! Unataka kupeleka ombi la nyenzo
DocType: Job Offer,Awaiting Response,Inasubiri Jibu
DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH -YYYY.-
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Above,Juu
DocType: Support Search Source,Link Options,Chaguo cha Kiungo
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Total Amount {0},Jumla ya Kiasi {0}
apps/erpnext/erpnext/controllers/item_variant.py,Invalid attribute {0} {1},Tabia isiyo sahihi {0} {1}
DocType: Supplier,Mention if non-standard payable account,Eleza kama akaunti isiyo ya kawaida kulipwa
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py,Please select the assessment group other than 'All Assessment Groups',Tafadhali chagua kikundi cha tathmini badala ya &#39;Makundi Yote ya Tathmini&#39;
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Row {0}: Cost center is required for an item {1},Row {0}: Kituo cha gharama kinahitajika kwa kipengee {1}
DocType: Training Event Employee,Optional,Hiari
DocType: Salary Slip,Earning & Deduction,Kufikia &amp; Kupunguza
DocType: Agriculture Analysis Criteria,Water Analysis,Uchambuzi wa Maji
DocType: Price List,Price Not UOM Dependent,Bei sio Mtegemezi wa UOM
apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} vigezo vimeundwa.
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Mkataba wa Kiwango cha Huduma ya Chaguzi tayari ipo.
DocType: Quality Objective,Quality Objective,Lengo la ubora
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Optional. This setting will be used to filter in various transactions.,Hiari. Mpangilio huu utatumika kufuta katika shughuli mbalimbali.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Negative Valuation Rate is not allowed,Kiwango cha Vikwazo Kibaya haruhusiwi
DocType: Holiday List,Weekly Off,Kutoka kwa kila wiki
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js,Reload Linked Analysis,Rejesha Upya Uchambuzi
DocType: Fiscal Year,"For e.g. 2012, 2012-13","Kwa mfano 2012, 2012-13"
DocType: Purchase Order,Purchase Order Pricing Rule,Sheria ya Ununuzi wa Bei ya Ununuzi
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Provisional Profit / Loss (Credit),Faida ya Muda / Kupoteza (Mikopo)
DocType: Sales Invoice,Return Against Sales Invoice,Rudi dhidi ya Invoice ya Mauzo
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 5,Kipengee 5
DocType: Serial No,Creation Time,Uumbaji Muda
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Total Revenue,Mapato ya jumla
DocType: Patient,Other Risk Factors,Mambo mengine ya Hatari
DocType: Sales Invoice,Product Bundle Help,Msaada wa Mfuko wa Bidhaa
,Monthly Attendance Sheet,Karatasi ya Kuhudhuria kila mwezi
DocType: Homepage Section Card,Subtitle,Subtitle
apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py,No record found,Hakuna rekodi iliyopatikana
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of Scrapped Asset,Gharama ya Kutolewa kwa Mali
DocType: Employee Checkin,OUT,BURE
apps/erpnext/erpnext/controllers/stock_controller.py,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Kituo cha Gharama ni lazima kwa Bidhaa {2}
DocType: Vehicle,Policy No,Sera ya Sera
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Get Items from Product Bundle,Pata vipengee kutoka kwenye Mfuko wa Bidhaa
DocType: Asset,Straight Line,Sawa Mstari
DocType: Project User,Project User,Mtumiaji wa Mradi
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split,Split
DocType: Tally Migration,Master Data,Takwimu za Mwalimu
DocType: Employee Transfer,Re-allocate Leaves,Rudia tena Majani
DocType: GL Entry,Is Advance,Ni Mapema
apps/erpnext/erpnext/config/hr.py,Employee Lifecycle,Mfanyakazi wa Maisha
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Attendance From Date and Attendance To Date is mandatory,Kuhudhuria Kutoka Tarehe na Kuhudhuria hadi Tarehe ni lazima
apps/erpnext/erpnext/controllers/buying_controller.py,Please enter 'Is Subcontracted' as Yes or No,"Tafadhali ingiza &#39;Je, unatetewa&#39; kama Ndiyo au Hapana"
DocType: Item,Default Purchase Unit of Measure,Kitengo cha Ununuzi cha Default
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication Date,Tarehe ya Mawasiliano ya Mwisho
DocType: Clinical Procedure Item,Clinical Procedure Item,Njia ya Utaratibu wa Kliniki
DocType: Sales Team,Contact No.,Wasiliana Na.
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Billing Address is same as Shipping Address,Anwani ya Bili ni sawa na Anwani ya Usafirishaji
DocType: Bank Reconciliation,Payment Entries,Entries ya Malipo
DocType: Location,Latitude,Latitude
DocType: Work Order,Scrap Warehouse,Ghala la Ghala
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,"Warehouse required at Row No {0}, please set default warehouse for the item {1} for the company {2}","Ghala inayotakiwa katika Row No {0}, tafadhali tengeneza ghala la msingi kwa kipengee {1} kwa kampuni {2}"
DocType: Work Order,Check if material transfer entry is not required,Angalia ikiwa kuingizwa kwa nyenzo haifai
DocType: Program Enrollment Tool,Get Students From,Pata Wanafunzi Kutoka
apps/erpnext/erpnext/config/help.py,Publish Items on Website,Chapisha Items kwenye tovuti
apps/erpnext/erpnext/utilities/activation.py,Group your students in batches,Shirikisha wanafunzi wako katika makundi
apps/erpnext/erpnext/accounts/utils.py,Allocated amount cannot be greater than unadjusted amount,Kiasi kilichowekwa haziwezi kuwa kubwa kuliko kiasi kisichorekebishwa
DocType: Authorization Rule,Authorization Rule,Sheria ya Uidhinishaji
apps/erpnext/erpnext/projects/doctype/project/project.py,Status must be Cancelled or Completed,Hali lazima ilifutwa au Kukamilishwa
DocType: Sales Invoice,Terms and Conditions Details,Masharti na Masharti Maelezo
DocType: Sales Invoice,Sales Taxes and Charges Template,Kigezo cha Malipo na Malipo
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Total (Credit),Jumla (Mikopo)
DocType: Repayment Schedule,Payment Date,Tarehe ya Malipo
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch Qty,Uchina Mpya
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Apparel & Accessories,Nguo &amp; Accessories
apps/erpnext/erpnext/controllers/accounts_controller.py,Item quantity can not be zero,Wingi wa kitu hauwezi kuwa sifuri
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Could not solve weighted score function. Make sure the formula is valid.,Haikuweza kutatua kazi ya alama ya uzito. Hakikisha fomu hiyo halali.
DocType: Invoice Discounting,Loan Period (Days),Kipindi cha mkopo (Siku)
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Purchase Order Items not received on time,Vipengee Vipengee vya Ununuzi havikupokea kwa wakati
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Number of Order,Idadi ya Utaratibu
DocType: Item Group,HTML / Banner that will show on the top of product list.,HTML / Banner ambayo itaonyesha juu ya orodha ya bidhaa.
DocType: Shipping Rule,Specify conditions to calculate shipping amount,Eleza hali ya kuhesabu kiasi cha meli
DocType: Program Enrollment,Institute's Bus,Basi ya Taasisi
DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Uwezo wa Kuruhusiwa Kuweka Akaunti Zenye Frozen &amp; Hariri Vitisho vya Frozen
DocType: Supplier Scorecard Scoring Variable,Path,Njia
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cannot convert Cost Center to ledger as it has child nodes,Haiwezi kubadilisha Kituo cha Gharama kwenye kiwanja kama ina nodes za watoto
DocType: Production Plan,Total Planned Qty,Uchina Uliopangwa
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Transactions already retreived from the statement,Manunuzi tayari yameshatolewa kutoka kwa taarifa
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Opening Value,Thamani ya Ufunguzi
DocType: Salary Component,Formula,Mfumo
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Serial #,Serial #
DocType: Material Request Plan Item,Required Quantity,Kiasi kinachohitajika
DocType: Lab Test Template,Lab Test Template,Kigezo cha Mtihani wa Lab
apps/erpnext/erpnext/accounts/doctype/accounting_period/accounting_period.py,Accounting Period overlaps with {0},Kipindi cha Uhasibu huingiliana na {0}
apps/erpnext/erpnext/setup/doctype/company/company.py,Sales Account,Akaunti ya Mauzo
DocType: Purchase Invoice Item,Total Weight,Uzito wote
DocType: Pick List Item,Pick List Item,Chagua Orodha ya Bidhaa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Commission on Sales,Tume ya Mauzo
DocType: Job Offer Term,Value / Description,Thamani / Maelezo
apps/erpnext/erpnext/controllers/accounts_controller.py,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Row # {0}: Malipo {1} haiwezi kufungwa, tayari ni {2}"
DocType: Tax Rule,Billing Country,Nchi ya kulipia
DocType: Purchase Order Item,Expected Delivery Date,Tarehe ya Utoaji Inayotarajiwa
DocType: Restaurant Order Entry,Restaurant Order Entry,Mkahawa wa Kuingia Uagizaji
apps/erpnext/erpnext/accounts/general_ledger.py,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debit na Mikopo si sawa kwa {0} # {1}. Tofauti ni {2}.
DocType: Clinical Procedure Item,Invoice Separately as Consumables,Invoice Separately kama Consumables
DocType: Budget,Control Action,Udhibiti wa Hatua
DocType: Asset Maintenance Task,Assign To Name,Weka kwa jina
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Entertainment Expenses,Gharama za Burudani
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open Item {0},Fungua Toleo {0}
DocType: Asset Finance Book,Written Down Value,Imeandikwa Thamani
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Invoice ya Mauzo {0} lazima iondoliwe kabla ya kufuta Utaratibu huu wa Mauzo
DocType: Clinical Procedure,Age,Umri
DocType: Sales Invoice Timesheet,Billing Amount,Kiwango cha kulipia
DocType: Cash Flow Mapping,Select Maximum Of 1,Chagua Upeo wa 1
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Kiasi batili kilichowekwa kwa kipengee {0}. Wingi wanapaswa kuwa mkubwa kuliko 0.
DocType: Company,Default Employee Advance Account,Akaunti ya Waajirika wa Mapendeleo ya Default
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Search Item (Ctrl + i),Tafuta Bidhaa (Ctrl + i)
DocType: C-Form,ACC-CF-.YYYY.-,ACC-CF -YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction can not be deleted,Akaunti na shughuli zilizopo haziwezi kufutwa
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Why do think this Item should be removed?,Je! Ni kwanini unafikiri Bidhaa hii inapaswa kuondolewa?
DocType: Vehicle,Last Carbon Check,Check Carbon Mwisho
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Gharama za Kisheria
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Tafadhali chagua kiasi kwenye mstari
DocType: Purchase Invoice,Posting Time,Wakati wa Kuchapa
DocType: Timesheet,% Amount Billed,Kiasi kinachojazwa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Malipo ya Simu
DocType: Sales Partner,Logo,Rangi
DocType: Naming Series,Check this if you want to force the user to select a series before saving. There will be no default if you check this.,Angalia hii ikiwa unataka kulazimisha mtumiaji kuchagua mfululizo kabla ya kuokoa. Hutakuwa na default ikiwa utaangalia hii.
apps/erpnext/erpnext/stock/get_item_details.py,No Item with Serial No {0},Hakuna kitu na Serial No {0}
DocType: Email Digest,Open Notifications,Fungua Arifa
DocType: Payment Entry,Difference Amount (Company Currency),Tofauti Kiasi (Fedha la Kampuni)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Direct Expenses,Malipo ya moja kwa moja
DocType: Pricing Rule Detail,Child Docname,Hati ya Mtoto
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,New Customer Revenue,Mapato ya Wateja Mpya
apps/erpnext/erpnext/config/support.py,Service Level.,Kiwango cha Huduma.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Travel Expenses,Gharama za kusafiri
DocType: Maintenance Visit,Breakdown,Kuvunja
DocType: Travel Itinerary,Vegetarian,Mboga
DocType: Patient Encounter,Encounter Date,Kukutana Tarehe
DocType: Work Order,Update Consumed Material Cost In Project,Sasisha Gharama Iliyodhaniwa ya nyenzo katika Mradi
apps/erpnext/erpnext/controllers/accounts_controller.py,Account: {0} with currency: {1} can not be selected,Akaunti: {0} kwa fedha: {1} haiwezi kuchaguliwa
DocType: Bank Statement Transaction Settings Item,Bank Data,Takwimu za Benki
DocType: Purchase Receipt Item,Sample Quantity,Mfano Wingi
DocType: Bank Guarantee,Name of Beneficiary,Jina la Mfadhili
DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.","Sasisha BOM gharama moja kwa moja kupitia Mpangilio, kwa kuzingatia kiwango cha hivi karibuni cha kiwango cha bei / bei ya bei / mwisho wa ununuzi wa vifaa vya malighafi."
DocType: Supplier,SUP-.YYYY.-,SUP-YYYY.-
,BOM Items and Scraps,Vitu vya BOM na chakavu
DocType: Bank Reconciliation Detail,Cheque Date,Tarehe ya Kuangalia
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} does not belong to company: {2},Akaunti {0}: Akaunti ya Mzazi {1} si ya kampuni: {2}
apps/erpnext/erpnext/setup/doctype/company/company.js,Successfully deleted all transactions related to this company!,Imefanikiwa kufutwa shughuli zote zinazohusiana na kampuni hii!
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,As on Date,Kama tarehe
DocType: Additional Salary,HR,HR
DocType: Course Enrollment,Enrollment Date,Tarehe ya Kuandikisha
DocType: Healthcare Settings,Out Patient SMS Alerts,Nje Tahadhari za Mgonjwa wa SMS
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Probation,Probation
DocType: Company,Sales Settings,Mipangilio ya Uuzaji
DocType: Program Enrollment Tool,New Academic Year,Mwaka Mpya wa Elimu
DocType: Supplier Scorecard,Load All Criteria,Pakia Viwango vyote
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Return / Credit Note,Kurudi / Taarifa ya Mikopo
DocType: Stock Settings,Auto insert Price List rate if missing,Weka kwa urahisi Orodha ya Bei ya Orodha ikiwa haipo
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Total Paid Amount,Jumla ya kulipwa
DocType: GST Settings,B2C Limit,Mpaka wa B2C
DocType: Job Card,Transferred Qty,Uchina uliotumwa
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,The selected payment entry should be linked with a creditor bank transaction,Kiingilio cha malipo kilichochaguliwa kinapaswa kuhusishwa na shughuli ya benki ya mkopeshaji
DocType: POS Closing Voucher,Amount in Custody,Kiasi katika Custody
apps/erpnext/erpnext/config/help.py,Navigating,Inasafiri
apps/erpnext/erpnext/hr/doctype/hr_settings/hr_settings.js,Password policy cannot contain spaces or simultaneous hyphens. The format will be restructured automatically,Sera ya nenosiri haiwezi kuwa na nafasi au hypanu wakati huo huo. Fomati itarekebishwa kiatomati
DocType: Quotation Item,Planning,Kupanga
DocType: Salary Component,Depends on Payment Days,Inategemea Siku za Malipo
DocType: Contract,Signee,Signee
DocType: Share Balance,Issued,Iliyotolewa
DocType: Loan,Repayment Start Date,Tarehe ya Kuanza Kulipa
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Student Activity,Shughuli ya Wanafunzi
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py,Supplier Id,Idha ya Wasambazaji
DocType: Payment Request,Payment Gateway Details,Maelezo ya Gateway ya Malipo
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity should be greater than 0,Wingi wanapaswa kuwa mkubwa kuliko 0
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,Price or product discount slabs are required,Bei au bei za bidhaa zinahitajika
DocType: Journal Entry,Cash Entry,Kuingia kwa Fedha
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js,Child nodes can be only created under 'Group' type nodes,Node za watoto zinaweza kuundwa tu chini ya nambari za aina ya &#39;Kikundi&#39;
DocType: Attendance Request,Half Day Date,Tarehe ya Nusu ya Siku
DocType: Academic Year,Academic Year Name,Jina la Mwaka wa Elimu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,{0} not allowed to transact with {1}. Please change the Company.,{0} haruhusiwi kuingiliana na {1}. Tafadhali mabadiliko ya Kampuni.
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_sub_category/employee_tax_exemption_sub_category.py,Max Exemption Amount cannot be greater than maximum exemption amount {0} of Tax Exemption Category {1},Kiasi cha Msamaha wa Msingi hauwezi kuwa mkubwa kuliko kiwango cha juu cha msamaha {0} wa Kitengo cha Msamaha wa Kodi {1}
DocType: Sales Partner,Contact Desc,Wasiliana Desc
DocType: Email Digest,Send regular summary reports via Email.,Tuma taarifa za muhtasari wa mara kwa mara kupitia barua pepe.
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Please set default account in Expense Claim Type {0},Tafadhali weka akaunti chaguo-msingi katika Aina ya Dai la Gharama {0}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Available Leaves,Majani Inapatikana
DocType: Assessment Result,Student Name,Jina la Mwanafunzi
DocType: Hub Tracked Item,Item Manager,Meneja wa Bidhaa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Payroll Payable,Mishahara ya kulipa
DocType: GSTR 3B Report,April,Aprili
DocType: Plant Analysis,Collection Datetime,Mkusanyiko wa Tarehe
DocType: Asset Repair,ACC-ASR-.YYYY.-,ACC-ASR -YYYY.-
DocType: Work Order,Total Operating Cost,Gharama ya Uendeshaji Yote
apps/erpnext/erpnext/controllers/selling_controller.py,Note: Item {0} entered multiple times,Kumbuka: Kipengee {0} kiliingizwa mara nyingi
apps/erpnext/erpnext/config/buying.py,All Contacts.,Mawasiliano Yote.
DocType: Accounting Period,Closed Documents,Nyaraka zilizofungwa
DocType: Healthcare Settings,Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Dhibiti Invoice ya Uteuzi kuwasilisha na kufuta moja kwa moja kwa Mkutano wa Mgonjwa
apps/erpnext/erpnext/config/website.py,Add cards or custom sections on homepage,Ongeza kadi au sehemu maalum kwenye ukurasa wa nyumbani
DocType: Patient Appointment,Referring Practitioner,Akizungumza na Daktari
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Abbreviation,Hali ya Kampuni
apps/erpnext/erpnext/hr/doctype/employee/employee.py,User {0} does not exist,Mtumiaji {0} haipo
DocType: Payment Term,Day(s) after invoice date,Siku (s) baada ya tarehe ya ankara
apps/erpnext/erpnext/setup/doctype/company/company.js,Date of Commencement should be greater than Date of Incorporation,Tarehe ya Kuanza inapaswa kuwa kubwa zaidi kuliko tarehe ya kuingizwa
DocType: Contract,Signed On,Iliyosainiwa
DocType: Bank Account,Party Type,Aina ya Chama
DocType: Discounted Invoice,Discounted Invoice,Ankara iliyopunguzwa
DocType: Payment Schedule,Payment Schedule,Ratiba ya Malipo
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,No Employee found for the given employee field value. '{}': {},Hakuna Mfanyikazi aliyepatikana kwa thamani ya shamba aliyopewa ya mfanyakazi. &#39;{}&#39;: {}
DocType: Item Attribute Value,Abbreviation,Hali
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Entry already exists,Kuingia kwa Malipo tayari kuna
DocType: Course Content,Quiz,Jaribio
DocType: Subscription,Trial Period End Date,Tarehe ya Mwisho wa Kipindi
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py,Not authroized since {0} exceeds limits,Sio kuchapishwa tangu {0} inapozidi mipaka
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Start entering data from here : ,Anza kuingiza data kutoka hapa:
DocType: Serial No,Asset Status,Hali ya Mali
DocType: Sales Invoice,Over Dimensional Cargo (ODC),Zaidi ya Cargo Dimensional (ODC)
DocType: Restaurant Order Entry,Restaurant Table,Jedwali la Mgahawa
DocType: Hotel Room,Hotel Manager,Meneja wa Hoteli
apps/erpnext/erpnext/utilities/activation.py,Create Student Batch,Unda Kundi la Wanafunzi
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Set Tax Rule for shopping cart,Weka Kanuni ya Ushuru kwa gari la ununuzi
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.py,There are no vacancies under staffing plan {0},Hakuna nafasi za kazi chini ya mpango wa wafanyikazi {0}
DocType: Purchase Invoice,Taxes and Charges Added,Kodi na Malipo Aliongeza
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Upungufu Row {0}: Tarehe ya Utoaji wa Dhamana haiwezi kuwa kabla ya Tarehe ya kupatikana
,Sales Funnel,Funnel ya Mauzo
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Nambari ya Bidhaa&gt; Kikundi cha bidhaa&gt; Brand
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Hali ni lazima
DocType: Project,Task Progress,Maendeleo ya Kazi
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Kadi
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_settings.py,Bank account {0} already exists and could not be created again,Akaunti ya benki {0} tayari ipo na haikuweza kuunda tena
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Missed,Simu Imekosa
DocType: Certified Consultant,GitHub ID,Kitambulisho cha GitHub
DocType: Staffing Plan,Total Estimated Budget,Jumla ya Bajeti ya Badirio
,Qty to Transfer,Uchina kwa Uhamisho
apps/erpnext/erpnext/config/selling.py,Quotes to Leads or Customers.,Quotes Kuongoza au Wateja.
DocType: Stock Settings,Role Allowed to edit frozen stock,Kazi Imeruhusiwa kuhariri hisa zilizohifadhiwa
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,All Customer Groups,Vikundi vyote vya Wateja
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Accumulated Monthly,Imekusanywa kila mwezi
DocType: Attendance Request,On Duty,Kazini
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} ni lazima. Kumbukumbu ya Kubadilisha Fedha Labda haikuundwa kwa {1} kwa {2}.
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,Staffing Plan {0} already exist for designation {1},Mpango wa Utumishi {0} tayari umekuwepo kwa ajili ya uteuzi {1}
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,Tax Template is mandatory.,Kigezo cha Kodi ni lazima.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Goods are already received against the outward entry {0},Bidhaa tayari zimepokelewa dhidi ya uingilio wa nje {0}
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Last Issue,Toleo la Mwisho
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} does not exist,Akaunti {0}: Akaunti ya Mzazi {1} haipo
DocType: Bank Account,Mask,Mask
DocType: POS Closing Voucher,Period Start Date,Tarehe ya Kuanza ya Kipindi
DocType: Purchase Invoice Item,Price List Rate (Company Currency),Orodha ya Bei ya Thamani (Fedha la Kampuni)
DocType: Products Settings,Products Settings,Mipangilio ya Bidhaa
,Item Price Stock,Item Bei Stock
apps/erpnext/erpnext/config/retail.py,To make Customer based incentive schemes.,Kufanya mipango ya motisha ya msingi ya Wateja.
DocType: Lab Prescription,Test Created,Mtihani Umeundwa
DocType: Healthcare Settings,Custom Signature in Print,Sahihi ya Sahihi katika Kuchapa
DocType: Account,Temporary,Muda
DocType: Material Request Plan Item,Customer Provided,Mteja Ametolewa
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Customer LPO No.,LPO ya Wateja
DocType: Amazon MWS Settings,Market Place Account Group,Kikundi cha Akaunti ya Mahali ya Soko
DocType: Program,Courses,Mafunzo
DocType: Monthly Distribution Percentage,Percentage Allocation,Asilimia ya Ugawaji
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Secretary,Katibu
apps/erpnext/erpnext/regional/india/utils.py,House rented dates required for exemption calculation,Nyumba iliyopangwa tarehe inahitajika kwa hesabu ya msamaha
DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Ikiwa imezima, shamba la &#39;Katika Maneno&#39; halitaonekana katika shughuli yoyote"
DocType: Quality Review Table,Quality Review Table,Jedwali la Mapitio ya Ubora
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,This action will stop future billing. Are you sure you want to cancel this subscription?,Hatua hii itaacha bili ya baadaye. Una uhakika unataka kufuta usajili huu?
DocType: Serial No,Distinct unit of an Item,Kitengo cha tofauti cha Kipengee
DocType: Supplier Scorecard Criteria,Criteria Name,Jina la Criteria
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.js,Please set Company,Tafadhali weka Kampuni
DocType: Procedure Prescription,Procedure Created,Utaratibu ulioundwa
DocType: Pricing Rule,Buying,Ununuzi
apps/erpnext/erpnext/config/agriculture.py,Diseases & Fertilizers,Magonjwa &amp; Fertilizers
DocType: HR Settings,Employee Records to be created by,Kumbukumbu za Waajiri zitaundwa na
DocType: Inpatient Record,AB Negative,AB Hasila
DocType: POS Profile,Apply Discount On,Tumia Ruzuku
DocType: Member,Membership Type,Aina ya Uanachama
,Reqd By Date,Reqd Kwa Tarehe
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Creditors,Wakopaji
DocType: Assessment Plan,Assessment Name,Jina la Tathmini
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No is mandatory,Row # {0}: Serial Hakuna lazima
DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Jedwali Maelezo ya kodi ya busara
DocType: Employee Onboarding,Job Offer,Kazi ya Kazi
apps/erpnext/erpnext/public/js/setup_wizard.js,Institute Abbreviation,Usanidi wa Taasisi
,Item-wise Price List Rate,Orodha ya bei ya bei ya bei
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Supplier Quotation,Nukuu ya Wafanyabiashara
apps/erpnext/erpnext/config/support.py,Issue Priority.,Kipaumbele cha Hoja.
DocType: Quotation,In Words will be visible once you save the Quotation.,Katika Maneno itaonekana wakati unapohifadhi Nukuu.
apps/erpnext/erpnext/utilities/transaction_base.py,Quantity ({0}) cannot be a fraction in row {1},Wingi ({0}) hawezi kuwa sehemu ya mstari {1}
DocType: Contract,Unsigned,Haijaandikwa
DocType: Selling Settings,Each Transaction,Kila Shughuli
apps/erpnext/erpnext/stock/doctype/item/item.py,Barcode {0} already used in Item {1},Barcode {0} tayari kutumika katika Item {1}
DocType: Shift Type,The time before the shift end time when check-out is considered as early (in minutes).,Wakati kabla ya wakati wa mwisho wa kuhama wakati kuondoka-nje kunazingatiwa mapema (dakika).
apps/erpnext/erpnext/config/selling.py,Rules for adding shipping costs.,Sheria ya kuongeza gharama za meli.
DocType: Hotel Room,Extra Bed Capacity,Uwezo wa kitanda cha ziada
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Varaiance ,Varaiance
apps/erpnext/erpnext/config/hr.py,Performance,Utendaji
DocType: Item,Opening Stock,Ufunguzi wa Hifadhi
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,Customer is required,Wateja inahitajika
DocType: Lab Test,Result Date,Tarehe ya matokeo
DocType: Purchase Order,To Receive,Kupokea
DocType: Leave Period,Holiday List for Optional Leave,Orodha ya Likizo ya Kuondoka kwa Hiari
DocType: Item Tax Template,Tax Rates,Viwango vya Ushuru
apps/erpnext/erpnext/utilities/user_progress.py,user@example.com,user@example.com
DocType: Asset,Asset Owner,Mmiliki wa Mali
DocType: Item,Website Content,Yaliyomo kwenye Tovuti
DocType: Bank Account,Integration ID,Kitambulisho cha Ujumuishaji
DocType: Purchase Invoice,Reason For Putting On Hold,Sababu ya kuweka juu ya kushikilia
DocType: Employee,Personal Email,Barua pepe ya kibinafsi
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Variance,Tofauti ya Jumla
DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Ikiwa imewezeshwa, mfumo utasoma fomu za uhasibu kwa hesabu moja kwa moja."
apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() accepted invalid IBAN {},BankAccount.validate_iban () imekubaliwa IBAN batili {}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Brokerage,Uhamisho
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Attendance for employee {0} is already marked for this day,Kuhudhuria kwa mfanyakazi {0} tayari umewekwa alama kwa siku hii
DocType: Work Order Operation,"in Minutes
Updated via 'Time Log'",Katika Dakika Iliyopita kupitia &quot;Muda wa Kuingia&quot;
DocType: Customer,From Lead,Kutoka Kiongozi
DocType: Amazon MWS Settings,Synch Orders,Amri ya Synch
apps/erpnext/erpnext/config/manufacturing.py,Orders released for production.,Amri iliyotolewa kwa ajili ya uzalishaji.
apps/erpnext/erpnext/public/js/account_tree_grid.js,Select Fiscal Year...,Chagua Mwaka wa Fedha ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,Profaili ya POS inahitajika ili ufanye POS Entry
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Vidokezo vya uaminifu vitahesabiwa kutoka kwa alitumia kufanyika (kwa njia ya ankara za Mauzo), kulingana na sababu ya kukusanya iliyotajwa."
DocType: Program Enrollment Tool,Enroll Students,Jiandikisha Wanafunzi
DocType: Company,HRA Settings,Mipangilio ya HRA
DocType: Homepage,Hero Section,Sehemu ya shujaa
DocType: Employee Transfer,Transfer Date,Tarehe ya Uhamisho
DocType: Lab Test,Approved Date,Tarehe iliyoidhinishwa
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py,Standard Selling,Uuzaji wa kawaida
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Atleast one warehouse is mandatory,Atleast ghala moja ni lazima
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py,"Configure Item Fields like UOM, Item Group, Description and No of Hours.","Sanidi Mashamba ya Bidhaa kama UOM, Kikundi cha Maelezo, Maelezo na Hakuna Masaa."
DocType: Certification Application,Certification Status,Hali ya vyeti
apps/erpnext/erpnext/public/js/hub/marketplace.js,Marketplace,Hifadhi ya Soko
DocType: Travel Itinerary,Travel Advance Required,Safari ya Safari inahitajika
DocType: Subscriber,Subscriber Name,Jina la Msajili
DocType: Serial No,Out of Warranty,Nje ya udhamini
DocType: Bank Statement Transaction Settings Item,Mapped Data Type,Aina ya Data Mapped
DocType: BOM Update Tool,Replace,Badilisha
apps/erpnext/erpnext/templates/includes/product_list.js,No products found.,Hakuna bidhaa zilizopatikana.
apps/erpnext/erpnext/public/js/hub/pages/PublishedItems.vue,Publish More Items,Chapisha Vitu Zaidi
apps/erpnext/erpnext/support/doctype/issue/issue.py,This Service Level Agreement is specific to Customer {0},Mkataba huu wa Kiwango cha Huduma ni maalum kwa Wateja {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Sales Invoice {1},{0} dhidi ya ankara ya mauzo {1}
DocType: Antibiotic,Laboratory User,Mtumiaji wa Maabara
DocType: Request for Quotation Item,Project Name,Jina la Mradi
apps/erpnext/erpnext/regional/italy/utils.py,Please set the Customer Address,Tafadhali weka Anwani ya Wateja
DocType: Customer,Mention if non-standard receivable account,Eleza kama akaunti isiyo ya kawaida ya kupokea
DocType: Bank,Plaid Access Token,Ishara ya Upataji wa Paa
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Please add the remaining benefits {0} to any of the existing component,Tafadhali ongeza faida zilizobaki {0} kwa sehemu yoyote iliyopo
DocType: Journal Entry Account,If Income or Expense,Kama Mapato au Gharama
DocType: Course Topic,Course Topic,Mada ya kozi
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/pos_closing_voucher.py,POS Closing Voucher alreday exists for {0} between date {1} and {2},Ushirikiano wa vocha ya kufunga POS inapatikana kwa {0} kati ya tarehe {1} na {2}
DocType: Bank Statement Transaction Entry,Matching Invoices,Invoices zinazofanana
DocType: Work Order,Required Items,Vitu vinavyotakiwa
DocType: Stock Ledger Entry,Stock Value Difference,Thamani ya Thamani ya Hifadhi
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Item Row {0}: {1} {2} does not exist in above '{1}' table,Row Row {0}: {1} {2} haipo katika meza ya juu &#39;{1}&#39;
apps/erpnext/erpnext/config/help.py,Human Resource,Rasilimali watu
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Malipo ya Upatanisho wa Malipo
DocType: Disease,Treatment Task,Kazi ya Matibabu
DocType: Payment Order Reference,Bank Account Details,Maelezo ya Akaunti ya Benki
DocType: Purchase Order Item,Blanket Order,Mpangilio wa kikapu
apps/erpnext/erpnext/hr/doctype/loan_application/loan_application.py,Repayment Amount must be greater than ,Kiasi cha Ulipaji lazima iwe kubwa kuliko
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Tax Assets,Mali ya Kodi
DocType: BOM Item,BOM No,BOM Hapana
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Journal Entry {0} does not have account {1} or already matched against other voucher,Uingiaji wa Vitambulisho {0} hauna akaunti {1} au tayari imefananishwa dhidi ya vyeti vingine
DocType: Item,Moving Average,Kusonga Wastani
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Benefit,Faida
DocType: BOM Update Tool,The BOM which will be replaced,BOM ambayo itabadilishwa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Electronic Equipments,Vifaa vya umeme
DocType: Asset,Maintenance Required,Matengenezo Inahitajika
DocType: Account,Debit,Debit
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leaves must be allocated in multiples of 0.5,Majani yanapaswa kuwekwa kwa mara nyingi ya 0.5
DocType: Work Order,Operation Cost,Gharama za Uendeshaji
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Identifying Decision Makers,Kutambua Waamuzi wa Uamuzi
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Outstanding Amt,Amt bora
DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Weka malengo Makala ya busara ya Kikundi kwa Mtu wa Mauzo.
DocType: Stock Settings,Freeze Stocks Older Than [Days],Zifungia Hifadhi za Kale kuliko [Siku]
DocType: Payment Entry,Payment Ordered,Malipo amri
DocType: Asset Maintenance Team,Maintenance Team Name,Jina la Timu ya Matengenezo
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"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.","Ikiwa Kanuni mbili za bei za bei zinapatikana kulingana na hali zilizo hapo juu, Kipaumbele kinatumika. Kipaumbele ni nambari kati ya 0 hadi 20 wakati thamani ya msingi ni sifuri (tupu). Nambari ya juu ina maana itatangulia kama kuna Kanuni nyingi za bei na hali sawa."
apps/erpnext/erpnext/controllers/trends.py,Fiscal Year: {0} does not exists,Mwaka wa Fedha: {0} haipo
DocType: Currency Exchange,To Currency,Ili Fedha
DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Ruhusu watumiaji wafuatayo kupitisha Maombi ya Kuacha kwa siku za kuzuia.
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Lifecycle,Uhai wa Maisha
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Payment Document Type,Aina ya Hati ya malipo
apps/erpnext/erpnext/controllers/selling_controller.py,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Kiwango cha kuuza kwa kipengee {0} ni cha chini kuliko {1} yake. Kiwango cha uuzaji kinapaswa kuwa salama {2}
DocType: Designation Skill,Skill,Ujuzi
DocType: Subscription,Taxes,Kodi
DocType: Purchase Invoice Item,Weight Per Unit,Uzito Kwa Kitengo
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Paid and Not Delivered,Ilipwa na Haijaokolewa
DocType: QuickBooks Migrator,Default Cost Center,Kituo cha Ghali cha Default
apps/erpnext/erpnext/www/all-products/index.html,Toggle Filters,Badilisha vichungi
apps/erpnext/erpnext/config/stock.py,Stock Transactions,Ushirikiano wa hisa
DocType: Budget,Budget Accounts,Hesabu za Bajeti
DocType: Employee,Internal Work History,Historia ya Kazi ya Kazi
DocType: Bank Statement Transaction Entry,New Transactions,Shughuli mpya
DocType: Depreciation Schedule,Accumulated Depreciation Amount,Kukusanya kiasi cha kushuka kwa thamani
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Private Equity,Private Equity
DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Scorecard ya Wafanyabiashara Inaweza kubadilika
DocType: Shift Type,Working Hours Threshold for Half Day,Kufanya Kazi Kizingiti cha Siku ya nusu
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please create purchase receipt or purchase invoice for the item {0},Tafadhali tengeneza risiti ya ununuzi au ankara ya ununuzi kwa kipengee {0}
DocType: Job Card,Material Transferred,Nyenzo Inahamishwa
DocType: Employee Advance,Due Advance Amount,Kutokana na Kiwango cha Mapema
DocType: Maintenance Visit,Customer Feedback,Maoni ya Wateja
DocType: Account,Expense,Gharama
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js,Score cannot be greater than Maximum Score,Alama haiwezi kuwa kubwa zaidi kuliko alama ya Maximum
DocType: Support Search Source,Source Type,Aina ya Chanzo
DocType: Course Content,Course Content,Yaliyomo ya kozi
apps/erpnext/erpnext/utilities/user_progress.py,Customers and Suppliers,Wateja na Wauzaji
DocType: Item Attribute,From Range,Kutoka Mbalimbali
DocType: BOM,Set rate of sub-assembly item based on BOM,Weka kiwango cha kipengee kidogo cha mkutano kulingana na BOM
DocType: Inpatient Occupancy,Invoiced,Imesajiliwa
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,WooCommerce Products,Bidhaa za WooCommerce
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Syntax error in formula or condition: {0},Hitilafu ya Syntax katika fomu au hali: {0}
apps/erpnext/erpnext/stock/utils.py,Item {0} ignored since it is not a stock item,Kipengee {0} kinachunguzwa kwani si kitu cha hisa
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Ili kuomba Sheria ya bei katika shughuli fulani, Sheria zote za Bei lazima zimezimwa."
DocType: Payment Term,Day(s) after the end of the invoice month,Siku (s) baada ya mwisho wa mwezi wa ankara
DocType: Assessment Group,Parent Assessment Group,Kundi la Tathmini ya Mzazi
DocType: Employee Checkin,Shift Actual End,Mwisho wa Shift
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,Jobs,Kazi
,Sales Order Trends,Mwelekeo wa Utaratibu wa Mauzo
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,The 'From Package No.' field must neither be empty nor it's value less than 1.,Ya &#39;Kutoka Pakiti&#39; shamba haipaswi kuwa tupu wala ni thamani chini ya 1.
DocType: Employee,Held On,Imewekwa
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js,Production Item,Bidhaa ya Uzalishaji
,Employee Information,Taarifa ya Waajiriwa
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Healthcare Practitioner not available on {0},Mtaalamu wa Afya haipatikani kwa {0}
DocType: Stock Entry Detail,Additional Cost,Gharama za ziada
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"Can not filter based on Voucher No, if grouped by Voucher","Haiwezi kuchuja kulingana na Voucher No, ikiwa imewekwa na Voucher"
DocType: Quality Inspection,Incoming,Inakuja
apps/erpnext/erpnext/setup/doctype/company/company.js,Default tax templates for sales and purchase are created.,Vidokezo vya kodi za kutosha kwa mauzo na ununuzi vinaloundwa.
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py,Assessment Result record {0} already exists.,Tathmini ya Matokeo ya Tathmini {0} tayari imepo.
DocType: Item,"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.","Mfano: ABCD. #####. Ikiwa mfululizo umewekwa na Batch No haijajwajwa katika shughuli, basi nambari ya kundi la moja kwa moja litaundwa kulingana na mfululizo huu. Ikiwa daima unataka kueleza wazi Kundi Hakuna kwa kipengee hiki, chagua hii tupu. Kumbuka: mipangilio hii itachukua kipaumbele juu ya Kiambatisho cha Msaada wa Naming katika Mipangilio ya Hifadhi"
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Outward taxable supplies(zero rated),Vifaa vya ushuru vya nje (vimekadiriwa zero)
DocType: BOM,Materials Required (Exploded),Vifaa vinavyotakiwa (Imelipuka)
apps/erpnext/erpnext/buying/report/purchase_analytics/purchase_analytics.js,based_on,kulingana na
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Submit Review,Wasilisha Ukaguzi
DocType: Contract,Party User,Mtumiaji wa Chama
apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Tafadhali weka Chujio cha Kampuni kikiwa tupu ikiwa Kundi Na &#39;Kampuni&#39;
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Tarehe ya Kuchapisha haiwezi kuwa tarehe ya baadaye
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: Serial No {1} hailingani na {2} {3}
DocType: Stock Entry,Target Warehouse Address,Anwani ya Wakala ya Ghala
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Kuondoka kwa kawaida
DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,Wakati kabla ya kuanza kwa wakati ambapo Kuingia kwa Wafanyakazi kunazingatiwa kwa mahudhurio.
DocType: Agriculture Task,End Day,Siku ya Mwisho
DocType: Batch,Batch ID,Kitambulisho cha Bundi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Note: {0},Kumbuka: {0}
DocType: Stock Settings,Action if Quality inspection is not submitted,Kitendo ikiwa ukaguzi wa Ubora haujawasilishwa
,Delivery Note Trends,Mwelekeo wa Kumbuka Utoaji
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,This Week's Summary,Muhtasari wa wiki hii
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,In Stock Qty,Katika Stock
,Daily Work Summary Replies,Muhtasari wa Kazi ya Kila siku
DocType: Delivery Trip,Calculate Estimated Arrival Times,Tumia Hesabu ya Kufika Iliyohesabiwa
apps/erpnext/erpnext/accounts/general_ledger.py,Account: {0} can only be updated via Stock Transactions,Akaunti: {0} inaweza kurekebishwa tu kupitia Ushirikiano wa Hifadhi
DocType: Student Group Creation Tool,Get Courses,Pata Mafunzo
DocType: Tally Migration,ERPNext Company,Kampuni ya ERPNext
DocType: Shopify Settings,Webhooks,Mtandao wa wavuti
DocType: Bank Account,Party,Chama
DocType: Healthcare Settings,Patient Name,Jina la subira
DocType: Variant Field,Variant Field,Field Variant
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Target Location,Mahali Mahali
DocType: Sales Order,Delivery Date,Tarehe ya Utoaji
DocType: Opportunity,Opportunity Date,Tarehe ya fursa
DocType: Employee,Health Insurance Provider,Mtoa Bima ya Afya
DocType: Service Level,Holiday List (ignored during SLA calculation),Orodha ya likizo (kupuuzwa wakati wa hesabu ya SLA)
DocType: Products Settings,Show Availability Status,Onyesha Hali ya Upatikanaji
DocType: Purchase Receipt,Return Against Purchase Receipt,Kurudi dhidi ya Receipt ya Ununuzi
DocType: Water Analysis,Person Responsible,Mtu anajibika
DocType: Request for Quotation Item,Request for Quotation Item,Ombi la Bidhaa ya Nukuu
DocType: Purchase Order,To Bill,Kwa Bill
DocType: Material Request,% Ordered,Aliamriwa
DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.","Kwa Kundi la Wanafunzi la msingi, Kozi itastahikiwa kwa kila Mwanafunzi kutoka Kozi zilizosajiliwa katika Uandikishaji wa Programu."
DocType: Employee Grade,Employee Grade,Wafanyakazi wa darasa
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Piecework
DocType: GSTR 3B Report,June,Juni
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Mtoaji&gt; Aina ya wasambazaji
DocType: Share Balance,From No,Kutoka Hapana
DocType: Shift Type,Early Exit Grace Period,Tarehe ya mapema ya Neema
DocType: Task,Actual Time (in Hours),Muda halisi (katika Masaa)
DocType: Employee,History In Company,Historia Katika Kampuni
DocType: Customer,Customer Primary Address,Anwani ya Msingi ya Wateja
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Connected,Simu Imeunganishwa
apps/erpnext/erpnext/config/crm.py,Newsletters,Majarida
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Reference No.,Nambari ya kumbukumbu.
DocType: Drug Prescription,Description/Strength,Maelezo / Nguvu
apps/erpnext/erpnext/config/hr.py,Energy Point Leaderboard,Bodi ya Uongozi wa Nishati
DocType: Bank Statement Transaction Entry,Create New Payment/Journal Entry,Unda Malipo Mpya / Uingiaji wa Machapisho
DocType: Certification Application,Certification Application,Programu ya Vyeti
DocType: Leave Type,Is Optional Leave,Ni Chaguo La Kuondoka
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Declare Lost,Tangaza waliopotea
DocType: Share Balance,Is Company,Ni Kampuni
DocType: Pricing Rule,Same Item,Jambo moja
DocType: Stock Ledger Entry,Stock Ledger Entry,Kuingia kwa Ledger Entry
DocType: Quality Action Resolution,Quality Action Resolution,Azimio la Utendaji Bora
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} on Half day Leave on {1},{0} kwenye siku ya nusu Acha {1}
DocType: Department,Leave Block List,Acha orodha ya kuzuia
DocType: Purchase Invoice,Tax ID,Kitambulisho cha Ushuru
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item {0} is not setup for Serial Nos. Column must be blank,Kipengee {0} sio kuanzisha kwa Nakala Zetu. Sawa lazima iwe tupu
apps/erpnext/erpnext/regional/india/utils.py,Either GST Transporter ID or Vehicle No is required if Mode of Transport is Road,Kitambulisho cha Transporter ya GST au gari La Hakuna inahitajika ikiwa Njia ya Usafiri ni Barabara
DocType: Accounts Settings,Accounts Settings,Mipangilio ya Akaunti
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Approve,Thibitisha
DocType: Loyalty Program,Customer Territory,Eneo la Wateja
DocType: Email Digest,Sales Orders to Deliver,Maagizo ya Mauzo ya Kutoa
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Number of new Account, it will be included in the account name as a prefix","Idadi ya Akaunti mpya, itaingizwa katika jina la akaunti kama kiambishi"
DocType: Maintenance Team Member,Team Member,Mwanachama wa Timu
DocType: GSTR 3B Report,Invoices with no Place Of Supply,Ankara bila Mahali pa Ugavi
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js,No Result to submit,Hakuna matokeo ya kuwasilisha
DocType: Customer,Sales Partner and Commission,Mshirika wa Mauzo na Tume
DocType: Loan,Rate of Interest (%) / Year,Kiwango cha Maslahi (%) / Mwaka
,Project Quantity,Mradi wa Wingi
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Jumla ya {0} kwa vitu vyote ni sifuri, huenda unapaswa kubadilisha &#39;Kusambaza mishahara ya msingi&#39;"
apps/erpnext/erpnext/hr/utils.py,To date can not be less than from date,Hadi sasa haiwezi kuwa chini ya tarehe
DocType: Opportunity,To Discuss,Kujadili
DocType: Loan Type,Rate of Interest (%) Yearly,Kiwango cha Maslahi (%) Kila mwaka
apps/erpnext/erpnext/config/quality_management.py,Quality Goal.,Lengo la ubora.
DocType: Support Settings,Forum URL,URL ya kikao
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Temporary Accounts,Akaunti ya Muda
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Source Location is required for the asset {0},Eneo la Chanzo linahitajika kwa mali {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Black,Nyeusi
DocType: BOM Explosion Item,BOM Explosion Item,BOM Bidhaa ya Mlipuko
DocType: Shareholder,Contact List,Orodha ya Mawasiliano
DocType: Account,Auditor,Mkaguzi
DocType: Project,Frequency To Collect Progress,Upepo wa Kukusanya Maendeleo
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} items produced,{0} vitu vilivyotengenezwa
apps/erpnext/erpnext/utilities/user_progress.py,Learn More,Jifunze zaidi
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,{0} is not added in the table,{0} haijaongezwa kwenye jedwali
DocType: Payment Entry,Party Bank Account,Akaunti ya Benki ya Chama
DocType: Cheque Print Template,Distance from top edge,Umbali kutoka makali ya juu
DocType: POS Closing Voucher Invoices,Quantity of Items,Wingi wa Vitu
apps/erpnext/erpnext/stock/get_item_details.py,Price List {0} is disabled or does not exist,Orodha ya Bei {0} imezimwa au haipo
DocType: Purchase Invoice,Return,Rudi
DocType: Account,Disable,Zima
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Mode of payment is required to make a payment,Njia ya kulipa inahitajika kufanya malipo
DocType: Task,Pending Review,Mapitio Yasubiri
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js,"Edit in full page for more options like assets, serial nos, batches etc.","Badilisha katika ukurasa kamili kwa chaguo zaidi kama vile mali, serial nos, batches nk"
DocType: Leave Type,Maximum Continuous Days Applicable,Siku Zilizozidi Kuendelea zinazohitajika
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 4,Umri wa kuzeeka 4
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is not enrolled in the Batch {2},{0} - {1} haijasajiliwa katika Batch {2}
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,"Asset {0} cannot be scrapped, as it is already {1}","Malipo {0} hayawezi kupigwa, kama tayari {1}"
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Cheques Required,Cheki Inahitajika
DocType: Task,Total Expense Claim (via Expense Claim),Madai ya jumla ya gharama (kupitia madai ya gharama)
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Absent,Weka alama
DocType: Job Applicant Source,Job Applicant Source,Chanzo cha Msaidizi wa Kazi
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,IGST Amount,IGST Kiasi
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup company,Imeshindwa kuanzisha kampuni
DocType: Asset Repair,Asset Repair,Ukarabati wa Mali
DocType: Warehouse,Warehouse Type,Aina ya ghala
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Row {0}: Fedha ya BOM # {1} inapaswa kuwa sawa na sarafu iliyochaguliwa {2}
DocType: Journal Entry Account,Exchange Rate,Kiwango cha Exchange
DocType: Patient,Additional information regarding the patient,Maelezo ya ziada kuhusu mgonjwa
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Sales Order {0} is not submitted,Sheria ya Mauzo {0} haijawasilishwa
DocType: Homepage,Tag Line,Mstari wa Tag
DocType: Fee Component,Fee Component,Fomu ya Malipo
apps/erpnext/erpnext/config/hr.py,Fleet Management,Usimamizi wa Fleet
apps/erpnext/erpnext/config/agriculture.py,Crops & Lands,Mazao na Nchi
DocType: Shift Type,Enable Exit Grace Period,Washa Tarehe ya Neema
DocType: Cheque Print Template,Regular,Mara kwa mara
DocType: Fertilizer,Density (if liquid),Uzito wiani (kama kioevu)
apps/erpnext/erpnext/education/doctype/course/course.py,Total Weightage of all Assessment Criteria must be 100%,Jumla ya uzito wa Vigezo vyote vya Tathmini lazima iwe 100%
DocType: Purchase Order Item,Last Purchase Rate,Kiwango cha Mwisho cha Ununuzi
DocType: GSTR 3B Report,August,Agosti
DocType: Account,Asset,Mali
DocType: Quality Goal,Revised On,Iliyorekebishwa On
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock cannot exist for Item {0} since has variants,Hifadhi haipatikani kwa Item {0} tangu ina tofauti
DocType: Healthcare Practitioner,Mobile,Rununu
DocType: Issue,Reset Service Level Agreement,Rudisha Mkataba wa Kiwango cha Huduma
,Sales Person-wise Transaction Summary,Muhtasari wa Shughuli za Wafanyabiashara wa Mauzo
DocType: Training Event,Contact Number,Namba ya mawasiliano
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} does not exist,Ghala {0} haipo
DocType: Cashier Closing,Custody,Usimamizi
DocType: Employee Tax Exemption Proof Submission Detail,Employee Tax Exemption Proof Submission Detail,Ushuru wa Wafanyakazi wa Ushuru Uthibitisho wa Uwasilishaji wa Maelezo
DocType: Monthly Distribution,Monthly Distribution Percentages,Asilimia ya Usambazaji wa Kila mwezi
apps/erpnext/erpnext/stock/doctype/batch/batch.py,The selected item cannot have Batch,Bidhaa iliyochaguliwa haiwezi kuwa na Batch
DocType: Delivery Note,% of materials delivered against this Delivery Note,% ya vifaa vinavyotolewa dhidi ya Kumbuka Utoaji huu
DocType: Asset Maintenance Log,Has Certificate,Ina Cheti
DocType: Project,Customer Details,Maelezo ya Wateja
apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.js,Print IRS 1099 Forms,Chapisha Fomu za IRS 1099
DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,Angalia kama Mali inahitaji Maintenance ya Uzuiaji au Calibration
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Abbreviation cannot have more than 5 characters,Hali ya Kampuni haiwezi kuwa na wahusika zaidi ya 5
DocType: Employee,Reports to,Ripoti kwa
,Unpaid Expense Claim,Madai ya gharama ya kulipwa
DocType: Payment Entry,Paid Amount,Kiwango kilicholipwa
apps/erpnext/erpnext/utilities/user_progress.py,Explore Sales Cycle,Pitia Mzunguko wa Mauzo
DocType: Assessment Plan,Supervisor,Msimamizi
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Retention Stock Entry,Kuhifadhi Usajili wa hisa
,Available Stock for Packing Items,Inapatikana Stock kwa Vipuri vya Ufungashaji
DocType: Item Variant,Item Variant,Tofauti ya Tofauti
DocType: Employee Skill Map,Trainings,Mafunzo
,Work Order Stock Report,Ripoti ya Kazi ya Kazi ya Kazi
DocType: Purchase Receipt,Auto Repeat Detail,Fanya maelezo ya kurudi
DocType: Assessment Result Tool,Assessment Result Tool,Kitabu cha Matokeo ya Tathmini
apps/erpnext/erpnext/education/doctype/instructor/instructor.js,As Supervisor,Kama Msimamizi
DocType: Leave Policy Detail,Leave Policy Detail,Acha Sera ya Ufafanuzi
DocType: BOM Scrap Item,BOM Scrap Item,BOM Kipengee cha Bidhaa
apps/erpnext/erpnext/accounts/page/pos/pos.js,Submitted orders can not be deleted,Maagizo yaliyowasilishwa hayawezi kufutwa
DocType: Leave Control Panel,Department (optional),Idara (hiari)
apps/erpnext/erpnext/accounts/doctype/account/account.py,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Usawa wa Akaunti tayari katika Debit, huruhusiwi kuweka &#39;Mizani lazima iwe&#39; kama &#39;Mikopo&#39;"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"If you {0} {1} worth item <b>{2}</b>, the scheme <b>{3}</b> will be applied on the item.
				","Ikiwa {0} {1} ya thamani ya bidhaa <b>{2}</b> , mpango <b>{3}</b> utatumika kwenye bidhaa hiyo."
DocType: Customer Feedback,Quality Management,Usimamizi wa Ubora
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} has been disabled,Item {0} imezimwa
DocType: Project,Total Billable Amount (via Timesheets),Kiwango cha Jumla cha Billable (kupitia Timesheets)
DocType: Agriculture Task,Previous Business Day,Siku ya Biashara ya awali
DocType: Loan,Repay Fixed Amount per Period,Rejesha Kiasi kilichopangwa kwa Kipindi
DocType: Employee,Health Insurance No,Bima ya Afya Bila
DocType: Employee Tax Exemption Proof Submission,Tax Exemption Proofs,Ushahidi wa Ushuru wa Kodi
apps/erpnext/erpnext/buying/utils.py,Please enter quantity for Item {0},Tafadhali ingiza kiasi cha Bidhaa {0}
DocType: Quality Procedure,Processes,Michakato
DocType: Shift Type,First Check-in and Last Check-out,Angalia kwanza na Uangalie mwisho
apps/erpnext/erpnext/regional/report/hsn_wise_summary_of_outward_supplies/hsn_wise_summary_of_outward_supplies.py,Total Taxable Amount,Jumla ya Kiasi cha Ushuru
DocType: Employee External Work History,Employee External Work History,Historia ya Kazi ya Wafanyakazi wa Nje
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Job card {0} created,Kadi ya Kazi {0} imeundwa
DocType: Opening Invoice Creation Tool,Purchase,Ununuzi
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Balance Qty,Kiwango cha usawa
DocType: Pricing Rule,Conditions will be applied on all the selected items combined. ,Masharti yatatumika kwa vitu vyote vilivyochaguliwa pamoja.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Goals cannot be empty,Malengo hayawezi kuwa tupu
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js,Enrolling students,Kujiandikisha wanafunzi
DocType: Item Group,Parent Item Group,Kikundi cha Mzazi cha Mzazi
DocType: Appointment Type,Appointment Type,Aina ya Uteuzi
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,{0} for {1},{0} kwa {1}
DocType: Healthcare Settings,Valid number of days,Nambari ya siku sahihi
apps/erpnext/erpnext/setup/doctype/company/company.js,Cost Centers,Vituo vya Gharama
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Restart Subscription,Anza upya Usajili
DocType: Linked Plant Analysis,Linked Plant Analysis,Uchunguzi wa Plant unaohusishwa
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Transporter ID,ID ya Transporter
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Value Proposition,Thamani pendekezo
DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,Kiwango cha sarafu ya wasambazaji ni chaguo la fedha za kampuni
DocType: Purchase Invoice Item,Service End Date,Tarehe ya Mwisho wa Huduma
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,Row #{0}: Timings conflicts with row {1},Row # {0}: Muda unapingana na mstari {1}
DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Ruhusu Kiwango cha Vigezo vya Zero
DocType: Bank Guarantee,Receiving,Kupokea
DocType: Training Event Employee,Invited,Alialikwa
apps/erpnext/erpnext/config/accounting.py,Setup Gateway accounts.,Akaunti za Kuweka Gateway.
apps/erpnext/erpnext/config/integrations.py,Connect your bank accounts to ERPNext,Unganisha akaunti zako za benki na ERPNext
DocType: Employee,Employment Type,Aina ya Ajira
apps/erpnext/erpnext/config/projects.py,Make project from a template.,Tengeneza mradi kutoka kwa kiolezo.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Fixed Assets,Mali za kudumu
DocType: Payment Entry,Set Exchange Gain / Loss,Weka Kuchangia / Kupoteza
,GST Purchase Register,Daftari ya Ununuzi wa GST
,Cash Flow,Mzunguko wa fedha
DocType: Shareholder,ACC-SH-.YYYY.-,ACC-SH-YYYY.-
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,Combined invoice portion must equal 100%,Sehemu ya ankara ya pamoja lazima iwe sawa na 100%
DocType: Item Default,Default Expense Account,Akaunti ya gharama nafuu
DocType: GST Account,CGST Account,Akaunti ya CGST
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Email ID,Kitambulisho cha Barua ya Wanafunzi
DocType: Employee,Notice (days),Angalia (siku)
DocType: POS Closing Voucher Invoices,POS Closing Voucher Invoices,POS Invoices ya Voucher Voucher
DocType: Tax Rule,Sales Tax Template,Kigezo cha Kodi ya Mauzo
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,Download JSON,Pakua JSON
DocType: Employee Benefit Application Detail,Pay Against Benefit Claim,Ulipa Kutoa Faida ya Kutaka
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Update Cost Center Number,Sasisha Nambari ya Kituo cha Gharama
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select items to save the invoice,Chagua vitu ili uhifadhi ankara
DocType: Employee,Encashment Date,Tarehe ya Kuingiza
DocType: Training Event,Internet,Internet
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Seller Information,Habari ya muuzaji
DocType: Special Test Template,Special Test Template,Kigezo cha Mtihani maalum
DocType: Account,Stock Adjustment,Marekebisho ya hisa
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,Default Activity Cost exists for Activity Type - {0},Gharama ya Shughuli ya Hifadhi ipo kwa Aina ya Shughuli - {0}
DocType: Work Order,Planned Operating Cost,Gharama za uendeshaji zilizopangwa
DocType: Academic Term,Term Start Date,Tarehe ya Mwisho wa Mwisho
apps/erpnext/erpnext/erpnext_integrations/doctype/plaid_settings/plaid_connector.py,Authentication Failed,Uthibitishaji Umeshindwa
apps/erpnext/erpnext/config/accounting.py,List of all share transactions,Orodha ya shughuli zote za kushiriki
DocType: Supplier,Is Transporter,"Je, ni Transporter"
DocType: Shopify Settings,Import Sales Invoice from Shopify if Payment is marked,Weka Invoice ya Mauzo kutoka Shopify ikiwa Malipo imewekwa
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp Count,Upinzani wa Opp
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Both Trial Period Start Date and Trial Period End Date must be set,Kipindi cha kwanza cha majaribio Tarehe ya Kuanza na Tarehe ya Mwisho wa Kipindi lazima iwekwa
apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py,Average Rate,Kiwango cha wastani
apps/erpnext/erpnext/controllers/accounts_controller.py,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Kiwango cha Malipo ya Jumla katika Ratiba ya Malipo lazima iwe sawa na Grand / Rounded Total
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot have Valuation Rate",&quot;Bidhaa iliyotolewa na Wateja&quot; haiwezi kuwa na Kiwango cha Tathimini
DocType: Subscription Plan Detail,Plan,Mpango
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Bank Statement balance as per General Ledger,Usawa wa Taarifa ya Benki kama kwa Jedwali Mkuu
DocType: Job Applicant,Applicant Name,Jina la Msaidizi
DocType: Authorization Rule,Customer / Item Name,Jina la Wateja / Bidhaa
DocType: Product Bundle,"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. 

The package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".

For Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.

Note: BOM = Bill of Materials","Kikundi kikubwa cha ** Vitu ** katika mwingine ** Item **. Hii ni muhimu ikiwa unatumia vipengee ** vya Hifadhi ** kwenye mfuko na unashika hisa za ** Items ** na sio jumla ** Item **. Mfuko ** Item ** itakuwa na &quot;Je, Item ya Hifadhi&quot; kama &quot;Hapana&quot; na &quot;Je! Bidhaa ya Mauzo&quot; kama &quot;Ndiyo&quot;. Kwa Mfano: Ikiwa unauza Laptops na Backpacks tofauti na una bei maalum kama mteja anaunua zote mbili, basi Laptop + Backpack itakuwa Bidhaa mpya ya Bundle Item. Kumbuka: BOM = Sheria ya Vifaa"
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Serial No is mandatory for Item {0},Hapana ya Serial ni ya lazima kwa Bidhaa {0}
DocType: Website Attribute,Attribute,Sifa
DocType: Staffing Plan Detail,Current Count,Hesabu ya sasa
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,Please specify from/to range,Tafadhali taja kutoka / kwa kuenea
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Opening {0} Invoice created,Ufunguzi {0} ankara imeundwa
DocType: Serial No,Under AMC,Chini ya AMC
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Item valuation rate is recalculated considering landed cost voucher amount,Kiwango cha upimaji wa kipengee kinarekebishwa kwa kuzingatia kiwango cha malipo cha malipo
apps/erpnext/erpnext/config/selling.py,Default settings for selling transactions.,Mipangilio ya mipangilio ya kuuza shughuli.
DocType: Guardian,Guardian Of ,Mlezi wa
DocType: Grading Scale Interval,Threshold,Kizuizi
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Filter Employees By (Optional),Filter Wafanyikazi Na (Hiari)
DocType: BOM Update Tool,Current BOM,BOM ya sasa
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Balance (Dr - Cr),Mizani (Dr - Cr)
DocType: Pick List,Qty of Finished Goods Item,Qty ya Bidhaa iliyokamilishwa Bidhaa
apps/erpnext/erpnext/public/js/utils.js,Add Serial No,Ongeza No ya Serial
DocType: Work Order Item,Available Qty at Source Warehouse,Uchina Inapatikana kwenye Ghala la Chanzo
apps/erpnext/erpnext/config/support.py,Warranty,Warranty
DocType: Purchase Invoice,Debit Note Issued,Kumbuka ya Debit imeondolewa
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Filter based on Cost Center is only applicable if Budget Against is selected as Cost Center,Filter kulingana na Kituo cha Gharama kinatumika tu ikiwa Bajeti Dhidi ni kuchaguliwa kama Kituo cha Gharama
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,"Search by item code, serial number, batch no or barcode","Utafute kwa nambari ya bidhaa, namba ya serial, msimbo wa bati wala barcode"
DocType: Work Order,Warehouses,Maghala
DocType: Shift Type,Last Sync of Checkin,Usawazishaji wa mwisho wa Checkin
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Add a new address,Ongeza anwani mpya
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,{0} asset cannot be transferred,{0} mali haiwezi kuhamishwa
DocType: Hotel Room Pricing,Hotel Room Pricing,Bei ya chumba cha Hoteli
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.py,"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Haiwezi kuandika rekodi ya wagonjwa inakabiliwa, kuna ankara ambazo hazipatikani {0}"
DocType: Subscription,Days Until Due,Siku hadi Mpangilio
apps/erpnext/erpnext/stock/doctype/item/item.js,This Item is a Variant of {0} (Template).,Ncha hii ni Tofauti ya {0} (Kigezo).
DocType: Workstation,per hour,kwa saa
DocType: Blanket Order,Purchasing,Ununuzi
DocType: Announcement,Announcement,Tangazo
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Customer LPO,LPO ya Wateja
DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","Kwa Kundi la Wanafunzi la msingi, Kikundi cha Wanafunzi kitathibitishwa kwa kila Mwanafunzi kutoka Uandikishaji wa Programu."
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Ghala haiwezi kufutwa kama kuingizwa kwa hisa ya hisa kunapo kwa ghala hili.
apps/erpnext/erpnext/public/js/setup_wizard.js,Distribution,Usambazaji
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Employee status cannot be set to 'Left' as following employees are currently reporting to this employee:&nbsp;,Hali ya mfanyikazi haiwezi kuweka &#39;Kushoto&#39; kwani wafanyikazi wanaofuata wanaripoti kwa mfanyakazi huyu:
DocType: Journal Entry Account,Loan,Mikopo
DocType: Expense Claim Advance,Expense Claim Advance,Tumia Madai ya Ushauri
DocType: Lab Test,Report Preference,Upendeleo wa Ripoti
apps/erpnext/erpnext/config/non_profit.py,Volunteer information.,Maelezo ya kujitolea.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Project Manager,Meneja wa mradi
,Quoted Item Comparison,Ilipendekeza Kulinganishwa kwa Bidhaa
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Overlap in scoring between {0} and {1},Inaingiliana kwa kufunga kati ya {0} na {1}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Dispatch,Tangaza
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Max discount allowed for item: {0} is {1}%,Upeo wa Max unaruhusiwa kwa bidhaa: {0} ni {1}%
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Net Asset value as on,Thamani ya Mali ya Nambari kama ilivyoendelea
DocType: Crop,Produce,Kuzalisha
DocType: Hotel Settings,Default Taxes and Charges,Kodi na malipo ya Default
DocType: Account,Receivable,Inapatikana
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Row # {0}: Hairuhusiwi kubadili Wasambazaji kama Ununuzi wa Utaratibu tayari upo
DocType: Stock Entry,Material Consumption for Manufacture,Matumizi ya Nyenzo kwa Utengenezaji
DocType: Item Alternative,Alternative Item Code,Msimbo wa Kipengee cha Mbadala
DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,Jukumu ambalo linaruhusiwa kuwasilisha ushirikiano unaozidi mipaka ya mikopo.
DocType: Production Plan,Select Items to Manufacture,Chagua Vitu Ili Kukuza
DocType: Delivery Stop,Delivery Stop,Utoaji wa Kuacha
apps/erpnext/erpnext/accounts/page/pos/pos.js,"Master data syncing, it might take some time","Usawazishaji wa data ya Mwalimu, inaweza kuchukua muda"
DocType: Material Request Plan Item,Material Issue,Matatizo ya Nyenzo
DocType: Employee Education,Qualification,Ustahili
DocType: Item Price,Item Price,Item Bei
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Soap & Detergent,Sabuni &amp; Daktari
DocType: BOM,Show Items,Onyesha Vitu
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.py,Duplicate Tax Declaration of {0} for period {1},Azimio la Kodi mbili ya {0} kwa kipindi {1}
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py,From Time cannot be greater than To Time.,Kutoka Muda haiwezi kuwa kubwa zaidi kuliko Ili Muda.
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Do you want to notify all the customers by email?,Unataka kuwajulisha wateja wote kwa barua pepe?
DocType: Subscription Plan,Billing Interval,Muda wa kulipia
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Motion Picture & Video,Picha na Video ya Mwendo
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js,Ordered,Amri
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Resume,Rejea
DocType: Salary Detail,Component,Kipengele
DocType: Video,YouTube,YouTube
apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py,Row {0}: {1} must be greater than 0,Row {0}: {1} lazima iwe kubwa kuliko 0
DocType: Assessment Criteria,Assessment Criteria Group,Makundi ya Vigezo vya Tathmini
DocType: Healthcare Settings,Patient Name By,Jina la Mgonjwa Na
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Accrual Journal Entry for salaries from {0} to {1},Usajili wa Taarifa ya Mishahara kutoka kwa {0} hadi {1}
DocType: Sales Invoice Item,Enable Deferred Revenue,Wezesha Mapato yaliyofanywa
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Opening Accumulated Depreciation must be less than equal to {0},Kufungua Upungufu wa Kusanyiko lazima uwe chini ya sawa na {0}
DocType: Warehouse,Warehouse Name,Jina la Ghala
DocType: Naming Series,Select Transaction,Chagua Shughuli
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Tafadhali ingiza Uwezeshaji au Kuidhinisha Mtumiaji
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Sababu ya ubadilishaji wa UOM ({0} -&gt; {1}) haipatikani kwa kipengee: {2}
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Mkataba wa Kiwango cha Huduma na Aina ya Taasisi {0} na Taasisi {1} tayari ipo.
DocType: Journal Entry,Write Off Entry,Andika Entry Entry
DocType: BOM,Rate Of Materials Based On,Kiwango cha Vifaa vya msingi
DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Ikiwa imewezeshwa, Muda wa Kitaa wa Shule utakuwa wa lazima katika Chombo cha Usajili wa Programu."
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Values of exempt, nil rated and non-GST inward supplies","Thamani za misamaha, vifaa vya ndani visivyo na kipimo na visivyo vya GST"
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Uncheck all,Futa yote
DocType: Purchase Taxes and Charges,On Item Quantity,Juu ya Wingi wa kitu
DocType: POS Profile,Terms and Conditions,Sheria na Masharti
DocType: Asset,Booked Fixed Asset,Maliko yaliyotafsiriwa
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,To Date should be within the Fiscal Year. Assuming To Date = {0},Tarehe inapaswa kuwa ndani ya Mwaka wa Fedha. Kufikiri Tarehe = {0}
DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Hapa unaweza kudumisha urefu, uzito, allergy, matatizo ya matibabu nk"
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Creating Accounts...,Kuunda Akaunti ...
DocType: Leave Block List,Applies to Company,Inahitajika kwa Kampuni
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Cannot cancel because submitted Stock Entry {0} exists,Haiwezi kufuta kwa sababu In Entry In Stock {0} ipo
DocType: Loan,Disbursement Date,Tarehe ya Malipo
DocType: Service Level Agreement,Agreement Details,Maelezo ya Mkataba
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Start Date of Agreement can't be greater than or equal to End Date.,Tarehe ya Kuanza ya Makubaliano haiwezi kuwa kubwa kuliko au sawa na Tarehe ya Mwisho.
DocType: BOM Update Tool,Update latest price in all BOMs,Sasisha bei ya hivi karibuni katika BOM zote
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Done,Imemaliza
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Medical Record,Rekodi ya Matibabu
DocType: Vehicle,Vehicle,Gari
DocType: Purchase Invoice,In Words,Katika Maneno
apps/erpnext/erpnext/hr/doctype/leave_ledger_entry/leave_ledger_entry.py,To date needs to be before from date,Hadi leo mahitaji ya kuwa kabla ya tarehe
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the name of the bank or lending institution before submittting.,Ingiza jina la benki au taasisi ya mikopo kabla ya kuwasilisha.
apps/erpnext/erpnext/hr/doctype/training_result/training_result.py,{0} must be submitted,{0} lazima iwasilishwa
DocType: POS Profile,Item Groups,Makala ya Vikundi
DocType: Company,Standard Working Hours,Saa za Kawaida za Kufanya kazi
DocType: Sales Order Item,For Production,Kwa Uzalishaji
DocType: Payment Request,payment_url,malipo_url
DocType: Exchange Rate Revaluation Account,Balance In Account Currency,Mizani Katika Fedha za Akaunti
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please add a Temporary Opening account in Chart of Accounts,Tafadhali ongeza Akaunti ya Kufungua Muda katika Chati ya Akaunti
DocType: Customer,Customer Primary Contact,Mawasiliano ya Msingi ya Wateja
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp/Lead %,Upinzani / Kiongozi%
DocType: Bank Guarantee,Bank Account Info,Maelezo ya Akaunti ya Benki
DocType: Bank Guarantee,Bank Guarantee Type,Aina ya Dhamana ya Benki
apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() failed for valid IBAN {},BankAccount.validate_iban () ilishindwa kwa IBAN halali {}
DocType: Payment Schedule,Invoice Portion,Sehemu ya ankara
,Asset Depreciations and Balances,Upungufu wa Mali na Mizani
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} transferred from {2} to {3},Kiasi {0} {1} kilichohamishwa kutoka {2} hadi {3}
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0} hana Ratiba ya Utunzaji wa Afya. Uongeze katika Mwalimu Mkuu wa Afya
DocType: Sales Invoice,Get Advances Received,Pata Mafanikio Yaliyopokelewa
DocType: Email Digest,Add/Remove Recipients,Ongeza / Ondoa Wapokeaji
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js,"To set this Fiscal Year as Default, click on 'Set as Default'","Ili kuweka Mwaka huu wa Fedha kama Msingi, bonyeza &#39;Weka kama Msingi&#39;"
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Amount of TDS Deducted,Kiasi cha TDS kilifutwa
DocType: Production Plan,Include Subcontracted Items,Jumuisha Vipengee vidogo
apps/erpnext/erpnext/projects/doctype/project/project.py,Join,Jiunge
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py,Shortage Qty,Uchina wa Ufupi
DocType: Purchase Invoice,Input Service Distributor,Msambazaji wa Huduma ya Kuingiza
apps/erpnext/erpnext/stock/doctype/item/item.py,Item variant {0} exists with same attributes,Tofauti ya kipengee {0} ipo na sifa sawa
DocType: Loan,Repay from Salary,Malipo kutoka kwa Mshahara
DocType: Exotel Settings,API Token,Ishara ya API
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Requesting payment against {0} {1} for amount {2},Inalipa malipo dhidi ya {0} {1} kwa kiasi {2}
DocType: Additional Salary,Salary Slip,Kulipwa kwa Mshahara
apps/erpnext/erpnext/support/doctype/issue/issue.py,Allow Resetting Service Level Agreement from Support Settings.,Ruhusu Kurudisha Mkataba wa Kiwango cha Huduma kutoka kwa Mipangilio ya Msaada.
DocType: Lead,Lost Quotation,Nukuu iliyopotea
apps/erpnext/erpnext/utilities/user_progress.py,Student Batches,Majaribio ya Wanafunzi
DocType: Pricing Rule,Margin Rate or Amount,Kiwango cha Margin au Kiasi
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,'To Date' is required,&#39;Tarehe&#39; inahitajika
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Actual Qty: Quantity available in the warehouse.,Qty halisi: Wingi unaopatikana katika ghala.
DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Tengeneza safu za kufunga kwenye vifurushi kutolewa. Ilijulisha nambari ya mfuko, maudhui ya mfuko na uzito wake."
DocType: Sales Invoice Item,Sales Order Item,Bidhaa ya Uagizaji wa Mauzo
DocType: Salary Slip,Payment Days,Siku za Malipo
DocType: Stock Settings,Convert Item Description to Clean HTML,Badilisha Maelezo ya Maelezo kwa Hifadhi ya HTML
DocType: Patient,Dormant,Imekaa
DocType: Payroll Entry,Deduct Tax For Unclaimed Employee Benefits,Kutoa Ushuru kwa Faida za Wafanyakazi Siojulikana
DocType: Salary Slip,Total Interest Amount,Kiasi cha Maslahi
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with child nodes cannot be converted to ledger,Maghala yenye nodes ya watoto hawezi kubadilishwa kwenye kiongozi
DocType: BOM,Manage cost of operations,Dhibiti gharama za shughuli
DocType: Accounts Settings,Stale Days,Siku za Stale
DocType: Travel Itinerary,Arrival Datetime,Saa ya Tarehe ya Kuwasili
DocType: Tax Rule,Billing Zipcode,Msimbo wa Zipcode
DocType: Attendance,HR-ATT-.YYYY.-,HR-ATT-YYYY.-
DocType: Crop,Row Spacing UOM,Upeo wa Uow UOM
DocType: Assessment Result Detail,Assessment Result Detail,Maelezo ya Matokeo ya Tathmini
DocType: Employee Education,Employee Education,Elimu ya Waajiriwa
DocType: Service Day,Workday,Siku ya kazi
apps/erpnext/erpnext/setup/doctype/terms_and_conditions/terms_and_conditions.py,At least one of the Applicable Modules should be selected,Angalau moja ya Moduli zinazotumika zinapaswa kuchaguliwa
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Duplicate item group found in the item group table,Kundi la kipengee cha kipengee kilichopatikana kwenye meza ya kikundi cha bidhaa
apps/erpnext/erpnext/config/quality_management.py,Tree of Quality Procedures.,Taratibu za Taratibu za ubora.
apps/erpnext/erpnext/public/js/controllers/transaction.js,It is needed to fetch Item Details.,Inahitajika Kuchukua Maelezo ya Bidhaa.
DocType: Fertilizer,Fertilizer Name,Jina la Mbolea
DocType: Salary Slip,Net Pay,Net Pay
DocType: Cash Flow Mapping Accounts,Account,Akaunti
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} has already been received,Hakuna Serial {0} tayari imepokea
,Requested Items To Be Transferred,Vitu Vilivyoombwa Ili Kuhamishwa
DocType: Expense Claim,Vehicle Log,Ingia ya Magari
DocType: Sales Invoice,Is Discounted,Imepunguzwa
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on Actual,Hatua kama Bajeti ya kila mwezi iliyokusanywa imepita juu ya kweli
DocType: Salary Component,Create Separate Payment Entry Against Benefit Claim,Unda Entry ya Malipo ya Kinyume dhidi ya Faida ya Kutaka
DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),Uwepo wa homa (temp&gt; 38.5 ° C / 101.3 ° F au temp.) 38 ° C / 100.4 ° F)
DocType: Customer,Sales Team Details,Maelezo ya Timu ya Mauzo
apps/erpnext/erpnext/accounts/page/pos/pos.js,Delete permanently?,Futa kwa kudumu?
DocType: Expense Claim,Total Claimed Amount,Kiasi kilichodaiwa
apps/erpnext/erpnext/config/crm.py,Potential opportunities for selling.,Uwezo wa fursa za kuuza.
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,{} is an invalid Attendance Status.,{} ni Hali isiyo sawa ya Mahudhurio.
DocType: Shareholder,Folio no.,Uliopita.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,Invalid {0},Inalidhika {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Sick Leave,Kuondoka kwa mgonjwa
DocType: Email Digest,Email Digest,Barua pepe ya Digest
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,"As raw materials projected quantity is more than required quantity, there is no need to create material request.
			Still if you want to make material request, kindly enable <b>Ignore Existing Projected Quantity</b> checkbox","Kwa vile malighafi inakadiriwa ni zaidi ya idadi inayohitajika, hakuna haja ya kuunda ombi la nyenzo. Bado ikiwa unataka kufanya ombi la nyenzo, kwa kuwezesha kwa <b>upuuzi kuangalia</b> kisanduku cha kuangalia <b>makadirio yaliyopo</b>"
DocType: Delivery Note,Billing Address Name,Jina la Anwani ya Kulipa
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Department Stores,Idara ya maduka
,Item Delivery Date,Tarehe ya Utoaji wa Item
DocType: Selling Settings,Sales Update Frequency,Mzunguko wa Mwisho wa Mauzo
DocType: Production Plan,Material Requested,Nyenzo Iliombwa
DocType: Warehouse,PIN,PIN
DocType: Bin,Reserved Qty for sub contract,Nambari iliyohifadhiwa kwa mkataba wa chini
DocType: Patient Service Unit,Patinet Service Unit,Kitengo cha Huduma ya Patinet
DocType: Sales Invoice,Base Change Amount (Company Currency),Kiwango cha Mabadiliko ya Msingi (Fedha la Kampuni)
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,No accounting entries for the following warehouses,Hakuna kuingizwa kwa uhasibu kwa maghala yafuatayo
apps/erpnext/erpnext/shopping_cart/cart.py,Only {0} in stock for item {1},Ni {0} pekee katika hisa kwa bidhaa {1}
DocType: Account,Chargeable,Inajibika
DocType: Company,Change Abbreviation,Badilisha hali
DocType: Contract,Fulfilment Details,Maelezo ya Utekelezaji
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py,Pay {0} {1},Kulipa {0} {1}
DocType: Employee Onboarding,Activities,Shughuli
DocType: Expense Claim Detail,Expense Date,Tarehe ya gharama
DocType: Item,No of Months,Hakuna Miezi
DocType: Item,Max Discount (%),Max Discount (%)
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,Credit Days cannot be a negative number,Siku za Mikopo haiwezi kuwa nambari hasi
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Upload a statement,Sasisha taarifa
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Report this item,Ripoti kipengee hiki
DocType: Purchase Invoice Item,Service Stop Date,Tarehe ya Kuacha Huduma
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Last Order Amount,Kiwango cha Mwisho cha Mwisho
DocType: Cash Flow Mapper,e.g Adjustments for:,kwa mfano Marekebisho kwa:
apps/erpnext/erpnext/stock/doctype/item/item.py," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Weka Mfano ni msingi wa batch, tafadhali angalia Batch No ili kuhifadhi sampuli ya bidhaa"
DocType: Task,Is Milestone,Ni muhimu sana
DocType: Certification Application,Yet to appear,Hata hivyo kuonekana
DocType: Delivery Stop,Email Sent To,Imepelekwa kwa barua pepe
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Salary Structure not found for employee {0} and date {1},Muundo wa Mshahara haupatikani kwa mfanyakazi {0} na tarehe {1}
DocType: Job Card Item,Job Card Item,Kadi ya Kadi ya Kazi
DocType: Accounts Settings,Allow Cost Center In Entry of Balance Sheet Account,Ruhusu Kituo cha Gharama Katika Kuingia kwa Akaunti ya Hesabu ya Hesabu
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge with Existing Account,Unganisha na Akaunti iliyopo
DocType: Budget,Warn,Tahadhari
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Vitu vyote vimehamishwa tayari kwa Kazi hii ya Kazi.
DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Maneno mengine yoyote, jitihada zinazostahili ambazo zinapaswa kuingia kwenye rekodi."
DocType: Asset Maintenance,Manufacturing User,Mtengenezaji wa Viwanda
DocType: Purchase Invoice,Raw Materials Supplied,Vifaa vya Malighafi hutolewa
DocType: Subscription Plan,Payment Plan,Mpango wa Malipo
DocType: Bank Transaction,Series,Mfululizo
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Currency of the price list {0} must be {1} or {2},Fedha ya orodha ya bei {0} lazima iwe {1} au {2}
apps/erpnext/erpnext/config/accounting.py,Subscription Management,Usimamizi wa Usajili
DocType: Appraisal,Appraisal Template,Kigezo cha Uhakiki
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Pin Code,Piga Kanuni
DocType: Soil Texture,Ternary Plot,Plot ya Ternary
DocType: Amazon MWS Settings,Check this to enable a scheduled Daily synchronization routine via scheduler,Angalia hii ili kuwezesha ratiba ya maingiliano ya kila siku kupitia mpangilio
DocType: Item Group,Item Classification,Uainishaji wa Bidhaa
apps/erpnext/erpnext/templates/pages/home.html,Publications,Machapisho
DocType: Driver,License Number,Nambari ya Leseni
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Business Development Manager,Meneja wa Maendeleo ya Biashara
DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Matengenezo ya Kutembelea Kusudi
DocType: Stock Entry,Stock Entry Type,Aina ya Uingilio wa Hisa
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Invoice Patient Registration,Usajili wa Msajili wa Msajili
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js,General Ledger,Mkuu Ledger
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,To Fiscal Year,Mwaka wa Fedha
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js,View Leads,Angalia Waongoza
DocType: Program Enrollment Tool,New Program,Programu mpya
DocType: Item Attribute Value,Attribute Value,Thamani ya Thamani
DocType: POS Closing Voucher Details,Expected Amount,Kiasi kinachotarajiwa
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js,Create Multiple,Unda Multiple
,Itemwise Recommended Reorder Level,Inemwise Inapendekezwa Mpangilio wa Mpangilio
apps/erpnext/erpnext/hr/utils.py,Employee {0} of grade {1} have no default leave policy,Mfanyakazi {0} wa daraja {1} hawana sera ya kuacha ya kuondoka
DocType: Salary Detail,Salary Detail,Maelezo ya Mshahara
DocType: Email Digest,New Purchase Invoice,Ankara mpya ya Ununuzi
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select {0} first,Tafadhali chagua {0} kwanza
apps/erpnext/erpnext/public/js/hub/marketplace.js,Added {0} users,Aliongeza {0} watumiaji
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Less Than Amount,Chini ya Kiasi
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"In the case of multi-tier program, Customers will be auto assigned to the concerned tier as per their spent","Katika kesi ya mpango wa mipango mbalimbali, Wateja watapatiwa auto kwa tier husika kama kwa matumizi yao"
DocType: Appointment Type,Physician,Daktari
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Batch {0} of Item {1} has expired.,Kipengee {0} cha Bidhaa {1} kimekamilika.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py,Consultations,Majadiliano
apps/erpnext/erpnext/manufacturing/report/bom_variance_report/bom_variance_report.py,Finished Good,Imekamilishwa vizuri
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,"Item Price appears multiple times based on Price List, Supplier/Customer, Currency, Item, UOM, Qty and Dates.","Item Bei inaonekana mara nyingi kulingana na Orodha ya Bei, Wafanyabiashara / Wateja, Fedha, Bidhaa, UOM, Uchina na Tarehe."
DocType: Sales Invoice,Commission,Tume
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) haiwezi kuwa kubwa kuliko kiasi kilichopangwa ({2}) katika Kazi ya Kazi {3}
DocType: Certification Application,Name of Applicant,Jina la Mombaji
apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Karatasi ya Muda kwa ajili ya utengenezaji.
apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,jumla ndogo
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Haiwezi kubadilisha mali tofauti baada ya shughuli za hisa. Utahitaji kufanya kitu kipya cha kufanya hivyo.
apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,Mandhari ya SEPA ya GoCardless
DocType: Healthcare Practitioner,Charges,Malipo
DocType: Production Plan,Get Items For Work Order,Pata Vipengee Kwa Kazi ya Kazi
DocType: Salary Detail,Default Amount,Kiasi cha malipo
DocType: Lab Test Template,Descriptive,Maelezo
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Warehouse not found in the system,Ghala haipatikani kwenye mfumo
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,This Month's Summary,Muhtasari wa Mwezi huu
DocType: Quality Inspection Reading,Quality Inspection Reading,Uhakiki wa Uhakiki wa Ubora
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py,`Freeze Stocks Older Than` should be smaller than %d days.,'Zuia Hifadhi za Bidha za Kale Kuliko` lazima iwe ndogo kuliko siku% d.
DocType: Tax Rule,Purchase Tax Template,Kigezo cha Kodi ya Ununuzi
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Earliest Age,Umri wa mapema
apps/erpnext/erpnext/utilities/user_progress.py,Set a sales goal you'd like to achieve for your company.,Weka lengo la mauzo ungependa kufikia kwa kampuni yako.
DocType: Quality Goal,Revision,Marudio
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Healthcare Services,Huduma za Huduma za Afya
,Project wise Stock Tracking,Ufuatiliaji wa Hitilafu wa Mradi
DocType: GST HSN Code,Regional,Mkoa
apps/erpnext/erpnext/config/healthcare.py,Laboratory,Maabara
DocType: UOM Category,UOM Category,Jamii ya UOM
DocType: Clinical Procedure Item,Actual Qty (at source/target),Uchina halisi (katika chanzo / lengo)
DocType: Item Customer Detail,Ref Code,Kanuni ya Ref
DocType: Accounts Settings,Address used to determine Tax Category in transactions.,Anwani inayotumika kuamua Aina ya Ushuru katika shughuli.
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Customer Group is Required in POS Profile,Kundi la Wateja Inahitajika katika POS Profile
DocType: HR Settings,Payroll Settings,Mipangilio ya Mishahara
apps/erpnext/erpnext/config/accounting.py,Match non-linked Invoices and Payments.,Mechi zisizohusishwa ankara na malipo.
DocType: POS Settings,POS Settings,Mipangilio ya POS
apps/erpnext/erpnext/templates/pages/cart.html,Place Order,Agiza
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.js,Create Invoice,Unda ankara
DocType: Email Digest,New Purchase Orders,Amri mpya ya Ununuzi
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Root cannot have a parent cost center,Mizizi haiwezi kuwa na kituo cha gharama ya wazazi
DocType: POS Closing Voucher,Expense Details,Maelezo ya Gharama
apps/erpnext/erpnext/public/js/stock_analytics.js,Select Brand...,Chagua Brand ...
apps/erpnext/erpnext/public/js/setup_wizard.js,Non Profit (beta),Sio faida (beta)
apps/erpnext/erpnext/portal/doctype/products_settings/products_settings.py,"Filter Fields Row #{0}: Fieldname <b>{1}</b> must be of type ""Link"" or ""Table MultiSelect""",Mizizi ya vichungi # {0}: Jina la uwanja <b>{1}</b> lazima liwe la aina &quot;Kiungo&quot; au &quot;Jedwali MultiSelect&quot;
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Accumulated Depreciation as on,Kushuka kwa thamani kwa wakati
DocType: Employee Tax Exemption Category,Employee Tax Exemption Category,Jamii ya Uhuru wa Wafanyakazi
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Amount should not be less than zero.,Kiasi haipaswi kuwa chini ya sifuri.
DocType: Sales Invoice,C-Form Applicable,Fomu ya C inahitajika
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Operation Time must be greater than 0 for Operation {0},Muda wa Uendeshaji lazima uwe mkubwa kuliko 0 kwa Uendeshaji {0}
DocType: Support Search Source,Post Route String,Njia ya Njia ya Chapisho
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Warehouse is mandatory,Ghala ni lazima
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to create website,Imeshindwa kuunda tovuti
DocType: Soil Analysis,Mg/K,Mg / K
DocType: UOM Conversion Detail,UOM Conversion Detail,Maelezo ya Uongofu wa UOM
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Admission and Enrollment,Kiingilio na Uandikishaji
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Retention Stock Entry already created or Sample Quantity not provided,Uhifadhi Uingiaji wa hisa umeundwa tayari au Mfano Wingi haujatolewa
DocType: Program,Program Abbreviation,Hali ya Mpangilio
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Voucher (Consolidated),Kikundi cha Voucher (Pamoja)
DocType: HR Settings,Encrypt Salary Slips in Emails,Encrypt Slary Slips katika Barua pepe
DocType: Question,Multiple Correct Answer,Jibu Sahihi
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Charges are updated in Purchase Receipt against each item,Malipo yanasasishwa katika Receipt ya Ununuzi dhidi ya kila kitu
DocType: Warranty Claim,Resolved By,Ilifanywa na
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js,Schedule Discharge,Ratiba ya Kuondolewa
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Cheques and Deposits incorrectly cleared,Cheki na Deposits zimeondolewa kwa usahihi
DocType: Homepage Section Card,Homepage Section Card,Kadi ya Sehemu ya Tovuti
,Amount To Be Billed,Kiasi cha Kujazwa
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: You can not assign itself as parent account,Akaunti {0}: Huwezi kujitolea kama akaunti ya mzazi
DocType: Purchase Invoice Item,Price List Rate,Orodha ya Bei ya Bei
apps/erpnext/erpnext/utilities/activation.py,Create customer quotes,Unda nukuu za wateja
apps/erpnext/erpnext/public/js/controllers/transaction.js,Service Stop Date cannot be after Service End Date,Tarehe ya Kuacha Huduma haiwezi kuwa baada ya tarehe ya mwisho ya huduma
DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",Onyesha &quot;Katika Hifadhi&quot; au &quot;Sio katika Hifadhi&quot; kulingana na hisa zilizopo katika ghala hii.
apps/erpnext/erpnext/config/manufacturing.py,Bill of Materials (BOM),Bill of Materials (BOM)
DocType: Item,Average time taken by the supplier to deliver,Wastani wa muda kuchukuliwa na muuzaji kutoa
DocType: Travel Itinerary,Check-in Date,Tarehe ya Kuingia
DocType: Sample Collection,Collected By,Imekusanywa na
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js,Assessment Result,Matokeo ya Tathmini
DocType: Hotel Room Package,Hotel Room Package,Kituo cha Chumba cha Hoteli
DocType: Employee Transfer,Employee Transfer,Uhamisho wa Wafanyakazi
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,Hours,Masaa
DocType: Project,Expected Start Date,Tarehe ya Mwanzo Inayotarajiwa
DocType: Purchase Invoice,04-Correction in Invoice,Marekebisho ya 04 katika ankara
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Order already created for all items with BOM,Kazi ya Kazi imeundwa tayari kwa vitu vyote na BOM
DocType: Bank Account,Party Details,Maelezo ya Chama
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant Details Report,Ripoti ya Taarifa ya Variant
DocType: Setup Progress Action,Setup Progress Action,Hatua ya Kuanzisha Programu
DocType: Course Activity,Video,Video
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Buying Price List,Kununua Orodha ya Bei
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Remove item if charges is not applicable to that item,Ondoa kipengee ikiwa mashtaka haifai kwa bidhaa hiyo
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Cancel Subscription,Futa Usajili
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Please select Maintenance Status as Completed or remove Completion Date,Tafadhali chagua Hali ya Matengenezo Kama Imekamilishwa au Tondoa Tarehe ya Kumaliza
DocType: Supplier,Default Payment Terms Template,Kigezo Masharti ya Malipo ya Kigeni
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Transaction currency must be same as Payment Gateway currency,Fedha ya ushirikiano lazima iwe sawa na Fedha ya Gateway ya Malipo
DocType: Payment Entry,Receive,Pata
DocType: Employee Benefit Application Detail,Earning Component,Kupokea kipengele
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Items and UOMs,Inasindika Vitu na UOM
apps/erpnext/erpnext/regional/italy/utils.py,Please set either the Tax ID or Fiscal Code on Company '%s',Tafadhali weka Kitambulisho cha Ushuru au Nambari ya Fedha kwenye Kampuni &#39;% s&#39;
apps/erpnext/erpnext/templates/pages/rfq.html,Quotations: ,Nukuu:
DocType: Contract,Partially Fulfilled,Kimatimizwa kikamilifu
DocType: Maintenance Visit,Fully Completed,Imekamilishwa kikamilifu
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,"Special Characters except ""-"", ""#"", ""."", ""/"", ""{"" and ""}"" not allowed in naming series","Tabia maalum isipokuwa &quot;-&quot;, &quot;#&quot;, &quot;.&quot;, &quot;/&quot;, &quot;{&quot; Na &quot;}&quot; hairuhusiwi katika kutaja mfululizo"
DocType: Purchase Invoice Item,Is nil rated or exempted,Haikadiriwa au kutolewa msamaha
DocType: Employee,Educational Qualification,Ufanisi wa Elimu
DocType: Workstation,Operating Costs,Gharama za uendeshaji
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Currency for {0} must be {1},Fedha ya {0} lazima iwe {1}
DocType: Shift Type,Mark attendance based on 'Employee Checkin' for Employees assigned to this shift.,Weka mahudhurio kulingana na &#39;Checkin Wafanyikazi&#39; kwa Wafanyikazi waliopewa kazi hii.
DocType: Asset,Disposal Date,Tarehe ya kupoteza
DocType: Service Level,Response and Resoution Time,Kujibu na Wakati wa Kujiuzulu
DocType: Employee Leave Approver,Employee Leave Approver,Msaidizi wa Kuondoa Waajiri
apps/erpnext/erpnext/stock/doctype/item/item.py,Row {0}: An Reorder entry already exists for this warehouse {1},Row {0}: Kuingilia upya tayari kunapo kwa ghala hili {1}
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.js,Please enter the designation,Tafadhali ingiza uteuzi
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py,"Cannot declare as lost, because Quotation has been made.","Haiwezi kutangaza kama kupotea, kwa sababu Nukuu imefanywa."
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Items for Raw Material Request,Vitu vya ombi la nyenzo mbichi
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,CWIP Account,Akaunti ya CWIP
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js,Training Feedback,Mafunzo ya Mafunzo
apps/erpnext/erpnext/config/accounting.py,Tax Withholding rates to be applied on transactions.,Viwango vya Kuzuia Ushuru kutumiwa kwenye shughuli.
DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Vigezo vya Scorecard za Wasambazaji
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select Start Date and End Date for Item {0},Tafadhali chagua tarehe ya kuanza na tarehe ya mwisho ya kipengee {0}
DocType: Maintenance Schedule,MAT-MSH-.YYYY.-,MAT-MSH -YYYY.-
,Amount to Receive,Kiasi cha Kupokea
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Course is mandatory in row {0},Kozi ni lazima katika mstari {0}
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,From date can not be greater than than To date,Kuanzia tarehe haiwezi kuwa kubwa kuliko leo
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,To date cannot be before from date,Hadi sasa haiwezi kuwa kabla kabla ya tarehe
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Non GST Inward Supplies,Ugavi wa ndani wa GST
DocType: Employee Group Table,Employee Group Table,Jedwali la Kikundi cha Wafanyakazi
DocType: Packed Item,Prevdoc DocType,Prevdoc DocType
DocType: Cash Flow Mapper,Section Footer,Sehemu ya Sehemu
apps/erpnext/erpnext/stock/doctype/item/item.js,Add / Edit Prices,Ongeza / Hariri Bei
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py,Employee Promotion cannot be submitted before Promotion Date ,Uendelezaji wa Wafanyakazi hauwezi kuwasilishwa kabla ya Tarehe ya Kukuza
DocType: Batch,Parent Batch,Kundi cha Mzazi
DocType: Cheque Print Template,Cheque Print Template,Angalia Kigezo cha Print
DocType: Salary Component,Is Flexible Benefit,Ni Flexible Faida
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Chart of Cost Centers,Chati ya Vituo vya Gharama
DocType: Subscription Settings,Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,Idadi ya siku baada ya tarehe ya ankara imetoka kabla ya kufuta usajili au kusajili usajili bila malipo
DocType: Clinical Procedure Template,Sample Collection,Mkusanyiko wa Mfano
,Requested Items To Be Ordered,Vitu Vilivyoombwa Ili Kuagizwa
DocType: Price List,Price List Name,Jina la Orodha ya Bei
DocType: Delivery Stop,Dispatch Information,Maelezo ya Maagizo
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill JSON can only be generated from submitted document,E-Way Bill JSON inaweza tu kutolewa kutoka hati iliyowasilishwa
DocType: Blanket Order,Manufacturing,Uzalishaji
,Ordered Items To Be Delivered,Vipengee vya Kutolewa
DocType: Account,Income,Mapato
DocType: Industry Type,Industry Type,Aina ya Sekta
apps/erpnext/erpnext/templates/includes/cart.js,Something went wrong!,Kitu kilichokosa!
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Warning: Leave application contains following block dates,Onyo: Acha programu ina tarehe zifuatazo za kuzuia
DocType: Bank Statement Settings,Transaction Data Mapping,Mapato ya Takwimu za Transaction
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Sales Invoice {0} has already been submitted,Invozi ya Mauzo {0} imetumwa tayari
DocType: Salary Component,Is Tax Applicable,"Je, kodi inatumika"
DocType: Supplier Scorecard Scoring Criteria,Score,Score
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Fiscal Year {0} does not exist,Mwaka wa Fedha {0} haipo
DocType: Asset Maintenance Log,Completion Date,Tarehe ya kukamilisha
DocType: Purchase Invoice Item,Amount (Company Currency),Kiasi (Fedha la Kampuni)
DocType: Program,Is Featured,Imeonekana
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Fetching...,Inachukua ...
DocType: Agriculture Analysis Criteria,Agriculture User,Mtumiaji wa Kilimo
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Valid till date cannot be before transaction date,Halali hadi tarehe haiwezi kuwa kabla ya tarehe ya shughuli
DocType: Fee Schedule,Student Category,Jamii ya Wanafunzi
DocType: Announcement,Student,Mwanafunzi
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js,Stock quantity to start procedure is not available in the warehouse. Do you want to record a Stock Transfer,Stock kiasi cha kuanza utaratibu haipatikani katika ghala. Unataka kurekodi Uhamisho wa Hifadhi
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,New {0} pricing rules are created,Sheria mpya za bei {0} zimeundwa
DocType: Shipping Rule,Shipping Rule Type,Aina ya Rule ya Utoaji
apps/erpnext/erpnext/utilities/user_progress.py,Go to Rooms,Nenda kwenye Vyumba
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,"Company, Payment Account, From Date and To Date is mandatory","Kampuni, Akaunti ya Malipo, Tarehe na Tarehe ni lazima"
DocType: Company,Budget Detail,Maelezo ya Bajeti
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py,Please enter message before sending,Tafadhali ingiza ujumbe kabla ya kutuma
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Setting up company,Kuanzisha kampuni
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Of the supplies shown in 3.1 (a) above, details of inter-State supplies made to unregisterd
	persons, composition taxable persons and UIN holders","Ya vifaa vilivyoonyeshwa katika 3.1 (a) hapo juu, maelezo ya vifaa vya kati ya Jimbo yaliyotolewa kwa watu ambao hawajasajiliwa, watu wanaoweza kulipa ushuru na wamiliki wa UIN"
DocType: Education Settings,Enable LMS,Washa LMS
DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DUPLICATE KWA MFASHAJI
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,Please save the report again to rebuild or update,Tafadhali hifadhi ripoti tena ili kuunda tena au kusasisha
DocType: Service Level Agreement,Response and Resolution Time,Kujibu na Wakati wa Azimio
DocType: Asset,Custodian,Mtunzaji
apps/erpnext/erpnext/config/retail.py,Point-of-Sale Profile,Ushauri wa Maandishi ya Uhakika
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py,{0} should be a value between 0 and 100,{0} lazima iwe thamani kati ya 0 na 100
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Payment of {0} from {1} to {2},Malipo ya {0} kutoka {1} hadi {2}
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward supplies liable to reverse charge (other than 1 & 2 above),Vifaa vya ndani vina jukumu la kubadili malipo (zaidi ya 1 &amp; 2 hapo juu)
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Amount(Company Currency),Kiasi cha Agizo la Ununuzi (Fedha ya Kampuni)
DocType: Chart of Accounts Importer,Import Chart of Accounts from a csv file,Ingiza Chati ya Hesabu kutoka faili ya csv
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Unsecured Loans,Mikopo isiyohakikishiwa
DocType: Cost Center,Cost Center Name,Jina la Kituo cha Gharama
DocType: Student,B+,B +
DocType: HR Settings,Max working hours against Timesheet,Saa nyingi za kazi dhidi ya Timesheet
DocType: Shift Type,Strictly based on Log Type in Employee Checkin,Kwa msingi wa Aina ya Ingia kwenye Checkin ya Mfanyakazi
DocType: Maintenance Schedule Detail,Scheduled Date,Tarehe iliyopangwa
DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Ujumbe mkubwa kuliko wahusika 160 utagawanywa katika ujumbe nyingi
DocType: Purchase Receipt Item,Received and Accepted,Imepokea na Kukubaliwa
,GST Itemised Sales Register,GST Register Itemized Sales Register
DocType: Staffing Plan,Staffing Plan Details,Maelezo ya Mpango wa Utumishi
DocType: Soil Texture,Silt Loam,Silt Loam
,Serial No Service Contract Expiry,Serial Hakuna Mpangilio wa Mkataba wa Huduma
DocType: Employee Health Insurance,Employee Health Insurance,Bima ya Afya ya Wafanyakazi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,You cannot credit and debit same account at the same time,Huwezi kulipa mikopo na kulipa akaunti sawa wakati huo huo
DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Kiwango cha pigo cha watu wazima ni popote kati ya beats 50 na 80 kwa dakika.
DocType: Naming Series,Help HTML,Msaada HTML
DocType: Student Group Creation Tool,Student Group Creation Tool,Chombo cha Uumbaji wa Wanafunzi
DocType: Item,Variant Based On,Tofauti kulingana na
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Total weightage assigned should be 100%. It is {0},Jumla ya uzito uliopangwa lazima iwe 100%. Ni {0}
DocType: Loyalty Point Entry,Loyalty Program Tier,Uaminifu wa Programu ya Uaminifu
apps/erpnext/erpnext/utilities/user_progress.py,Your Suppliers,Wauzaji wako
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Cannot set as Lost as Sales Order is made.,Haiwezi kuweka kama Lost kama Mauzo Order inafanywa.
DocType: Request for Quotation Item,Supplier Part No,Sehemu ya Wafanyabiashara No
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reason for hold: ,Sababu ya kushikilia:
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Haiwezi kufuta wakati kiwanja ni kwa &#39;Valuation&#39; au &#39;Vikwazo na Jumla&#39;
apps/erpnext/erpnext/public/js/hub/components/reviews.js,Anonymous,Haijulikani
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Received From,Imepokea Kutoka
DocType: Lead,Converted,Ilibadilishwa
DocType: Item,Has Serial No,Ina Serial No
DocType: Stock Entry Detail,PO Supplied Item,Bidhaa Iliyopeanwa
DocType: Employee,Date of Issue,Tarehe ya Suala
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}","Kwa mujibu wa Mipangilio ya Ununuzi ikiwa Ununuzi wa Reciept Inahitajika == &#39;Ndiyo&#39;, kisha kwa Kujenga Invoice ya Ununuzi, mtumiaji haja ya kuunda Receipt ya Ununuzi kwanza kwa kipengee {0}"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Set Supplier for item {1},Row # {0}: Weka wauzaji kwa kipengee {1}
DocType: Global Defaults,Default Distance Unit,Kitengo cha Default Distance
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: Hours value must be greater than zero.,Row {0}: Thamani ya saa lazima iwe kubwa kuliko sifuri.
apps/erpnext/erpnext/stock/doctype/item/item.py,Website Image {0} attached to Item {1} cannot be found,Image ya tovuti {0} iliyoambatana na Item {1} haiwezi kupatikana
DocType: Asset,Assets,Mali
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Computer,Kompyuta
DocType: Item,List this Item in multiple groups on the website.,Andika kitu hiki katika makundi mengi kwenye tovuti.
DocType: Subscription,Current Invoice End Date,Sasa Tarehe ya Mwisho ya Invoice
DocType: Payment Term,Due Date Based On,Kutokana na Tarehe ya Kuzingatia
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Please set default customer group and territory in Selling Settings,Tafadhali weka kikundi cha wateja na chaguo la msingi katika Ununuzi wa Mipangilio
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} does not exist,{0} {1} haipo
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please check Multi Currency option to allow accounts with other currency,Tafadhali angalia Chaguo cha Fedha Multi kuruhusu akaunti na sarafu nyingine
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Item: {0} does not exist in the system,Item: {0} haipo katika mfumo
apps/erpnext/erpnext/accounts/doctype/account/account.py,You are not authorized to set Frozen value,Huna mamlaka ya kuweka thamani iliyosafishwa
DocType: Payment Reconciliation,Get Unreconciled Entries,Pata Maingiliano yasiyotambulika
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} is on Leave on {1},Mfanyakazi {0} ni juu ya Acha kwenye {1}
apps/erpnext/erpnext/hr/doctype/loan/loan.py,No repayments selected for Journal Entry,Hakuna malipo yaliyochaguliwa kwa Kuingia kwa Journal
DocType: Purchase Invoice,GST Category,Jamii ya GST
DocType: Payment Reconciliation,From Invoice Date,Kutoka tarehe ya ankara
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year_dashboard.py,Budgets,Bajeti
DocType: Invoice Discounting,Disbursed,Kutengwa
DocType: Healthcare Settings,Laboratory Settings,Mazingira ya Maabara
DocType: Clinical Procedure,Service Unit,Kitengo cha Huduma
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js,Successfully Set Supplier,Tengeneza Wasambazaji kwa Ufanisi
DocType: Leave Encashment,Leave Encashment,Acha Acha
apps/erpnext/erpnext/public/js/setup_wizard.js,What does it do?,Inafanya nini?
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py,Tasks have been created for managing the {0} disease (on row {1}),Kazi zimeundwa kwa ajili ya kusimamia {0} ugonjwa (kwenye mstari {1})
DocType: Crop,Byproducts,Bidhaa
apps/erpnext/erpnext/stock/doctype/batch/batch.js,To Warehouse,Kwa Ghala
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,All Student Admissions,Uingizaji wa Wanafunzi wote
,Average Commission Rate,Wastani wa Tume ya Kiwango
DocType: Share Balance,No of Shares,Hakuna ya Hisa
DocType: Taxable Salary Slab,To Amount,Kwa Kiasi
apps/erpnext/erpnext/stock/doctype/item/item.py,'Has Serial No' can not be 'Yes' for non-stock item,&#39;Ina Serial No&#39; haiwezi kuwa &#39;Ndio&#39; kwa bidhaa zisizo za hisa
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Status,Chagua Hali
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance can not be marked for future dates,Mahudhurio hayawezi kutambuliwa kwa tarehe za baadaye
DocType: Support Search Source,Post Description Key,Maelezo ya kuchapisha Muhimu
DocType: Pricing Rule,Pricing Rule Help,Msaada wa Kanuni ya bei
DocType: School House,House Name,Jina la Nyumba
DocType: Fee Schedule,Total Amount per Student,Jumla ya Kiasi kwa Mwanafunzi
DocType: Opportunity,Sales Stage,Hatua ya Mauzo
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Customer PO,Mteja PO
DocType: Purchase Taxes and Charges,Account Head,Kichwa cha Akaunti
DocType: Company,HRA Component,HRA Kipengele
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Electrical,Umeme
apps/erpnext/erpnext/utilities/activation.py,Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,Ongeza shirika lako lote kama watumiaji wako. Unaweza pia kuongeza Watejaji kwenye bandari yako kwa kuongezea kutoka kwa Washauri
DocType: Stock Entry,Total Value Difference (Out - In),Tofauti ya Thamani ya Jumla (Nje-Ndani)
DocType: Employee Checkin,Location / Device ID,Kitambulisho cha Mahali / Kifaa
DocType: Grant Application,Requested Amount,Kiasi kilichoombwa
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Exchange Rate is mandatory,Row {0}: Kiwango cha Exchange ni lazima
DocType: Invoice Discounting,Bank Charges Account,Akaunti ya malipo ya benki
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,User ID not set for Employee {0},Kitambulisho cha mtumiaji hakiwekwa kwa Waajiriwa {0}
DocType: Vehicle,Vehicle Value,Thamani ya Gari
DocType: Crop Cycle,Detected Diseases,Magonjwa yaliyoambukizwa
DocType: Stock Entry,Default Source Warehouse,Ghala la Chanzo cha Chanzo
DocType: Item,Customer Code,Kanuni ya Wateja
DocType: Bank,Data Import Configuration,Usanidi wa Uingizaji wa data
DocType: Asset Maintenance Task,Last Completion Date,Tarehe ya mwisho ya kukamilika
apps/erpnext/erpnext/accounts/report/inactive_sales_items/inactive_sales_items.js,Days Since Last Order,Siku Tangu Toleo la Mwisho
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To account must be a Balance Sheet account,Debit Kwa akaunti lazima iwe Hesabu ya Hesabu ya Hesabu
DocType: Asset,Naming Series,Mfululizo wa majina
DocType: Vital Signs,Coated,Imefunikwa
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Row {0}: Thamani Inayotarajiwa Baada ya Maisha ya Muhimu lazima iwe chini ya Kiasi cha Ununuzi wa Gross
apps/erpnext/erpnext/regional/italy/utils.py,Please set {0} for address {1},Tafadhali weka {0} kwa anuani {1}
DocType: GoCardless Settings,GoCardless Settings,Mipangilio ya GoCardless
apps/erpnext/erpnext/controllers/stock_controller.py,Create Quality Inspection for Item {0},Unda ukaguzi wa Ubora wa Bidhaa {0}
DocType: Leave Block List,Leave Block List Name,Acha jina la orodha ya kuzuia
DocType: Certified Consultant,Certification Validity,Uthibitishaji wa vyeti
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py,Insurance Start date should be less than Insurance End date,Tarehe ya kuanza kwa bima inapaswa kuwa chini ya tarehe ya mwisho ya Bima
DocType: Support Settings,Service Level Agreements,Mikataba ya Kiwango cha Huduma
DocType: Shopping Cart Settings,Display Settings,Mipangilio ya kuonyesha
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Assets,Mali ya Hifadhi
DocType: Restaurant,Active Menu,Menyu ya Kazi
DocType: Accounting Dimension Detail,Default Dimension,Vipimo Mbadala
DocType: Target Detail,Target Qty,Uchina wa Target
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Against Loan: {0},Dhidi ya mkopo: {0}
DocType: Shopping Cart Settings,Checkout Settings,Mipangilio ya Checkout
DocType: Student Attendance,Present,Sasa
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Delivery Note {0} must not be submitted,Kumbuka Utoaji {0} haipaswi kuwasilishwa
DocType: HR Settings,"The salary slip emailed to the employee will be password protected, the password will be generated based on the password policy.","Kijitabu cha mshahara kilichotumwa kwa mfanyikazi kitalindwa nywila, nywila itatolewa kwa kuzingatia sera ya nenosiri."
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Closing Account {0} must be of type Liability / Equity,Akaunti ya kufungwa {0} lazima iwe ya Dhima / Usawa wa aina
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Slip of employee {0} already created for time sheet {1},Kulipwa kwa mshahara wa mfanyakazi {0} tayari kuundwa kwa karatasi ya muda {1}
DocType: Vehicle Log,Odometer,Odometer
DocType: Production Plan Item,Ordered Qty,Iliyoamriwa Uchina
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is disabled,Item {0} imezimwa
DocType: Stock Settings,Stock Frozen Upto,Stock Frozen Upto
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,BOM does not contain any stock item,BOM haina kitu chochote cha hisa
DocType: Chapter,Chapter Head,Mlango Mkuu
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Search for a payment,Tafuta malipo
DocType: Payment Term,Month(s) after the end of the invoice month,Mwezi (s) baada ya mwisho wa mwezi wa ankara
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Salary Structure should have flexible benefit component(s) to dispense benefit amount,Mfumo wa Mshahara unapaswa kuwa na kipengele cha manufaa cha faida ili kutoa kiasi cha faida
apps/erpnext/erpnext/config/projects.py,Project activity / task.,Shughuli ya mradi / kazi.
DocType: Vital Signs,Very Coated,Imevaliwa sana
DocType: Salary Component,Only Tax Impact (Cannot Claim But Part of Taxable Income),Impact Tu ya Impact (Haiwezi kudai Lakini sehemu ya Mapato ya Kodi)
DocType: Vehicle Log,Refuelling Details,Maelezo ya Refueling
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py,Lab result datetime cannot be before testing datetime,Siku ya tarehe ya matokeo ya Lab haiwezi kuwa kabla ya tarehe ya kupima
DocType: Delivery Trip,Use Google Maps Direction API to optimize route,Tumia API ya Uelekezaji wa Ramani za Google ili kuongeza njia
DocType: POS Profile,Allow user to edit Discount,Ruhusu mtumiaji kuhariri Discount
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Get customers from,Pata wateja kutoka
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,As per rules 42 & 43 of CGST Rules,Kama kwa sheria 42 &amp; 43 ya Sheria za CGST
DocType: Purchase Invoice Item,Include Exploded Items,Jumuisha Vipengee Vipengee
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,"Buying must be checked, if Applicable For is selected as {0}","Ununuzi lazima uangaliwe, ikiwa Inahitajika Ilichaguliwa kama {0}"
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Discount must be less than 100,Punguzo lazima liwe chini ya 100
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,"Start Time can't be greater than or equal to End Time \
					for {0}.",Saa ya Kuanza haiwezi kuwa kubwa kuliko au sawa na Muda wa Mwisho \ kwa {0}.
DocType: Shipping Rule,Restrict to Countries,Uzuia Nchi
DocType: Shift Type,Alternating entries as IN and OUT during the same shift,Kubadilisha maingizo kama IN na OUT wakati wa mabadiliko sawa
DocType: Shopify Settings,Shared secret,Imeshirikiwa siri
DocType: Amazon MWS Settings,Synch Taxes and Charges,Taasisi za Vipindi na Chaguzi
DocType: Purchase Invoice,Write Off Amount (Company Currency),Andika Kiasi (Dhamana ya Kampuni)
DocType: Sales Invoice Timesheet,Billing Hours,Masaa ya kulipia
DocType: Project,Total Sales Amount (via Sales Order),Jumla ya Mauzo Kiasi (kupitia Mauzo ya Mauzo)
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Default BOM for {0} not found,BOM ya default kwa {0} haipatikani
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Fiscal Year Start Date should be one year earlier than Fiscal Year End Date,Tarehe ya Kuanza Mwaka wa Fedha inapaswa kuwa mwaka mmoja mapema kuliko Tarehe ya Mwisho wa Mwaka wa Fedha
apps/erpnext/erpnext/stock/doctype/item/item.py,Row #{0}: Please set reorder quantity,Row # {0}: Tafadhali weka upya kiasi
apps/erpnext/erpnext/public/js/pos/pos.html,Tap items to add them here,Gonga vitu ili uziweze hapa
DocType: Course Enrollment,Program Enrollment,Uandikishaji wa Programu
apps/erpnext/erpnext/controllers/item_variant.py,Rename Not Allowed,Badili jina Hairuhusiwi
DocType: Share Transfer,To Folio No,Kwa No ya Folio
DocType: Landed Cost Voucher,Landed Cost Voucher,Voucher ya Gharama ya Uliopita
apps/erpnext/erpnext/config/accounting.py,Tax Category for overriding tax rates.,Jamii ya ushuru ya viwango vya juu vya ushuru.
apps/erpnext/erpnext/public/js/queries.js,Please set {0},Tafadhali weka {0}
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} ni mwanafunzi asiye na kazi
DocType: Employee,Health Details,Maelezo ya Afya
DocType: Leave Encashment,Encashable days,Siku isiyoweza
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Ili kuunda hati ya kumbukumbu ya Rufaa ya Malipo inahitajika
DocType: Soil Texture,Sandy Clay,Mchanga wa Mchanga
DocType: Grant Application,Assessment  Manager,Meneja wa Tathmini
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Allocate Payment Amount,Weka Kiwango cha Malipo
DocType: Subscription Plan,Subscription Plan,Mpango wa Usajili
DocType: Employee External Work History,Salary,Mshahara
DocType: Serial No,Delivery Document Type,Aina ya Nyaraka za Utoaji
DocType: Sales Order,Partly Delivered,Sehemu iliyotolewa
DocType: Item Variant Settings,Do not update variants on save,Usasasishe vipengee kwenye salama
DocType: Email Digest,Receivables,Mapato
DocType: Lead Source,Lead Source,Chanzo cha Mwelekeo
DocType: Customer,Additional information regarding the customer.,Maelezo ya ziada kuhusu mteja.
DocType: Quality Inspection Reading,Reading 5,Kusoma 5
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} inahusishwa na {2}, lakini Akaunti ya Chama ni {3}"
DocType: Bank Statement Settings Item,Bank Header,Kiongozi wa Benki
apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js,View Lab Tests,Angalia Majaribio ya Lab
DocType: Hub Users,Hub Users,Watumiaji wa Hub
DocType: Purchase Invoice,Y,Y
DocType: Maintenance Visit,Maintenance Date,Tarehe ya Matengenezo
DocType: Purchase Invoice Item,Rejected Serial No,Imekataliwa Serial No
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Year start date or end date is overlapping with {0}. To avoid please set company,Tarehe ya kuanza kwa mwaka au tarehe ya mwisho ni kuingiliana na {0}. Ili kuepuka tafadhali kuweka kampuni
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Please mention the Lead Name in Lead {0},Tafadhali kutaja jina la kiongozi katika kiongozi {0}
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Start date should be less than end date for Item {0},Tarehe ya mwanzo inapaswa kuwa chini ya tarehe ya mwisho ya Bidhaa {0}
DocType: Shift Type,Auto Attendance Settings,Mipangilio ya Mahudhurio Moja kwa moja
DocType: Item,"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.","Mfano: ABCD. ##### Ikiwa mfululizo umewekwa na Serial No haijajwajwa katika shughuli, nambari ya serial moja kwa moja itaundwa kulingana na mfululizo huu. Ikiwa daima unataka kutaja wazi Serial Nos kwa kipengee hiki. shika hii tupu."
DocType: Upload Attendance,Upload Attendance,Pakia Mahudhurio
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,BOM and Manufacturing Quantity are required,BOM na Uzalishaji wa Wingi huhitajika
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 2,Aina ya kuzeeka 2
DocType: SG Creation Tool Course,Max Strength,Nguvu ya Max
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Installing presets,Inaweka presets
DocType: Fee Schedule,EDU-FSH-.YYYY.-,EDU-FSH -YYYY.-
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,No Delivery Note selected for Customer {},Hakuna Kumbukumbu ya Utoaji iliyochaguliwa kwa Wateja {}
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,Rows Added in {0},Mizizi Zimeongezwa katika {0}
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Employee {0} has no maximum benefit amount,Mfanyakazi {0} hana kiwango cha juu cha faida
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select Items based on Delivery Date,Chagua Vitu kulingana na tarehe ya utoaji
DocType: Grant Application,Has any past Grant Record,Ina nakala yoyote ya Ruzuku iliyopita
,Sales Analytics,Uchambuzi wa Mauzo
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Available {0},Inapatikana {0}
,Prospects Engaged But Not Converted,Matarajio yaliyotumika lakini haijaongozwa
DocType: Manufacturing Settings,Manufacturing Settings,Mipangilio ya Uzalishaji
DocType: Quality Feedback Template Parameter,Quality Feedback Template Parameter,Kigezo cha Kiolezo cha Maoni ya Ubora
apps/erpnext/erpnext/config/settings.py,Setting up Email,Kuweka Barua pepe
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Mobile No,Guardian1 Simu ya Mkono Hakuna
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please enter default currency in Company Master,Tafadhali ingiza fedha za msingi kwa Kampuni ya Kampuni
DocType: Stock Entry Detail,Stock Entry Detail,Maelezo ya Entry Entry
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Daily Reminders,Kumbukumbu za kila siku
apps/erpnext/erpnext/templates/pages/help.html,See all open tickets,Angalia tiketi zote za wazi
DocType: Brand,Brand Defaults,Maonyesho ya Bidhaa
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js,Healthcare Service Unit Tree,Kitengo cha Utunzaji wa Huduma ya Afya
DocType: Pricing Rule,Product,Bidhaa
DocType: Products Settings,Home Page is Products,Ukurasa wa Kwanza ni Bidhaa
,Asset Depreciation Ledger,Msanidi wa Upungufu wa Mali
DocType: Salary Structure,Leave Encashment Amount Per Day,Acha Kiasi Kiasi kwa Siku
DocType: Loyalty Program Collection,For how much spent = 1 Loyalty Point,Kwa kiasi gani kilichotumika = 1 Uhalali Point
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,Tax Rule Conflicts with {0},Migogoro ya Kanuni za Ushuru na {0}
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,New Account Name,Jina la Akaunti Mpya
DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Malighafi ya Raw zinazotolewa
DocType: Selling Settings,Settings for Selling Module,Mipangilio kwa ajili ya kuuza Moduli
DocType: Hotel Room Reservation,Hotel Room Reservation,Uhifadhi wa Chumba cha Hoteli
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Customer Service,Huduma kwa wateja
DocType: BOM,Thumbnail,Picha ndogo
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,No contacts with email IDs found.,Hakuna anwani na Vitambulisho vya barua pepe vilivyopatikana.
DocType: Item Customer Detail,Item Customer Detail,Maelezo ya Wateja wa Bidhaa
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum benefit amount of employee {0} exceeds {1},Ufikiaji wa kiasi cha mfanyakazi {0} unazidi {1}
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total allocated leaves are more than days in the period,Majani yote yaliyotengwa ni zaidi ya siku katika kipindi
DocType: Linked Soil Analysis,Linked Soil Analysis,Uchunguzi wa ardhi uliohusishwa
DocType: Pricing Rule,Percentage,Asilimia
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Item {0} must be a stock Item,Kipengee {0} kinafaa kuwa kitu cha hisa
DocType: Manufacturing Settings,Default Work In Progress Warehouse,Kazi ya Kazi katika Hifadhi ya Maendeleo
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Mipangilio ya {0} inaingizwa, unataka kuendelea baada ya kuruka mipaka iliyopandwa?"
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js,Grant Leaves,Majani ya Ruzuku
DocType: Restaurant,Default Tax Template,Kigezo cha Ushuru cha Default
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,{0} Students have been enrolled,{0} Wanafunzi wamejiandikisha
DocType: Fees,Student Details,Maelezo ya Wanafunzi
DocType: Woocommerce Settings,"This is the default UOM used for items and Sales orders. The fallback UOM is ""Nos"".",Hii ndio UOM ya msingi inayotumika kwa vitu na maagizo ya Uuzaji. UOM ya kurudi nyuma ni &quot;Nos&quot;.
DocType: Purchase Invoice Item,Stock Qty,Kiwanda
apps/erpnext/erpnext/public/js/hub/components/ReviewArea.vue,Ctrl+Enter to submit,Ctrl + Ingiza ili kuwasilisha
DocType: Contract,Requires Fulfilment,Inahitaji kutimiza
DocType: QuickBooks Migrator,Default Shipping Account,Akaunti ya Utoaji wa Default
DocType: Loan,Repayment Period in Months,Kipindi cha ulipaji kwa Miezi
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Error: Not a valid id?,Hitilafu: Si id idhini?
DocType: Naming Series,Update Series Number,Sasisha Nambari ya Mfululizo
DocType: Account,Equity,Equity
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: Akaunti ya aina ya faida na ya kupoteza {2} hairuhusiwi katika Kufungua Ingia
DocType: Job Offer,Printing Details,Maelezo ya Uchapishaji
DocType: Task,Closing Date,Tarehe ya kufunga
DocType: Sales Order Item,Produced Quantity,Waliyotokana na Wingi
DocType: Item Price,Quantity  that must be bought or sold per UOM,Wingi ambao unapaswa kununuliwa au kuuzwa kwa UOM
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Engineer,Mhandisi
DocType: Promotional Scheme Price Discount,Max Amount,Kiasi Kikubwa
DocType: Journal Entry,Total Amount Currency,Jumla ya Fedha ya Fedha
DocType: Pricing Rule,Min Amt,Min Amt
DocType: Item,Is Customer Provided Item,Je! Mteja Ametolewa Bidhaa
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Search Sub Assemblies,Tafuta Sub Assemblies
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Item Code required at Row No {0},Msimbo wa kipengee unahitajika kwenye Row No {0}
DocType: GST Account,SGST Account,Akaunti ya SGST
apps/erpnext/erpnext/utilities/user_progress.py,Go to Items,Nenda kwa Vitu
DocType: Sales Partner,Partner Type,Aina ya Washirika
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Actual,Kweli
DocType: Restaurant Menu,Restaurant Manager,Meneja wa Mgahawa
DocType: Call Log,Call Log,Simu ya Kuingia
DocType: Authorization Rule,Customerwise Discount,Ugawaji wa Wateja
apps/erpnext/erpnext/config/projects.py,Timesheet for tasks.,Timesheet kwa ajili ya kazi.
DocType: Purchase Invoice,Against Expense Account,Dhidi ya Akaunti ya gharama
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Installation Note {0} has already been submitted,Maelezo ya Usanidi {0} tayari imewasilishwa
DocType: BOM,Raw Material Cost (Company Currency),Gharama ya Nyenzo Mbichi (Fedha ya Kampuni)
apps/erpnext/erpnext/regional/india/utils.py,House rent paid days overlapping with {0},Kodi ya nyumba kulipwa siku zinazoingiliana na {0}
DocType: GSTR 3B Report,October,Oktoba
DocType: Bank Reconciliation,Get Payment Entries,Pata Maingizo ya Malipo
DocType: Quotation Item,Against Docname,Dhidi ya Nyaraka
DocType: SMS Center,All Employee (Active),Wafanyakazi wote (Active)
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Detailed Reason,Sababu ya Kina
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,View Now,Tazama Sasa
DocType: BOM,Raw Material Cost,Gharama za Nyenzo za Raw
DocType: Woocommerce Settings,Woocommerce Server URL,URL ya Server ya Woocommerce
DocType: Item Reorder,Re-Order Level,Kiwango cha Udhibiti wa Rejea
DocType: Additional Salary,Deduct Full Tax on Selected Payroll Date,Punguza Ushuru kamili kwenye Tarehe ya malipo ya kuchaguliwa
DocType: Shopify Tax Account,Shopify Tax/Shipping Title,Shopify Tax / Shipping Title
apps/erpnext/erpnext/projects/doctype/project/project.js,Gantt Chart,Chati ya Gantt
DocType: Crop Cycle,Cycle Type,Aina ya Mzunguko
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Part-time,Wakati wa sehemu
DocType: Employee,Applicable Holiday List,Orodha ya likizo ya kuhitajika
DocType: Employee,Cheque,Angalia
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Synchronize this account,Sawazisha akaunti hii
DocType: Training Event,Employee Emails,Barua za Waajiriwa
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Series Updated,Mfululizo umehifadhiwa
apps/erpnext/erpnext/accounts/doctype/account/account.py,Report Type is mandatory,Aina ya Ripoti ni lazima
DocType: Item,Serial Number Series,Serial Number Series
,Sales Partner Transaction Summary,Muhtasari wa Uuzaji wa Washirika wa Uuzaji
apps/erpnext/erpnext/buying/utils.py,Warehouse is mandatory for stock Item {0} in row {1},Ghala ni lazima kwa kipengee cha hisa {0} mfululizo {1}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Retail & Wholesale,Retail &amp; Wholesale
DocType: Issue,First Responded On,Kwanza Alijibu
DocType: Website Item Group,Cross Listing of Item in multiple groups,Kuweka Orodha ya Msalaba katika vikundi vingi
DocType: Employee Tax Exemption Declaration,Other Incomes,Matokeo mengine
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Tarehe ya Mwanzo wa Fedha na Tarehe ya Mwisho wa Fedha Tarehe tayari imewekwa mwaka wa Fedha {0}
DocType: Projects Settings,Ignore User Time Overlap,Puuza Wakati wa Mtumiaji Unaingiliana
DocType: Accounting Period,Accounting Period,Kipindi cha Uhasibu
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Clearance Date updated,Tarehe ya kufuta imewekwa
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split Batch,Piga Kundi
DocType: Stock Settings,Batch Identification,Kitambulisho cha Bundi
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,Successfully Reconciled,Imefanikiwa kuunganishwa
DocType: Request for Quotation Supplier,Download PDF,Pakua PDF
DocType: Work Order,Planned End Date,Tarehe ya Mwisho Imepangwa
DocType: Shareholder,Hidden list maintaining the list of contacts linked to Shareholder,Orodha ya siri inayohifadhi orodha ya anwani zinazohusishwa na Mshirika
DocType: Exchange Rate Revaluation Account,Current Exchange Rate,Kiwango cha sasa cha Exchange
DocType: Item,"Sales, Purchase, Accounting Defaults","Mauzo, Ununuzi, Uhasibu Ufafanuzi"
DocType: Accounting Dimension Detail,Accounting Dimension Detail,Maelezo ya Vipimo vya Uhasibu
apps/erpnext/erpnext/config/non_profit.py,Donor Type information.,Aina ya Msaidizi wa habari.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} on Leave on {1},{0} juu ya Acha kwenye {1}
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Available for use date is required,Inapatikana kwa tarehe ya matumizi inahitajika
DocType: Request for Quotation,Supplier Detail,Maelezo ya Wasambazaji
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Error in formula or condition: {0},Hitilafu katika fomu au hali: {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Invoiced Amount,Kiasi kilichopishwa
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Criteria weights must add up to 100%,Vipimo vya vigezo lazima kuongeza hadi 100%
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js,Attendance,Mahudhurio
apps/erpnext/erpnext/public/js/pos/pos.html,Stock Items,Vitu vya hisa
DocType: Sales Invoice,Update Billed Amount in Sales Order,Mwisho uliolipwa Kiasi katika Utaratibu wa Mauzo
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Contact Seller,Wasiliana na muuzaji
DocType: BOM,Materials,Vifaa
DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Ikiwa hakizingatiwa, orodha itahitajika kuongezwa kwa kila Idara ambapo itatakiwa kutumika."
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Posting date and posting time is mandatory,Tarehe ya kuchapisha na muda wa kuchapisha ni lazima
apps/erpnext/erpnext/config/buying.py,Tax template for buying transactions.,Template ya kodi kwa kununua shughuli.
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Please login as a Marketplace User to report this item.,Tafadhali ingia kama Mtumiaji wa Soko ili kuripoti bidhaa hii.
,Sales Partner Commission Summary,Muhtasari wa Tume ya Mshirika wa Uuzaji
,Item Prices,Bei ya Bidhaa
DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,Katika Maneno itaonekana wakati unapohifadhi Amri ya Ununuzi.
DocType: Holiday List,Add to Holidays,Ongeza kwenye Likizo
DocType: Woocommerce Settings,Endpoint,Mwisho
DocType: Period Closing Voucher,Period Closing Voucher,Voucher ya kufunga ya muda
DocType: Patient Encounter,Review Details,Tathmini maelezo
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shareholder does not belong to this company,Mbia sio kampuni hii
DocType: Dosage Form,Dosage Form,Fomu ya Kipimo
apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,Please set up the Campaign Schedule in the Campaign {0},Tafadhali sasisha Mpangilio wa Kampeni katika Kampeni {0}
apps/erpnext/erpnext/config/buying.py,Price List master.,Orodha ya bei ya bwana.
DocType: Task,Review Date,Tarehe ya Marekebisho
DocType: BOM,Allow Alternative Item,Ruhusu Nakala Mbadala
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Purchase Receipt doesn't have any Item for which Retain Sample is enabled.,Risiti ya Ununuzi haina Bidhaa yoyote ambayo Sampuli ya Uwezeshaji imewashwa.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Invoice Grand Total,Jumla ya ankara
DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Mfululizo wa Kuingia kwa Upungufu wa Mali (Kuingia kwa Jarida)
DocType: Membership,Member Since,Mwanachama Tangu
DocType: Purchase Invoice,Advance Payments,Malipo ya awali
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Time logs are required for job card {0},Magogo ya wakati yanahitajika kwa kadi ya kazi {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Please select Healthcare Service,Tafadhali chagua Huduma ya Afya
DocType: Purchase Taxes and Charges,On Net Total,Juu ya Net Jumla
apps/erpnext/erpnext/controllers/item_variant.py,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Thamani ya Ushirikina {0} lazima iwe kati ya {1} hadi {2} katika vipengee vya {3} kwa Bidhaa {4}
DocType: Pricing Rule,Product Discount Scheme,Mpango wa Punguzo la Bidhaa
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,No issue has been raised by the caller.,Hakuna suala lililotolewa na mpigaji.
DocType: Restaurant Reservation,Waitlisted,Inastahiliwa
DocType: Employee Tax Exemption Declaration Category,Exemption Category,Jamii ya Ukombozi
apps/erpnext/erpnext/accounts/doctype/account/account.py,Currency can not be changed after making entries using some other currency,Fedha haiwezi kubadilishwa baada ya kuingiza saini kwa kutumia sarafu nyingine
DocType: Shipping Rule,Fixed,Zisizohamishika
DocType: Vehicle Service,Clutch Plate,Bamba la Clutch
DocType: Tally Migration,Round Off Account,Ondoa Akaunti
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Administrative Expenses,Gharama za Utawala
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Consulting,Ushauri
DocType: Subscription Plan,Based on price list,Kulingana na orodha ya bei
DocType: Customer Group,Parent Customer Group,Kundi la Wateja wa Mzazi
apps/erpnext/erpnext/regional/india/utils.py,e-Way Bill JSON can only be generated from Sales Invoice,E-Way Bill JSON inaweza tu kutengenezwa kutoka ankara ya Uuzaji
apps/erpnext/erpnext/education/doctype/quiz/quiz.py,Maximum attempts for this quiz reached!,Jaribio kubwa la jaribio hili limefikiwa!
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Subscription,Usajili
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Creation Pending,Uumbaji wa Ada Inasubiri
DocType: Project Template Task,Duration (Days),Muda (Siku)
DocType: Appraisal Goal,Score Earned,Score Ilipatikana
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Notice Period,Kipindi cha Taarifa
DocType: Asset Category,Asset Category Name,Jina la Jamii ya Mali
apps/erpnext/erpnext/setup/doctype/territory/territory.js,This is a root territory and cannot be edited.,Hii ni eneo la mizizi na haiwezi kuhaririwa.
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js,New Sales Person Name,Jina la mtu mpya wa mauzo
DocType: Packing Slip,Gross Weight UOM,Uzito wa Pato UOM
DocType: Employee Transfer,Create New Employee Id,Unda Id Idhini ya Waajiriwa
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js,Set Details,Weka Maelezo
apps/erpnext/erpnext/templates/pages/home.html,By {0},Na {0}
DocType: Travel Itinerary,Travel From,Kutoka Kutoka
DocType: Asset Maintenance Task,Preventive Maintenance,Matengenezo ya kuzuia
DocType: Delivery Note Item,Against Sales Invoice,Dhidi ya ankara za Mauzo
DocType: Purchase Invoice,07-Others,07-Wengine
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please enter serial numbers for serialized item ,Tafadhali ingiza namba za serial kwa bidhaa iliyotumiwa
DocType: Bin,Reserved Qty for Production,Nambari iliyohifadhiwa ya Uzalishaji
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,Acha kuondoka bila kufuata kama hutaki kuzingatia kundi wakati wa kufanya makundi ya msingi.
DocType: Asset,Frequency of Depreciation (Months),Upeo wa kushuka kwa thamani (Miezi)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Credit Account,Akaunti ya Mikopo
DocType: Landed Cost Item,Landed Cost Item,Nambari ya Gharama ya Uliopita
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js,Show zero values,Onyesha maadili ya sifuri
DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Wingi wa bidhaa zilizopatikana baada ya viwanda / repacking kutokana na kiasi kilichotolewa cha malighafi
DocType: Lab Test,Test Group,Jaribio la Kikundi
DocType: Service Level Agreement,Entity,Chombo
DocType: Payment Reconciliation,Receivable / Payable Account,Akaunti ya Kulipwa / Kulipa
DocType: Delivery Note Item,Against Sales Order Item,Dhidi ya Vipengee vya Udhibiti wa Mauzo
DocType: Company,Company Logo,Logo ya Kampuni
DocType: QuickBooks Migrator,Default Warehouse,Ghala la Ghalafa
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Budget cannot be assigned against Group Account {0},Bajeti haipatikani dhidi ya Akaunti ya Kundi {0}
DocType: Shopping Cart Settings,Show Price,Onyesha Bei
DocType: Healthcare Settings,Patient Registration,Usajili wa Mgonjwa
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Please enter parent cost center,Tafadhali ingiza kituo cha gharama ya wazazi
DocType: Delivery Note,Print Without Amount,Chapisha bila Bila
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py,Depreciation Date,Tarehe ya kushuka kwa thamani
,Work Orders in Progress,Kazi ya Kazi katika Maendeleo
DocType: Customer Credit Limit,Bypass Credit Limit Check,Kikomo cha Mkopo wa Bypass Angalia
DocType: Issue,Support Team,Timu ya Kusaidia
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,Expiry (In Days),Mwisho (Katika Siku)
DocType: Appraisal,Total Score (Out of 5),Jumla ya alama (Kati ya 5)
DocType: Student Attendance Tool,Batch,Kundi
DocType: Support Search Source,Query Route String,Njia ya String Route
DocType: Tally Migration,Day Book Data,Takwimu za Kitabu cha Siku
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Update rate as per last purchase,Kiwango cha uhakiki kama kwa ununuzi wa mwisho
DocType: Donor,Donor Type,Aina ya wafadhili
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Auto repeat document updated,Rudia tena hati iliyosasishwa
apps/erpnext/erpnext/stock/doctype/item/item.js,Balance,Mizani
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please select the Company,Tafadhali chagua Kampuni
DocType: Employee Checkin,Skip Auto Attendance,Kuruka Kuhudhuria Moja kwa moja
DocType: BOM,Job Card,Kadi ya Kazi
DocType: Room,Seating Capacity,Kuweka uwezo
DocType: Issue,ISS-,ISS-
DocType: Item,Is Non GST,Sio ya GST
DocType: Lab Test Groups,Lab Test Groups,Makundi ya Majaribio ya Lab
apps/erpnext/erpnext/config/accounting.py,Profitability,Faida
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,Party Type and Party is mandatory for {0} account,Aina ya Chama na Chama ni lazima kwa akaunti ya {0}
DocType: Project,Total Expense Claim (via Expense Claims),Madai ya jumla ya gharama (kupitia madai ya gharama)
DocType: GST Settings,GST Summary,Muhtasari wa GST
apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py,Please enable default incoming account before creating Daily Work Summary Group,Tafadhali uwawezesha akaunti ya kuingia iliyoingia kabla ya kuunda Kikundi cha Muhtasari wa Kazi ya Kila siku
DocType: Assessment Result,Total Score,Jumla ya alama
DocType: Crop Cycle,ISO 8601 standard,ISO 8601 kiwango
DocType: Journal Entry,Debit Note,Kumbuka Debit
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,You can only redeem max {0} points in this order.,Unaweza tu kukomboa max {0} pointi kwa utaratibu huu.
DocType: Expense Claim,HR-EXP-.YYYY.-,HR-EXP -YYYY.-
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter API Consumer Secret,Tafadhali ingiza Siri ya Watumiaji wa API
DocType: Stock Entry,As per Stock UOM,Kama kwa Stock UOM
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js,Not Expired,Haikuzimia
DocType: Student Log,Achievement,Mafanikio
DocType: Asset,Insurer,Bima
DocType: Batch,Source Document Type,Aina ya Hati ya Chanzo
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Following course schedules were created,Kufuatia ratiba ya kozi iliundwa
DocType: Employee Onboarding,Employee Onboarding,Wafanyakazi Onboarding
DocType: Journal Entry,Total Debit,Debit Jumla
DocType: Travel Request Costing,Sponsored Amount,Kiasi kilichopatiwa
DocType: Manufacturing Settings,Default Finished Goods Warehouse,Ghala la Wafanyabiashara wa Malifadi
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Please select Patient,Tafadhali chagua Mgonjwa
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Sales Person,Mtu wa Mauzo
DocType: Hotel Room Package,Amenities,Huduma
DocType: Accounts Settings,Automatically Fetch Payment Terms,Chukua moja kwa moja Masharti ya Malipo
DocType: QuickBooks Migrator,Undeposited Funds Account,Akaunti ya Mfuko usiopuuzwa
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Njia ya malipo ya malipo ya kuruhusiwa haiwezi kuruhusiwa
DocType: Sales Invoice,Loyalty Points Redemption,Ukombozi wa Ukweli wa Ukweli
,Appointment Analytics,Uchambuzi wa Uteuzi
DocType: Lead,Blog Subscriber,Msajili wa Blog
DocType: Guardian,Alternate Number,Nambari mbadala
DocType: Assessment Plan Criteria,Maximum Score,Upeo wa alama
apps/erpnext/erpnext/config/settings.py,Create rules to restrict transactions based on values.,Unda sheria ili kuzuia shughuli kulingana na maadili.
DocType: Cash Flow Mapping Accounts,Cash Flow Mapping Accounts,Akaunti za Mapato ya Mapato ya Fedha
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py, Group Roll No,Na. ya Kikundi
DocType: Quality Goal,Revision and Revised On,Marekebisho na Marekebisho ya
DocType: Batch,Manufacturing Date,Tarehe ya Uzalishaji
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Creation Failed,Uumbaji wa Ada Imeshindwa
DocType: Opening Invoice Creation Tool,Create Missing Party,Unda Chama Chache
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Jumla ya Bajeti
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Acha tupu ikiwa unafanya makundi ya wanafunzi kwa mwaka
DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Ikiwa hunakiliwa, Jumla ya. ya siku za kazi zitajumuisha likizo, na hii itapunguza thamani ya mshahara kwa siku"
apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Kuruhusu kupokea / utoaji, sasisha &quot;Risiti zaidi ya / risiti ya Utoaji&quot; katika Mipangilio ya Hisa au Bidhaa."
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Programu za kutumia kitufe cha sasa hazitaweza kufikia, una uhakika?"
DocType: Subscription Settings,Prorate,Pendeza
DocType: Purchase Invoice,Total Advance,Jumla ya Advance
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Template Code,Badilisha Msimbo wa Kigezo
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Tarehe ya Mwisho wa Mwisho haiwezi kuwa mapema kuliko Tarehe ya Mwisho wa Mwisho. Tafadhali tengeneza tarehe na jaribu tena.
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot Count,Hesabu ya Quot
DocType: Bank Statement Transaction Entry,Bank Statement,Taarifa ya benki
DocType: Employee Benefit Claim,Max Amount Eligible,Kiasi Kikubwa kinastahili
,BOM Stock Report,Ripoti ya hisa ya BOM
DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Ikiwa hakuna nyara aliyopewa, basi mawasiliano yatashughulikiwa na kikundi hiki"
DocType: Stock Reconciliation Item,Quantity Difference,Tofauti Tofauti
DocType: Opportunity Item,Basic Rate,Kiwango cha Msingi
DocType: GL Entry,Credit Amount,Mikopo
,Electronic Invoice Register,Usajili wa ankara ya elektroniki
DocType: Cheque Print Template,Signatory Position,Hali ya Ishara
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Set as Lost,Weka kama Imepotea
DocType: Timesheet,Total Billable Hours,Masaa Yote ya Billable
DocType: Subscription,Number of days that the subscriber has to pay invoices generated by this subscription,Idadi ya siku ambazo msajili anapaswa kulipa ankara zinazozalishwa na usajili huu
DocType: Employee Benefit Application Detail,Employee Benefit Application Detail,Maelezo ya Maombi ya Faida ya Wafanyakazi
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Payment Receipt Note,Kumbuka Receipt Kumbuka
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py,This is based on transactions against this Customer. See timeline below for details,Hii inategemea shughuli za Wateja hii. Tazama kalenda ya chini kwa maelezo zaidi
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Create Material Request,Unda Ombi la Nyenzo
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"Start and end dates not in a valid Payroll Period, cannot calculate {0}","Tarehe za kuanza na kumalizika sio katika kipindi halali cha malipo, haziwezi kuhesabu {0}"
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Row {0}: Kiasi kilichowekwa {1} lazima kiwe chini au kinalingana na Kiasi cha Kuingia kwa Malipo {2}
DocType: Program Enrollment Tool,New Academic Term,Muda Mpya wa Elimu
,Course wise Assessment Report,Njia ya Ripoti ya Tathmini ya busara
DocType: Customer Feedback Template,Customer Feedback Template,Kiolezo cha Maoni ya Wateja
DocType: Purchase Invoice,Availed ITC State/UT Tax,Imepatikana ITC Jimbo / UT Kodi
DocType: Tax Rule,Tax Rule,Kanuni ya Ushuru
DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Kudumisha Kiwango Chake Katika Mzunguko wa Mauzo
apps/erpnext/erpnext/hub_node/api.py,Please login as another user to register on Marketplace,Tafadhali ingia kama mtumiaji mwingine kujiandikisha kwenye Marketplace
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Panga magogo ya wakati nje ya Masaa ya kazi ya Kazini.
apps/erpnext/erpnext/public/js/pos/pos.html,Customers in Queue,Wateja katika foleni
DocType: Driver,Issuing Date,Tarehe ya Kutuma
DocType: Procedure Prescription,Appointment Booked,Uteuzi umeandaliwa
DocType: Student,Nationality,Urithi
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure,Sanidi
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Submit this Work Order for further processing.,Tuma Order hii Kazi ya usindikaji zaidi.
,Items To Be Requested,Vitu Ili Kuombwa
DocType: Company,Allow Account Creation Against Child Company,Ruhusu Uundaji wa Akaunti dhidi ya Kampuni ya Mtoto
DocType: Company,Company Info,Maelezo ya Kampuni
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select or add new customer,Chagua au kuongeza mteja mpya
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Cost center is required to book an expense claim,Kituo cha gharama kinahitajika kuandika madai ya gharama
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Application of Funds (Assets),Matumizi ya Fedha (Mali)
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,This is based on the attendance of this Employee,Hii inategemea mahudhurio ya Waajiriwa
DocType: Payment Request,Payment Request Type,Aina ya Ombi la Malipo
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Mark Attendance,Mark Attendance
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Debit Account,Akaunti ya Debit
DocType: Fiscal Year,Year Start Date,Tarehe ya Mwanzo wa Mwaka
DocType: Additional Salary,Employee Name,Jina la Waajiriwa
DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Mgahawa wa Uagizaji wa Kuagiza
apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,{0} bank transaction(s) created and {1} errors,{0} shughuli za benki iliyoundwa na makosa ya {1}
DocType: Purchase Invoice,Rounded Total (Company Currency),Jumla ya mviringo (Fedha la Kampuni)
apps/erpnext/erpnext/accounts/doctype/account/account.py,Cannot covert to Group because Account Type is selected.,Haiwezi kufunika kwa Kundi kwa sababu Aina ya Akaunti imechaguliwa.
DocType: Quiz,Max Attempts,Majaribio ya Max
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} has been modified. Please refresh.,{0} {1} imebadilishwa. Tafadhali furahisha.
DocType: Leave Block List,Stop users from making Leave Applications on following days.,Waacha watumiaji wa kufanya Maombi ya Kuacha siku zifuatazo.
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.","Iwapo muda usio na ukomo wa Pointi ya Uaminifu, endelea Muda wa Muda Uliopita tupu au 0."
DocType: Asset Maintenance Team,Maintenance Team Members,Washirika wa Timu ya Matengenezo
DocType: Loyalty Point Entry,Purchase Amount,Ununuzi wa Kiasi
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot deliver Serial No {0} of item {1} as it is reserved \
											to fullfill Sales Order {2}",Haiwezi kutoa Serial Hapana {0} ya kipengee {1} kama imehifadhiwa \ kwa Maagizo ya Mauzo Kamili {2}
DocType: Quotation,SAL-QTN-.YYYY.-,SAL-QTN -YYYY.-
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Supplier Quotation {0} created,Nukuu ya Wafanyabiashara {0} imeundwa
apps/erpnext/erpnext/accounts/report/financial_statements.py,End Year cannot be before Start Year,Mwaka wa Mwisho hauwezi kuwa kabla ya Mwaka wa Mwanzo
DocType: Employee Benefit Application,Employee Benefits,Faida ya Waajiriwa
apps/erpnext/erpnext/projects/report/billing_summary.py,Employee ID,Kitambulisho cha mfanyakazi
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Packed quantity must equal quantity for Item {0} in row {1},Wingi uliowekwa lazima iwe sawa kiasi cha Bidhaa {0} mfululizo {1}
DocType: Work Order,Manufactured Qty,Uchina uliotengenezwa
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shares don't exist with the {0},Hifadhi haipo na {0}
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Select Difference Account,Chagua Akaunti ya Tofauti
DocType: Sales Partner Type,Sales Partner Type,Aina ya Mshirika wa Mauzo
DocType: Shopify Webhook Detail,Webhook ID,Kitambulisho cha wavuti
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Invoice Created,Invoice Iliyoundwa
DocType: Asset,Out of Order,Nje ya Utaratibu
DocType: Purchase Receipt Item,Accepted Quantity,Nambari iliyokubaliwa
DocType: Projects Settings,Ignore Workstation Time Overlap,Kupuuza Muda wa Kazi ya Ufanyika
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please set a default Holiday List for Employee {0} or Company {1},Tafadhali weka Orodha ya likizo ya default kwa Waajiriwa {0} au Kampuni {1}
apps/erpnext/erpnext/accounts/party.py,{0}: {1} does not exists,{0}: {1} haipo
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Batch Numbers,Chagua Hesabu za Batch
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To GSTIN,Kwa GSTIN
apps/erpnext/erpnext/config/accounting.py,Bills raised to Customers.,Miradi iliyotolewa kwa Wateja.
DocType: Healthcare Settings,Invoice Appointments Automatically,Uteuzi wa ankara Moja kwa moja
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Id,Id ya Mradi
DocType: Salary Component,Variable Based On Taxable Salary,Tofauti kulingana na Mshahara wa Ushuru
DocType: Company,Basic Component,Msingi wa Msingi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Row No {0}: Kiasi hawezi kuwa kikubwa kuliko Kiwango cha Kusubiri dhidi ya Madai ya Madai {1}. Kiasi kinachosubiri ni {2}
DocType: Patient Service Unit,Medical Administrator,Msimamizi wa Matibabu
DocType: Assessment Plan,Schedule,Ratiba
DocType: Account,Parent Account,Akaunti ya Mzazi
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py,Salary Structure Assignment for Employee already exists,Mgao wa Muundo wa Mshahara kwa Mfanyakazi tayari upo
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Available,Inapatikana
DocType: Quality Inspection Reading,Reading 3,Kusoma 3
DocType: Stock Entry,Source Warehouse Address,Anwani ya Ghala la Chanzo
DocType: GL Entry,Voucher Type,Aina ya Voucher
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Future Payments,Malipo ya baadaye
DocType: Amazon MWS Settings,Max Retry Limit,Upeo wa Max Retry
apps/erpnext/erpnext/accounts/page/pos/pos.js,Price List not found or disabled,Orodha ya Bei haipatikani au imezimwa
DocType: Content Activity,Last Activity ,Shughuli ya Mwisho
DocType: Student Applicant,Approved,Imekubaliwa
DocType: Pricing Rule,Price,Bei
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Employee relieved on {0} must be set as 'Left',Wafanyakazi waliondolewa kwenye {0} lazima waweke kama &#39;kushoto&#39;
DocType: Guardian,Guardian,Mlezi
apps/erpnext/erpnext/support/doctype/issue/issue.js,All communications including and above this shall be moved into the new Issue,Mawasiliano yote ikiwa ni pamoja na hapo juu itahamishwa kwenye suala jipya
DocType: Salary Detail,Tax on additional salary,Kodi ya mshahara wa ziada
DocType: Item Alternative,Item Alternative,Njia Mbadala
DocType: Healthcare Settings,Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,Akaunti za kipato cha mapato zitatumiwa kama haziwekwa katika Daktari wa Huduma za Afya ili kuchagulia mashtaka ya Uteuzi.
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Total contribution percentage should be equal to 100,Asilimia ya jumla ya michango inapaswa kuwa sawa na 100
DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,Unda mteja aliyepotea au muuzaji.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Appraisal {0} created for Employee {1} in the given date range,Tathmini {0} iliundwa kwa Mfanyakazi {1} katika kipindi cha tarehe iliyotolewa
DocType: Academic Term,Education,Elimu
DocType: Payroll Entry,Salary Slips Created,Slips za Mshahara Kuundwa
DocType: Inpatient Record,Expected Discharge,Utekelezaji uliotarajiwa
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Del,Del
DocType: Selling Settings,Campaign Naming By,Kampeni inayoitwa na
DocType: Employee,Current Address Is,Anwani ya sasa Is
apps/erpnext/erpnext/utilities/user_progress.py,Monthly Sales Target (,Lengo la Mauzo ya Mwezi (
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html,modified,ilibadilishwa
DocType: Travel Request,Identification Document Number,Nambari ya Nyaraka ya Utambulisho
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Optional. Sets company's default currency, if not specified.","Hiari. Inaweka sarafu ya msingi ya kampuni, ikiwa sio maalum."
DocType: Sales Invoice,Customer GSTIN,GSTIN ya Wateja
DocType: Crop Cycle,List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,Orodha ya magonjwa wanaona kwenye shamba. Ukichaguliwa itaongeza moja kwa moja orodha ya kazi ili kukabiliana na ugonjwa huo
apps/erpnext/erpnext/manufacturing/page/bom_comparison_tool/bom_comparison_tool.js,BOM 1,BOM 1
apps/erpnext/erpnext/assets/report/fixed_asset_register/fixed_asset_register.py,Asset Id,Kitambulisho cha mali
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js,This is a root healthcare service unit and cannot be edited.,Hii ni kitengo cha huduma ya afya ya mizizi na haiwezi kuhaririwa.
DocType: Asset Repair,Repair Status,Hali ya Ukarabati
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Requested Qty: Quantity requested for purchase, but not ordered.","Qty Iliyoulizwa: Wingi uliomba ununuliwe, lakini haujaamriwa."
,Subcontracted Item To Be Received,Bidhaa Iliyolipwa Ili Kupokelewa
apps/erpnext/erpnext/public/js/event.js,Add Sales Partners,Ongeza Washirika wa Mauzo
apps/erpnext/erpnext/config/accounting.py,Accounting journal entries.,Injili ya mwandishi wa habari.
DocType: Travel Request,Travel Request,Ombi la Kusafiri
DocType: Payment Reconciliation,System will fetch all the entries if limit value is zero.,Mfumo utachukua maingizo yote ikiwa thamani ya kikomo ni sifuri.
DocType: Delivery Note Item,Available Qty at From Warehouse,Uchina Inapatikana Kutoka Kwenye Ghala
apps/erpnext/erpnext/hr/doctype/department_approver/department_approver.py,Please select Employee Record first.,Tafadhali chagua Rekodi ya Waajiri kwanza.
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Attendance not submitted for {0} as it is a Holiday.,Mahudhurio hayajawasilishwa kwa {0} kama likizo.
DocType: POS Profile,Account for Change Amount,Akaunti ya Kiasi cha Mabadiliko
DocType: QuickBooks Migrator,Connecting to QuickBooks,Kuunganisha kwa QuickBooks
DocType: Exchange Rate Revaluation,Total Gain/Loss,Jumla ya Kupata / Kupoteza
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Pick List,Unda Orodha ya Chaguo
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Row {0}: Chama / Akaunti hailingani na {1} / {2} katika {3} {4}
DocType: Employee Promotion,Employee Promotion,Kukuza waajiriwa
DocType: Maintenance Team Member,Maintenance Team Member,Mwanachama wa Timu Mwanachama
DocType: Agriculture Analysis Criteria,Soil Analysis,Uchunguzi wa ardhi
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Course Code: ,Msimbo wa Kozi:
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please enter Expense Account,Tafadhali ingiza Akaunti ya gharama
DocType: Quality Action Resolution,Problem,Shida
DocType: Account,Stock,Stock
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Row # {0}: Aina ya Kumbukumbu ya Kumbukumbu inapaswa kuwa moja ya Utaratibu wa Ununuzi, Invoice ya Ununuzi au Ingia ya Jarida"
DocType: Employee,Current Address,Anuani ya sasa
DocType: Item,"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Ikiwa kipengee ni tofauti ya kipengee kingine basi maelezo, picha, bei, kodi nk zitawekwa kutoka template isipokuwa waziwazi"
DocType: Production Plan Item,Make Work Order for Sub Assembly Items,Tengeneza Agizo la Kazi kwa Vitu vya Bunge Kuu
DocType: Serial No,Purchase / Manufacture Details,Maelezo ya Ununuzi / Utengenezaji
DocType: Assessment Group,Assessment Group,Kundi la Tathmini
DocType: Stock Entry,Per Transferred,Kwa Kuhamishwa
apps/erpnext/erpnext/config/help.py,Batch Inventory,Orodha ya Kundi
DocType: Sales Invoice,GST Transporter ID,Kitambulisho cha GST Transporter
DocType: Procedure Prescription,Procedure Name,Jina la utaratibu
DocType: Employee,Contract End Date,Tarehe ya Mwisho wa Mkataba
DocType: Amazon MWS Settings,Seller ID,Kitambulisho cha muuzaji
DocType: Sales Order,Track this Sales Order against any Project,Fuatilia Utaratibu huu wa Mauzo dhidi ya Mradi wowote
DocType: Bank Statement Transaction Entry,Bank Statement Transaction Entry,Taarifa ya Benki Kuingia kwa Msajili
DocType: Sales Invoice Item,Discount and Margin,Punguzo na Margin
DocType: Lab Test,Prescription,Dawa
DocType: Company,Default Deferred Revenue Account,Akaunti ya Revenue iliyochaguliwa
DocType: Project,Second Email,Barua ya pili
DocType: Budget,Action if Annual Budget Exceeded on Actual,Hatua kama Bajeti ya Mwaka imeendelea juu ya kweli
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Not Available,Haipatikani
DocType: Pricing Rule,Min Qty,Nini
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Disable Template,Zima Kigezo
DocType: Bank Statement Transaction Invoice Item,Transaction Date,Tarehe ya ushirikiano
DocType: Production Plan Item,Planned Qty,Uliopita
DocType: Project Template Task,Begin On (Days),Anza (Siku)
DocType: Quality Action,Preventive,Kuzuia
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Supplies made to Unregistered Persons,Ugavi uliotolewa kwa Watu wasio sajiliwa
DocType: Company,Date of Incorporation,Tarehe ya Kuingizwa
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py,Total Tax,Jumla ya Ushuru
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Last Purchase Price,Bei ya Ununuzi ya Mwisho
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,For Quantity (Manufactured Qty) is mandatory,Kwa Wingi (Uchina uliofanywa) ni lazima
DocType: Stock Entry,Default Target Warehouse,Ghala la Ghala la Kawaida
DocType: Purchase Invoice,Net Total (Company Currency),Jumla ya Net (Kampuni ya Fedha)
DocType: Sales Invoice,Air,Air
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Tarehe ya Mwisho wa Mwaka haiwezi kuwa mapema kuliko Tarehe ya Mwanzo wa Mwaka. Tafadhali tengeneza tarehe na jaribu tena.
DocType: Purchase Order,Set Target Warehouse,Weka Ghala ya Lengo
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0} is not in Optional Holiday List,{0} sio orodha ya likizo ya hiari
DocType: Amazon MWS Settings,JP,JP
DocType: BOM,Scrap Items,Vipande vya Vipande
DocType: Work Order,Actual Start Date,Tarehe ya Kwanza ya Kuanza
DocType: Sales Order,% of materials delivered against this Sales Order,% ya vifaa vinavyotolewa dhidi ya Maagizo ya Mauzo haya
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,"Skipping Salary Structure Assignment for the following employees, as Salary Structure Assignment records already exists against them. {0}","Kuruka Muundo wa Mfumo wa Mshahara kwa waajiriwa zifuatazo, kama kumbukumbu za muundo wa muundo wa Mshahara tayari zipo dhidi yao. {0}"
apps/erpnext/erpnext/config/manufacturing.py,Generate Material Requests (MRP) and Work Orders.,Tengeneza Maombi ya Nyenzo (MRP) na Maagizo ya Kazi.
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Set default mode of payment,Weka hali ya malipo ya default
DocType: Stock Entry Detail,Against Stock Entry,Dhidi ya Kuingia kwa Hisa
DocType: Grant Application,Withdrawn,Imeondolewa
DocType: Support Search Source,Support Search Source,Kusaidia Chanzo cha Utafutaji
apps/erpnext/erpnext/accounts/report/account_balance/account_balance.js,Chargeble,Kubwa
DocType: Project,Gross Margin %,Margin ya Pato%
DocType: BOM,With Operations,Na Uendeshaji
DocType: Support Search Source,Post Route Key List,Orodha ya Njia ya Njia ya Njia
apps/erpnext/erpnext/accounts/party.py,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Uingizaji wa uhasibu umefanywa kwa fedha {0} kwa kampuni {1}. Tafadhali chagua akaunti inayolipwa au inayolipwa kwa sarafu {0}.
DocType: Asset,Is Existing Asset,"Je, kuna Malipo"
DocType: Salary Component,Statistical Component,Kipengele cha Takwimu
DocType: Warranty Claim,If different than customer address,Ikiwa tofauti na anwani ya wateja
DocType: Purchase Invoice,Without Payment of Tax,Bila Malipo ya Kodi
DocType: BOM Operation,BOM Operation,Uendeshaji wa BOM
DocType: Purchase Taxes and Charges,On Previous Row Amount,Kwenye Mshahara Uliopita
DocType: Options,Is Correct,Ni sahihi
DocType: Item,Has Expiry Date,Ina Tarehe ya Muda
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Transfer Asset,Weka Malipo
apps/erpnext/erpnext/config/support.py,Issue Type.,Aina ya Toleo.
DocType: POS Profile,POS Profile,Profaili ya POS
DocType: Training Event,Event Name,Jina la Tukio
DocType: Healthcare Practitioner,Phone (Office),Simu (Ofisi)
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,"Cannot Submit, Employees left to mark attendance","Haiwezi Kuwasilisha, Wafanyakazi wameachwa kuashiria washiriki"
DocType: Inpatient Record,Admission,Uingizaji
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,Admissions for {0},Kukubali kwa {0}
DocType: Shift Type,Last Known Successful Sync of Employee Checkin. Reset this only if you are sure that all Logs are synced from all the locations. Please don't modify this if you are unsure.,Usawazishaji uliofanikiwa wa mwisho wa Checkin ya Mfanyakazi. Rudisha hii tu ikiwa una uhakika kuwa kumbukumbu zote zimesawazishwa kutoka kwa maeneo yote. Tafadhali usibadilishe hii ikiwa hauna uhakika.
apps/erpnext/erpnext/config/accounting.py,"Seasonality for setting budgets, targets etc.","Msimu wa kuweka bajeti, malengo nk."
apps/erpnext/erpnext/www/all-products/index.html,No values,Hakuna maadili
DocType: Supplier Scorecard Scoring Variable,Variable Name,Jina linalofautiana
apps/erpnext/erpnext/stock/get_item_details.py,"Item {0} is a template, please select one of its variants","Kipengee {0} ni template, tafadhali chagua moja ya vipengele vyake"
DocType: Purchase Invoice Item,Deferred Expense,Gharama zilizochaguliwa
apps/erpnext/erpnext/public/js/hub/pages/Messages.vue,Back to Messages,Rudi kwa Ujumbe
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py,From Date {0} cannot be before employee's joining Date {1},Kutoka tarehe {0} haiwezi kuwa kabla ya tarehe ya kujiunga na mfanyakazi {1}
DocType: Asset,Asset Category,Jamii ya Mali
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Net pay cannot be negative,Mshahara wa Net hauwezi kuwa hasi
DocType: Purchase Order,Advance Paid,Ilipwa kulipwa
DocType: Manufacturing Settings,Overproduction Percentage For Sales Order,Asilimia ya upungufu kwa Uagizaji wa Mauzo
DocType: Item Group,Item Tax,Kodi ya Item
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Material to Supplier,Nyenzo kwa Wafanyabiashara
DocType: Soil Texture,Loamy Sand,Loamy Sand
,Lost Opportunity,Fursa Iliyopotea
DocType: Accounts Settings,Determine Address Tax Category From,Amua Jamii ya Ushuru ya anwani
DocType: Production Plan,Material Request Planning,Mipango ya Kuomba Nyenzo
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Excise Invoice,Ankara ya ushuru
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Treshold {0}% appears more than once,Kizuizi {0}% kinaonekana zaidi ya mara moja
DocType: Expense Claim,Employees Email Id,Waajiri Barua Id
DocType: Employee Attendance Tool,Marked Attendance,Kuhudhuria Msajili
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Current Liabilities,Madeni ya sasa
apps/erpnext/erpnext/public/js/projects/timer.js,Timer exceeded the given hours.,Muda ulizidi masaa uliyopewa.
apps/erpnext/erpnext/config/crm.py,Send mass SMS to your contacts,Tuma SMS ya wingi kwa anwani zako
DocType: Inpatient Record,A Positive,Chanya
DocType: Program,Program Name,Jina la Programu
DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Fikiria kodi au malipo kwa
DocType: Driver,Driving License Category,Jamii ya Leseni ya Kuendesha
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Actual Qty is mandatory,Uhakika halisi ni lazima
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.","{0} kwa sasa ina {1} Wafanyabiashara Scorecard amesimama, na Amri ya Ununuzi kwa mtoa huduma hii inapaswa kutolewa."
DocType: Asset Maintenance Team,Asset Maintenance Team,Timu ya Matengenezo ya Mali
apps/erpnext/erpnext/setup/default_success_action.py,{0} has been submitted successfully,{0} imewasilishwa kwa mafanikio
DocType: Loan,Loan Type,Aina ya Mikopo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Credit Card,Kadi ya Mikopo
DocType: Quality Goal,Quality Goal,Lengo la ubora
DocType: BOM,Item to be manufactured or repacked,Kipengee cha kutengenezwa au kupakiwa
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Syntax error in condition: {0},Hitilafu ya Syntax kwa hali: {0}
DocType: Fee Structure,EDU-FST-.YYYY.-,EDU-FST -YYYY.-
DocType: Employee Education,Major/Optional Subjects,Majukumu makubwa / Chaguo
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please Set Supplier Group in Buying Settings.,Tafadhali Weka Kikundi cha Wasambazaji katika Mipangilio ya Ununuzi.
DocType: Sales Invoice Item,Drop Ship,Turua Utoaji
DocType: Driver,Suspended,Imesimamishwa
DocType: Training Event,Attendees,Waliohudhuria
DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Hapa unaweza kudumisha maelezo ya familia kama jina na kazi ya mzazi, mke na watoto"
DocType: Academic Term,Term End Date,Tarehe ya Mwisho wa Mwisho
DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Kodi na Malipo yamefutwa (Fedha la Kampuni)
DocType: Item Group,General Settings,Mazingira ya Jumla
DocType: Article,Article,Kifungu
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Kutoka kwa Fedha na Fedha haiwezi kuwa sawa
DocType: Taxable Salary Slab,Percent Deduction,Kupunguza kwa asilimia
DocType: GL Entry,To Rename,Kubadilisha jina
DocType: Stock Entry,Repack,Piga
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select to add Serial Number.,Chagua kuongeza Nambari ya serial.
apps/erpnext/erpnext/regional/italy/utils.py,Please set Fiscal Code for the customer '%s',Tafadhali weka Nambari ya Fedha kwa wateja &#39;%&#39;
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select the Company first,Tafadhali chagua Kampuni kwanza
DocType: Item Attribute,Numeric Values,Vigezo vya Hesabu
apps/erpnext/erpnext/public/js/setup_wizard.js,Attach Logo,Ambatisha Alama
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Stock Levels,Ngazi za hisa
DocType: Customer,Commission Rate,Kiwango cha Tume
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Successfully created payment entries,Imeingia vyeo vya malipo ya ufanisi
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Created {0} scorecards for {1} between: ,Iliunda {0} alama za alama kwa {1} kati ya:
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.py,Not permitted. Please disable the Procedure Template,Hairuhusiwi. Tafadhali Lemaza Kiolezo cha Utaratibu
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,"Payment Type must be one of Receive, Pay and Internal Transfer","Aina ya Malipo lazima iwe moja ya Kupokea, Kulipa na Uhamisho wa Ndani"
DocType: Travel Itinerary,Preferred Area for Lodging,Eneo Lolote la Kuingia
apps/erpnext/erpnext/config/agriculture.py,Analytics,Analytics
DocType: Salary Detail,Additional Amount,Kiasi cha ziada
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html,Cart is Empty,Cart ni tupu
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Item {0} has no Serial No. Only serilialized items \
						can have delivery based on Serial No",Kipengee {0} hazina vitu vya Serial No tu pekee \ vinaweza kuwa na utoaji kulingana na Serial No
DocType: Vehicle,Model,Mfano
DocType: Work Order,Actual Operating Cost,Gharama halisi ya uendeshaji
DocType: Payment Entry,Cheque/Reference No,Angalia / Kumbukumbu Hapana
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Fetch based on FIFO,Pakua kwa msingi wa FIFO
DocType: Soil Texture,Clay Loam,Clay Loam
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root cannot be edited.,Mizizi haiwezi kuhaririwa.
DocType: Item,Units of Measure,Units of Measure
DocType: Employee Tax Exemption Declaration,Rented in Metro City,Ilipatikana katika Metro City
DocType: Supplier,Default Tax Withholding Config,Mpangilio wa Kuzuia Ushuru wa Kutoka
DocType: Manufacturing Settings,Allow Production on Holidays,Ruhusu Uzalishaji kwenye Likizo
DocType: Sales Invoice,Customer's Purchase Order Date,Tarehe ya Utunzaji wa Wateja
DocType: Production Plan,MFG-PP-.YYYY.-,MFG-PP-YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Capital Stock,Capital Stock
DocType: Asset,Default Finance Book,Kitabu cha Fedha cha Default
DocType: Shopping Cart Settings,Show Public Attachments,Onyesha Viambatisho vya Umma
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js,Edit Publishing Details,Hariri Maelezo ya Uchapishaji
DocType: Packing Slip,Package Weight Details,Maelezo ya Ufuatiliaji wa Pakiti
DocType: Leave Type,Is Compensatory,Ni fidia
DocType: Restaurant Reservation,Reservation Time,Muda wa Uhifadhi
DocType: Payment Gateway Account,Payment Gateway Account,Akaunti ya Gateway ya Malipo
DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Baada ya kukamilika kwa malipo kulirejesha mtumiaji kwenye ukurasa uliochaguliwa.
DocType: Company,Existing Company,Kampuni iliyopo
DocType: Healthcare Settings,Result Emailed,Matokeo yamefunuliwa
DocType: Item Tax Template Detail,Item Tax Template Detail,Maelezo ya Kiolezo cha Kodi
apps/erpnext/erpnext/controllers/buying_controller.py,"Tax Category has been changed to ""Total"" because all the Items are non-stock items",Jamii ya Kodi imebadilishwa kuwa &quot;Jumla&quot; kwa sababu Vitu vyote si vitu vya hisa
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,To date can not be equal or less than from date,Hadi sasa haiwezi kuwa sawa au chini kuliko tarehe
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Nothing to change,Hakuna mabadiliko
apps/erpnext/erpnext/crm/doctype/lead/lead.py,A Lead requires either a person's name or an organization's name,Kiongozi inahitaji jina la mtu au jina la shirika
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please select a csv file,Tafadhali chagua faili ya csv
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Error in some rows,Kosa katika safu zingine
DocType: Holiday List,Total Holidays,Jumla ya Likizo
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Missing email template for dispatch. Please set one in Delivery Settings.,Halafu ya template ya barua pepe ya kupeleka. Tafadhali weka moja kwenye Mipangilio ya Utoaji.
DocType: Student Leave Application,Mark as Present,Mark kama sasa
DocType: Supplier Scorecard,Indicator Color,Rangi ya Kiashiria
DocType: Purchase Order,To Receive and Bill,Kupokea na Bill
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Reqd by Date cannot be before Transaction Date,Row # {0}: Reqd kwa tarehe haiwezi kuwa kabla ya Tarehe ya Ushirika
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Select Serial No,Chagua Serial No
DocType: Pricing Rule,Is Cumulative,Inakua
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Designer,Muumbaji
apps/erpnext/erpnext/config/buying.py,Terms and Conditions Template,Masharti na Masharti Kigezo
DocType: Delivery Trip,Delivery Details,Maelezo ya utoaji
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js,Please fill in all the details to generate Assessment Result.,Tafadhali jaza maelezo yote ili kutoa Matokeo ya Tathmini.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Cost Center is required in row {0} in Taxes table for type {1},Kituo cha gharama kinahitajika kwenye mstari {0} katika meza ya kodi kwa aina {1}
DocType: Terms and Conditions,Terms and Conditions Help,Masharti na Masharti Msaada
,Item-wise Purchase Register,Rejista ya Ununuzi wa hekima
DocType: Loyalty Point Entry,Expiry Date,Tarehe ya mwisho wa matumizi
DocType: Healthcare Settings,Employee name and designation in print,Jina la mfanyakazi na sifa katika kuchapishwa
apps/erpnext/erpnext/config/buying.py,Supplier Addresses and Contacts,Anwani za Wasambazaji na Anwani
,accounts-browser,mshambuliaji wa akaunti
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Please select Category first,Tafadhali chagua Jamii kwanza
apps/erpnext/erpnext/config/projects.py,Project master.,Mradi wa mradi.
DocType: Contract,Contract Terms,Masharti ya Mkataba
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Continue Configuration,Endelea Usanidi
DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Uonyeshe alama yoyote kama $ nk karibu na sarafu.
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Maximum benefit amount of component {0} exceeds {1},Ufikiaji wa kiwango kikubwa cha sehemu {0} unazidi {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py, (Half Day),Nusu Siku
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Process Master Data,Takwimu za Mchakato
DocType: Payment Term,Credit Days,Siku za Mikopo
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Please select Patient to get Lab Tests,Tafadhali chagua Mgonjwa kupata Majaribio ya Lab
DocType: Exotel Settings,Exotel Settings,Mipangilio ya Exotel
DocType: Leave Ledger Entry,Is Carry Forward,Inaendelea mbele
DocType: Shift Type,Working hours below which Absent is marked. (Zero to disable),Kufanya kazi masaa chini ambayo Yaliyo alama ni alama. (Zero ya kuzima)
apps/erpnext/erpnext/public/js/hub/pages/Item.vue,Send a message,Tuma ujumbe
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Get Items from BOM,Pata Vitu kutoka kwa BOM
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Lead Time Days,Siku za Kiongozi
DocType: Cash Flow Mapping,Is Income Tax Expense,"Je, gharama ya Kodi ya Mapato"
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py,Your order is out for delivery!,Amri yako ni nje ya utoaji!
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Row # {0}: Tarehe ya Kuweka lazima iwe sawa na tarehe ya ununuzi {1} ya mali {2}
DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,Angalia hii ikiwa Mwanafunzi anaishi katika Hosteli ya Taasisi.
DocType: Course,Hero Image,Picha ya shujaa
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Sales Orders in the above table,Tafadhali ingiza Amri za Mauzo kwenye jedwali hapo juu
,Stock Summary,Summary Stock
apps/erpnext/erpnext/config/assets.py,Transfer an asset from one warehouse to another,Tumia mali kutoka kwa ghala moja hadi nyingine
DocType: Vehicle,Petrol,Petroli
DocType: Employee Benefit Application,Remaining Benefits (Yearly),Faida iliyobaki (kwa mwaka)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Bill of Materials,Sheria ya Vifaa
DocType: Shift Type,The time after the shift start time when check-in is considered as late (in minutes).,Wakati baada ya kuanza kwa wakati wa kuanza wakati kuingia-inazingatiwa kama marehemu (kwa dakika).
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Row {0}: Aina ya Chama na Chama inahitajika kwa Akaunti ya Kupokea / Kulipa {1}
DocType: Employee,Leave Policy,Acha Sera
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Update Items,Vipengele vya Mwisho
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Ref Date,Tarehe ya Marehemu
DocType: Employee,Reason for Leaving,Sababu ya Kuacha
apps/erpnext/erpnext/public/js/call_popup/call_popup.js,View call log,Angalia logi ya simu
DocType: BOM Operation,Operating Cost(Company Currency),Gharama za Uendeshaji (Fedha la Kampuni)
DocType: Loan Application,Rate of Interest,Kiwango cha Maslahi
DocType: Expense Claim Detail,Sanctioned Amount,Kizuizi
DocType: Item,Shelf Life In Days,Uhai wa Shelf Katika Siku
DocType: GL Entry,Is Opening,Inafungua
DocType: Department,Expense Approvers,Vidokezo vya gharama
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Debit entry can not be linked with a {1},Row {0}: Uingizaji wa malipo hauwezi kuunganishwa na {1}
DocType: Journal Entry,Subscription Section,Sehemu ya Usajili
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0} does not exist,Akaunti {0} haipo
DocType: Training Event,Training Program,Programu ya Mafunzo
DocType: Account,Cash,Fedha
DocType: Sales Invoice,Unpaid and Discounted,Iliyolipwa na Imepunguzwa
DocType: Employee,Short biography for website and other publications.,Wasifu mfupi wa tovuti na machapisho mengine.
