DocType: Employee,Salary Mode,Njia ya Mshahara
DocType: Patient,Divorced,Talaka
DocType: Buying Settings,Allow Item to be added multiple times in a transaction,Ruhusu Item kuongezwa mara nyingi katika shughuli
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,Futa Ziara ya Nyenzo {0} kabla ya kufuta madai ya Waranti
apps/erpnext/erpnext/config/education.py +118,Assessment Reports,Ripoti za Tathmini
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19,Consumer Products,Bidhaa za Watumiaji
DocType: Purchase Receipt,Subscription Detail,Maelezo ya usajili
DocType: Supplier Scorecard,Notify Supplier,Arifaza Wasambazaji
DocType: Item,Customer Items,Vitu vya Wateja
DocType: Project,Costing and Billing,Gharama na Ulipaji
apps/erpnext/erpnext/accounts/doctype/account/account.py +48,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/config/setup.py +88,Email Notifications,Arifa za Barua pepe
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26,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: Employee,Leave Approvers,Acha vibali
DocType: Sales Partner,Dealer,Muzaji
DocType: Work Order,WO-,WO-
DocType: Consultation,Investigations,Uchunguzi
DocType: Restaurant Order Entry,Click Enter To Add,Bonyeza Ingia Kuongeza
DocType: Employee,Rented,Ilipangwa
DocType: Purchase Order,PO-,PO-
DocType: Vehicle Service,Mileage,Mileage
apps/erpnext/erpnext/assets/doctype/asset/asset.js +253,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 +44,Select Default Supplier,Chagua Mtoa Default
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37,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: Purchase Order,Customer Contact,Mawasiliano ya Wateja
DocType: Patient Appointment,Check availability,Angalia upatikanaji
DocType: Job Applicant,Job Applicant,Mwombaji wa Ayubu
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6,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
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120,Legal,Kisheria
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191,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: Bank Guarantee,Customer,Wateja
DocType: Purchase Receipt Item,Required By,Inahitajika
DocType: Delivery Note,Return Against Delivery Note,Kurudi dhidi ya Kumbuka utoaji
DocType: Purchase Order,% Billed,Imelipwa
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43,Exchange Rate must be same as {0} {1} ({2}),Kiwango cha Exchange lazima iwe sawa na {0} {1} ({2})
DocType: Sales Invoice,Customer Name,Jina la Wateja
DocType: Vehicle,Natural Gas,Gesi ya asili
apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64,Bank account cannot be named as {0},Akaunti ya benki haiwezi kuitwa jina la {0}
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 +196,Outstanding for {0} cannot be less than zero ({1}),Bora kwa {0} haiwezi kuwa chini ya sifuri ({1})
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +348,There are no submitted Salary Slips to process.,Hakuna Slips za Mshahara zilizosajiliwa.
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 +62,Show open,Onyesha wazi
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8,It is necessary to take this action today itself for the above mentioned recurring,Ni muhimu kuchukua hatua hii leo yenyewe kwa mara kwa mara iliyotajwa hapo juu
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +156,Series Updated Successfully,Mfululizo umehifadhiwa kwa ufanisi
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6,Checkout,Angalia
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/projects/doctype/project/project.py +75,Expected End Date can not be less than Expected Start Date,Tarehe ya Mwisho Inayotarajiwa haiwezi kuwa chini ya Tarehe ya Mwanzo Iliyotarajiwa
apps/erpnext/erpnext/utilities/transaction_base.py +121,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Row # {0}: Kiwango lazima kiwe sawa na {1}: {2} ({3} / {4})
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +241,New Leave Application,Maombi Mpya ya Kuacha
,Batch Item Expiry Status,Kipengee cha Muhtasari wa Kipengee Hali
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184,Bank Draft,Rasimu ya Benki
DocType: Membership,membership validaty section,uanachama wa validaty sehemu
DocType: Mode of Payment Account,Mode of Payment Account,Akaunti ya Akaunti ya Malipo
DocType: Consultation,Consultation,Ushauri
DocType: Accounts Settings,Show Payment Schedule in Print,Onyesha Ratiba ya Malipo katika Chapisha
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19,Sales and Returns,Mauzo na Kurudi
apps/erpnext/erpnext/stock/doctype/item/item.js +56,Show Variants,Onyesha Mabadiliko
DocType: Academic Term,Academic Term,Muda wa Elimu
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,Nyenzo
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66,Making website,Kufanya tovuti
DocType: Opening Invoice Creation Tool Item,Quantity,Wingi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546,Accounts table cannot be blank.,Jedwali la Akaunti hawezi kuwa tupu.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154,Loans (Liabilities),Mikopo (Madeni)
DocType: Employee Education,Year of Passing,Mwaka wa Kupitisha
DocType: Item,Country of Origin,Nchi ya asili
DocType: Soil Texture,Soil Texture Criteria,Vigezo vya Maandishi ya Udongo
apps/erpnext/erpnext/templates/includes/product_page.js +25,In Stock,Katika Stock
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16,Primary Contact Details,Maelezo ya Mawasiliano ya Msingi
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46,Open Issues,Masuala ya Fungua
DocType: Production Plan Item,Production Plan Item,Kipengee cha Mpango wa Uzalishaji
apps/erpnext/erpnext/hr/doctype/employee/employee.py +150,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/setup/setup_wizard/data/industry_type.py +31,Health Care,Huduma ya afya
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,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: Lab Prescription,Lab Prescription,Dawa ya Dawa
,Delay Days,Siku za kuchelewa
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26,Service Expense,Gharama za Huduma
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +899,Serial Number: {0} is already referenced in Sales Invoice: {1},Nambari ya Serial: {0} tayari imeelezea katika Invoice ya Mauzo: {1}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +889,Invoice,Invoice
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 +21,Fiscal Year {0} is required,Mwaka wa Fedha {0} inahitajika
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/setup/setup_wizard/data/industry_type.py +21,Defense,Ulinzi
DocType: Salary Component,Abbr,Abbr
DocType: Appraisal Goal,Score (0-5),Score (0-5)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +225,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 +77,Row # {0}:,Row # {0}:
DocType: Timesheet,Total Costing Amount,Kiasi cha jumla ya gharama
DocType: Delivery Note,Vehicle No,Hakuna Gari
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +163,Please select Price List,Tafadhali chagua Orodha ya Bei
DocType: Accounts Settings,Currency Exchange Settings,Mipangilio ya Kubadilisha Fedha
apps/erpnext/erpnext/public/js/hub/hub_factory.js +61,Please check your network connection.,Tafadhali angalia uunganisho wako wa mtandao.
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +94,Row #{0}: Payment document is required to complete the trasaction,Row # {0}: Hati ya kulipa inahitajika ili kukamilisha shughuli
DocType: Work Order Operation,Work In Progress,Kazi inaendelea
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13,Please select date,Tafadhali chagua tarehe
DocType: Daily Work Summary Group,Holiday List,Orodha ya likizo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127,Accountant,Mhasibu
DocType: Hub Settings,Selling Price List,Orodha ya Bei ya Kuuza
DocType: Patient,Tobacco Current Use,Tabibu Matumizi ya Sasa
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +56,Selling Rate,Kiwango cha Mauzo
DocType: Cost Center,Stock User,Mtumiaji wa hisa
DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
DocType: Company,Phone No,No Simu
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +239,New {0}: #{1},Mpya {0}: # {1}
DocType: Delivery Trip,Initial Email Notification Sent,Arifa ya awali ya barua pepe iliyotumwa
,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 +46,Abbreviation cannot have more than 5 characters,Hali haiwezi kuwa na wahusika zaidi ya 5
DocType: Physician Schedule Time Slot,Physician Schedule Time Slot,Ratiba ya Ratiba ya Muda Wakati
DocType: Payment Request,Payment Request,Ombi la Malipo
DocType: Asset,Value After Depreciation,Thamani Baada ya kushuka kwa thamani
DocType: Student,O+,O +
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan_dashboard.py +8,Related,Kuhusiana
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43,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: Subscription,Repeat on Day,Rudia Siku
apps/erpnext/erpnext/accounts/doctype/account/account.js +37,This is a root account and cannot be edited.,Hii ni akaunti ya mizizi na haiwezi kuhaririwa.
DocType: Sales Invoice,Company Address,Anwani ya Kampuni
DocType: BOM,Operations,Uendeshaji
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38,Cannot set authorization on basis of Discount for {0},Haiwezi kuweka idhini kulingana na Punguzo la {0}
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/accounts/utils.py +73,{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 +69,"Reference: {0}, Item Code: {1} and Customer: {2}","Rejea: {0}, Msimbo wa Item: {1} na Wateja: {2}"
apps/erpnext/erpnext/utilities/user_progress.py +146,Kg,Kilo
apps/erpnext/erpnext/config/hr.py +45,Opening for a Job.,Kufungua kwa Kazi.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +114,BOM is not specified for subcontracting item {0} at row {1},BOM haijainishwa kwa kipengee cha kutenganisha {0} katika mfululizo {1}
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149,{0} Result submittted,Matokeo ya {0} yaliyotolewa
DocType: Item Attribute,Increment,Uingizaji
apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +74,Timespan,Timespan
apps/erpnext/erpnext/public/js/stock_analytics.js +58,Select Warehouse...,Chagua Warehouse ...
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6,Advertising,Matangazo
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22,Same Company is entered more than once,Kampuni sawa imeingia zaidi ya mara moja
DocType: Patient,Married,Ndoa
apps/erpnext/erpnext/accounts/party.py +41,Not permitted for {0},Hairuhusiwi kwa {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593,Get items from,Pata vitu kutoka
DocType: Price List,Price Not UOM Dependant,Bei Si UOM Inategemea
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +467,Stock cannot be updated against Delivery Note {0},Hifadhi haiwezi kurekebishwa dhidi ya Kumbuka Utoaji {0}
apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},Bidhaa {0}
apps/erpnext/erpnext/templates/generators/item_group.html +43,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 +30,Grocery,Kula
DocType: Quality Inspection Reading,Reading 1,Kusoma 1
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40,Pension Funds,Mfuko wa Pensheni
apps/erpnext/erpnext/assets/doctype/asset/asset.py +91,Next Depreciation Date cannot be before Purchase Date,Tarehe ya Uzito ya pili haiwezi kuwa kabla ya Tarehe ya Ununuzi
DocType: Crop,Perennial,Kudumu
DocType: Consultation,Consultation Date,Tarehe ya Ushauri
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 +1753,Not items found,Si vitu vilivyopatikana
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +184,Salary Structure Missing,Mfumo wa Mshahara Ukosefu
DocType: Lead,Person Name,Jina la Mtu
DocType: Sales Invoice Item,Sales Invoice Item,Bidhaa Invoice Bidhaa
DocType: Account,Credit,Mikopo
DocType: POS Profile,Write Off Cost Center,Andika Kituo cha Gharama
apps/erpnext/erpnext/public/js/setup_wizard.js +117,"e.g. ""Primary School"" or ""University""",mfano &quot;Shule ya Msingi&quot; au &quot;Chuo Kikuu&quot;
apps/erpnext/erpnext/config/stock.py +28,Stock Reports,Ripoti za hisa
DocType: Warehouse,Warehouse Detail,Maelezo ya Ghala
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +33,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 +269,"""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
apps/erpnext/erpnext/controllers/taxes_and_totals.py +581,Taxable Amount,Kiwango cha Ushuru
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160,You are not authorized to add or update entries before {0},Huna mamlaka ya kuongeza au kusasisha safu kabla ya {0}
DocType: BOM,Item Image (if not slideshow),Image Image (kama si slideshow)
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 +1103,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 +975,Select BOM,Chagua BOM
DocType: SMS Log,SMS Log,Ingia ya SMS
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Gharama ya Vitu Vilivyotolewa
apps/erpnext/erpnext/config/hr.py +127,Manage advance amount given to the Employee,Dhibiti kiasi cha mapema kilichopewa Waajiriwa
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38,The holiday on {0} is not between From Date and To Date,Likizo ya {0} si kati ya Tarehe na Tarehe
DocType: Student Log,Student Log,Ingia ya Wanafunzi
apps/erpnext/erpnext/config/buying.py +165,Templates of supplier standings.,Matukio ya kusimama kwa wasambazaji.
DocType: Lead,Interested,Inastahili
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +216,Opening,Ufunguzi
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +32,From {0} to {1},Kutoka {0} hadi {1}
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +234,Program: ,Programu:
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50,Failed to setup taxes,Imeshindwa kuanzisha kodi
DocType: Item,Copy From Item Group,Nakala Kutoka Kundi la Bidhaa
DocType: Delivery Trip,Delivery Notification,Arifa ya utoaji
DocType: Journal Entry,Opening Entry,Kuingia Uingiaji
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25,Account Pay Only,Malipo ya Akaunti tu
DocType: Employee Loan,Repay Over Number of Periods,Rejesha Zaidi ya Kipindi cha Kipindi
DocType: Stock Entry,Additional Costs,Gharama za ziada
apps/erpnext/erpnext/accounts/doctype/account/account.py +138,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 +35,No leave record found for employee {0} for {1},Hakuna rekodi ya kuondoka iliyopatikana kwa mfanyakazi {0} kwa {1}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23,Please enter company first,Tafadhali ingiza kampuni kwanza
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +365,Please select Company first,Tafadhali chagua Kampuni kwanza
DocType: Employee Education,Under Graduate,Chini ya Uhitimu
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27,Target On,Target On
DocType: BOM,Total Cost,Gharama ya jumla
DocType: Soil Analysis,Ca/K,Ca / K
DocType: Journal Entry Account,Employee Loan,Mkopo wa Wafanyakazi
DocType: Fee Schedule,Send Payment Request Email,Tuma Email Request Request
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +268,Item {0} does not exist in the system or has expired,Item {0} haipo katika mfumo au imeisha muda
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44,Real Estate,Real Estate
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,Taarifa ya Akaunti
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41,Pharmaceuticals,Madawa
DocType: Purchase Invoice Item,Is Fixed Asset,"Je, ni Mali isiyohamishika"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +313,"Available qty is {0}, you need {1}","Inapatikana qty ni {0}, unahitaji {1}"
DocType: Expense Claim Detail,Claim Amount,Tumia Kiasi
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +679,Work Order has been {0},Kazi ya Kazi imekuwa {0}
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56,Duplicate customer group found in the cutomer group table,Duplicate kundi la mteja kupatikana katika meza cutomer kundi
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31,Supplier Type / Supplier,Aina ya Wasambazaji / Wasambazaji
DocType: Naming Series,Prefix,Kiambatisho
apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7,Event Location,Eneo la Tukio
DocType: Asset Settings,Asset Settings,Mipangilio ya Mali
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68,Consumable,Inatumiwa
DocType: Student,B-,B-
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +140,Successfully unregistered.,Imefanikiwa bila usajili.
DocType: Assessment Result,Grade,Daraja
DocType: Restaurant Table,No of Seats,Hakuna Viti
DocType: Subscription,"To add dynamic subject, use jinja tags like

<div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>","Ili kuongeza somo la nguvu, tumia tags za jinja kama <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>"
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 +232,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 +392,{0} {1} is frozen,{0} {1} imehifadhiwa
apps/erpnext/erpnext/setup/doctype/company/company.py +140,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.py +80,Stock Expenses,Gharama za Hifadhi
apps/erpnext/erpnext/stock/doctype/batch/batch.js +111,Select Target Warehouse,Chagua Ghala la Target
apps/erpnext/erpnext/hr/doctype/employee/employee.js +80,Please enter Preferred Contact Email,Tafadhali ingiza barua pepe ya Mawasiliano ya Preferred
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45,CompAuxNum,CompAuxNum
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 +135,"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 +350,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: Request for Quotation,RFQ-,RFQ-
DocType: Item,Supply Raw Materials for Purchase,Vifaa vya Raw kwa Ununuzi
DocType: Agriculture Analysis Criteria,Fertilizer,Mbolea
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +152,At least one mode of payment is required for POS invoice.,Angalau mode moja ya malipo inahitajika kwa ankara za POS.
DocType: Products Settings,Show Products as a List,Onyesha Bidhaa kama Orodha
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +574,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 +190,Example: Basic Mathematics,Mfano: Msabati Msingi
DocType: Customer,Primary Address,Anwani ya Msingi
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 +802,"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/hr.py +223,Settings for HR Module,Mipangilio ya Moduli ya HR
DocType: SMS Center,SMS Center,Kituo cha SMS
DocType: Sales Invoice,Change Amount,Badilisha kiasi
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/accounts/report/sales_payment_summary/sales_payment_summary.js +36,Show only POS,Onyesha POS tu
DocType: Driver,Driving License Categories,Makundi ya leseni ya kuendesha gari
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118,Please enter Delivery Date,Tafadhali ingiza tarehe ya utoaji
DocType: Depreciation Schedule,Make Depreciation Entry,Fanya kuingia kwa kushuka kwa thamani
DocType: Appraisal Template Goal,KRA,KRA
DocType: Lead,Request Type,Aina ya Ombi
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +17,Make Employee,Fanya Waajiriwa
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14,Broadcasting,Matangazo
apps/erpnext/erpnext/config/accounts.py +313,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 +191,Execution,Utekelezaji
apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Maelezo ya shughuli zilizofanywa.
DocType: Asset Maintenance Log,Maintenance Status,Hali ya Matengenezo
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10,Membership Details,Maelezo ya Uanachama
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Muuzaji inahitajika dhidi ya akaunti inayolipwa {2}
apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,Vitu na bei
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2,Total hours: {0},Masaa yote: {0}
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,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: Drug Prescription,Interval,Muda
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +253,Preference,Upendeleo
DocType: Grant Application,Individual,Kila mtu
DocType: Academic Term,Academics User,Mwanafunzi wa Wasomi
DocType: Cheque Print Template,Amount In Figure,Kiasi Kielelezo
DocType: Employee Loan Application,Loan Info,Info Loan
apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,Mpango wa ziara za matengenezo.
DocType: Supplier Scorecard Period,Supplier Scorecard Period,Kipindi cha Scorecard Kipindi
DocType: Share Transfer,Share Transfer,Shiriki Uhamisho
DocType: POS Profile,Customer Groups,Vikundi vya Wateja
apps/erpnext/erpnext/public/js/financial_statements.js +51,Financial Statements,Taarifa za Fedha
DocType: Guardian,Students,Wanafunzi
apps/erpnext/erpnext/config/selling.py +91,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: Physician Schedule,Time Slots,Muda wa Muda
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,Orodha ya Bei lazima iwezekanavyo kwa Ununuzi au Ununuzi
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79,Installation date cannot be before delivery date for Item {0},Tarehe ya usanii haiwezi kuwa kabla ya tarehe ya utoaji wa Bidhaa {0}
DocType: Pricing Rule,Discount on Price List Rate (%),Punguzo kwa Orodha ya Bei Kiwango (%)
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112,Item Template,Kigezo cha Kigezo
apps/erpnext/erpnext/healthcare/setup.py +215,Biochemistry,Biochemistry
DocType: Job Offer,Select Terms and Conditions,Chagua Masharti na Masharti
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72,Out Value,Thamani ya nje
DocType: Woocommerce Settings,Woocommerce Settings,Mipangilio ya Woocommerce
DocType: Production Plan,Sales Orders,Maagizo ya Mauzo
DocType: Purchase Taxes and Charges,Valuation,Vigezo
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +394,Set as Default,Weka kama Msingi
DocType: Production Plan,PLN-,PLN-
,Purchase Order Trends,Mwelekeo wa Utaratibu wa Ununuzi
apps/erpnext/erpnext/utilities/user_progress.py +78,Go to Customers,Nenda kwa Wateja
DocType: Hotel Room Reservation,Late Checkin,Checkin ya muda mfupi
apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7,The request for quotation can be accessed by clicking on the following link,Ombi la nukuu inaweza kupatikana kwa kubonyeza kiungo kinachofuata
apps/erpnext/erpnext/config/hr.py +81,Allocate leaves for the year.,Shirikisha majani kwa mwaka.
DocType: SG Creation Tool Course,SG Creation Tool Course,Njia ya Uumbaji wa SG
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +315,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 Guarantee,Bank Account,Akaunti ya benki
DocType: Leave Type,Allow Negative Balance,Ruhusu Kiwango cha Mizani
apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13,You cannot delete Project Type 'External',Huwezi kufuta Aina ya Mradi &#39;Nje&#39;
apps/erpnext/erpnext/public/js/utils.js +194,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 +53,Television,Televisheni
DocType: Work Order Operation,Updated via 'Time Log',Imesasishwa kupitia &#39;Ingia ya Muda&#39;
apps/erpnext/erpnext/controllers/taxes_and_totals.py +430,Advance amount cannot be greater than {0} {1},Kiasi cha juu hawezi kuwa kikubwa kuliko {0} {1}
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42,JournalCode,JournalCode
DocType: Naming Series,Series List for this Transaction,Orodha ya Mfululizo kwa Shughuli hii
DocType: Company,Enable Perpetual Inventory,Wezesha Mali ya daima
DocType: Company,Default Payroll Payable Account,Akaunti ya malipo ya malipo ya malipo
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51,Update Email Group,Sasisha Kikundi cha Barua pepe
DocType: Sales Invoice,Is Opening Entry,"Je, unafungua kuingia"
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: Supplier Scorecard,Criteria Setup,Uwekaji wa Kanuni
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +206,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 +8,Received On,Imepokea
DocType: Sales Partner,Reseller,Muuzaji
DocType: Codification Table,Medical Code,Kanuni ya Matibabu
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20,Please enter Company,Tafadhali ingiza Kampuni
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 +44,Net Cash from Financing,Fedha Nasi kutoka kwa Fedha
apps/erpnext/erpnext/accounts/page/pos/pos.js +2371,"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: Lab Test,Custom Result,Matokeo ya Desturi
DocType: Delivery Stop,Contact Name,Jina la Mawasiliano
DocType: Course Assessment Criteria,Course Assessment Criteria,Vigezo vya Tathmini ya Kozi
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Tax Id: ,Id ya kodi:
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +216,Student ID: ,Kitambulisho cha Mwanafunzi:
DocType: POS Customer Group,POS Customer Group,Kundi la Wateja wa POS
DocType: Land Unit,Land Unit describing various land assets,Kitengo cha Ardhi kuelezea mali mbalimbali za ardhi
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 +85,No description given,Hakuna maelezo yaliyotolewa
apps/erpnext/erpnext/config/buying.py +13,Request for purchase.,Omba la ununuzi.
DocType: Lab Test,Submitted Date,Tarehe iliyotolewa
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6,This is based on the Time Sheets created against this project,Hii inategemea Majedwali ya Muda yaliyoundwa dhidi ya mradi huu
,Open Work Orders,Omba Kazi za Kazi
DocType: Payment Term,Credit Months,Miezi ya Mikopo
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +409,Net Pay cannot be less than 0,Net Pay haiwezi kuwa chini ya 0
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,"To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription","Ili kuacha kutuma arifa za kurudia hitilafu kutoka kwa mfumo, tumeangalia shamba la Walemavu katika usajili"
apps/erpnext/erpnext/hr/doctype/employee/employee.py +122,Relieving Date must be greater than Date of Joining,Tarehe ya Kuondoa lazima iwe kubwa kuliko Tarehe ya kujiunga
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +240,Leaves per Year,Majani kwa mwaka
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130,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 +219,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 +147,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 +76,Please setup Students under Student Groups,Tafadhali kuanzisha Wanafunzi chini ya Vikundi vya Wanafunzi
DocType: Item Website Specification,Item Website Specification,Ufafanuzi wa Tovuti
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +449,Leave Blocked,Acha Kuzuiwa
apps/erpnext/erpnext/stock/doctype/item/item.py +740,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 +83,Bank Entries,Entries ya Benki
DocType: Crop,Annual,Kila mwaka
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Toleo la Upatanisho wa hisa
DocType: Stock Entry,Sales Invoice No,Nambari ya ankara ya mauzo
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 +210,People who teach at your organisation,Watu ambao hufundisha katika shirika lako
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135,Software Developer,Msanidi Programu
DocType: Item,Minimum Order Qty,Kiwango cha chini cha Uchina
DocType: Pricing Rule,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
,Terretory,Terretory
apps/erpnext/erpnext/stock/doctype/item/item.py +762,Item {0} is cancelled,Kipengee {0} kimefutwa
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1064,Material Request,Ombi la Nyenzo
DocType: Bank Reconciliation,Update Clearance Date,Sasisha tarehe ya kufuta
,GSTR-2,GSTR-2
DocType: Item,Purchase Details,Maelezo ya Ununuzi
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +448,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: Student Guardian,Mother,Mama
DocType: Restaurant Reservation,Reservation End Time,Muda wa Mwisho wa Uhifadhi
DocType: Crop,Biennial,Biennial
apps/erpnext/erpnext/config/selling.py +18,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 +80,Payment request {0} created,Ombi la kulipa {0} limeundwa
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +79,Open Orders,Fungua Maagizo
apps/erpnext/erpnext/healthcare/setup.py +255,Low Sensitivity,Sensitivity Low
DocType: Notification Control,Notification Control,Udhibiti wa Arifa
apps/erpnext/erpnext/templates/emails/training_event.html +17,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: 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 +276,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Malipo dhidi ya {0} {1} haiwezi kuwa kubwa zaidi kuliko Kiasi Kikubwa {2}
DocType: Shareholder,Address HTML,Weka HTML
DocType: Lead,Mobile No.,Simu ya Simu
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 +138,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 +41,Latest,Latest
DocType: Asset Maintenance Task,2 Yearly,2 kwa mwaka
DocType: Education Settings,Education Settings,Mipangilio ya Elimu
DocType: Vehicle Service,Inspection,Ukaguzi
DocType: Supplier Scorecard Scoring Standing,Max Grade,Daraja la Max
DocType: Email Digest,New Quotations,Nukuu mpya
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: Employee,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
DocType: Tax Rule,Shipping County,Kata ya Meli
apps/erpnext/erpnext/config/desktop.py +167,Learn,Jifunze
DocType: Asset,Next Depreciation Date,Tarehe ya Uzito ya pili
apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,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 +673,Supplier Invoice No exists in Purchase Invoice {0},Invozi ya Wauzaji Hakuna ipo katika ankara ya ununuzi {0}
apps/erpnext/erpnext/config/selling.py +118,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 +37,Outstanding Cheques and Deposits to clear,Cheki Bora na Deposits ili kufuta
DocType: Item,Synced With Hub,Ilifananishwa na Hub
DocType: Driver,Fleet Manager,Meneja wa Fleet
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542,Row #{0}: {1} can not be negative for item {2},Row # {0}: {1} haiwezi kuwa hasi kwa kipengee {2}
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +86,Wrong Password,Nywila isiyo sahihi
DocType: Item,Variant Of,Tofauti Ya
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +406,Completed Qty can not be greater than 'Qty to Manufacture',Uchina uliokamilika hauwezi kuwa mkubwa kuliko &#39;Uchina kwa Utengenezaji&#39;
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 +111,Circular Reference Error,Hitilafu ya Kumbukumbu ya Circular
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +206,Student Report Card,Kadi ya Ripoti ya Wanafunzi
DocType: Appointment Type,Is Inpatient,"Je, ni mgonjwa"
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,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 +29,{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: Employee,Job Profile,Profaili ya Kazi
DocType: BOM Item,Rate & Amount,Kiwango na Kiasi
apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6,This is based on transactions against this Company. See timeline below for details,Hii inategemea shughuli za Kampuni hii. Tazama kalenda ya chini kwa maelezo zaidi
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
apps/erpnext/erpnext/healthcare/setup.py +259,Resistant,Wanakabiliwa
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +77,Please set Hotel Room Rate on {},Tafadhali weka Kiwango cha Chumba cha Hoteli kwenye {}
DocType: Journal Entry,Multi Currency,Fedha nyingi
DocType: Opening Invoice Creation Tool,Invoice Type,Aina ya ankara
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +939,Delivery Note,Kumbuka Utoaji
DocType: Consultation,Encounter Impression,Kukutana na Mchapishaji
apps/erpnext/erpnext/config/learn.py +82,Setting up Taxes,Kuweka Kodi
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134,Cost of Sold Asset,Gharama ya Malipo ya Kuuza
DocType: Volunteer,Morning,Asubuhi
apps/erpnext/erpnext/accounts/utils.py +345,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/stock/doctype/item/item.py +479,{0} entered twice in Item Tax,{0} imeingia mara mbili katika Kodi ya Item
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113,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/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81,Amount After Depreciation,Kiasi Baada ya kushuka kwa thamani
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97,Upcoming Calendar Events,Matukio ya kalenda ijayo
apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1,Variant Attributes,Tabia za aina tofauti
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85,Please select month and year,Tafadhali chagua mwezi na mwaka
DocType: Employee,Company Email,Kampuni ya barua pepe
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 +21,Order Value,Thamani ya Utaratibu
apps/erpnext/erpnext/config/accounts.py +27,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/stock/doctype/item/item.js +55,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 +69,Total Order Considered,Amri ya Jumla imezingatiwa
apps/erpnext/erpnext/config/hr.py +243,"Employee designation (e.g. CEO, Director etc.).","Jina la waajiriwa (kwa mfano Mkurugenzi Mtendaji, Mkurugenzi nk)."
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 +623,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Row # {0}: Invoice ya Ununuzi haiwezi kufanywa dhidi ya mali iliyopo {1}
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +257,[Urgent] Error while creating recurring %s for %s,Hitilafu [ya haraka] wakati wa kujenga% s mara kwa mara kwa% s
DocType: Land Unit,LInked Analysis,Uchunguzi LInked
DocType: Item Tax,Tax Rate,Kiwango cha Kodi
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +73,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 +59,{0} already allocated for Employee {1} for period {2} to {3},{0} tayari imetengwa kwa Mfanyakazi {1} kwa muda {2} hadi {3}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +141,Purchase Invoice {0} is already submitted,Invozi ya Ununuzi {0} imewasilishwa tayari
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +92,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
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52,Convert to non-Group,Badilisha kwa mashirika yasiyo ya Kundi
DocType: Project Update,Good/Steady,Nzuri / imara
DocType: C-Form Invoice Detail,Invoice Date,Tarehe ya ankara
DocType: GL Entry,Debit Amount,Kiwango cha Debit
apps/erpnext/erpnext/accounts/party.py +248,There can only be 1 Account per Company in {0} {1},Kunaweza tu Akaunti 1 kwa Kampuni katika {0} {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +426,Please see attachment,Tafadhali tazama kiambatisho
DocType: Purchase Order,% Received,Imepokea
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Unda Vikundi vya Wanafunzi
DocType: Volunteer,Weekends,Mwishoni mwa wiki
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +125,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 Maintenance Log,Maintenance Type,Aina ya Matengenezo
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45,{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 +225,Student Name: ,Jina la Mwanafunzi:
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,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 +97,"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 +47,ERPNext Demo,ERPNext Demo
apps/erpnext/erpnext/public/js/utils/item_selector.js +20,Add Items,Ongeza Vitu
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Kipimo cha Ubora wa Bidhaa
DocType: Depreciation Schedule,Schedule Date,Tarehe ya Ratiba
apps/erpnext/erpnext/config/hr.py +116,"Earnings, Deductions and other Salary components","Mapato, Deductions na vipengele vingine vya Mshahara"
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 +65,Default settings for buying transactions.,Mipangilio ya mipangilio ya kununua shughuli.
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29,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 +15,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
DocType: Opening Invoice Creation Tool Item,Item Name,Jina la kipengee
DocType: Authorization Rule,Approving User  (above authorized value),Kupitisha Mtumiaji (juu ya thamani iliyoidhinishwa)
DocType: Email Digest,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: Salary Slip Timesheet,Working Hours,Saa za kazi
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +66,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: Dosage Strength,Strength,Nguvu
apps/erpnext/erpnext/accounts/page/pos/pos.js +1534,Create a new Customer,Unda Wateja wapya
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59,"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/utilities/activation.py +90,Create Purchase Orders,Unda Amri ya Ununuzi
,Purchase Register,Daftari ya Ununuzi
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +116,Patient not found,Mgonjwa haipatikani
DocType: Scheduling Tool,Rechedule,Rejea
DocType: Landed Cost Item,Applicable Charges,Malipo ya kuomba
DocType: Workstation,Consumable Cost,Gharama zinazoweza kutumika
DocType: Purchase Receipt,Vehicle Date,Tarehe ya Gari
DocType: Student Log,Medical,Matibabu
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175,Reason for losing,Sababu ya kupoteza
apps/erpnext/erpnext/accounts/doctype/account/account.js +46,Update Account Number,Sasisha Nambari ya Akaunti
apps/erpnext/erpnext/crm/doctype/lead/lead.py +44,Lead Owner cannot be same as the Lead,Mmiliki wa kiongozi hawezi kuwa sawa na Kiongozi
apps/erpnext/erpnext/accounts/utils.py +351,Allocated amount can not greater than unadjusted amount,Kiwango kilichowekwa hawezi kuwa kikubwa zaidi kuliko kiasi ambacho haijasimamiwa
DocType: Announcement,Receiver,Mpokeaji
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83,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 +32,Opportunities,Fursa
DocType: Lab Test Template,Single,Mmoja
DocType: Salary Slip,Total Loan Repayment,Ulipaji wa Mkopo wa Jumla
DocType: Account,Cost of Goods Sold,Gharama ya bidhaa zilizouzwa
DocType: Subscription,Yearly,Kila mwaka
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230,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 +69,Avg. Selling Rate,Mg. Kiwango cha Mauzo
DocType: Assessment Plan,Examiner Name,Jina la Mchunguzi
DocType: Lab Test Template,No Result,Hakuna Matokeo
DocType: Purchase Invoice Item,Quantity and Rate,Wingi na Kiwango
DocType: Delivery Note,% Installed,Imewekwa
apps/erpnext/erpnext/utilities/user_progress.py +230,Classrooms/ Laboratories etc where lectures can be scheduled.,"Madarasa / Maabara, nk ambapo mihadhara inaweza kufanyika."
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46,Please enter company name first,Tafadhali ingiza jina la kampuni kwanza
DocType: Purchase Invoice,Supplier Name,Jina la wauzaji
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25,Read the ERPNext Manual,Soma Mwongozo wa ERPNext
DocType: Purchase Invoice,01-Sales Return,Kurudi kwa Mauzo ya 01
DocType: Account,Is Group,Ni Kikundi
DocType: Email Digest,Pending Purchase Orders,Maagizo ya Ununuzi yaliyotarajiwa
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 +34,Primary Address Details,Maelezo ya Anwani ya Msingi
DocType: Vehicle Service,Oil Change,Mabadiliko ya Mafuta
DocType: Asset Maintenance Log,Asset Maintenance Log,Ingia ya Matengenezo ya Mali
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'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: Chapter,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 +19,Mandatory field - Academic Year,Sehemu ya lazima - Mwaka wa Elimu
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +220,{0} {1} is not associated with {2} {3},{0} {1} haihusiani na {2} {3}
DocType: Notification Control,Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,Customize maandishi ya utangulizi ambayo huenda kama sehemu ya barua pepe hiyo. Kila shughuli ina maandishi tofauti ya utangulizi.
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +176,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 +553,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 +84,Global settings for all manufacturing processes.,Mipangilio ya Global kwa mchakato wa utengenezaji wote.
DocType: Accounts Settings,Accounts Frozen Upto,Akaunti Yamehifadhiwa Upto
DocType: SMS Log,Sent On,Imepelekwa
apps/erpnext/erpnext/stock/doctype/item/item.py +700,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
apps/erpnext/erpnext/config/hr.py +70,Holiday master.,Likizo ya bwana.
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +85,Opening Invoice Item,Ufunguzi wa Bidhaa ya Invoice
DocType: Request for Quotation Item,Required Date,Tarehe inahitajika
DocType: Delivery Note,Billing Address,Mahali deni litakapotumwa
DocType: BOM,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"
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46,PieceRef,PieceRef
DocType: Request for Quotation,Message for Supplier,Ujumbe kwa Wafanyabiashara
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +40,Work Order,Kazi ya Kazi
DocType: Driver,DRIVER-.#####,Mtoaji -. #####
DocType: Sales Invoice,Total Qty,Uchina wa jumla
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2 Barua ya barua pepe
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 +49,Reserved for sale,Imehifadhiwa kwa ajili ya kuuza
DocType: Packing Slip,From Package No.,Kutoka kwa pakiti No.
DocType: Item Attribute,To Range,Kupanga
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29,Securities and Deposits,Usalama na Deposits
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +46,"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/leave_allocation/leave_allocation.py +82,Total leaves allocated is mandatory,Majani yote yaliyotengwa ni lazima
DocType: Patient,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 +110,Pending activities for today,Shughuli zinasubiri leo
apps/erpnext/erpnext/config/hr.py +24,Attendance record.,Kuhudhuria rekodi.
DocType: Salary Structure,Salary Component for timesheet based payroll.,Kipengele cha Mshahara kwa malipo ya nyakati ya maraheet.
DocType: Sales Order Item,Used for Production Plan,Kutumika kwa Mpango wa Uzalishaji
DocType: Employee Loan,Total Payment,Malipo ya Jumla
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +99,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/stock/doctype/material_request/material_request.py +132,{0} {1} is cancelled so the action cannot be completed,{0} {1} imefutwa ili hatua haiwezi kukamilika
DocType: Customer,Buyer of Goods and Services.,Mnunuzi wa Bidhaa na Huduma.
DocType: Journal Entry,Accounts Payable,Akaunti za kulipwa
DocType: Patient,Allergies,Dawa
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +33,The selected BOMs are not for the same item,BOM zilizochaguliwa sio kwa bidhaa moja
DocType: Supplier Scorecard Standing,Notify Other,Arifa nyingine
DocType: Vital Signs,Blood Pressure (systolic),Shinikizo la damu (systolic)
DocType: Pricing Rule,Valid Upto,Halafu Upto
DocType: Training Event,Workshop,Warsha
DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Angalia Amri za Ununuzi
apps/erpnext/erpnext/utilities/user_progress.py +67,List a few of your customers. They could be organizations or individuals.,Andika orodha ya wateja wako wachache. Wanaweza kuwa mashirika au watu binafsi.
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +23,Enough Parts to Build,Vipande vyenye Kujenga
DocType: POS Profile User,POS Profile User,Mtumiaji wa Programu ya POS
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128,Direct Income,Mapato ya moja kwa moja
DocType: Patient Appointment,Date TIme,Tarehe TIme
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +45,"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 +130,Administrative Officer,Afisa wa Usimamizi
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39,Setting up company and taxes,Kuanzisha kampuni na kodi
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,Tafadhali chagua kozi
DocType: Codification Table,Codification Table,Jedwali la Ushauri
DocType: Timesheet Detail,Hrs,Hrs
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +349,Please select Company,Tafadhali chagua Kampuni
DocType: Stock Entry Detail,Difference Account,Akaunti ya Tofauti
DocType: Purchase Invoice,Supplier GSTIN,GSTIN wa Wasambazaji
apps/erpnext/erpnext/projects/doctype/task/task.py +47,Cannot close task as its dependant task {0} is not closed.,Haiwezi kufunga kazi kama kazi yake ya kutegemea {0} haijafungwa.
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +435,Please enter Warehouse for which Material Request will be raised,Tafadhali ingiza Ghala la Maombi ya Nyenzo ambayo itafufuliwa
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 +20,Cosmetics,Vipodozi
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18,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/item/item.py +552,"To merge, following properties must be same for both items","Ili kuunganisha, mali zifuatazo lazima ziwe sawa kwa vitu vyote viwili"
DocType: Shipping Rule,Net Weight,Weight Net
DocType: Employee,Emergency Phone,Simu ya dharura
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +82,{0} {1} does not exist.,{0} {1} haipo.
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29,Buy,Nunua
,Serial No Warranty Expiry,Serial Hakuna Mwisho wa Udhamini
DocType: Sales Invoice,Offline POS Name,Jina la POS la Nje ya mtandao
apps/erpnext/erpnext/utilities/user_progress.py +180,Student Application,Maombi ya Wanafunzi
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Tafadhali fafanua daraja la Msingi 0%
DocType: Sales Order,To Deliver,Ili Kuokoa
DocType: Purchase Invoice Item,Item,Kipengee
apps/erpnext/erpnext/healthcare/setup.py +256,High Sensitivity,Sensitivity High
apps/erpnext/erpnext/config/non_profit.py +48,Volunteer Type information.,Aina ya kujitolea habari.
DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,Kigezo cha Ramani ya Mapato ya Fedha
apps/erpnext/erpnext/accounts/page/pos/pos.js +2551,Serial no item cannot be a fraction,Serial hakuna bidhaa haiwezi kuwa sehemu
DocType: Journal Entry,Difference (Dr - Cr),Tofauti (Dr - Cr)
DocType: Account,Profit and Loss,Faida na Kupoteza
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +104,"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 +279,Stock Entries already created for Work Order ,Entries Entries tayari kuundwa kwa Kazi Order
DocType: Vital Signs,Respiratory rate,Kiwango cha kupumua
apps/erpnext/erpnext/config/stock.py +338,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
DocType: Detected Disease,Disease,Magonjwa
apps/erpnext/erpnext/config/projects.py +29,Define Project type.,Eleza aina ya Mradi.
DocType: Supplier Scorecard,Weighting Function,Weighting Kazi
DocType: Physician,OP Consulting Charge,Ushauri wa ushauri wa OP
apps/erpnext/erpnext/utilities/user_progress.py +28,Setup your ,Weka yako
DocType: Student Report Generation Tool,Show Marks,Onyesha alama
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 +70,Account {0} does not belong to company: {1},Akaunti {0} sio ya kampuni: {1}
apps/erpnext/erpnext/setup/doctype/company/company.py +52,Abbreviation already used for another company,Hali tayari kutumika kwa kampuni nyingine
DocType: Selling Settings,Default Customer Group,Kikundi cha Wateja Chaguo-msingi
DocType: Asset Repair,ARLOG-,ARLOG-
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: Sales Order Item,Gross Profit,Faida Pato
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49,Increment cannot be 0,Uingizaji hauwezi kuwa 0
DocType: Company,Delete Company Transactions,Futa Shughuli za Kampuni
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +364,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
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158,"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 +256,Closing (Cr),Kufungwa (Cr)
apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1,Hello,Sawa
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118,Move Item,Hoja Item
DocType: Serial No,Warranty Period (Days),Kipindi cha udhamini (Siku)
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 +396,{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/accounts.py +272,Setup cheque dimensions for printing,Weka vipimo vipimo vya kuchapisha
DocType: Salary Slip,Salary Slip Timesheet,Timesheet ya Mshahara Mshahara
apps/erpnext/erpnext/controllers/buying_controller.py +161,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Ghala la Wafanyabiashara lazima kwa Receipt ya Ununuzi wa chini ya mkataba
DocType: Pricing Rule,Valid From,Halali Kutoka
DocType: Sales Invoice,Total Commission,Jumla ya Tume
DocType: Pricing Rule,Sales Partner,Mshirika wa Mauzo
apps/erpnext/erpnext/config/buying.py +150,All Supplier scorecards.,Mapendekezo yote ya Wasambazaji.
DocType: Buying Settings,Purchase Receipt Required,Receipt ya Ununuzi inahitajika
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +228,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 +155,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 +143,No records found in the Invoice table,Hakuna kumbukumbu zilizopatikana kwenye meza ya ankara
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +34,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 +31,"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/accounts.py +293,Financial / accounting year.,Mwaka wa fedha / uhasibu.
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9,Accumulated Values,Maadili yaliyokusanywa
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162,"Sorry, Serial Nos cannot be merged","Samahani, Serial Nos haiwezi kuunganishwa"
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +72,Territory is Required in POS Profile,Territory Inahitajika katika POS Profile
DocType: Supplier,Prevent RFQs,Zuia RFQs
apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Fanya Mauzo ya Mauzo
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168,Salary Slip submitted for period from {0} to {1},Slip ya Mshahara imewasilishwa kwa kipindi cha {0} hadi {1}
DocType: Project Task,Project Task,Kazi ya Mradi
,Lead Id,Weka Id
DocType: C-Form Invoice Detail,Grand Total,Jumla ya Jumla
DocType: Assessment Plan,Course,Kozi
DocType: Timesheet,Payslip,Ilipigwa
apps/erpnext/erpnext/public/js/pos/pos.html +4,Item Cart,Ramani ya Bidhaa
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38,Fiscal Year Start Date should not be greater than Fiscal Year End Date,Tarehe ya Mwanzo wa Fedha haipaswi kuwa kubwa kuliko Tarehe ya Mwisho wa Fedha
DocType: Issue,Resolution,Azimio
DocType: C-Form,IV,IV
apps/erpnext/erpnext/templates/pages/order.html +76,Delivered: {0},Imetolewa: {0}
DocType: Expense Claim,Payable Account,Akaunti ya kulipa
DocType: Payment Entry,Type of Payment,Aina ya Malipo
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 +58,Repeat Customers,Rudia Wateja
DocType: Leave Control Panel,Allocate,Weka
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108,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
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +853,Sales Return,Kurudi kwa Mauzo
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96,Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period,Kumbuka: Majani yote yaliyotengwa {0} hayapaswi kuwa chini ya majani yaliyoidhinishwa tayari {1} kwa muda
,Total Stock Summary,Jumla ya muhtasari wa hisa
DocType: Announcement,Posted By,Imewekwa By
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 +12,Database of potential customers.,Database ya wateja uwezo.
DocType: Authorization Rule,Customer or Item,Wateja au Bidhaa
apps/erpnext/erpnext/config/selling.py +28,Customer database.,Wateja database.
DocType: Quotation,Quotation To,Nukuu Kwa
DocType: Lead,Middle Income,Mapato ya Kati
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +228,Opening (Cr),Kufungua (Cr)
apps/erpnext/erpnext/stock/doctype/item/item.py +872,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.
apps/erpnext/erpnext/accounts/utils.py +349,Allocated amount can not be negative,Kiwango kilichowekwa hawezi kuwa hasi
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Tafadhali weka Kampuni
DocType: Share Balance,Share Balance,Shiriki Mizani
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.
DocType: Repayment Schedule,Principal Amount,Kiasi kikubwa
DocType: Employee Loan Application,Total Payable Interest,Jumla ya Maslahi ya kulipa
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +57,Total Outstanding: {0},Jumla ya Kipaumbele: {0}
DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Timesheet ya Mauzo ya Mauzo
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118,Reference No & Reference Date is required for {0},Tarehe ya Kumbukumbu na Kitabu cha Marejeo inahitajika kwa {0}
DocType: Payroll Entry,Select Payment Account to make Bank Entry,Chagua Akaunti ya Malipo kwa Kufungua Benki
DocType: Hotel Settings,Default Invoice Naming Series,Mfululizo wa Majina ya Kutoa Invoice
apps/erpnext/erpnext/utilities/activation.py +136,"Create Employee records to manage leaves, expense claims and payroll","Unda kumbukumbu za Wafanyakazi kusimamia majani, madai ya gharama na malipo"
DocType: Restaurant Reservation,Restaurant Reservation,Uhifadhi wa Mkahawa
DocType: Land Unit,Land Unit Name,Jina la Kitengo cha Ardhi
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190,Proposal Writing,Kuandika Proposal
DocType: Payment Entry Deduction,Payment Entry Deduction,Utoaji wa Kuingia kwa Malipo
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14,Wrapping up,Kufunga juu
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35,Notify Customers via Email,Wajulishe Wateja kupitia Barua pepe
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,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/config/education.py +180,Masters,Masters
DocType: Assessment Plan,Maximum Assessment Score,Makadirio ya Kiwango cha Tathmini
apps/erpnext/erpnext/config/accounts.py +138,Update Bank Transaction Dates,Sasisha Dates ya Shughuli za Benki
apps/erpnext/erpnext/config/projects.py +41,Time Tracking,Ufuatiliaji wa Muda
DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DUPLICATE kwa TRANSPORTER
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49,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: Timesheet,Billed,Inauzwa
DocType: Batch,Batch Description,Maelezo ya Bande
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Kujenga makundi ya wanafunzi
apps/erpnext/erpnext/accounts/utils.py +720,"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 +51,Not eligible for the admission in this program as per DOB,Haikubaliki kuingia kwenye programu hii kama DOB
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Msimbo wa Item&gt; Kikundi cha Bidhaa&gt; Brand
DocType: Sales Invoice,Sales Taxes and Charges,Malipo ya Kodi na Malipo
DocType: Employee,Organization Profile,Profaili ya Shirika
DocType: Vital Signs,Height (In Meter),Urefu (Katika mita)
DocType: Student,Sibling Details,Maelezo ya Kikabila
DocType: Vehicle Service,Vehicle Service,Huduma ya Gari
apps/erpnext/erpnext/config/setup.py +101,Automatically triggers the feedback request based on conditions.,Inatoa moja kwa moja ombi la maoni kulingana na hali.
DocType: Employee,Reason for Resignation,Sababu ya Kuondolewa
apps/erpnext/erpnext/config/hr.py +152,Template for performance appraisals.,Kigezo cha tathmini za utendaji.
DocType: Sales Invoice,Credit Note Issued,Maelezo ya Mikopo imeondolewa
DocType: Project Task,Weight,Uzito
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Invoice / Maelezo ya Maelezo ya Kuingia
apps/erpnext/erpnext/accounts/utils.py +83,{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 +21,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 +70,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
DocType: Maintenance Schedule,Maintenance Schedule,Ratiba ya Matengenezo
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36,"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."
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +29,Net Change in Inventory,Mabadiliko ya Net katika Mali
apps/erpnext/erpnext/config/hr.py +162,Employee Loan Management,Usimamizi wa Mikopo ya Waajiriwa
DocType: Employee,Passport Number,Nambari ya Pasipoti
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,Uhusiano na Guardian2
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124,Manager,Meneja
DocType: Payment Entry,Payment From / To,Malipo Kutoka / Kwa
apps/erpnext/erpnext/selling/doctype/customer/customer.py +170,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 +428,Please set account in Warehouse {0},Tafadhali weka akaunti katika Warehouse {0}
apps/erpnext/erpnext/controllers/trends.py +39,'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: Installation Note,IN-,IN-
DocType: Work Order Operation,In minutes,Kwa dakika
DocType: Issue,Resolution Date,Tarehe ya Azimio
DocType: Lab Test Template,Compound,Kipengee
DocType: Student Batch Name,Batch Name,Jina la Kundi
DocType: Fee Validity,Max number of visit,Idadi kubwa ya ziara
,Hotel Room Occupancy,Kazi ya chumba cha Hoteli
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +358,Timesheet created:,Timesheet iliunda:
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +931,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 +24,Enroll,Ingia
DocType: GST Settings,GST Settings,Mipangilio ya GST
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 +56,Convert to Group,Badilisha hadi Kikundi
DocType: Delivery Trip,TOUR-.#####,TOUR -. #####
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)
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Amount,Kiasi kilichotolewa
apps/erpnext/erpnext/healthcare/doctype/physician/physician_dashboard.py +14,Lab Tests,Majaribio ya Lab
DocType: Quotation Item,Item Balance,Mizani ya Bidhaa
DocType: Sales Invoice,Packing List,Orodha ya Ufungashaji
apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,Amri ya Ununuzi iliyotolewa kwa Wauzaji.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43,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 +40,Consumed,Inatumiwa
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +158,{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 +242,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Kutembelea kutembelea {0} lazima kufutwa kabla ya kufuta Sheria hii ya Mauzo
DocType: Asset Maintenance Log,AML-,AML-
DocType: Item,Material Transfer,Uhamisho wa Nyenzo
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24,Could not find path for ,Haikuweza kupata njia
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +221,Opening (Dr),Ufunguzi (Dk)
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39,Posting timestamp must be after {0},Kutuma timestamp lazima iwe baada ya {0}
apps/erpnext/erpnext/config/accounts.py +39,To make recurring documents,Kufanya nyaraka za mara kwa mara
,GST Itemised Purchase Register,GST Kujiandikisha Ununuzi wa Item
DocType: Course Scheduling Tool,Reschedule,Rekebisha
DocType: Employee Loan,Total Interest Payable,Jumla ya Maslahi ya Kulipa
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Malipo ya Gharama na Malipo
DocType: Work Order Operation,Actual Start Time,Muda wa Kuanza
DocType: BOM Operation,Operation Time,Muda wa Uendeshaji
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +337,Finish,Kumaliza
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +422,Base,Msingi
DocType: Timesheet,Total Billed Hours,Masaa Yote yaliyolipwa
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1553,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: Subscription,Quarterly,Jumatatu
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +47,EcritureLib,AndikaLib
DocType: Lab Test Template,Grouped,Yameunganishwa
DocType: Selling Settings,Delivery Note Required,Kumbuka Utoaji Inahitajika
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)
DocType: Student Attendance,Student Attendance,Mahudhurio ya Wanafunzi
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 +957,Reserve Warehouse,Ghala la Hifadhi
DocType: Lead,Lead is an Organization,Kiongozi ni Shirika
DocType: Guardian Interest,Interest,Hamu
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,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 +18,Suplier,Kuinua
DocType: Lab Test,Test Template,Kigezo cha Mtihani
DocType: Restaurant Order Entry Item,Served,Imehudumiwa
apps/erpnext/erpnext/config/non_profit.py +13,Chapter information.,Maelezo ya sura.
DocType: Account,Accounts,Akaunti
DocType: Vehicle,Odometer Value (Last),Thamani ya Odometer (Mwisho)
apps/erpnext/erpnext/config/buying.py +160,Templates of supplier scorecard criteria.,Matukio ya vigezo vya scorecard ya wasambazaji.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109,Marketing,Masoko
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +303,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
apps/erpnext/erpnext/controllers/accounts_controller.py +610,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 +404,Preview Salary Slip,Angalia Slip ya Mshahara
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54,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 +37,You can only renew if your membership expires within 30 days,Unaweza tu upya kama wanachama wako muda wake ndani ya siku 30
DocType: Land Unit,Longitude,Longitude
,Absent Student Report,Ripoti ya Wanafunzi Yasiyo
DocType: Crop,Crop Spacing UOM,Ugawaji wa mazao ya UOM
DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,Chagua tu ikiwa umeweka hati za Mapato ya Mapato ya Fedha
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 +666,Item has variants.,Item ina tofauti.
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,Jumla ya Mwanafunzi
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65,Item {0} not found,Kipengee {0} haipatikani
DocType: Bin,Stock Value,Thamani ya Hifadhi
apps/erpnext/erpnext/accounts/doctype/account/account.py +239,Company {0} does not exist,Kampuni {0} haipo
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40,{0} has fee validity till {1},{0} ina uhalali wa ada mpaka {1}
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +54,Tree Type,Aina ya Mti
DocType: BOM Explosion Item,Qty Consumed Per Unit,Uchina hutumiwa kwa kitengo
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: Hub Settings,Unregister,Wala usajili
DocType: Sales Invoice,Commission Rate (%),Kiwango cha Tume (%)
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24,Please select Program,Tafadhali chagua Programu
DocType: Project,Estimated Cost,Gharama zilizohesabiwa
DocType: Purchase Order,Link to material requests,Unganisha maombi ya vifaa
DocType: Hub Settings,Publish,Kuchapisha
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7,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/accounts.py +57,Company and Accounts,Kampuni na Akaunti
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70,In Value,Kwa Thamani
DocType: Asset Settings,Depreciation Options,Chaguzi za uchafuzi
apps/erpnext/erpnext/utilities/transaction_base.py +35,Invalid Posting Time,Muda usio sahihi wa Kuchapa
DocType: Lead,Campaign Name,Jina la Kampeni
DocType: Hotel Room,Capacity,Uwezo
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 +85,The field From Shareholder cannot be blank,Shamba Kutoka kwa Mshirika haiwezi kuwa tupu
DocType: Purchase Order,Supply Raw Materials,Vifaa vya Malighafi
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,Malipo ya sasa
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +133,{0} is not a stock Item,{0} si kitu cha hisa
apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6,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: Mode of Payment Account,Default Account,Akaunti ya Akaunti
apps/erpnext/erpnext/stock/doctype/item/item.py +273,Please select Sample Retention Warehouse in Stock Settings first,Tafadhali chagua Ghala la Wafanyakazi Kuhifadhiwa katika Mipangilio ya Hifadhi kwanza
DocType: Payment Entry,Received Amount (Company Currency),Kiasi kilichopokelewa (Fedha la Kampuni)
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192,Lead must be set if Opportunity is made from Lead,Kiongozi lazima kiweke kama Mfanyabiashara unafanywa kutoka kwa Kiongozi
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +136,Payment Cancelled. Please check your GoCardless Account for more details,Malipo Imepigwa. Tafadhali angalia Akaunti yako ya GoCardless kwa maelezo zaidi
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29,Please select weekly off day,Tafadhali chagua kila wiki siku
DocType: Patient,O Negative,O Hasi
DocType: Work Order Operation,Planned End Time,Muda wa Mwisho
,Sales Person Target Variance Item Group-Wise,Mtazamo wa Mtazamo wa Mtu wa Mtaalam Kikundi Kikundi-Hekima
apps/erpnext/erpnext/accounts/doctype/account/account.py +93,Account with existing transaction cannot be converted to ledger,Akaunti na shughuli zilizopo haziwezi kubadilishwa kuwa kiongozi
apps/erpnext/erpnext/config/non_profit.py +33,Memebership Type Details,Maelezo ya Aina ya Uhifadhi
DocType: Delivery Note,Customer's Purchase Order No,Nambari ya Ununuzi wa Wateja No
DocType: Budget,Budget Against,Bajeti ya Dhidi
DocType: Employee,Cell Number,Nambari ya Kiini
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +450,There's no employee for the given criteria. Check that Salary Slips have not already been created.,Hakuna mfanyakazi kwa vigezo vinavyopewa. Angalia kwamba Slips za Mshahara bado haijaundwa.
apps/erpnext/erpnext/stock/reorder_item.py +194,Auto Material Requests Generated,Maombi ya Nyenzo za Auto yanayotokana
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,Potea
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +152,You can not enter current voucher in 'Against Journal Entry' column,Huwezi kuingia hati ya sasa katika safu ya &#39;Against Journal Entry&#39;
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,Imehifadhiwa kwa ajili ya utengenezaji
DocType: Soil Texture,Sand,Mchanga
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25,Energy,Nishati
DocType: Opportunity,Opportunity From,Fursa Kutoka
apps/erpnext/erpnext/config/hr.py +98,Monthly salary statement.,Taarifa ya mshahara kila mwezi.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +887,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/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79,Please select a table,Tafadhali chagua meza
DocType: BOM,Website Specifications,Ufafanuzi wa tovuti
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78,{0} is an invalid email address in 'Recipients',{0} ni anwani ya barua pepe batili katika &#39;Wapokeaji&#39;
DocType: Special Test Items,Particulars,Maelezo
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24,{0}: From {0} of type {1},{0}: Kutoka {0} ya aina {1}
DocType: Warranty Claim,CI-,CI-
apps/erpnext/erpnext/controllers/buying_controller.py +316,Row {0}: Conversion Factor is mandatory,Row {0}: Kiini cha Kubadilisha ni lazima
DocType: Student,A+,A +
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +344,"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}"
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +519,Cannot deactivate or cancel BOM as it is linked with other BOMs,Haiwezi kuzima au kufuta BOM kama inavyounganishwa na BOM nyingine
DocType: Asset,Maintenance,Matengenezo
DocType: Item Attribute Value,Item Attribute Value,Thamani ya Thamani ya Bidhaa
apps/erpnext/erpnext/projects/doctype/project/project.py +406,Please Update your Project Status,Tafadhali sasisha Hali yako ya Mradi
DocType: Item,Maximum sample quantity that can be retained,Upeo wa kiwango cha sampuli ambacho kinaweza kuhifadhiwa
DocType: Project Update,How is the Project Progressing Right Now?,Je! Mradi unaendeleaje sasa?
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +459,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/selling.py +158,Sales campaigns.,Kampeni za mauzo.
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +117,Make Timesheet,Fanya Timesheet
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: Employee,Bank A/C No.,Benki ya A / C.
DocType: Bank Guarantee,Project,Mradi
DocType: Quality Inspection Reading,Reading 7,Kusoma 7
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9,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: 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/healthcare/doctype/physician_schedule/physician_schedule.js +27,Add Timeslots,Ongeza Timeslots
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138,Asset scrapped via Journal Entry {0},Mali yamepigwa kupitia Entri ya Journal {0}
DocType: Employee Loan,Interest Income Account,Akaunti ya Mapato ya riba
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58,Review Invitation Sent,Kagua Mwaliko uliotumwa
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13,Biotechnology,Bioteknolojia
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Office Maintenance Expenses,Malipo ya Matengenezo ya Ofisi
apps/erpnext/erpnext/utilities/user_progress.py +54,Go to ,Enda kwa
apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,Kuweka Akaunti ya Barua pepe
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +21,Please enter Item first,Tafadhali ingiza kipengee kwanza
DocType: Asset Repair,Downtime,Downtime
DocType: Account,Liability,Dhima
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +220,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 +11,Academic Term: ,Muda wa Elimu:
DocType: Salary Detail,Do not include in total,Usijumuishe kwa jumla
DocType: Company,Default Cost of Goods Sold Account,Akaunti ya Kuuza Gharama ya Bidhaa
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1177,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 +369,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
apps/erpnext/erpnext/stock/doctype/item/item.py +228,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 +766,No Permission,Hakuna Ruhusa
apps/erpnext/erpnext/public/js/hub/hub_form.js +351,Quote Requested,Quote Iliombwa
DocType: Vital Signs,Heart Rate / Pulse,Kiwango cha Moyo / Pulse
DocType: Company,Default Bank Account,Akaunti ya Akaunti ya Default
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +59,"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 +48,'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/utilities/user_progress.py +146,Nos,Nasi
DocType: Item,Items with higher weightage will be shown higher,Vitu vinavyo na uzito mkubwa vitaonyeshwa juu
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14,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 +614,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 +40,No employee found,Hakuna mfanyakazi aliyepatikana
DocType: Subscription,Stopped,Imesimamishwa
DocType: Item,If subcontracted to a vendor,Ikiwa unatambuliwa kwa muuzaji
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111,Student Group is already updated.,Kundi la Wanafunzi tayari limehifadhiwa.
apps/erpnext/erpnext/config/projects.py +18,Project Update.,Mwisho wa Mradi.
DocType: SMS Center,All Customer Contact,Mawasiliano ya Wateja wote
DocType: Land Unit,Tree Details,Maelezo ya Miti
DocType: Training Event,Event Status,Hali ya Tukio
DocType: Volunteer,Availability Timeslot,Timeslot ya Upatikanaji
,Support Analytics,Analytics Support
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +365,"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 +111,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Kituo cha Gharama {2} si cha Kampuni {3}
apps/erpnext/erpnext/utilities/user_progress.py +92,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 +88,{0} {1}: Account {2} cannot be a Group,{0} {1}: Akaunti {2} haiwezi kuwa Kikundi
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table,Jambo Row {idx}: {doctype} {docname} haipo katika meza ya &#39;{doctype}&#39; hapo juu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +295,Timesheet {0} is already completed or cancelled,Timesheet {0} tayari imekamilika au kufutwa
apps/erpnext/erpnext/templates/pages/projects.html +42,No tasks,Hakuna kazi
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 +49,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/accounts.py +335,C-Form records,Rekodi za Fomu za C
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +73,The shares already exist,Sehemu tayari zipo
apps/erpnext/erpnext/config/selling.py +316,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 +367,Thank you for your business!,Asante kwa biashara yako!
apps/erpnext/erpnext/config/support.py +12,Support queries from customers.,Maswali ya msaada kutoka kwa wateja.
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: Production Plan,Select Items,Chagua Vitu
DocType: Share Transfer,To Shareholder,Kwa Mshirika
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372,{0} against Bill {1} dated {2},{0} dhidi ya Sheria {1} iliyowekwa {2}
apps/erpnext/erpnext/utilities/user_progress.py +27,Setup Institution,Taasisi ya Kuweka
DocType: Program Enrollment,Vehicle/Bus Number,Nambari ya Gari / Bus
apps/erpnext/erpnext/education/doctype/course/course.js +17,Course Schedule,Ratiba ya Kozi
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
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: 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 +133,Please select a warehouse,Tafadhali chagua ghala
DocType: Cheque Print Template,Starting location from left edge,Kuanzia eneo kutoka kwa makali ya kushoto
DocType: Item,Allow over delivery or receipt upto this percent,Ruhusu utoaji au risiti hadi asilimia hii
DocType: Stock Entry,STE-,STE-
DocType: Upload Attendance,Import Attendance,Weka Mahudhurio
apps/erpnext/erpnext/public/js/pos/pos.html +124,All Item Groups,Vikundi vyote vya Item
apps/erpnext/erpnext/config/setup.py +89,Automatically compose message on submission of transactions.,Tuma ujumbe wa moja kwa moja kwenye uwasilishaji wa shughuli.
DocType: Work Order,Item To Manufacture,Mchapishaji wa Utengenezaji
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44,CompteLib,CompteLib
apps/erpnext/erpnext/buying/utils.py +80,{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/learn.py +202,Purchase Order to Payment,Amri ya Malipo ya Ununuzi
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,Uchina uliopangwa
DocType: Sales Invoice,Payment Due Date,Tarehe ya Kutayarisha Malipo
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/stock/doctype/item/item.js +544,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 +123,'Opening',&#39;Kufungua&#39;
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,Fungua Kufanya
DocType: Notification Control,Delivery Note Message,Ujumbe wa Kumbuka Utoaji
DocType: Lab Test Template,Result Format,Fomu ya matokeo
DocType: Expense Claim,Expenses,Gharama
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 +119,Research & Development,Utafiti na Maendeleo
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20,Amount to Bill,Kiasi cha Bill
DocType: Company,Registration Details,Maelezo ya Usajili
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
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +94,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 +92,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: Sales Team,Incentives,Vidokezo
DocType: SMS Log,Requested Numbers,Hesabu zilizoombwa
DocType: Volunteer,Evening,Jioni
DocType: Customer,Bypass credit limit check at Sales Order,Kagua kikomo cha mkopo wa Udhibiti wa Mauzo
apps/erpnext/erpnext/config/hr.py +147,Performance appraisal.,Tathmini ya utendaji.
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +100,"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"
apps/erpnext/erpnext/controllers/accounts_controller.py +412,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Uingiaji wa Malipo {0} umeunganishwa dhidi ya Amri {1}, angalia ikiwa inapaswa kuvutwa kama mapema katika ankara hii."
DocType: Sales Invoice Item,Stock Details,Maelezo ya hisa
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Thamani ya Mradi
apps/erpnext/erpnext/config/selling.py +326,Point-of-Sale,Uhakika wa Kuuza
DocType: Fee Schedule,Fee Creation Status,Hali ya Uumbaji wa Mali
DocType: Vehicle Log,Odometer Reading,Kusoma Odometer
apps/erpnext/erpnext/accounts/doctype/account/account.py +116,"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
DocType: Hub Settings,Publish Pricing,Chapisha bei
DocType: Notification Control,Expense Claim Rejected Message,Imesajili Ujumbe Uliokataliwa
,Available Qty,Uchina unaopatikana
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: Delivery Trip,Delivery Stops,Utoaji wa Utoaji
DocType: Salary Slip,Working Days,Siku za Kazi
DocType: Serial No,Incoming Rate,Kiwango kinachoingia
DocType: Packing Slip,Gross Weight,Uzito wa Pato
,Final Assessment Grades,Tathmini ya Mwisho ya Masomo
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +60,Enable Hub,Wezesha Hub
apps/erpnext/erpnext/public/js/setup_wizard.js +110,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 +108,Setup your Institute in ERPNext,Weka Taasisi yako katika ERPNext
DocType: Agriculture Analysis Criteria,Plant Analysis,Uchunguzi wa kupanda
DocType: Job Applicant,Hold,Weka
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +128,Alternate Item,Nakala mbadala
DocType: Project Update,Progress Details,Maelezo ya Maendeleo
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 +845,Purchase Receipt,Receipt ya Ununuzi
,Received Items To Be Billed,Vipokee Vipokee vya Kulipwa
apps/erpnext/erpnext/config/accounts.py +303,Currency exchange rate master.,Kiwango cha ubadilishaji wa fedha.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,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 +46,Filter Total Zero Qty,Futa Jumla ya Zero Uchina
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +341,Unable to find Time Slot in the next {0} days for Operation {1},Haiwezi kupata Muda wa Slot katika siku zifuatazo {0} kwa Uendeshaji {1}
DocType: Work Order,Plan material for sub-assemblies,Panga nyenzo kwa makusanyiko ndogo
apps/erpnext/erpnext/config/selling.py +97,Sales Partners and Territory,Washirika wa Mauzo na Wilaya
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +601,BOM {0} must be active,BOM {0} lazima iwe hai
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +414,No Items available for transfer,Hakuna Vipengele vinavyopatikana kwa uhamisho
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +218,Closing (Opening + Total),Kufungwa (Kufungua + Jumla)
DocType: Journal Entry,Depreciation Entry,Kuingia kwa kushuka kwa thamani
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +32,Please select the document type first,Tafadhali chagua aina ya hati kwanza
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,Futa Ziara Nyenzo {0} kabla ya kufuta Kutembelea Utunzaji huu
DocType: Crop Cycle,ISO 8016 standard,Kiwango cha ISO 8016
DocType: Pricing Rule,Rate or Discount,Kiwango au Punguzo
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,Serial No {0} does not belong to Item {1},Serial Hakuna {0} si ya Bidhaa {1}
DocType: Purchase Receipt Item Supplied,Required Qty,Uliohitajika Uchina
apps/erpnext/erpnext/public/js/hub/hub_listing.js +58,Favourites,Mapendeleo
DocType: Hub Settings,Custom Data,Takwimu za Desturi
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +126,Warehouses with existing transaction can not be converted to ledger.,Maghala na shughuli zilizopo haziwezi kubadilishwa kwenye kiwanja.
DocType: Bank Reconciliation,Total Amount,Jumla
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32,Internet Publishing,Kuchapisha mtandao
DocType: Prescription Duration,Number,Nambari
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25,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 (%)
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81,Please save before assigning task.,Tafadhali salama kabla ya kugawa kazi.
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +74,Balance Value,Thamani ya usawa
DocType: Lab Test,Lab Technician,Mtaalamu wa Lab
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,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."
DocType: Bank Reconciliation,Account Currency,Fedha za Akaunti
DocType: Lab Test,Sample ID,Kitambulisho cha Mfano
apps/erpnext/erpnext/accounts/general_ledger.py +167,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 +49,Employee {0} is not active or does not exist,Mfanyakazi {0} haifanyi kazi au haipo
DocType: Fee Structure,Components,Vipengele
DocType: Item Barcode,Item Barcode,Msimbo wa Barcode
DocType: Woocommerce Settings,Endpoints,Mwisho
apps/erpnext/erpnext/assets/doctype/asset/asset.py +329,Please enter Asset Category in Item {0},Tafadhali ingiza Kundi la Mali katika Item {0}
apps/erpnext/erpnext/stock/doctype/item/item.py +661,Item Variants {0} updated,Vipengee vya Toleo {0} vinavyosasishwa
DocType: Quality Inspection Reading,Reading 6,Kusoma 6
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +9,"to be generated. If delayed, you will have to manually change the ""Repeat on Day of Month"" field
of this","ili kuzalishwa. Ikiwa imechelewa, utahitajika kubadilisha &quot;Rudia Siku ya Mwezi&quot; shamba hili"
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +961,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
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199,Row {0}: Credit entry can not be linked with a {1},Row {0}: Uingiaji wa mikopo hauwezi kuunganishwa na {1}
apps/erpnext/erpnext/config/accounts.py +246,Define budget for a financial year.,Eleza bajeti kwa mwaka wa kifedha.
DocType: Lead,LEAD-,MKAZI-
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?
DocType: Payment Terms Template,Payment Terms Template,Masharti ya Malipo Kigezo
apps/erpnext/erpnext/public/js/setup_wizard.js +51,The Brand,Brand
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: Journal Entry Account,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: Stock Ledger Entry,Voucher Detail No,Maelezo ya Voucher No
apps/erpnext/erpnext/accounts/page/pos/pos.js +789,New Sales Invoice,Invozi mpya ya Mauzo
DocType: Stock Entry,Total Outgoing Value,Thamani Yote ya Kuondoka
DocType: Physician,Appointments,Uteuzi
apps/erpnext/erpnext/public/js/account_tree_grid.js +223,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
,LeaderBoard,Kiongozi wa Viongozi
DocType: Sales Invoice Item,Rate With Margin (Company Currency),Kiwango na Margin (Kampuni ya Fedha)
apps/erpnext/erpnext/accounts/page/pos/pos.js +802,Sync Offline Invoices,Sawazisha ankara zisizo kwenye mtandao
DocType: Payment Request,Paid,Ilipwa
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."
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +447,The following Work Orders were created:,Amri za Kazi zifuatazo zimeundwa:
DocType: Salary Slip,Total in words,Jumla ya maneno
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: Employee Loan,Sanctioned,Imeteuliwa
apps/erpnext/erpnext/accounts/page/pos/pos.js +75, is mandatory. Maybe Currency Exchange record is not created for ,ni lazima. Labda Rekodi ya ubadilishaji Fedha haikuundwa
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +151,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Tafadhali taja Serial Hakuna kwa Bidhaa {1}
DocType: Crop Cycle,Crop Cycle,Mzunguko wa Mazao
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +633,"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: Student Admission,Publish on website,Chapisha kwenye tovuti
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +651,Supplier Invoice Date cannot be greater than Posting Date,Tarehe ya Invozi ya Wasambazaji haiwezi kuwa kubwa kuliko Tarehe ya Kuweka
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.py +132,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: Cheque Print Template,Date Settings,Mpangilio wa Tarehe
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48,Variance,Tofauti
,Company Name,jina la kampuni
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 +24,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 +25,Print Report Card,Kadi ya Ripoti ya Kuchapa
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +30,"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 +132,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 +16,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: BOM,Raw Material Cost(Company Currency),Gharama za Nyenzo za Raw (Fedha la Kampuni)
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +88,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 +147,Meter,Mita
DocType: Workstation,Electricity Cost,Gharama za Umeme
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +23,Lab testing datetime cannot be before collection datetime,Siku ya tarehe ya kupima Lab haiwezi kuwa kabla ya tarehe ya kukusanya
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/hub_node/doctype/hub_settings/hub_settings.js +47,Save Settings,Weka Mipangilio
DocType: Delivery Stop,Notified by Email,Taarifa kwa barua pepe
DocType: Item,Inspection Criteria,Vigezo vya ukaguzi
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Transfered,Imehamishwa
DocType: BOM Website Item,BOM Website Item,BOM ya Bidhaa ya Tovuti
apps/erpnext/erpnext/public/js/setup_wizard.js +52,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/assets/doctype/asset/asset.py +88,Next Depreciation Date is entered as past date,Tarehe ya Uzito ya pili imeingia kama tarehe iliyopita
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208,White,Nyeupe
DocType: SMS Center,All Lead (Open),Viongozi wote (Ufunguzi)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +310,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Row {0}: Uliopatikana kwa {4} katika ghala {1} wakati wa kutuma muda wa kuingia ({2} {3})
apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18,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
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +635,Assigning {0} to {1} (row {2}),Kuagiza {0} kwa {1} (mstari {2})
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810,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 +29,New Employee,Mfanyakazi Mpya
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7,There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.,Kulikuwa na hitilafu. Sababu moja ya uwezekano inaweza kuwa kwamba haujahifadhi fomu. Tafadhali wasiliana na support@erpnext.com ikiwa tatizo linaendelea.
apps/erpnext/erpnext/templates/pages/cart.html +5,My Cart,Yangu Cart
apps/erpnext/erpnext/controllers/selling_controller.py +130,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 +36,Opening Qty,Ufunguzi wa Uchina
DocType: Healthcare Settings,Appointment Reminder,Kumbukumbu ya Uteuzi
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +478,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: Consultation,Doctor,Daktari
DocType: Holiday List,Holiday List Name,Jina la Orodha ya likizo
DocType: Repayment Schedule,Balance Loan Amount,Kiwango cha Mikopo
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,Ratiba ya Kozi
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +236,Stock Options,Chaguzi za hisa
DocType: Buying Settings,Disable Fetching Last Purchase Details in Purchase Order,Lemaza Kurejesha Maelezo ya Mwisho ya Ununuzi katika Ununuzi wa Utaratibu
DocType: Journal Entry Account,Expense Claim,Madai ya Madai
apps/erpnext/erpnext/assets/doctype/asset/asset.js +267,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 +402,Qty for {0},Uchina kwa {0}
DocType: Leave Application,Leave Application,Acha Maombi
DocType: Patient,Patient Relation,Uhusiano wa Mgonjwa
apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,Acha Chombo cha Ugawaji
DocType: Item,Hub Category to Publish,Jamii ya Hifadhi ya Kuchapisha
DocType: Leave Block List,Leave Block List Dates,Acha Tarehe ya Kuzuia Orodha
DocType: Sales Invoice,Billing Address GSTIN,Anwani ya kulipia GSTIN
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: Company,Default Terms,Masharti ya Default
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
apps/erpnext/erpnext/public/js/queries.js +96,Please specify a {0},Tafadhali taja {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +73,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 +415,Variant creation has been queued.,Uumbaji wa viumbe umefungwa.
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +100,Work Summary for {0},Muhtasari wa Kazi kwa {0}
apps/erpnext/erpnext/stock/doctype/item/item.py +696,Attribute table is mandatory,Toleo la meza ni lazima
DocType: Production Plan,Get Sales Orders,Pata Maagizo ya Mauzo
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +68,{0} can not be negative,{0} haiwezi kuwa hasi
DocType: Training Event,Self-Study,Kujitegemea
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +27,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 +567,Discount,Punguzo
DocType: Membership,Membership,Uanachama
DocType: Asset,Total Number of Depreciations,Jumla ya Idadi ya Dhamana
DocType: Sales Invoice Item,Rate With Margin,Kiwango cha Kwa Margin
DocType: Workstation,Wages,Mishahara
DocType: Asset Maintenance,Maintenance Manager Name,Jina la Meneja wa Matengenezo
DocType: Agriculture Task,Urgent,Haraka
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,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 +84,Unable to find variable: ,Haiwezi kupata variable:
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +807,Please select a field to edit from numpad,Tafadhali chagua shamba kuhariri kutoka numpad
apps/erpnext/erpnext/stock/doctype/item/item.py +264,Cannot be a fixed asset item as Stock Ledger is created.,Haiwezi kuwa kitu cha kudumu cha mali kama Stock Ledger imeundwa.
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,Nenda kwenye Desktop na uanze kutumia ERPNext
DocType: Item,Manufacturer,Mtengenezaji
DocType: Landed Cost Item,Purchase Receipt Item,Ununuzi wa Receipt Item
DocType: Purchase Receipt,PREC-RET-,PREC-RET-
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: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Ghala iliyohifadhiwa katika Mauzo ya Hifadhi / Bidhaa Zilizohitimishwa
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71,Selling Amount,Kuuza Kiasi
DocType: Repayment Schedule,Interest Amount,Kiwango cha riba
DocType: Serial No,Creation Document No,Hati ya Uumbaji No
DocType: Share Transfer,Issue,Suala
apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11,Records,Kumbukumbu
DocType: Asset,Scrapped,Imepigwa
DocType: Purchase Invoice,Returns,Inarudi
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +42,WIP Warehouse,Ghala la WIP
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195,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 +35,Recruitment,Uajiri
DocType: Lead,Organization Name,Jina la Shirika
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 +61,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 +858,Delivery Trip,Safari ya Utoaji
DocType: Student,A-,A-
DocType: Share Transfer,Transfer Type,Aina ya Uhamisho
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Sales Expenses,Gharama za Mauzo
DocType: Consultation,Diagnosis,Utambuzi
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18,Standard Buying,Ununuzi wa kawaida
DocType: GL Entry,Against,Dhidi
DocType: Item,Default Selling Cost Center,Kituo cha Gharama ya Kuuza Ghali
apps/erpnext/erpnext/public/js/pos/pos.html +85,Disc,Duru
DocType: Sales Partner,Implementation Partner,Utekelezaji wa Mshiriki
apps/erpnext/erpnext/accounts/page/pos/pos.js +1624,ZIP Code,Namba ya Posta
apps/erpnext/erpnext/controllers/selling_controller.py +252,Sales Order {0} is {1},Amri ya Mauzo {0} ni {1}
DocType: Opportunity,Contact Info,Maelezo ya Mawasiliano
apps/erpnext/erpnext/config/stock.py +323,Making Stock Entries,Kufanya Entries Stock
DocType: Packing Slip,Net Weight UOM,Uzito wa Uzito wa Nambari
DocType: Item,Default Supplier,Muuzaji wa Default
DocType: Manufacturing Settings,Over Production Allowance Percentage,Kwa Asilimia ya Uwezo wa Uzalishaji
DocType: Employee Loan,Repayment Schedule,Ratiba ya Ulipaji
DocType: Shipping Rule Condition,Shipping Rule Condition,Hali ya Kanuni ya Utoaji
DocType: Holiday List,Get Weekly Off Dates,Pata Dondoo za Majuma
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33,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 +337,Invoice can't be made for zero billing hour,Invozi haiwezi kufanywa kwa saa ya kulipa zero
DocType: Sales Person,Select company name first.,Chagua jina la kampuni kwanza.
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +182,Email sent to {0},Barua pepe imetumwa kwa {0}
apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Nukuu zilizopokea kutoka kwa Wauzaji.
apps/erpnext/erpnext/config/manufacturing.py +74,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 +27,To {0} | {1} {2},Kwa {0} | {1} {2}
DocType: Delivery Trip,Driver Name,Jina la dereva
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Umri wa Umri
DocType: Education Settings,Attendance Freeze Date,Tarehe ya Kuhudhuria Tarehe
apps/erpnext/erpnext/utilities/user_progress.py +110,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.
apps/erpnext/erpnext/templates/pages/home.html +31,View All Products,Tazama Bidhaa Zote
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Umri wa Kiongozi wa Chini (Siku)
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +60,All BOMs,BOM zote
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +35,Hotel Rooms of type {0} are unavailable on {1},Vyumba vya aina ya aina {0} hazipatikani kwa {1}
DocType: Patient,Default Currency,Fedha ya Default
DocType: Expense Claim,From Employee,Kutoka kwa Mfanyakazi
DocType: Driver,Cellphone Number,Nambari ya simu ya mkononi
DocType: Project,Monitor Progress,Kufuatilia Maendeleo
apps/erpnext/erpnext/controllers/accounts_controller.py +472,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: 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 +94,Invalid Attribute,Attribute batili
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +240,{0} {1} must be submitted,{0} {1} lazima iwasilishwa
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +159,Quantity must be less than or equal to {0},Wingi lazima iwe chini au sawa na {0}
DocType: SMS Center,Total Characters,Washirika wa jumla
DocType: Employee Advance,Claimed,Alidai
DocType: Crop,Row Spacing,Upeo wa Row
apps/erpnext/erpnext/controllers/buying_controller.py +165,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 +22,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
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +38,Contribution %,Mchango%
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215,"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}"
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Nambari za usajili wa Kampuni kwa kumbukumbu yako. Nambari za kodi nk
DocType: Sales Partner,Distributor,Wasambazaji
DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Ununuzi wa Ununuzi wa Kusafirishwa
apps/erpnext/erpnext/public/js/controllers/transaction.js +71,Please set 'Apply Additional Discount On',Tafadhali weka &#39;Weka Kutoa Kinga ya ziada&#39;
,Ordered Items To Be Billed,Vipengele vya Amri vinavyopigwa
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46,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 +230,Project Collaboration Invitation,Mwaliko wa Ushirikiano wa Mradi
DocType: Salary Slip,Deductions,Kupunguza
DocType: Leave Allocation,LAL/,LAL /
DocType: Setup Progress Action,Action Name,Jina la Hatua
apps/erpnext/erpnext/public/js/financial_statements.js +75,Start Year,Mwaka wa Mwanzo
apps/erpnext/erpnext/regional/india/utils.py +25,First 2 digits of GSTIN should match with State number {0},Majina ya kwanza ya GSTIN yanapaswa kufanana na Nambari ya Jimbo {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +75,PDC/LC,PDC / LC
DocType: Purchase Invoice,Start date of current invoice's period,Tarehe ya mwanzo wa kipindi cha ankara ya sasa
DocType: Salary Slip,Leave Without Pay,Acha bila Bila Kulipa
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +385,Capacity Planning Error,Hitilafu ya Kupanga Uwezo
,Trial Balance for Party,Mizani ya majaribio kwa Chama
DocType: Lead,Consultant,Mshauri
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +356,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 +483,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/learn.py +87,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/manufacturing/doctype/production_planning_tool/production_planning_tool.py +552,Nothing to request,Hakuna chochote cha kuomba
apps/erpnext/erpnext/public/js/setup_wizard.js +18,Select your Domains,Chagua Domains yako
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34,Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3},Rekodi nyingine ya Bajeti &#39;{0}&#39; tayari imesimama dhidi ya {1} &#39;{2}&#39; kwa mwaka wa fedha {3}
DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Mashamba yatakopwa zaidi wakati wa uumbaji.
DocType: Setup Progress Action,Domains,Domains
apps/erpnext/erpnext/projects/doctype/task/task.py +41,'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 +117,Management,Usimamizi
DocType: Cheque Print Template,Payer Settings,Mipangilio ya Payer
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: Purchase Invoice,Is Return,Inarudi
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92,Caution,Tahadhari
apps/erpnext/erpnext/agriculture/doctype/disease/disease.py +17,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 +815,Return / Debit Note,Kurudi / Kumbuka Debit
DocType: Price List Country,Price List Country,Orodha ya Bei ya Nchi
DocType: Item,UOMs,UOM
apps/erpnext/erpnext/stock/utils.py +212,{0} valid serial nos for Item {1},{0} salama ya serial kwa Bidhaa {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57,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/stock/doctype/stock_entry/stock_entry.js +40,Please enter Item Code to get Batch Number,Tafadhali ingiza Msimbo wa Nambari ili kupata Nambari ya Batch
DocType: Stock Settings,Default Item Group,Kikundi cha Kichwa cha Kichwa
DocType: Employee Loan,Partially Disbursed,Kutengwa kwa sehemu
apps/erpnext/erpnext/config/non_profit.py +73,Grant information.,Ruhusu habari.
apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Duka la wauzaji.
DocType: Account,Balance Sheet,Karatasi ya Mizani
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +750,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 +2512,"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 +74,Same item cannot be entered multiple times.,Kitu kimoja hawezi kuingizwa mara nyingi.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +30,"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: Lead,Lead,Cheza
DocType: Email Digest,Payables,Malipo
DocType: Course,Course Intro,Intro Course
apps/erpnext/erpnext/stock/doctype/batch/batch.js +105,Stock Entry {0} created,Entry Entry {0} imeundwa
apps/erpnext/erpnext/controllers/buying_controller.py +322,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 +182,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
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +63,Updating estimated arrival times.,Inasasisha nyakati za kuwasili za makadirio.
DocType: Program Enrollment Tool,Enrollment Details,Maelezo ya Uandikishaji
DocType: Purchase Invoice Item,Net Rate,Kiwango cha Nambari
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +152,Please select a customer,Tafadhali chagua mteja
DocType: Purchase Invoice Item,Purchase Invoice Item,Bidhaa ya Invoice ya Ununuzi
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58,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 +8,Item 1,Kipengee 1
DocType: Holiday,Holiday,Sikukuu
DocType: Support Settings,Close Issue After Days,Funga Suala Baada ya Siku
DocType: Leave Control Panel,Leave blank if considered for all branches,Acha tupu ikiwa inachukuliwa kwa matawi yote
DocType: Bank Guarantee,Validity in Days,Uthibitisho katika Siku
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21,C-form is not applicable for Invoice: {0},Fomu ya C haina kutumika kwa ankara: {0}
DocType: Payment Reconciliation,Unreconciled Payment Details,Maelezo ya Malipo yasiyotambulika
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6,Member Activity,Shughuli ya Mjumbe
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Hesabu ya Hesabu
DocType: Global Defaults,Current Fiscal Year,Mwaka wa Fedha wa sasa
DocType: Purchase Order,Group same items,Jumuisha vitu sawa
DocType: Purchase Invoice,Disable Rounded Total,Lemaza Jumla ya Mviringo
DocType: Employee Loan Application,Repayment Info,Maelezo ya kulipa
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448,'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 +92,Duplicate row {0} with same {1},Mstari wa Duplicate {0} na sawa {1}
,Trial Balance,Mizani ya majaribio
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +443,Fiscal Year {0} not found,Mwaka wa Fedha {0} haukupatikana
apps/erpnext/erpnext/config/hr.py +309,Setting up Employees,Kuweka Wafanyakazi
DocType: Sales Order,SO-,SO-
DocType: Hotel Room Reservation,Hotel Reservation User,User Reservation User
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +158,Please select prefix first,Tafadhali chagua kiambatisho kwanza
DocType: Student,O-,O-
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189,Research,Utafiti
DocType: Maintenance Visit Purpose,Work Done,Kazi Imefanyika
apps/erpnext/erpnext/controllers/item_variant.py +35,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 +45,Item {0} must be a non-stock item,Kipengee {0} lazima iwe kipengee cha hisa
apps/erpnext/erpnext/stock/doctype/batch/batch.js +18,View Ledger,Tazama kizuizi
DocType: Grading Scale,Intervals,Mapumziko
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Mapema kabisa
apps/erpnext/erpnext/stock/doctype/item/item.py +526,"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"
DocType: Crop Cycle,Less than a year,Chini ya mwaka
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Namba ya Mkono ya Mwanafunzi
apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +104,Rest Of The World,Mwisho wa Dunia
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,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/projects/doctype/timesheet/timesheet.py +118,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.py +166,Dividends Paid,Mgawanyiko ulipwa
apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36,Accounting Ledger,Ledger ya Uhasibu
DocType: Stock Reconciliation,Difference Amount,Tofauti Kiasi
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +107,Dr {0} on Leave on {1},Dr {0} juu ya Acha juu ya {1}
DocType: Purchase Invoice,Reverse Charge,Malipo ya Reverse
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +172,Retained Earnings,Mapato yaliyohifadhiwa
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 +18,Payment Mode,Njia ya Malipo
DocType: Purchase Invoice,Supplied Items,Vitu vinavyopatikana
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +85,Please set an active menu for Restaurant {0},Tafadhali weka orodha ya kazi ya Mgahawa {0}
DocType: Student,STUD.,STUD.
DocType: Work Order,Qty To Manufacture,Uchina Ili Kufanya
DocType: Email Digest,New Income,Mapato mapya
DocType: Buying Settings,Maintain same rate throughout purchase cycle,Weka kiwango sawa katika mzunguko wa ununuzi
DocType: Opportunity Item,Opportunity Item,Kitu cha Fursa
,Student and Guardian Contact Details,Mwanafunzi na Mlinzi Maelezo ya Mawasiliano
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +53,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
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72,Temporary Opening,Ufunguo wa Muda
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +9,View Hub,Tazama Hub
,Employee Leave Balance,Mizani ya Waajiriwa
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147,Balance for Account {0} must always be {1},Mizani ya Akaunti {0} lazima iwe {1}
DocType: Patient Appointment,More Info,Maelezo zaidi
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +180,Valuation Rate required for Item in row {0},Kiwango cha Vigezo kinachohitajika kwa Bidhaa katika mstari {0}
DocType: Supplier Scorecard,Scorecard Actions,Vitendo vya kadi ya alama
apps/erpnext/erpnext/utilities/user_progress.py +169,Example: Masters in Computer Science,Mfano: Masters katika Sayansi ya Kompyuta
DocType: Purchase Invoice,Rejected Warehouse,Ghala iliyokataliwa
DocType: GL Entry,Against Voucher,Dhidi ya Voucher
DocType: Item,Default Buying Cost Center,Kituo cha Gharama cha Ununuzi cha Default
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +6,"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/accounts/page/pos/pos.js +76, to ,kwa
DocType: Supplier Quotation Item,Lead Time in days,Tembea Muda katika siku
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +70,Accounts Payable Summary,Muhtasari wa Kulipa Akaunti
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +326,Payment of salary from {0} to {1},Malipo ya mshahara kutoka {0} hadi {1}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213,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 +84,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 +91,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 +151,Lab Test Prescriptions,Maagizo ya Majaribio ya Lab
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +166,"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 +197,Small,Ndogo
DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Kufungua Kitufe cha Uumbaji wa Dawa ya Invoice
DocType: Education Settings,Employee Number,Nambari ya Waajiriwa
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67,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)
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14,Item 2,Kipengee 2
DocType: Supplier,SUPP-,SUPP-
DocType: Training Event,Training Event,Tukio la Mafunzo
DocType: Item,Auto re-order,Rejesha upya
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Achieved,Jumla imefikia
DocType: Employee,Place of Issue,Pahali pa kupewa
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101,Contract,Mkataba
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 +1145,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.py +92,Indirect Expenses,Gharama zisizo sahihi
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +110,Row {0}: Qty is mandatory,Row {0}: Uchina ni lazima
DocType: Agriculture Analysis Criteria,Agriculture,Kilimo
apps/erpnext/erpnext/accounts/page/pos/pos.js +794,Sync Master Data,Sawa Data ya Mwalimu
DocType: Asset Repair,Repair Cost,Tengeneza Gharama
apps/erpnext/erpnext/utilities/user_progress.py +138,Your Products or Services,Bidhaa au Huduma zako
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15,Failed to login,Imeshindwa kuingia
DocType: Special Test Items,Special Test Items,Vipimo vya Mtihani maalum
DocType: Mode of Payment,Mode of Payment,Hali ya Malipo
apps/erpnext/erpnext/stock/doctype/item/item.py +202,Website Image should be a public file or website URL,Image ya tovuti lazima iwe faili ya umma au URL ya tovuti
DocType: Student Applicant,AP,AP
DocType: Purchase Invoice Item,BOM,BOM
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37,This is a root item group and cannot be edited.,Hii ni kikundi cha bidhaa cha mizizi na haiwezi kuhaririwa.
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/hr/doctype/salary_slip/salary_slip.py +434,"{0}: Employee email not found, hence email not sent","{0}: barua pepe ya mfanyakazi haipatikani, hivyo barua pepe haitumwa"
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85,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/healthcare/doctype/patient_appointment/patient_appointment.js +89,Please select Physician and Date,Tafadhali chagua Mganga na Tarehe
DocType: Student Group Student,Group Roll Number,Nambari ya Roll ya Kikundi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145,"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/projects/doctype/project/project.py +84,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,Jumla ya yote uzito wa kazi lazima 1. Tafadhali weka uzito wa kazi zote za Mradi ipasavyo
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +588,Delivery Note {0} is not submitted,Kumbuka Utoaji {0} haujawasilishwa
apps/erpnext/erpnext/stock/get_item_details.py +148,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.py +43,Capital Equipments,Vifaa vya Capital
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33,"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 +246,Please set the Item Code first,Tafadhali weka Kanuni ya Kwanza
DocType: Item,ITEM-,ITEM-
apps/erpnext/erpnext/controllers/selling_controller.py +123,Total allocated percentage for sales team should be 100,Asilimia ya jumla iliyotengwa kwa timu ya mauzo inapaswa kuwa 100
DocType: Sales Invoice Item,Edit Description,Hariri Maelezo
DocType: Antibiotic,Antibiotic,Antibiotic
,Team Updates,Updates ya Timu
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +912,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 +9,Create Print Format,Unda Format Print
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5,Fee Created,Ada Iliyoundwa
apps/erpnext/erpnext/utilities/bot.py +39,Did not find any item called {0},Haikupata kitu kilichoitwa {0}
DocType: Supplier Scorecard Criteria,Criteria Formula,Mfumo wa Kanuni
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Total Outgoing,Jumla ya Kuondoka
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +39,"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: Authorization Rule,Transaction,Shughuli
DocType: Patient Appointment,Duration,Muda
apps/erpnext/erpnext/controllers/status_updater.py +160,"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 +27,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/stock/doctype/warehouse/warehouse.py +53,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/stock/utils.py +207,Serial number {0} entered more than once,Nambari ya serial {0} imeingia zaidi ya mara moja
DocType: Journal Entry,Journal Entry,Kuingia kwa Jarida
DocType: Expense Claim Advance,Unclaimed amount,Kiasi kisichojulikana
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +148,{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 +17,Email Digest:,Ujumbe wa barua pepe:
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py +23,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 +617,BOM {0} does not belong to Item {1},BOM {0} sio Kipengee {1}
DocType: Sales Partner,Target Distribution,Usambazaji wa Target
DocType: Purchase Invoice,06-Finalization of Provisional assessment,06-Kukamilisha tathmini ya muda
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)"
DocType: Quality Inspection Reading,Reading 8,Kusoma 8
DocType: Sales Partner,Agent,Agent
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 +154,Hardware,Vifaa
DocType: Prescription Dosage,Prescription Dosage,Kipimo cha Dawa
DocType: Attendance,HR Manager,Meneja wa HR
apps/erpnext/erpnext/accounts/party.py +175,Please select a Company,Tafadhali chagua Kampuni
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92,Privilege Leave,Uondoaji wa Hifadhi
DocType: Purchase Invoice,Supplier Invoice Date,Tarehe ya Invoice ya Wasambazaji
DocType: Asset Settings,This value is used for pro-rata temporis calculation,Thamani hii hutumiwa kwa hesabu ya pro-rata temporis
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90,You need to enable Shopping Cart,Unahitaji kuwezesha Kifaa cha Ununuzi
DocType: Payment Entry,Writeoff,Andika
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
,BOM Browser,BOM Browser
apps/erpnext/erpnext/templates/emails/training_event.html +13,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 +148,Overlapping conditions found between:,Hali ya uingiliano hupatikana kati ya:
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187,Against Journal Entry {0} is already adjusted against some other voucher,Dhidi ya Kuingia kwa Vitambulisho {0} tayari imebadilishwa dhidi ya hati ya nyingine
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68,Total Order Value,Thamani ya Udhibiti wa Jumla
apps/erpnext/erpnext/demo/setup/setup_data.py +328,Food,Chakula
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +57,Ageing Range 3,Kipindi cha kuzeeka 3
DocType: Maintenance Schedule Item,No of Visits,Hakuna ya Ziara
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165,Maintenance Schedule {0} exists against {1},Ratiba ya Matengenezo {0} ipo dhidi ya {1}
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36,Enrolling student,Kujiandikisha mwanafunzi
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33,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 +21,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
,Delivered Items To Be Billed,Vitu vilivyopakiwa Kufanywa
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16,Open BOM {0},Fungua BOM {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60,Warehouse cannot be changed for Serial No.,Ghala haiwezi kubadilishwa kwa Nambari ya Serial.
DocType: Authorization Rule,Average Discount,Average Discount
DocType: Project Update,Great/Quickly,Kubwa / haraka
DocType: Purchase Invoice Item,UOM,UOM
DocType: Rename Tool,Utilities,Vya kutumia
DocType: POS Profile,Accounting,Uhasibu
DocType: Employee,EMP/,EMP /
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +138,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/regional/report/gstr_1/gstr_1.py +192,Following accounts might be selected in GST Settings:,Kufuatia akaunti inaweza kuchaguliwa katika Mipangilio ya GST:
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +70,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 +31,From {0} | {1} {2},Kutoka {0} | {1} {2}
apps/erpnext/erpnext/public/js/hub/hub_listing.js +341,Removed from Favourites,Imeondolewa kutoka kwa Mapendeleo
DocType: Work Order Operation,Operation Description,Ufafanuzi wa Uendeshaji
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34,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 +41,Avg Daily Outgoing,Kuondoka Kila siku
DocType: POS Profile,Campaign,Kampeni
DocType: Supplier,Name and Type,Jina na Aina
DocType: Physician,Contacts and Address,Mawasiliano na Anwani
DocType: Purchase Invoice,Contact Person,Kuwasiliana na mtu
apps/erpnext/erpnext/projects/doctype/task/task.py +38,'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;
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: Purchase Invoice Item,Item Tax Amount,Kiwango cha Kodi ya Kodi
DocType: Water Analysis,Water Analysis Criteria,Vigezo vya Uchambuzi wa Maji
DocType: Item,Maintain Stock,Weka Stock
DocType: Employee,Prefered Email,Barua pepe iliyopendekezwa
DocType: Student Admission,Eligibility and Details,Uhalali na Maelezo
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +38,Net Change in Fixed Asset,Mabadiliko ya Net katika Mali isiyohamishika
DocType: Leave Control Panel,Leave blank if considered for all designations,Acha tupu ikiwa inachukuliwa kwa sifa zote
apps/erpnext/erpnext/controllers/accounts_controller.py +808,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 +403,Max: {0},Max: {0}
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,Kutoka wakati wa Tarehe
DocType: Email Digest,For Company,Kwa Kampuni
apps/erpnext/erpnext/config/support.py +17,Communication log.,Ingia ya mawasiliano.
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +195,"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 +72,Buying Amount,Kununua Kiasi
DocType: Sales Invoice,Shipping Address Name,Jina la Jina la Mafikisho
DocType: Material Request,Terms and Conditions Content,Masharti na Masharti Maudhui
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18,There were errors creating Course Schedule,Kulikuwa na hitilafu za kuunda ratiba ya kozi
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +581,cannot be greater than 100,haiwezi kuwa zaidi ya 100
apps/erpnext/erpnext/stock/doctype/item/item.py +752,Item {0} is not a stock Item,Kipengee {0} si kitu cha hisa
DocType: Maintenance Visit,Unscheduled,Haijahamishwa
DocType: Employee,Owned,Imepewa
DocType: Salary Detail,Depends on Leave Without Pay,Inategemea kuondoka bila kulipa
DocType: Pricing Rule,"Higher the number, higher the priority","Nambari ya juu, juu ya kipaumbele"
,Purchase Invoice Trends,Ununuzi wa Misaada ya ankara
DocType: Employee,Better Prospects,Matarajio Bora
apps/erpnext/erpnext/stock/doctype/batch/batch.py +217,"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: Vehicle,License Plate,Bamba la leseni
DocType: Appraisal,Goals,Malengo
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +357,Select POS Profile,Chagua Profaili ya POS
DocType: Warranty Claim,Warranty / AMC Status,Waranti / Hali ya AMC
,Accounts Browser,Kivinjari cha Hesabu
DocType: Payment Entry Reference,Payment Entry Reference,Kumbukumbu ya Kuingia kwa Malipo
DocType: GL Entry,GL Entry,Uingiaji wa GL
DocType: HR Settings,Employee Settings,Mipangilio ya Waajiriwa
,Batch-Wise Balance History,Historia ya Mizani-Hekima
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73,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 +105,Apprentice,Mwanafunzi
DocType: Purchase Invoice,Company GSTIN,Kampuni ya GSTIN
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +105,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
DocType: Supplier Scorecard Period,SSC-,SSC-
apps/erpnext/erpnext/hr/doctype/employee/employee.py +160,Employee cannot report to himself.,Mfanyakazi hawezi kujijulisha mwenyewe.
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/accounts/party.py +240,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: 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/accounts.py +183,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/gl_entry/gl_entry.py +53,{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 +60,Show unclosed fiscal year's P&L balances,Onyesha mizani ya P &amp; L isiyopunguzwa mwaka wa fedha
apps/erpnext/erpnext/public/js/hub/hub_form.js +336,Request a Quote,Ombia Nukuu
DocType: Lab Test Template,Collection Details,Maelezo ya Ukusanyaji
DocType: POS Profile,Allow Print Before Pay,Ruhusu Chapisha Kabla ya Kulipa
DocType: Land Unit,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 +92,{0} {1}: Account {2} is inactive,{0} {1}: Akaunti {2} haitumiki
apps/erpnext/erpnext/utilities/activation.py +82,Make Sales Orders to help you plan your work and deliver on-time,Fanya Maagizo ya Mauzo kukusaidia kupanga mpango wako na kutoa muda
DocType: Quality Inspection,Readings,Kusoma
DocType: Stock Entry,Total Additional Costs,Jumla ya gharama za ziada
DocType: Course Schedule,SH,SH
DocType: BOM,Scrap Material Cost(Company Currency),Gharama za Nyenzo za Nyenzo (Fedha la Kampuni)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66,Sub Assemblies,Assemblies ndogo
DocType: Asset,Asset Name,Jina la Mali
DocType: Project,Task Weight,Uzito wa Kazi
DocType: Shipping Rule Condition,To Value,Ili Thamani
DocType: Asset Movement,Stock Manager,Meneja wa Stock
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +211,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 +38,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 +30,Agriculture (beta),Kilimo (beta)
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +863,Packing Slip,Ufungashaji wa Ufungashaji
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Office Rent,Kodi ya Ofisi
apps/erpnext/erpnext/config/setup.py +111,Setup SMS gateway settings,Sanidi mipangilio ya uingizaji wa SMS
DocType: Disease,Common Name,Jina la kawaida
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61,Import Failed!,Ingiza Imeshindwa!
apps/erpnext/erpnext/public/js/templates/address_list.html +20,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 +125,Analyst,Mchambuzi
DocType: Item,Inventory,Uuzaji
DocType: Item,Sales Details,Maelezo ya Mauzo
DocType: Quality Inspection,QI-,QI-
DocType: Opportunity,With Items,Na Vitu
DocType: Asset Maintenance,Maintenance Team,Timu ya Matengenezo
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,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: Notification Control,Expense Claim Rejected,Madai ya Madai yamekataliwa
DocType: Item,Item Attribute,Kipengee cha kipengee
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147,Government,Serikali
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40,Expense Claim {0} already exists for the Vehicle Log,Madai ya Madai {0} tayari yupo kwa Ingia ya Gari
apps/erpnext/erpnext/public/js/setup_wizard.js +64,Institute Name,Jina la Taasisi
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117,Please enter repayment Amount,Tafadhali ingiza Kiwango cha kulipa
apps/erpnext/erpnext/config/stock.py +313,Item Variants,Tofauti ya Tofauti
apps/erpnext/erpnext/public/js/setup_wizard.js +29,Services,Huduma
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/buying/doctype/request_for_quotation/request_for_quotation.js +1041,Select Possible Supplier,Chagua Wasambazaji Inawezekana
DocType: Sales Invoice,Source,Chanzo
DocType: Customer,"Select, to make the customer searchable with these fields","Chagua, ili uweze kutafutwa na mteja na mashamba haya"
apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,Onyesha imefungwa
DocType: Leave Type,Is Leave Without Pay,Anatoka bila Kulipa
apps/erpnext/erpnext/stock/doctype/item/item.py +261,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 +146,No records found in the Payment table,Hakuna kumbukumbu zilizopatikana kwenye meza ya Malipo
apps/erpnext/erpnext/education/utils.py +19,This {0} conflicts with {1} for {2} {3},Hii {0} inakabiliana na {1} kwa {2} {3}
DocType: Student Attendance Tool,Students HTML,Wanafunzi HTML
DocType: POS Profile,Apply Discount,Omba Discount
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 +70,Open Projects,Fungua Miradi
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +295,Packing Slip(s) cancelled,Kulipishwa kwa Slip (s) kufutwa
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +36,Cash Flow from Investing,Mtoko wa Fedha kutoka Uwekezaji
DocType: Program Course,Program Course,Kozi ya Programu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99,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 +27,Taken,Kuchukuliwa
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 +27,Executive Search,Utafutaji wa Mtendaji
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55,Setting defaults,Kuweka desfaults
apps/erpnext/erpnext/utilities/activation.py +63,Create Leads,Unda Mwongozo
DocType: Maintenance Schedule,Schedules,Mipango
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +472,POS Profile is required to use Point-of-Sale,Profaili ya POS inahitajika kutumia Point-of-Sale
DocType: Purchase Invoice Item,Net Amount,Kiasi cha Nambari
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +141,{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: 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
DocType: Student,Leaving Certificate Number,Kuondoka Nambari ya Cheti
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +58,"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 +9,Update Print Format,Sasisha Format ya Kuchapa
DocType: Landed Cost Voucher,Landed Cost Help,Msaada wa Gharama za Utoaji
DocType: Purchase Invoice,Select Shipping Address,Chagua Anwani ya Meli
DocType: Timesheet Detail,Expected Hrs,Haki zilizotarajiwa
apps/erpnext/erpnext/config/non_profit.py +28,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 +220,Please input all required Result Value(s),Tafadhali ingiza Thamani zote za Thamani zinazohitajika
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +106,Accounts Receivable Summary,Muhtasari wa Akaunti ya Kupokea
DocType: Employee Loan,Monthly Repayment Amount,Kiasi cha kulipa kila mwezi
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9,Opening Invoices,Invoices za Ufunguzi
apps/erpnext/erpnext/hr/doctype/employee/employee.py +196,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
DocType: GST HSN Code,HSN Code,Msimbo wa HSN
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +39,Contribution Amount,Mchango wa Mchango
DocType: Purchase Invoice,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.
DocType: Expense Claim,EXP,EXP
apps/erpnext/erpnext/erpnext_integrations/connectors/woocommerce_connection.py +21,Unverified Webhook Data,Takwimu zisizothibitishwa za Mtandao
DocType: Water Analysis,Container,Chombo
apps/erpnext/erpnext/education/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Mwanafunzi {0} - {1} inaonekana mara nyingi mfululizo {2} &amp; {3}
DocType: Item Alternative,Two-way,Njia mbili
DocType: Project,Day to Send,Siku ya Kutuma
DocType: Healthcare Settings,Manage Sample Collection,Dhibiti Mkusanyiko wa Mfano
DocType: Production Plan,Ignore Existing Ordered Quantity,Kupuuza Waliyoagizwa Wingi
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +66,Please set the series to be used.,Tafadhali weka mfululizo kutumiwa.
DocType: Patient,Tobacco Past Use,Tabibu Matumizi ya zamani
DocType: Sales Invoice Item,Brand Name,Jina la Brand
DocType: Purchase Receipt,Transporter Details,Maelezo ya Transporter
apps/erpnext/erpnext/accounts/page/pos/pos.js +2696,Default warehouse is required for selected item,Ghala la msingi linahitajika kwa kipengee kilichochaguliwa
apps/erpnext/erpnext/utilities/user_progress.py +146,Box,Sanduku
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1038,Possible Supplier,Wafanyabiashara wawezekana
DocType: Budget,Monthly Distribution,Usambazaji wa kila mwezi
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68,Receiver List is empty. Please create Receiver List,Orodha ya Receiver haina tupu. Tafadhali tengeneza Orodha ya Kupokea
apps/erpnext/erpnext/public/js/setup_wizard.js +31,Healthcare (beta),Huduma ya afya (beta)
DocType: Production Plan Sales Order,Production Plan Sales Order,Mpango wa Mauzo ya Mauzo
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 +58,Duplicate roll number for student {0},Duplicate roll idadi kwa mwanafunzi {0}
DocType: Budget,Action if Annual Budget Exceeded,Hatua kama Bajeti ya Mwaka imeendelea
apps/erpnext/erpnext/config/learn.py +197,Material Request to Purchase Order,Nambari ya Nyenzo ya Ununuzi wa Utaratibu
DocType: Shopping Cart Settings,Payment Success URL,URL ya Mafanikio ya Malipo
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +81,Row # {0}: Returned Item {1} does not exists in {2} {3},Row # {0}: Bidhaa iliyorejeshwa {1} haipo katika {2} {3}
DocType: Purchase Receipt,PREC-,PREC-
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16,Bank Accounts,Akaunti za Benki
,Bank Reconciliation Statement,Taarifa ya Upatanisho wa Benki
DocType: Consultation,Medical Coding,Coding ya matibabu
DocType: Healthcare Settings,Reminder Message,Ujumbe wa Ukumbusho
,Lead Name,Jina la Kiongozi
,POS,POS
DocType: C-Form,III,III
apps/erpnext/erpnext/config/stock.py +318,Opening Stock Balance,Kufungua Mizani ya Stock
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58,{0} must appear only once,{0} lazima ionekane mara moja tu
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59,Leaves Allocated Successfully for {0},Majani yaliyopangwa kwa Mafanikio kwa {0}
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42,No Items to pack,Hakuna Vipande vya kuingiza
DocType: Shipping Rule Condition,From Value,Kutoka kwa Thamani
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +655,Manufacturing Quantity is mandatory,Uzalishaji wa Wingi ni lazima
DocType: Employee 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/config/hr.py +132,Claims for company expense.,Madai kwa gharama za kampuni.
apps/erpnext/erpnext/utilities/activation.py +118,"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/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,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
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +196,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.py +145,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/selling/page/point_of_sale/point_of_sale.js +403,Select Company,Chagua Kampuni
,Material Requests for which Supplier Quotations are not created,Maombi ya nyenzo ambayo Nukuu za Wasambazaji haziumbwa
DocType: Student Report Generation Tool,Print Section,Sehemu ya Magazeti
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34,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: Student Group,Set 0 for no limit,Weka 0 bila kikomo
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +122,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.
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64,Row {idx}: {field} is required to create the Opening {invoice_type} Invoices,Row {idx}: {field} inahitajika ili kuunda ankara za kufungua {invoice_type}
DocType: Customer,Primary Address and Contact Detail,Anwani ya Msingi na Maelezo ya Mawasiliano
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20,Resend Payment Email,Tuma barua pepe ya malipo
apps/erpnext/erpnext/templates/pages/projects.html +27,New task,Kazi mpya
DocType: Consultation,Appointment,Uteuzi
apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,Fanya Nukuu
apps/erpnext/erpnext/config/education.py +230,Other Reports,Taarifa nyingine
apps/erpnext/erpnext/public/js/setup_wizard.js +39,Please select at least one domain.,Tafadhali chagua angalau kikoa kimoja.
DocType: Dependent Task,Dependent Task,Kazi ya Kudumu
apps/erpnext/erpnext/stock/doctype/item/item.py +444,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 +188,Leave of type {0} cannot be longer than {1},Kuondoka kwa aina {0} haiwezi kuwa zaidi kuliko {1}
DocType: Manufacturing Settings,Try planning operations for X days in advance.,Jaribu kupanga shughuli kwa siku X kabla.
DocType: HR Settings,Stop Birthday Reminders,Weka Vikumbusho vya Kuzaliwa
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +235,Please set Default Payroll Payable Account in Company {0},Tafadhali weka Akaunti ya Kulipa ya Payroll ya Kipawa katika Kampuni {0}
DocType: SMS Center,Receiver List,Orodha ya Kupokea
apps/erpnext/erpnext/accounts/page/pos/pos.js +1094,Search Item,Tafuta kitu
DocType: Payment Schedule,Payment Amount,Kiwango cha Malipo
DocType: Patient Appointment,Referring Physician,Akizungumzia Mganga
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,Kiwango kilichotumiwa
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +100,Net Change in Cash,Mabadiliko ya Net katika Fedha
DocType: Assessment Plan,Grading Scale,Kuweka Scale
apps/erpnext/erpnext/stock/doctype/item/item.py +438,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/manufacturing/doctype/work_order/work_order.py +665,Already completed,Tayari imekamilika
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock In Hand,Stock In Hand
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64,Import Successful!,Ingiza Mafanikio!
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29,Payment Request already exists {0},Ombi la Malipo tayari lipo {0}
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Gharama ya Vitu Vipitishwa
DocType: Physician,Hospital,Hospitali
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +406,Quantity must not be more than {0},Wingi haipaswi kuwa zaidi ya {0}
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117,Previous Financial Year is not closed,Mwaka wa Fedha uliopita haujafungwa
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +68,Age (Days),Umri (Siku)
DocType: Quotation Item,Quotation Item,Nukuu ya Nukuu
DocType: Customer,Customer POS Id,Idhaa ya POS ya Wateja
DocType: Account,Account Name,Jina la Akaunti
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40,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 +198,Serial No {0} quantity {1} cannot be a fraction,Serial Hapana {0} wingi {1} haiwezi kuwa sehemu
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py +96,Please enter Woocommerce Server URL,Tafadhali ingiza URL ya Woocommerce Server
apps/erpnext/erpnext/config/buying.py +43,Supplier Type master.,Aina ya Wafanyabiashara.
DocType: Purchase Order Item,Supplier Part Number,Nambari ya Sehemu ya Wasambazaji
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108,Conversion rate cannot be 0 or 1,Kiwango cha uongofu hawezi kuwa 0 au 1
DocType: Share Balance,To No,Hapana
DocType: Subscription,Reference Document,Hati ya Kumbukumbu
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +229,{0} {1} is cancelled or stopped,{0} {1} imefutwa au imesimamishwa
DocType: Accounts Settings,Credit Controller,Mdhibiti wa Mikopo
DocType: Grant Application,Applicant Type,Aina ya Msaidizi
DocType: Purchase Invoice,03-Deficiency in services,Upungufu wa 03 katika huduma
DocType: Delivery Note,Vehicle Dispatch Date,Tarehe ya Kuondoa Gari
DocType: Healthcare Settings,Default Medical Code Standard,Kiwango cha Kiwango cha Matibabu cha Kudumu
DocType: Purchase Invoice Item,HSN/SAC,HSN / SAC
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237,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 +17,"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."
apps/erpnext/erpnext/controllers/website_list_for_contact.py +113,{0}% Billed,{0}% Imelipwa
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18,Reserved Qty,Nambari iliyohifadhiwa
DocType: Party Account,Party Account,Akaunti ya Chama
apps/erpnext/erpnext/config/setup.py +122,Human Resources,Rasilimali
DocType: Lead,Upper Income,Mapato ya Juu
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17,Reject,Kataa
DocType: Journal Entry Account,Debit in Company Currency,Debit katika Fedha ya Kampuni
DocType: BOM Item,BOM Item,Kipengee cha BOM
DocType: Appraisal,For Employee,Kwa Mfanyakazi
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49,Make Disbursement Entry,Fanya Uingiaji wa Malipo
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138,Row {0}: Advance against Supplier must be debit,Row {0}: Kabla ya Mtoaji lazima awe deni
DocType: Company,Default Values,Maadili ya Maadili
DocType: Membership,INR,INR
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60,{frequency} Digest,{mzunguko} Piga
DocType: Expense Claim,Total Amount Reimbursed,Jumla ya Kizuizi
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5,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/accounts/doctype/purchase_invoice/purchase_invoice.py +90,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 +322,Asset Movement record {0} created,Rekodi ya Movement ya Malipo {0} imeundwa
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51,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
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,A customer with the same name already exists,Mteja mwenye jina sawa tayari yupo
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +185,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
DocType: Purchase Invoice,Eligibility For ITC,Ustahiki Kwa ITC
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 +28,Net Change in Accounts Payable,Mabadiliko ya Nambari ya Akaunti yanapatikana
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48,EcritureLet,UandishiLet
apps/erpnext/erpnext/selling/doctype/customer/customer.py +209,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 +42,Customer required for 'Customerwise Discount',Wateja wanahitajika kwa &#39;Msaada wa Wateja&#39;
apps/erpnext/erpnext/config/accounts.py +140,Update bank payment dates with journals.,Sasisha tarehe za malipo ya benki na majarida.
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21,Pricing,Bei
DocType: Quotation,Term Details,Maelezo ya muda
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30,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 +4,Total (Without Tax),Jumla (bila ya Kodi)
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Hesabu ya Kiongozi
apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} lazima iwe kubwa kuliko 0
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +30,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 +10,Procurement,Ununuzi
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +66,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 +17,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 +46,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: Purchase Invoice,End date of current invoice's period,Tarehe ya mwisho ya kipindi cha ankara ya sasa
DocType: Pricing Rule,Applicable For,Inafaa Kwa
DocType: Lab Test,Technician Name,Jina la mafundi
DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Unlink Malipo ya Kuondoa Invoice
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16,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}
DocType: Restaurant Reservation,No Show,Hakuna Onyesha
DocType: Shipping Rule Country,Shipping Rule Country,Nchi ya Maagizo ya Utoaji
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10,Leave and Attendance,Acha na Uhudhuriaji
DocType: Maintenance Visit,Partially Completed,Ilikamilishwa kikamilifu
apps/erpnext/erpnext/healthcare/setup.py +257,Moderate Sensitivity,Sensitivity ya wastani
DocType: Leave Type,Include holidays within leaves as leaves,Jumuisha likizo ndani ya majani kama majani
DocType: Sales Invoice,Packed Items,Vipuri vilivyowekwa
apps/erpnext/erpnext/config/support.py +27,Warranty Claim against Serial No.,Madai ya Udhamini dhidi ya Namba ya Serial.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +209,'Total',&#39;Jumla&#39;
DocType: Shopping Cart Settings,Enable Shopping Cart,Wezesha Kifaa cha Ununuzi
DocType: Employee,Permanent Address,Anwani ya Kudumu
DocType: Consultation,Medication,Dawa
DocType: Production Plan,Include Non Stock Items,Jumuisha Vipengee Visivyo vya hisa
DocType: Project Update,Challenging/Slow,Changamoto / Kupungua
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147,Please select item code,Tafadhali chagua msimbo wa kipengee
DocType: Student Sibling,Studying in Same Institute,Kujifunza katika Taasisi hiyo
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/hub_node/doctype/hub_settings/hub_settings.js +110,Confirm Action,Thibitisha Hatua
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39,Online Auctions,Madaada ya mtandaoni
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +100,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 +18,Fulfillment,Utekelezaji
apps/erpnext/erpnext/templates/generators/item.html +82,View in Cart,Angalia katika Kifaa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103,Marketing Expenses,Malipo ya Masoko
,Item Shortage Report,Ripoti ya uhaba wa habari
apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py +15,Can't create standard criteria. Please rename the criteria,Haiwezi kuunda vigezo vigezo. Tafadhali renama vigezo
apps/erpnext/erpnext/stock/doctype/item/item.js +311,"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
apps/erpnext/erpnext/assets/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Tarehe ya Uzito ya pili inahitajika kwa mali mpya
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Toka Kundi la kozi la Kundi kwa kila Batch
apps/erpnext/erpnext/config/support.py +32,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
DocType: Drug Prescription,Dosage by time interval,Kipimo kwa wakati wa muda
DocType: Cash Flow Mapper,Section Header,Sehemu ya kichwa
,Student Fee Collection,Ukusanyaji wa Mali ya Wanafunzi
apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +24,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/accounts/doctype/purchase_invoice/purchase_invoice.py +163,Warehouse required at Row No {0},Ghala inayohitajika kwenye Row No {0}
apps/erpnext/erpnext/public/js/setup_wizard.js +145,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
DocType: Material Request,Transferred,Imehamishwa
DocType: Vehicle,Doors,Milango
apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +116,ERPNext Setup Complete!,ERPNext Setup Kamili!
DocType: Healthcare Settings,Collect Fee for Patient Registration,Kukusanya ada kwa Usajili wa Mgonjwa
apps/erpnext/erpnext/stock/doctype/item/item.py +678,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: Packing Slip,PS-,PS-
DocType: Member,Non Profit Member,Mwanachama asiye na faida
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67,{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 +160,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: Land Unit,Area,Eneo
apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,Mawasiliano mpya
DocType: Territory,Parent Territory,Eneo la Mzazi
DocType: Purchase Invoice,Place of Supply,Mahali ya Ugavi
DocType: Quality Inspection Reading,Reading 2,Kusoma 2
DocType: Stock Entry,Material Receipt,Receipt ya nyenzo
DocType: Homepage,Products,Bidhaa
DocType: Announcement,Instructor,Mwalimu
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +95,Select Item (optional),Chagua kitu (hiari)
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: Lead,Next Contact By,Kuwasiliana Nafuatayo
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +325,Quantity required for Item {0} in row {1},Kiasi kinachohitajika kwa Item {0} mfululizo {1}
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +45,Warehouse {0} can not be deleted as quantity exists for Item {1},Ghala {0} haiwezi kufutwa kama kiasi kilichopo kwa Bidhaa {1}
DocType: Quotation,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 +39,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/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Target,Jumla ya Target
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
DocType: Stock Reconciliation,Reconciliation JSON,Upatanisho JSON
apps/erpnext/erpnext/accounts/report/financial_statements.html +3,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: 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 +61,Guardian2 Mobile No,Guardian2 Simu ya Mkono Hakuna
apps/erpnext/erpnext/setup/doctype/company/company.py +218,Main,Kuu
apps/erpnext/erpnext/stock/doctype/item/item.js +72,Variant,Tofauti
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 +458,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?
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,Fursa kutoka shamba ni lazima
DocType: Email Digest,Annual Expenses,Gharama za kila mwaka
DocType: Item,Variants,Tofauti
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1149,Make Purchase Order,Fanya Order ya Ununuzi
DocType: SMS Center,Send To,Tuma kwa
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133,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
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
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +204,Work-in-Progress Warehouse is required before Submit,Ghala ya Maendeleo ya Kazi inahitajika kabla ya Wasilisha
apps/erpnext/erpnext/config/hr.py +40,Applicant for a Job.,Mwombaji wa Kazi.
DocType: Purchase Order Item,Warehouse and Reference,Ghala na Kumbukumbu
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 +42,Student Group Strength,Nguvu ya Kikundi cha Wanafunzi
apps/erpnext/erpnext/config/hr.py +142,Appraisals,Tathmini
apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8,Training Events,Mazoezi ya Mafunzo
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205,Duplicate Serial No entered for Item {0},Duplicate Serial Hakuna aliingia kwa Item {0}
apps/erpnext/erpnext/config/selling.py +179,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
apps/erpnext/erpnext/hr/doctype/employee/employee.py +168,Please enter ,Tafadhali ingiza
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43,Maintenance Log,Ingia ya Matengenezo
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +236,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 +815,Discount amount cannot be greater than 100%,Kiasi cha punguzo hawezi kuwa zaidi ya 100%
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
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +604,BOM {0} must be submitted,BOM {0} lazima iwasilishwa
apps/erpnext/erpnext/config/accounts.py +460,Share Management,Shiriki Usimamizi
DocType: Authorization Control,Authorization Control,Kudhibiti Udhibiti
apps/erpnext/erpnext/controllers/buying_controller.py +333,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Row # {0}: Ghala iliyokataliwa ni lazima dhidi ya Kitu kilichokataliwa {1}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810,Payment,Malipo
apps/erpnext/erpnext/controllers/stock_controller.py +92,"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 +81,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 +56,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: Crop,Crop Spacing,Upeo wa Mazao
DocType: Course,Course Abbreviation,Hali ya Mafunzo
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 +217,"Asset cannot be cancelled, as it is already {0}","Mali haziwezi kufutwa, kama tayari {0}"
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} on Half day on {1},Mfanyakazi {0} kwenye siku ya nusu kwenye {1}
apps/erpnext/erpnext/templates/pages/task_info.html +90,On,On
apps/erpnext/erpnext/config/selling.py +62,Bundle items at time of sale.,Vifungu vya vitu wakati wa kuuza.
DocType: Material Request Plan Item,Actual Qty,Uhakika halisi
DocType: Sales Invoice Item,References,Marejeleo
DocType: Quality Inspection Reading,Reading 10,Kusoma 10
DocType: Item,Barcodes,Barcodes
DocType: Hub Category,Hub Node,Node ya Hub
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,Umeingiza vitu vya duplicate. Tafadhali tengeneza na jaribu tena.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129,Associate,Washirika
DocType: Asset Movement,Asset Movement,Mwendo wa Mali
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +550,Work Order {0} must be submitted,Kazi ya Kazi {0} lazima iwasilishwa
apps/erpnext/erpnext/accounts/page/pos/pos.js +2210,New Cart,New Cart
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Item {0} is not a serialized Item,Kipengee {0} si Kipengee cha sina
DocType: SMS Center,Create Receiver List,Unda Orodha ya Kupokea
DocType: Vehicle,Wheels,Magurudumu
DocType: Packing Slip,To Package No.,Kwa Package No..
DocType: Patient Relation,Family,Familia
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 +52,Telecommunications,Mawasiliano ya simu
apps/erpnext/erpnext/accounts/party.py +263,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)
DocType: Soil Texture,Loam,Loam
apps/erpnext/erpnext/controllers/accounts_controller.py +707,Row {0}: Due Date cannot be before posting date,Row {0}: Tarehe ya Tuzo haiwezi kuwa kabla ya kutuma tarehe
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36,Make Payment Entry,Fanya Uingiaji wa Malipo
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129,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/templates/emails/recurring_document_failed.html +3,For,Kwa
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +167,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
apps/erpnext/erpnext/config/accounts.py +241,Tree of financial Cost Centers.,Mti wa vituo vya gharama za kifedha.
DocType: Serial No,Delivery Document No,Nambari ya Hati ya Utoaji
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191,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}
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/stock/doctype/item_price/item_price.py +33,Item {0} appears multiple times in Price List {1},Kipengee {0} kinaonekana mara nyingi katika orodha ya bei {1}
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41,"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 +181,Material Consumption is not set in Manufacturing Settings.,Matumizi ya Nyenzo haijawekwa katika Mipangilio ya Uzalishaji.
DocType: Student,Student Mobile Number,Namba ya Simu ya Wanafunzi
DocType: Item,Has Variants,Ina tofauti
apps/erpnext/erpnext/controllers/accounts_controller.py +488,"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 +11,Update Response,Sasisha jibu
apps/erpnext/erpnext/public/js/utils.js +374,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
apps/erpnext/erpnext/stock/doctype/batch/batch.py +95,Batch ID is mandatory,Kitambulisho cha Batch ni lazima
DocType: Sales Person,Parent Sales Person,Mtu wa Mauzo ya Mzazi
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +100,The seller and the buyer cannot be the same,Muuzaji na mnunuzi hawezi kuwa sawa
DocType: Project,Collect Progress,Kusanya Maendeleo
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24,Select the program first,Chagua programu kwanza
DocType: Patient Appointment,Patient Age,Umri mgonjwa
apps/erpnext/erpnext/config/learn.py +253,Managing Projects,Miradi ya Kusimamia
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +224,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
DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Consultation charges.,Akaunti zilizopatikana zinazotumiwa kutumiwa ikiwa haziwekwa katika Mgonjwa ili uweke gharama za ushauri.
DocType: Vehicle Log,Fuel Price,Bei ya Mafuta
DocType: Budget,Budget,Bajeti
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +65,Set Open,Weka wazi
apps/erpnext/erpnext/stock/doctype/item/item.py +258,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 +50,"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"
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,Imetimizwa
DocType: Student Admission,Application Form Route,Njia ya Fomu ya Maombi
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66,Territory / Customer,Territory / Wateja
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +44,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 +167,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
DocType: Item,Is Sales Item,Ni Bidhaa ya Mauzo
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21,Item Group Tree,Mti wa Kikundi cha Bidhaa
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69,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
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +335,Same item has been entered multiple times. {0},Kitu kimoja kimeingizwa mara nyingi. {0}
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +30,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/crm/doctype/opportunity/opportunity.js +190,There were errors.,Kulikuwa na makosa.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +166,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
DocType: Naming Series,Current Value,Thamani ya sasa
apps/erpnext/erpnext/controllers/accounts_controller.py +273,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_planning_tool/production_planning_tool.py +229,{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 +137,"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 +6,This is based on stock movement. See {0} for details,Hii inategemea harakati za hisa. Angalia {0} kwa maelezo
DocType: Pricing Rule,Selling,Kuuza
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +392,Amount {0} {1} deducted against {2},Kiasi {0} {1} kilichopunguzwa dhidi ya {2}
DocType: Employee,Salary Information,Maelezo ya Mshahara
DocType: Sales Person,Name and Employee ID,Jina na ID ya Waajiriwa
apps/erpnext/erpnext/accounts/party.py +308,Due Date cannot be before Posting Date,Tarehe ya Kutokana haiwezi kuwa kabla ya Tarehe ya Kuweka
DocType: Website Item Group,Website Item Group,Website Item Group
apps/erpnext/erpnext/public/js/hub/hub_listing.js +339,Added to Favourites,Imeongezwa kwa Mapendeleo
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +463,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.py +150,Duties and Taxes,Kazi na Kodi
DocType: Projects Settings,Projects Settings,Mipangilio ya Miradi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356,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 +44,{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: Purchase Order Item,Material Request Item,Nakala ya Kuomba Nyenzo
apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Mti wa Vikundi vya Bidhaa.
DocType: Production Plan,Total Produced Qty,Uchina uliozalishwa
DocType: Payroll Entry,Get Employee Details,Pata Maelezo ya Waajiri
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +177,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 +230,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
DocType: Sales Invoice Payment,Base Amount (Company Currency),Kiasi cha Msingi (Fedha la Kampuni)
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +928,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
apps/erpnext/erpnext/setup/doctype/company/company.js +113,Delete all the Transactions for this Company,Futa Shughuli zote za Kampuni hii
DocType: Patient,O Positive,O Chanya
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,Investments,Uwekezaji
DocType: Issue,Resolution Details,Maelezo ya Azimio
apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3,Allocations,Ugawaji
DocType: Item Quality Inspection Parameter,Acceptance Criteria,Vigezo vya Kukubali
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +159,Please enter Material Requests in the above table,Tafadhali ingiza Maombi ya Nyenzo katika meza iliyo hapo juu
DocType: Item Attribute,Attribute Name,Jina la sifa
DocType: BOM,Show In Website,Onyesha kwenye tovuti
DocType: Shopping Cart Settings,Show Quantity in Website,Onyesha Wingi kwenye Tovuti
DocType: Employee 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/config/projects.py +36,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 +15,{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 +119,Available slots,Inapatikana
DocType: C-Form Invoice Detail,Invoice No,No ya ankara
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +363,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 +81,"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 +234,Customer Addresses And Contacts,Anwani za Wateja Na Mawasiliano
,Campaign Efficiency,Ufanisi wa Kampeni
DocType: Discussion,Discussion,Majadiliano
DocType: Payment Entry,Transaction ID,Kitambulisho cha Shughuli
DocType: Volunteer,Anytime,Wakati wowote
DocType: Patient,Surgical History,Historia ya upasuaji
DocType: Employee,Resignation Letter Date,Barua ya Kuondoa Tarehe
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39,Pricing Rules are further filtered based on quantity.,Kanuni za bei ni zilizochujwa zaidi kulingana na wingi.
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +127,Not Set,Haijawekwa
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335,Please set the Date Of Joining for employee {0},Tafadhali weka tarehe ya kujiunga na mfanyakazi {0}
DocType: Task,Total Billing Amount (via Time Sheet),Kiasi cha kulipa jumla (kupitia Karatasi ya Muda)
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Rudia Mapato ya Wateja
DocType: Soil Texture,Silty Clay Loam,Mchoro wa Clay Silly
DocType: Chapter,Chapter,Sura
apps/erpnext/erpnext/utilities/user_progress.py +146,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 +970,Select BOM and Qty for Production,Chagua BOM na Uchina kwa Uzalishaji
DocType: Asset,Depreciation Schedule,Ratiba ya kushuka kwa thamani
apps/erpnext/erpnext/config/selling.py +124,Sales Partner Addresses And Contacts,Mauzo ya Mazungumzo ya Washiriki na Mawasiliano
DocType: Bank Reconciliation Detail,Against Account,Dhidi ya Akaunti
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52,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 +139,Please set the Default Cost Center in {0} company.,Tafadhali weka Kituo cha Ghali cha Default katika {0} kampuni.
DocType: Item,Has Batch No,Ina Bande No
apps/erpnext/erpnext/public/js/utils.js +106,Annual Billing: {0},Ulipaji wa Mwaka: {0}
apps/erpnext/erpnext/config/accounts.py +200,Goods and Services Tax (GST India),Malipo na Huduma za Kodi (GST India)
DocType: Delivery Note,Excise Page Number,Nambari ya Ukurasa wa Ushuru
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +227,"Company, From Date and To Date is mandatory","Kampuni, Tarehe na Tarehe ni lazima"
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33,Get from Consultation,Pata kutoka kwenye Ushauri
DocType: Asset,Purchase Date,Tarehe ya Ununuzi
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js +33,Could not generate Secret,Haikuweza kuzalisha Siri
DocType: Volunteer,Volunteer Type,Aina ya kujitolea
DocType: Student,Personal Details,Maelezo ya kibinafsi
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193,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: Task,Actual End Date (via Time Sheet),Tarehe ya mwisho ya mwisho (kupitia Karatasi ya Muda)
DocType: Soil Texture,Soil Type,Aina ya Udongo
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +387,Amount {0} {1} against {2} {3},Kiasi {0} {1} dhidi ya {2} {3}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +277,New Message,Ujumbe mpya
,Quotation Trends,Mwelekeo wa Nukuu
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +160,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 +368,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/utilities/user_progress.py +66,Add Customers,Ongeza Wateja
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Pending Amount,Kiasi kinachosubiri
DocType: Lab Test Template,Special,Maalum
DocType: Purchase Order Item Supplied,Conversion Factor,Fact Conversion
DocType: Purchase Order,Delivered,Imetolewa
,Vehicle Expenses,Gharama za Gari
DocType: Serial No,Invoice Details,Maelezo ya ankara
DocType: Grant Application,Show on Website,Onyesha kwenye tovuti
apps/erpnext/erpnext/assets/doctype/asset/asset.py +212,Expected value after useful life must be greater than or equal to {0},Thamani inayotarajiwa baada ya maisha muhimu lazima iwe kubwa kuliko au sawa na {0}
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29,Start on,Anza
DocType: Hub Category,Hub Category,Jamii ya Hub
DocType: Purchase Invoice,SEZ,SEZ
DocType: Purchase Receipt,Vehicle Number,Nambari ya Gari
DocType: Employee 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 +443,Row {0}: Bill of Materials not found for the Item {1},Row {0}: Sheria ya Vifaa haipatikani kwa Bidhaa {1}
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +98,Total allocated leaves {0} cannot be less than already approved leaves {1} for the period,Majani yaliyotengwa {0} hayawezi kuwa chini ya majani yaliyoidhinishwa tayari {1} kwa muda
DocType: Journal Entry,Accounts Receivable,Akaunti inapatikana
,Supplier-Wise Sales Analytics,Wafanyabiashara-Wiseja Mauzo Analytics
DocType: Purchase Invoice,Availed ITC Central Tax,Taasisi ya Kati ya ITC iliyopatikana
DocType: Salary Structure,Select employees for current Salary Structure,Chagua wafanyakazi kwa muundo wa mshahara wa sasa
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
DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Kozi ya Mzazi (Acha tupu, kama hii si sehemu ya Kozi ya Mzazi)"
DocType: Leave Control Panel,Leave blank if considered for all employee types,Acha tupu ikiwa inachukuliwa kwa aina zote za mfanyakazi
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
DocType: Salary Slip,net pay info,maelezo ya kulipa wavu
DocType: Woocommerce Settings,Enable Sync,Wezesha Sync
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.
DocType: Email Digest,New Expenses,Gharama mpya
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +101,PDC/LC Amount,Kiwango cha PDC / LC
DocType: Shareholder,Shareholder,Mbia
DocType: Purchase Invoice,Additional Discount Amount,Kipengee cha ziada cha Kiasi
DocType: Cash Flow Mapper,Position,Nafasi
DocType: Patient,Patient Details,Maelezo ya Mgonjwa
DocType: Patient,B Positive,B Chanya
apps/erpnext/erpnext/controllers/accounts_controller.py +596,"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 +317,Abbr can not be blank or space,Abbr haiwezi kuwa tupu au nafasi
DocType: Patient Medical Record,Patient Medical Record,Kumbukumbu ya Matibabu Mgonjwa
apps/erpnext/erpnext/accounts/doctype/account/account.js +62,Group to Non-Group,Gundi kwa Wasio Kikundi
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50,Sports,Michezo
DocType: Loan Type,Loan Name,Jina la Mikopo
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Actual,Jumla halisi
DocType: Lab Test UOM,Test UOM,UOM ya mtihani
DocType: Student Siblings,Student Siblings,Ndugu wa Wanafunzi
apps/erpnext/erpnext/utilities/user_progress.py +146,Unit,Kitengo
apps/erpnext/erpnext/stock/get_item_details.py +138,Please specify Company,Tafadhali taja Kampuni
,Customer Acquisition and Loyalty,Upatikanaji wa Wateja na Uaminifu
DocType: Asset Maintenance Task,Maintenance Task,Kazi ya Matengenezo
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +118,Please set B2C Limit in GST Settings.,Tafadhali weka Mpaka wa B2C katika Mipangilio ya GST.
DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,Ghala ambapo unashikilia vitu vya kukataliwa
DocType: Work Order,Skip Material Transfer,Badilisha Transfer Material
apps/erpnext/erpnext/setup/utils.py +109,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 +22,{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 +45,Expense Claims,Madai ya gharama
DocType: Issue,Support,Msaada
,BOM Search,Utafutaji wa BOM
DocType: Project,Total Consumed Material Cost  (via Stock Entry),Jumla ya Gharama za Nyenzo Zilizotumiwa (kupitia Uingiaji wa hisa)
DocType: Hub Settings,Company Registered,Kampuni iliyosajiliwa
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 +27,Please specify currency in Company,Tafadhali taja fedha katika Kampuni
DocType: Workstation,Wages per hour,Mshahara kwa saa
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47,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 +1,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
DocType: Email Digest,Pending Sales Orders,Amri ya Mauzo inasubiri
apps/erpnext/erpnext/controllers/accounts_controller.py +312,Account {0} is invalid. Account Currency must be {1},Akaunti {0} ni batili. Fedha ya Akaunti lazima iwe {1}
DocType: Employee,Create User Permission,Unda Ruhusa ya Mtumiaji
DocType: Healthcare Settings,Remind Before,Kumkumbusha Kabla
apps/erpnext/erpnext/buying/utils.py +34,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 +1087,"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: Salary Component,Deduction,Utoaji
DocType: Item,Retain Sample,Weka Mfano
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,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/stock/get_item_details.py +356,Item Price added for {0} in Price List {1},Item Bei imeongezwa kwa {0} katika Orodha ya Bei {1}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8,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 +78,In Production,Katika Uzalishaji
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +65,Difference Amount must be zero,Tofauti Kiasi lazima iwe sifuri
DocType: Project,Gross Margin,Margin ya Pato
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +61,Please enter Production Item first,Tafadhali ingiza Bidhaa ya Uzalishaji kwanza
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,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 +64,disabled user,mtumiaji mlemavu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +919,Quotation,Nukuu
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +984,Cannot set a received RFQ to No Quote,Haiwezi kuweka RFQ iliyopokea kwa No Quote
DocType: Quotation,QTN-,QTN-
DocType: Salary Slip,Total Deduction,Utoaji Jumla
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +18,Select an account to print in account currency,Chagua akaunti ili uchapishe katika sarafu ya akaunti
,Production Analytics,Uchambuzi wa Uzalishaji
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6,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/manufacturing/doctype/bom/bom.py +204,Cost Updated,Gharama ya Kusasishwa
DocType: Patient,Date of Birth,Tarehe ya kuzaliwa
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +133,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
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Jina la Mpango wa Tathmini
DocType: Work Order Operation,Work Order Operation,Kazi ya Kazi ya Kazi
apps/erpnext/erpnext/stock/doctype/item/item.py +233,Warning: Invalid SSL certificate on attachment {0},Onyo: Cheti cha SSL batili kwenye kiambatisho {0}
apps/erpnext/erpnext/utilities/activation.py +64,"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 +238,Job Description,Maelezo ya Kazi
DocType: Student Applicant,Applied,Imewekwa
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874,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 +59,Guardian2 Name,Jina la Guardian2
DocType: Purchase Invoice,02-Post Sale Discount,02-Chapisha Kuuza Discount
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +132,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Tabia maalum isipokuwa &quot;-&quot;, &quot;#&quot;, &quot;.&quot; na &quot;/&quot; haruhusiwi katika kutaja mfululizo"
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."
,SO Qty,Uchina huo
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +91,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: Health Insurance,Health Insurance,Bima ya Afya
DocType: Asset Repair,Manufacturing Manager,Meneja wa Uzalishaji
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191,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 +41,User {0} already exists,Mtumiaji {0} tayari yupo
apps/erpnext/erpnext/hooks.py +109,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 +233,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/buying/doctype/purchase_order/purchase_order.js +1018,"Item Code, warehouse, quantity are required on row","Msimbo wa kipengee, ghala, wingi unahitajika kwenye mstari"
DocType: Pricing Rule,Supplier,Mtoa huduma
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41,Show Payment Details,Onyesha Maelezo ya Malipo
DocType: Consultation,Consultation Time,Muda wa Ushauri
DocType: C-Form,Quarter,Quarter
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,Miscellaneous Expenses,Malipo tofauti
DocType: Global Defaults,Default Company,Kampuni ya Kichwa
apps/erpnext/erpnext/controllers/stock_controller.py +227,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: Payment Request,PR,PR
DocType: Cheque Print Template,Bank Name,Jina la Benki
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +30,-Above,-Above
DocType: Employee Loan,Employee Loan Account,Akaunti ya Mikopo ya Wafanyakazi
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 +14,Number of Interaction,Idadi ya Mahusiano
apps/erpnext/erpnext/stock/doctype/item/item.js +105,Item Variant Settings,Mipangilio ya Mchapishaji ya Bidhaa
apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +37,Select Company...,Chagua Kampuni ...
DocType: Leave Control Panel,Leave blank if considered for all departments,Acha tupu ikiwa inachukuliwa kwa idara zote
apps/erpnext/erpnext/config/hr.py +228,"Types of employment (permanent, contract, intern etc.).","Aina ya ajira (kudumu, mkataba, intern nk)."
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434,{0} is mandatory for Item {1},{0} ni lazima kwa Bidhaa {1}
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +136,"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/gstr_1/gstr_1.py +202,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 +31,Type of Business,Aina ya Biashara
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +171,"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 +128,Cost of New Purchase,Gharama ya Ununuzi Mpya
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py +35,All tasks for the detected diseases were imported,Kazi zote kwa magonjwa yaliyogunduliwa ziliagizwa
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97,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: Payment Entry,Unallocated Amount,Kiasi kilichowekwa
apps/erpnext/erpnext/templates/includes/product_page.js +91,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 +44,No more updates,Hakuna updates tena
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171,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
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6,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 +29,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 +12,Banking,Banking
apps/erpnext/erpnext/utilities/activation.py +108,Add Timesheets,Ongeza Nyakati za Nyakati
DocType: Vehicle Service,Service Item,Kitu cha Huduma
DocType: Bank Guarantee,Bank Guarantee,Dhamana ya Benki
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39,Please click on 'Generate Schedule' to get schedule,Tafadhali bonyeza &#39;Generate Schedule&#39; ili kupata ratiba
DocType: Bin,Ordered Quantity,Amri ya Amri
apps/erpnext/erpnext/public/js/setup_wizard.js +118,"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/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Profit for the year,Faida kwa mwaka
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125,{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/accounts.py +75,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 +364,{0} against Sales Order {1},{0} dhidi ya Uagizaji wa Mauzo {1}
DocType: Account,Fixed Asset,Mali isiyohamishika
apps/erpnext/erpnext/config/stock.py +328,Serialized Inventory,Mali isiyohamishika
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74,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 +23,Generate Secret,Kuzalisha siri
DocType: Employee 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 +77,{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 +50,Program in the Fee Structure and Student Group {0} are different.,Mpango katika muundo wa ada na kikundi cha wanafunzi {0} ni tofauti.
DocType: Fee Schedule,Receivable Account,Akaunti ya Kupokea
apps/erpnext/erpnext/controllers/accounts_controller.py +618,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/selling.py +321,Sales Order to Payment,Mauzo ya Malipo ya Malipo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123,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
DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,FINDA KWA MFASHAJI
DocType: Land Unit,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 +871,Please select correct account,Tafadhali chagua akaunti sahihi
DocType: Purchase Invoice Item,Weight UOM,Uzito UOM
apps/erpnext/erpnext/config/accounts.py +466,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 +45,Show Variant Attributes,Onyesha sifa za Tofauti
DocType: Student,Blood Group,Kikundi cha Damu
DocType: Course,Course Name,Jina la kozi
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.py +52,Office Equipments,Vifaa vya ofisi
DocType: Purchase Invoice Item,Qty,Uchina
DocType: Fiscal Year,Companies,Makampuni
DocType: Supplier Scorecard,Scoring Setup,Kuweka Kuweka
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24,Electronics,Electoniki
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +326,Debit ({0}),Debit ({0})
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 +98,Full-time,Wakati wote
DocType: Payroll Entry,Employees,Wafanyakazi
DocType: Employee,Contact Details,Maelezo ya Mawasiliano
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 +13,Payment Confirmation,Uthibitishaji wa Malipo
DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,Bei haitaonyeshwa kama Orodha ya Bei haijawekwa
DocType: Stock Entry,Total Incoming Value,Thamani ya Ingizo Yote
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +362,Debit To is required,Debit To inahitajika
apps/erpnext/erpnext/utilities/activation.py +109,"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 +39,Purchase Price List,Orodha ya Bei ya Ununuzi
apps/erpnext/erpnext/config/buying.py +155,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: Payment Reconciliation,Payment Reconciliation,Upatanisho wa Malipo
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153,Please select Incharge Person's name,Tafadhali chagua jina la Incharge Person
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51,Technology,Teknolojia
DocType: Hub Settings,Unregister from Hub,Ungiajili kutoka Hub
apps/erpnext/erpnext/public/js/utils.js +108,Total Unpaid: {0},Jumla isiyolipwa: {0}
DocType: BOM Website Operation,BOM Website Operation,Huduma ya tovuti ya BOM
DocType: Supplier Scorecard,Supplier Score,Score ya Wasambazaji
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +225,Total Invoiced Amt,Jumla ya Amt Invoiced
DocType: Supplier,Warn RFQs,Thibitisha RFQs
DocType: BOM,Conversion Rate,Kiwango cha Kubadilisha
apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,Utafutaji wa Bidhaa
DocType: Assessment Plan,To Time,Kwa Muda
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 +118,Credit To account must be a Payable account,Mikopo Kwa akaunti lazima iwe akaunti ya kulipwa
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43,Please select Student Admission which is mandatory for the paid student applicant,Tafadhali chagua Uingizaji wa Mwanafunzi ambao ni lazima kwa mwombaji aliyepwa msamaha
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +355,BOM recursion: {0} cannot be parent or child of {2},Upungufu wa BOM: {0} hawezi kuwa mzazi au mtoto wa {2}
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +36,Please select a Price List to publish pricing,Tafadhali chagua Orodha ya Bei ili kuchapisha bei
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38,Budget List,Orodha ya Bajeti
DocType: Work Order Operation,Completed Qty,Uliokamilika Uchina
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148,"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"
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27,Price List {0} is disabled,Orodha ya Bei {0} imezimwa
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127,Row {0}: Completed Qty cannot be more than {1} for operation {2},Row {0}: Uchina uliokamilika hauwezi kuwa zaidi ya {1} kwa uendeshaji {2}
DocType: Manufacturing Settings,Allow Overtime,Ruhusu muda wa ziada
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Item ya Msingi {0} haiwezi kurekebishwa kwa kutumia Upatanisho wa Stock, tafadhali utumie Stock Entry"
DocType: Training Event Employee,Training Event Employee,Mafunzo ya Tukio la Mfanyakazi
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1189,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/physician_schedule/physician_schedule.js +7,Add Time Slots,Ongeza Muda wa Muda
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,{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
DocType: Training Event,Advance,Mapema
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,for making recurring again.,kwa kufanya mara kwa mara tena.
apps/erpnext/erpnext/config/erpnext_integrations.py +13,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.py +122,Exchange Gain/Loss,Kubadilisha / Kupoteza
DocType: Opportunity,Lost Reason,Sababu iliyopotea
apps/erpnext/erpnext/controllers/accounts_controller.py +265,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 +30,Unable to find DocType {0},Haikuweza kupata DocType {0}
apps/erpnext/erpnext/public/js/templates/address_list.html +22,New Address,Anwani mpya
DocType: Quality Inspection,Sample Size,Ukubwa wa Mfano
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47,Please enter Receipt Document,Tafadhali ingiza Hati ya Receipt
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +369,All items have already been invoiced,Vitu vyote tayari vinatumiwa
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49,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 +24,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/config/setup.py +66,Users and Permissions,Watumiaji na Ruhusa
DocType: Vehicle Log,VLOG.,VLOG.
DocType: Branch,Branch,Tawi
DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
DocType: Delivery Trip,Fulfillment User,Utimizaji Mtumiaji
apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Uchapishaji na Kubandika
DocType: Company,Total Monthly Sales,Jumla ya Mauzo ya Mwezi
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 +187,Serial No {0} not found,Serial Hapana {0} haipatikani
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +291,Subscription has been {0},Usajili umekuwa {0}
DocType: Fee Schedule Program,Fee Schedule Program,Mpango wa ratiba ya ada
DocType: Fee Schedule Program,Student Batch,Kundi la Wanafunzi
apps/erpnext/erpnext/utilities/activation.py +119,Make Student,Fanya Mwanafunzi
DocType: Supplier Scorecard Scoring Standing,Min Grade,Daraja la Kidogo
apps/erpnext/erpnext/projects/doctype/project/project.py +218,You have been invited to collaborate on the project: {0},Umealikwa kushirikiana kwenye mradi: {0}
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +157,Physician not available on {0},Daktari haipatikani kwenye {0}
DocType: Leave Block List Date,Block Date,Weka Tarehe
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 +70,Apply Now,Tumia Sasa
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,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/setup.py +106,"Create and manage daily, weekly and monthly email digests.","Unda na udhibiti majaribio ya barua pepe kila siku, kila wiki na kila mwezi."
DocType: Appraisal Goal,Appraisal Goal,Lengo la Kutathmini
apps/erpnext/erpnext/public/js/hub/hub_form.js +420,Suggest Category?,Panga Jamii?
DocType: Stock Reconciliation Item,Current Amount,Kiwango cha sasa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +58,Buildings,Majengo
DocType: Fee Schedule,Fee Structure,Mfumo wa Mali
DocType: Timesheet Detail,Costing Amount,Kiwango cha gharama
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Wasambazaji&gt; Aina ya Wasambazaji
DocType: Student Admission Program,Application Fee,Malipo ya Maombi
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +52,Submit Salary Slip,Tuma Slip ya Mshahara
apps/erpnext/erpnext/controllers/selling_controller.py +137,Maxiumm discount for Item {0} is {1}%,Maxiumm discount kwa Item {0} ni {1}%
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16,Import in Bulk,Ingiza katika Bonde
DocType: Sales Partner,Address & Contacts,Anwani na Mawasiliano
DocType: SMS Log,Sender Name,Jina la Sender
DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Vigezo vya Uchambuzi wa Kilimo
DocType: POS Profile,[Select],[Chagua]
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.py +61,Softwares,Softwares
apps/erpnext/erpnext/crm/doctype/lead/lead.py +53,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/healthcare/doctype/patient_appointment/patient_appointment.js +112,Physician {0} not available on {1},Daktari {0} haipatikani kwenye {1}
apps/erpnext/erpnext/accounts/page/pos/pos.js +2577,Select Batch No,Chagua Batch No
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +61,Invalid {0}: {1},Halafu {0}: {1}
,GSTR-1,GSTR-1
DocType: Purchase Invoice,PINV-RET-,PINV-RET-
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
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43,'From Date' is required,&#39;Tarehe Tarehe&#39; inahitajika
DocType: Journal Entry,Reference Number,Nambari ya Kumbukumbu
DocType: Employee,Employment Details,Maelezo ya Ajira
DocType: Employee,New Workplace,Sehemu Mpya ya Kazi
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +330,Material Consumption,Matumizi ya Nyenzo
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Weka kama Imefungwa
apps/erpnext/erpnext/stock/get_item_details.py +127,No Item with Barcode {0},Hakuna kitu na Barcode {0}
DocType: Normal Test Items,Require Result Value,Thamani ya Thamani ya Uhitaji
DocType: Item,Show a slideshow at the top of the page,Onyesha slideshow juu ya ukurasa
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +532,Boms,Boms
apps/erpnext/erpnext/stock/doctype/item/item.py +162,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 +33,Ageing Based On,Kuzeeka kwa Msingi
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +61,Appointment cancelled,Uteuzi umefutwa
DocType: Item,End of Life,Mwisho wa Uzima
apps/erpnext/erpnext/demo/setup/setup_data.py +331,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 +183,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
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +1,Recurring,Inaendelea
DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Maelezo ya Kigezo cha Mapangilio ya Fedha
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 +72,Update Cost,Sasisha Gharama
DocType: Item Reorder,Item Reorder,Kipengee Upya
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +473,Show Salary Slip,Onyesha Slip ya Mshahara
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +849,Transfer Material,Nyenzo za Uhamisho
DocType: Fees,Send Payment Request,Tuma Ombi la Malipo
DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.","Taja shughuli, gharama za uendeshaji na kutoa Operesheni ya kipekee bila shughuli zako."
DocType: Water Analysis,Origin,Mwanzo
apps/erpnext/erpnext/controllers/status_updater.py +204,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 +1155,Please set recurring after saving,Tafadhali kuweka mara kwa mara baada ya kuokoa
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +769,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
DocType: Soil Texture,Clay,Clay
DocType: Topic,Topic,Mada
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +45,Cash Flow from Financing,Mtoko wa Fedha kutoka Fedha
DocType: Budget Account,Budget Account,Akaunti ya Bajeti
DocType: Quality Inspection,Verified By,Imehakikishwa na
apps/erpnext/erpnext/setup/doctype/company/company.py +78,"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: Stock Entry,Purchase Receipt No,Ununuzi wa Receipt No
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Earnest Money,Fedha za Kulipwa
DocType: Sales Invoice, Shipping Bill Number,Nambari ya Bili ya Utoaji
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,Ufuatiliaji
DocType: Asset Maintenance Log,Actions performed,Vitendo vilifanyika
DocType: Cash Flow Mapper,Section Leader,Kiongozi wa sehemu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137,Source of Funds (Liabilities),Chanzo cha Mfuko (Madeni)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +473,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}
DocType: Supplier Scorecard Scoring Standing,Employee,Mfanyakazi
DocType: Asset Repair,Failure Date,Tarehe ya Kushindwa
DocType: Sample Collection,Collected Time,Wakati uliokusanywa
DocType: Company,Sales Monthly History,Historia ya Mwezi ya Mauzo
DocType: Asset Maintenance Task,Next Due Date,Tarehe ya Kuondolewa Inayofuata
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +240,Select Batch,Chagua Batch
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244,{0} {1} is fully billed,{0} {1} imekamilika kikamilifu
apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +31,Vital Signs,Vital Ishara
DocType: Training Event,End Time,Muda wa Mwisho
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,Active Salary Structure {0} found for employee {1} for the given dates,Muundo wa Mshahara wa Active {0} uliopatikana kwa mfanyakazi {1} kwa tarehe zilizopewa
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/setup.py +42,Standard contract terms for Sales or Purchase.,Kanuni za mkataba wa Standard kwa Mauzo au Ununuzi.
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +114,Group by Voucher,Jumuisha kwa Voucher
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +233,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/config/crm.py +6,Sales Pipeline,Bomba la Mauzo
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201,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 +7,Required On,Inahitajika
DocType: Rename Tool,File to Rename,Funga Kurejesha tena
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200,Please select BOM for Item in Row {0},Tafadhali chagua BOM kwa Bidhaa katika Row {0}
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28,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 +480,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 +301,Course: ,Kozi:
DocType: Soil Texture,Sandy Loam,Sandy Loam
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Ratiba ya Matengenezo {0} lazima iondoliwe kabla ya kufuta Sheria hii ya Mauzo
DocType: POS Profile,Applicable for Users,Inatumika kwa Watumiaji
DocType: Notification Control,Expense Claim Approved,Madai ya Madai yaliidhinishwa
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231,No Work Orders created,Hakuna Amri za Kazi zilizoundwa
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +321,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 +155,Pharmaceutical,Madawa
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,Gharama ya Vitu Vilivyotunzwa
DocType: Selling Settings,Sales Order Required,Amri ya Mauzo Inahitajika
DocType: Purchase Invoice,Credit To,Mikopo Kwa
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46,PieceDate,KipandeDate
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31,Active Leads / Customers,Msaidizi wa Active / Wateja
DocType: Employee Education,Post Graduate,Chapisha Chuo
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
DocType: Supplier,Is Frozen,Ni Frozen
apps/erpnext/erpnext/stock/utils.py +224,Group node warehouse is not allowed to select for transactions,Ghala la node ya kikundi hairuhusiwi kuchagua kwa shughuli
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: Warranty Claim,Raised By,Iliyotolewa na
DocType: Payment Gateway Account,Payment Account,Akaunti ya Malipo
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +909,Please specify Company to proceed,Tafadhali taja Kampuni ili kuendelea
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +27,Net Change in Accounts Receivable,Mabadiliko ya Nambari katika Akaunti ya Kukubalika
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88,Compensatory Off,Off Compensation
DocType: Job Offer,Accepted,Imekubaliwa
DocType: Grant Application,Organization,Shirika
DocType: BOM Update Tool,BOM Update Tool,Chombo cha Mwisho cha BOM
DocType: SG Creation Tool Course,Student Group Name,Jina la Kikundi cha Wanafunzi
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js +17,Show exploded view,Onyesha maoni yaliyopuka
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Kujenga ada
apps/erpnext/erpnext/setup/doctype/company/company.js +91,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 +21,Search Results,Matokeo ya Utafutaji
DocType: Room,Room Number,Idadi ya Chumba
apps/erpnext/erpnext/utilities/transaction_base.py +107,Invalid reference {0} {1},Kumbukumbu batili {0} {1}
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 +75,View Fees Records,Angalia Kumbukumbu za Malipo
apps/erpnext/erpnext/setup/doctype/company/company.js +35,Make Tax Template,Fanya Kigezo cha Kodi
apps/erpnext/erpnext/public/js/conf.js +28,User Forum,Forum Forum
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +319,Raw Materials cannot be blank.,Malighafi haziwezi kuwa tupu.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +498,"Could not update stock, invoice contains drop shipping item.","Haikuweza kusasisha hisa, ankara ina bidhaa ya kusafirisha kushuka."
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 +491,Quick Journal Entry,Quick Journal Entry
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200,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
DocType: Stock Entry,For Quantity,Kwa Wingi
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205,Please enter Planned Qty for Item {0} at row {1},Tafadhali ingiza Kiini kilichopangwa kwa Bidhaa {0} kwenye safu {1}
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +93,Google Maps integration is not enabled,Ushirikiano wa Ramani za Google haukuwezeshwa
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241,{0} {1} is not submitted,{0} {1} haijawasilishwa
DocType: Member,Membership Expiry Date,Tarehe ya Kumalizika kwa Uanachama
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +131,{0} must be negative in return document,{0} lazima iwe hasi katika hati ya kurudi
,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 +109,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/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116,Please save the document before generating maintenance schedule,Tafadhali salama waraka kabla ya kuzalisha ratiba ya matengenezo
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30,Latest price updated in all BOMs,Bei ya hivi karibuni imesasishwa katika BOM zote
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,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)
DocType: Delivery Note,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 +68,Total Absent,Jumla ya Ukosefu
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +995,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/config/stock.py +195,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 +1026,Opportunity,Fursa
DocType: Operation,Default Workstation,Kituo cha Kazi cha Kazi
DocType: Notification Control,Expense Claim Approved Message,Ujumbe ulioidhinishwa wa dai
DocType: Payment Entry,Deductions or Loss,Kupoteza au kupoteza
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +247,{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 +55,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 +46,Tree of Bill of Materials,Mti wa Matayarisho ya Vifaa
DocType: Student,Joining Date,Tarehe ya Kujiunga
,Employees working on a holiday,Wafanyakazi wanaofanya kazi likizo
DocType: Share Balance,Current State,Hali ya sasa
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,Andika Sasa
DocType: Share Transfer,From Shareholder,Kutoka kwa Mshirika
DocType: Project,% Complete Method,Njia kamili
apps/erpnext/erpnext/healthcare/setup.py +181,Drug,Madawa
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200,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: Purchase Invoice,PINV-,PINV-
DocType: Authorization Rule,Applicable To (Role),Inafaa kwa (Mgawo)
DocType: BOM Update Tool,Replace BOM,Badilisha BOM
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110,Code {0} already exist,Kanuni {0} tayari iko
DocType: Employee Advance,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: 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 +14,Assessment Group: ,Kundi la Tathmini:
DocType: Item Reorder,Request for,Ombi la
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,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 +246,Leave Without Pay does not match with approved Leave Application records,Acha bila ya kulipa hailingani na kumbukumbu za Maombi ya Kuondoka
DocType: Campaign,Campaign-.####,Kampeni -. ####
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Hatua Zingine
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +796,Please supply the specified items at the best possible rates,Tafadhali usambaze vitu maalum kwa viwango bora zaidi
DocType: Membership,USD,USD
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Make Invoice,Fanya ankara
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +102,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 +86,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 +498,Barcode {0} is not a valid {1} code,Barcode {0} sio sahihi {1} kificho
apps/erpnext/erpnext/public/js/financial_statements.js +83,End Year,Mwisho wa Mwaka
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Quot / Kiongozi%
apps/erpnext/erpnext/hr/doctype/employee/employee.py +125,Contract End Date must be greater than Date of Joining,Tarehe ya Mwisho wa Mkataba lazima iwe kubwa kuliko Tarehe ya Kujiunga
DocType: Driver,Driver,Dereva
DocType: Vital Signs,Nutrition Values,Maadili ya lishe
DocType: Lab Test Template,Is billable,Ni billable
DocType: Delivery Note,DN-,DN-
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 +376,{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 +15,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 +43,Ageing Range 1,Kipindi cha kuzeeka 1
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +212,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
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +68,Select Physician...,Chagua Mganga ...
apps/erpnext/erpnext/public/js/hub/hub_listing.js +606,Back to Products,Rudi kwenye Bidhaa
DocType: Grant Application,Grant Application Details ,Ruhusu Maelezo ya Maombi
DocType: Stock Entry Detail,Original Item,Nakala ya awali
DocType: Purchase Receipt Item,Recd Quantity,Vipimo vya Recd
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +65,Fee Records Created - {0},Kumbukumbu za ada zilizoundwa - {0}
DocType: Asset Category Account,Asset Category Account,Akaunti ya Jamii ya Mali
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +913,Row #{0} (Payment Table): Amount must be positive,Row # {0} (Jedwali la Malipo): Kiasi kinachofaa
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44,CompteNum,CompteNum
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +137,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/stock/doctype/item/item.js +391,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 +539,Stock Entry {0} is not submitted,Uingiaji wa hisa {0} haujawasilishwa
DocType: Payment Reconciliation,Bank / Cash Account,Akaunti ya Benki / Cash
apps/erpnext/erpnext/crm/doctype/lead/lead.py +47,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
DocType: Asset,Manual,Mwongozo
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 +58,Donor information.,Maelezo ya wafadhili.
apps/erpnext/erpnext/config/accounts.py +330,"e.g. Bank, Cash, Credit Card","mfano Benki, Fedha, Kadi ya Mikopo"
DocType: Lead Source,Source Name,Jina la Chanzo
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;"
apps/erpnext/erpnext/stock/doctype/batch/batch.py +119,"Set items shelf life in days, to set expiry based on manufacturing_date plus self life","Weka vitu vya rafu katika siku, kuweka ufikiaji kulingana na viwanda_date pamoja na maisha ya kujitegemea"
DocType: Journal Entry,Credit Note,Maelezo ya Mikopo
DocType: Projects Settings,Ignore Employee Time Overlap,Puuza Muda wa Waajiriwa
DocType: Warranty Claim,Service Address,Anwani ya Huduma
DocType: Asset Maintenance Task,Calibration,Calibration
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +97,{0} is a company holiday,{0} ni likizo ya kampuni
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49,Furnitures and Fixtures,Furnitures na Marekebisho
DocType: Item,Manufacture,Tengeneza
apps/erpnext/erpnext/utilities/user_progress.py +27,Setup Company,Kampuni ya Kuweka
,Lab Test Report,Ripoti ya Mtihani wa Lab
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13,Please Delivery Note first,Tafadhali Tafadhali Tuma Kumbuka
DocType: Student Applicant,Application Date,Tarehe ya Maombi
DocType: Salary Detail,Amount based on formula,Kiasi kilichowekwa kwenye formula
DocType: Purchase Invoice,Currency and Price List,Orodha ya Fedha na Bei
DocType: Opportunity,Customer / Lead Name,Wateja / Jina la Kiongozi
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +115,Clearance Date not mentioned,Tarehe ya kufuta haijajwajwa
apps/erpnext/erpnext/config/manufacturing.py +7,Production,Uzalishaji
DocType: Guardian,Occupation,Kazi
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74,Row {0}:Start Date must be before End Date,Row {0}: tarehe ya mwanzo lazima iwe kabla ya tarehe ya mwisho
DocType: Crop,Planting Area,Eneo la Kupanda
apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),Jumla (Uchina)
DocType: Installation Note Item,Installed Qty,Uchina uliowekwa
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4,This could be because of some invalid Email Addresses in the,Hii inaweza kuwa kwa sababu ya Anwani za barua pepe zisizo sahihi katika
apps/erpnext/erpnext/utilities/user_progress.py +31,You added ,Uliongeza
DocType: Purchase Taxes and Charges,Parenttype,Mzazi
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +10,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/config/hr.py +233,Organization branch master.,Shirika la tawi la taasisi.
apps/erpnext/erpnext/controllers/accounts_controller.py +313, or ,au
DocType: Sales Order,Billing Status,Hali ya kulipia
apps/erpnext/erpnext/public/js/conf.js +32,Report an Issue,Ripoti Suala
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,Utility Expenses,Malipo ya matumizi
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64,90-Above,90-juu
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +252,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
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 +43,Buying Rate,Kiwango cha kununua
DocType: Notification Control,Sales Order Message,Ujumbe wa Utaratibu wa Mauzo
apps/erpnext/erpnext/config/setup.py +15,"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 +240,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: Hub Category,Parent Category,Jamii ya Mzazi
DocType: Payroll Entry,Select Employees,Chagua Waajiriwa
DocType: Opportunity,Potential Sales Deal,Uwezekano wa Mauzo ya Mauzo
DocType: Complaint,Complaints,Malalamiko
DocType: Payment Entry,Cheque/Reference Date,Tazama / Tarehe ya Marejeo
DocType: Purchase Invoice,Total Taxes and Charges,Jumla ya Kodi na Malipo
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 +73,Ledger,Ledger
DocType: Patient Medical Record,PMR-,PMR-
DocType: Drug Prescription,Drug Code,Msimbo wa Dawa
DocType: Target Detail,Target  Amount,Kiwango cha Target
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
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17,"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;"
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,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
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,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 +340,Not Paid and Not Delivered,Hailipatikani na Haijaokolewa
DocType: Product Bundle,Parent Item,Item ya Mzazi
DocType: Account,Account Type,Aina ya Akaunti
DocType: Delivery Note,DN-RET-,DN-RET-
apps/erpnext/erpnext/templates/pages/projects.html +58,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 +123,Leave Type {0} cannot be carry-forwarded,Acha Aina {0} haiwezi kubeba
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215,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
apps/erpnext/erpnext/config/hr.py +93,Payroll,Mishahara
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +196,"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: Patient Service Unit,Parent Service Unit,Kitengo cha Utumishi wa Mzazi
apps/erpnext/erpnext/utilities/activation.py +101,Make User,Fanya Mtumiaji
DocType: Packing Slip,Identification of the package for the delivery (for print),Utambulisho wa mfuko wa utoaji (kwa kuchapishwa)
DocType: Bin,Reserved Quantity,Waliohifadhiwa Wingi
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,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
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +797,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/config/learn.py +21,Customizing Forms,Fomu za Customizing
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +74,Arrear,Nyuma
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158,Depreciation Amount during the period,Upungufu Kiasi wakati wa kipindi
apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +43,Disabled template must not be default template,Template ya ulemavu haipaswi kuwa template default
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +314,For row {0}: Enter planned qty,Kwa mstari {0}: Ingiza qty iliyopangwa
DocType: Shareholder,SH-,SH-
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 +825,Delivery,Utoaji
DocType: Volunteer,Weekdays,Siku za wiki
DocType: Stock Reconciliation Item,Current Qty,Uchina wa sasa
DocType: Restaurant Menu,Restaurant Menu,Mkahawa wa Menyu
apps/erpnext/erpnext/templates/generators/item_group.html +36,Prev,Kabla
DocType: Appraisal Goal,Key Responsibility Area,Eneo la Ujibu wa Ufunguo
apps/erpnext/erpnext/utilities/activation.py +127,"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 +151,Set default inventory account for perpetual inventory,Weka akaunti ya hesabu ya msingi kwa hesabu ya daima
DocType: Item Reorder,Material Request Type,Aina ya Uomba wa Nyenzo
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17,Send Grant Review Email,Tuma Email Review Review
apps/erpnext/erpnext/accounts/page/pos/pos.js +848,"LocalStorage is full, did not save","Mitaa ya Mitaa imejaa, haikuhifadhi"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +112,Row {0}: UOM Conversion Factor is mandatory,Row {0}: Kipengele cha kubadilisha UOM ni lazima
apps/erpnext/erpnext/utilities/user_progress.py +235,Room Capacity,Uwezo wa Chumba
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py +28,Already record exists for the item {0},Tayari rekodi ipo kwa kipengee {0}
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +28,Ref,Ref
DocType: Lab Test,LP-,LP-
DocType: Healthcare Settings,Registration Fee,Malipo ya Usajili
DocType: Budget,Cost Center,Kituo cha Gharama
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +46,Voucher #,Voucher #
DocType: Notification Control,Purchase Order Message,Ujumbe wa Utaratibu wa Ununuzi
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
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14,"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."
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
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134,Head of Marketing and Sales,Mkuu wa Masoko na Mauzo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72,Income Tax,Kodi ya mapato
apps/erpnext/erpnext/config/selling.py +174,Track Leads by Industry Type.,Orodha inayoongozwa na Aina ya Viwanda.
apps/erpnext/erpnext/utilities/user_progress.py +101,Go to Letterheads,Nenda kwenye Barua
DocType: Item Supplier,Item Supplier,Muuzaji wa Bidhaa
apps/erpnext/erpnext/public/js/controllers/transaction.js +1256,Please enter Item Code to get batch no,Tafadhali ingiza Msimbo wa Nambari ili kupata bat
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +880,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 +419,No Items selected for transfer,Hakuna Vichaguliwa kwa uhamisho
apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Anwani zote.
DocType: Company,Stock Settings,Mipangilio ya hisa
apps/erpnext/erpnext/accounts/doctype/account/account.py +183,"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.py +123,Gain/Loss on Asset Disposal,Kupata / Kupoteza kwa Upunguzaji wa Mali
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +21,"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.
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +117,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/selling.py +36,Manage Customer Group Tree.,Dhibiti mti wa Wateja wa Wateja.
DocType: Shopping Cart Settings,Attachments can be shown without enabling the shopping cart,Viambatisho vinaweza kuonyeshwa bila kuwezesha gari la ununuzi
DocType: Normal Test Items,Result Value,Thamani ya matokeo
DocType: Hotel Room,Hotels,Hoteli
DocType: Supplier Quotation,SQTN-,SQTN-
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22,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/includes/product_page.js +22,Not in Stock,Sio katika Hifadhi
DocType: Volunteer,Volunteer Skills,Ujuzi wa Kujitolea
DocType: Appraisal,HR User,Mtumiaji wa HR
DocType: Purchase Invoice,Taxes and Charges Deducted,Kodi na Malipo zimefutwa
apps/erpnext/erpnext/hooks.py +142,Issues,Mambo
apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Hali lazima iwe moja ya {0}
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +64,Reminder to update GSTIN Sent,Kumbusho ya kurekebisha GSTIN Iliyotumwa
DocType: Sales 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 +35,Student Admissions,Uingizaji wa Wanafunzi
apps/erpnext/erpnext/accounts/party.py +388,{0} {1} is disabled,{0} {1} imezimwa
DocType: Supplier,Billing Currency,Fedha ya kulipia
DocType: Sales Invoice,SINV-RET-,SINV-RET-
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200,Extra Large,Ziada kubwa
DocType: Crop,Scientific Name,Jina la Sayansi
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,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: Consultation,In print,Ili kuchapishwa
,Profit and Loss Statement,Taarifa ya Faida na Kupoteza
DocType: Bank Reconciliation Detail,Cheque Number,Angalia Nambari
,Sales Browser,Kivinjari cha Mauzo
DocType: Journal Entry,Total Credit,Jumla ya Mikopo
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542,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 +66,Local,Mitaa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),Mikopo na Maendeleo (Mali)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,Wadaiwa
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199,Large,Kubwa
DocType: Homepage Featured Product,Homepage Featured Product,Bidhaa ya Matukio ya Ukurasa
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +248,All Assessment Groups,Makundi yote ya Tathmini
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,Jina jipya la ghala
apps/erpnext/erpnext/accounts/report/financial_statements.py +259,Total {0} ({1}),Jumla {0} ({1})
DocType: C-Form Invoice Detail,Territory,Nchi
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151,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/student/student_dashboard.py +26,Fee,Malipo
apps/erpnext/erpnext/setup/doctype/company/company.js +154,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/accounts.py +267,Close Balance Sheet and book Profit or Loss.,Funga Karatasi ya Mizani na Kitabu Faida au Kupoteza.
DocType: Student Applicant,Application Status,Hali ya Maombi
DocType: Sensitivity Test Items,Sensitivity Test Items,Vipimo vya Mtihani wa Sensiti
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 +159,Quotation {0} is cancelled,Nukuu {0} imefutwa
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +126,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 +54,Please register the SIREN number in the company information file,Tafadhali kujiandikisha namba ya SIREN katika faili ya habari ya kampuni
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.
,S.O. No.,SO Hapana.
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241,Please create Customer from Lead {0},Tafadhali tengeneza Wateja kutoka Kiongozi {0}
apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3,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/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52,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
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13,This is a root customer group and cannot be edited.,Huu ni kikundi cha wateja wa mizizi na hauwezi kuhaririwa.
DocType: Student,AB-,AB-
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 +83,"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
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65,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: 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 +233,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: Project,Copied From,Ilikosa Kutoka
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +340,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 +96,Name error: {0},Jina la kosa: {0}
DocType: Cash Flow Mapping,Is Finance Cost,Ni Gharama za Fedha
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,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 +27,Please set default customer in Restaurant Settings,Tafadhali weka mteja default katika Mipangilio ya Mkahawa
,Salary Register,Daftari ya Mshahara
DocType: Warehouse,Parent Warehouse,Ghala la Mzazi
DocType: C-Form Invoice Detail,Net Total,Jumla ya Net
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +570,Default BOM not found for Item {0} and Project {1},BOM ya kutosha haipatikani kwa Item {0} na Mradi {1}
apps/erpnext/erpnext/config/hr.py +168,Define various loan types,Eleza aina mbalimbali za mkopo
DocType: Bin,FCFS Rate,Kiwango cha FCFS
DocType: Opening Invoice Creation Tool Item,Outstanding Amount,Kiasi Kikubwa
apps/erpnext/erpnext/templates/generators/bom.html +71,Time(in mins),Muda (kwa mchana)
DocType: Project Task,Working,Kufanya kazi
DocType: Stock Ledger Entry,Stock Queue (FIFO),Taa ya Hifadhi (FIFO)
apps/erpnext/erpnext/public/js/setup_wizard.js +127,Financial Year,Mwaka wa Fedha
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46,{0} does not belong to Company {1},{0} sio Kampuni {1}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66,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 +122,Cost as on,Gharama kama
DocType: Healthcare Settings,Out Patient Settings,Nje Mipangilio ya Mgonjwa
DocType: Account,Round Off,Pande zote
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +263,Quantity must be positive,Wingi lazima uwe na chanya
DocType: Material Request Plan Item,Requested Qty,Uliotakiwa Uchina
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +96,The fields From Shareholder and To Shareholder cannot be blank,Mashamba Kutoka kwa Mshirika na Mshirika hawezi kuwa tupu
DocType: Tax Rule,Use for Shopping Cart,Tumia kwa Ununuzi wa Ununuzi
apps/erpnext/erpnext/controllers/item_variant.py +101,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},Thamani {0} ya Attribute {1} haikuwepo katika orodha ya Makala ya Hifadhi ya Thamani ya Bidhaa {2}
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79,Select Serial Numbers,Chagua Nambari za Serial
DocType: BOM Item,Scrap %,Vipande%
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46,"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"
DocType: Maintenance Visit,Purposes,Malengo
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +112,Atleast one item should be entered with negative quantity in return document,Atleast kitu kimoja kinapaswa kuingizwa kwa kiasi kikubwa katika hati ya kurudi
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +71,"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
,Requested,Aliomba
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93,No Remarks,Hakuna Maneno
DocType: Asset,In Maintenance,Katika Matengenezo
DocType: Purchase Invoice,Overdue,Kuondolewa
DocType: Account,Stock Received But Not Billed,Stock imepata lakini haijatibiwa
apps/erpnext/erpnext/accounts/doctype/account/account.py +84,Root Account must be a group,Akaunti ya mizizi lazima iwe kikundi
DocType: Drug Prescription,Drug Prescription,Dawa ya Dawa
DocType: Fees,FEE.,FEE.
DocType: Employee Loan,Repaid/Closed,Kulipwa / Kufungwa
DocType: Item,Total Projected Qty,Jumla ya Uchina uliopangwa
DocType: Monthly Distribution,Distribution Name,Jina la Usambazaji
apps/erpnext/erpnext/stock/stock_ledger.py +477,"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 kiwango cha thamani haipatikani kwa Bidhaa {0}, ambayo inahitajika kufanya fomu za uhasibu kwa {1} {2}. Ikiwa kipengee kinatumia kama kiwango cha kiwango cha hesabu ya kiwango cha {1}, tafadhali angalia kuwa kwenye {1} meza ya jedwali. Vinginevyo, tafadhali tengeneza shughuli za hisa zinazoingia kwa kipengee au tumaja kiwango cha hesabu katika rekodi ya Bidhaa, kisha jaribu kuwasilisha / kufuta kufungua hii"
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +206,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Tafadhali weka Mfululizo wa Naming kwa {0} kupitia Setup&gt; Mipangilio&gt; Mfululizo wa Naming
DocType: Course,Course Code,Msimbo wa Kozi
apps/erpnext/erpnext/controllers/stock_controller.py +337,Quality Inspection required for Item {0},Ukaguzi wa Ubora unaohitajika kwa Bidhaa {0}
DocType: POS Settings,Use POS in Offline Mode,Tumia POS katika Hali ya Nje
DocType: Supplier Scorecard,Supplier Variables,Vipengele vya Wasambazaji
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/selling.py +105,Manage Territory Tree.,Dhibiti Miti ya Wilaya.
DocType: Patient Service Unit,Patient Service Unit,Unit Service Service
DocType: Journal Entry Account,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 +498,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
DocType: Physician Schedule,Physician Schedule,Ratiba ya Mbaguzi
DocType: Purchase Invoice,Deemed Export,Exported kuagizwa
DocType: Stock Entry,Material Transfer for Manufacture,Uhamisho wa Nyenzo kwa Utengenezaji
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20,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.
DocType: Subscription,Half-yearly,Nusu ya mwaka
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +407,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 +61,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 +1006,Work Orders Created: {0},Amri ya Kazi Iliundwa: {0}
DocType: Sales Invoice,Sales Team1,Timu ya Mauzo1
apps/erpnext/erpnext/stock/doctype/item/item.py +547,Item {0} does not exist,Kipengee {0} haipo
DocType: Sales Invoice,Customer Address,Anwani ya Wateja
DocType: Employee Loan,Loan Details,Maelezo ya Mikopo
DocType: Company,Default Inventory Account,Akaunti ya Akaunti ya Default
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +192,The folio numbers are not matching,Nambari za folio hazifananishi
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124,Row {0}: Completed Qty must be greater than zero.,Row {0}: Uchina uliokamilika lazima uwe mkubwa kuliko sifuri.
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +262,Payment Request for {0},Ombi la Malipo kwa {0}
DocType: Item Barcode,Barcode Type,Aina ya Barcode
DocType: Antibiotic,Antibiotic Name,Jina la Antibiotic
DocType: Purchase Invoice,Apply Additional Discount On,Weka Kutoa Discount On
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +66,Select Type...,Chagua Aina ...
DocType: Crop Cycle,A link to all the Land Units in which the Crop is growing,Kiungo kwa Units zote za Ardhi ambazo Mazao huongezeka
DocType: Account,Root Type,Aina ya mizizi
DocType: Item,FIFO,FIFO
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +136,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 +217,Target warehouse is mandatory for row {0},Ghala inayolenga ni lazima kwa mstari {0}
DocType: Cheque Print Template,Primary Settings,Mipangilio ya msingi
DocType: Purchase Invoice,Select Supplier Address,Chagua Anwani ya Wasambazaji
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +407,Add Employees,Ongeza Waajiriwa
DocType: Purchase Invoice Item,Quality Inspection,Ukaguzi wa Ubora
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196,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 +806,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 +211,Account {0} is frozen,Akaunti {0} imehifadhiwa
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 +29,"Food, Beverage & Tobacco","Chakula, Beverage &amp; Tobacco"
DocType: Account,Account Number,Idadi ya Akaunti
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +752,Can only make payment against unbilled {0},Inaweza tu kulipa malipo dhidi ya unbilled {0}
apps/erpnext/erpnext/controllers/selling_controller.py +102,Commission rate cannot be greater than 100,Kiwango cha Tume haiwezi kuwa zaidi ya 100
DocType: Volunteer,Volunteer,Kujitolea
DocType: Stock Entry,Subcontract,Usikilize
apps/erpnext/erpnext/public/js/utils/party.js +166,Please enter {0} first,Tafadhali ingiza {0} kwanza
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +104,No replies from,Hakuna majibu kutoka
DocType: Work Order Operation,Actual End Time,Wakati wa mwisho wa mwisho
DocType: Item,Manufacturer Part Number,Nambari ya Sehemu ya Mtengenezaji
DocType: Work Order Operation,Estimated Time and Cost,Muda na Gharama zilizohesabiwa
DocType: Bin,Bin,Bin
DocType: Crop,Crop Name,Jina la Mazao
DocType: SMS Log,No of Sent SMS,Hakuna SMS iliyotumwa
DocType: Antibiotic,Healthcare Administrator,Msimamizi wa Afya
apps/erpnext/erpnext/utilities/user_progress.py +47,Set a Target,Weka Lengo
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Tafadhali kuanzisha mfululizo wa kuhesabu kwa Mahudhurio kupitia Upangilio&gt; Orodha ya Kuhesabu
DocType: Dosage Strength,Dosage Strength,Nguvu ya Kipimo
DocType: Account,Expense Account,Akaunti ya gharama
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49,Software,Programu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203,Colour,Rangi
DocType: Assessment Plan Criteria,Assessment Plan Criteria,Vigezo vya Mpango wa Tathmini
apps/erpnext/erpnext/stock/doctype/batch/batch.py +118,Expiry date is mandatory for selected item,Tarehe ya kumalizika ni lazima kwa bidhaa iliyochaguliwa
DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Zuia Maagizo ya Ununuzi
apps/erpnext/erpnext/healthcare/setup.py +258,Susceptible,Inapotosha
DocType: Patient Appointment,Scheduled,Imepangwa
apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Ombi la nukuu.
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js +13,"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 +148,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 +51,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 +541,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})
DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,Chagua Usambazaji wa Kila mwezi ili usambaze malengo kwa miezi.
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78,Change Code,Badilisha Kanuni
DocType: Purchase Invoice Item,Valuation Rate,Kiwango cha Thamani
DocType: Stock Reconciliation,SR/,SR /
DocType: Vehicle,Diesel,Dizeli
apps/erpnext/erpnext/stock/get_item_details.py +388,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 +96,Shipping rule only applicable for Selling,Sheria ya usafirishaji inatumika tu kwa Kuuza
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Tarehe ya Kuanza Mradi
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +30,Until,Mpaka
DocType: Rename Tool,Rename Log,Rejesha Ingia
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Kundi la Wanafunzi au Ratiba ya Kozi ni lazima
DocType: HR Settings,Maintain Billing Hours and Working Hours Same on Timesheet,Hifadhi Masaa ya Ulipaji na Masaa ya Kazi sawa na Timesheet
DocType: Maintenance Visit Purpose,Against Document No,Dhidi ya Nambari ya Hati
DocType: BOM,Scrap,Vipande
apps/erpnext/erpnext/utilities/user_progress.py +217,Go to Instructors,Nenda kwa Walimu
apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,Dhibiti Washirika wa Mauzo.
DocType: Quality Inspection,Inspection Type,Aina ya Ukaguzi
DocType: Fee Validity,Visited yet,Alirudi bado
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +134,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
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35,Expires On,Inamalizika
apps/erpnext/erpnext/utilities/activation.py +117,Add Students,Ongeza Wanafunzi
apps/erpnext/erpnext/public/js/utils.js +412,Please select {0},Tafadhali chagua {0}
DocType: C-Form,C-Form No,Fomu ya Fomu ya C
DocType: BOM,Exploded_items,Ililipuka_items
apps/erpnext/erpnext/utilities/user_progress.py +139,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: Employee Attendance Tool,Unmarked Attendance,Uhudhurio usiojulikana
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137,Researcher,Mtafiti
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 +16,Start date should be less than end date for task {0},Tarehe ya kuanza lazima iwe chini ya tarehe ya mwisho ya kazi {0}
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Jina au barua pepe ni lazima
DocType: Member,MEM-,MEM-
DocType: Instructor,Instructor Log,Ingia ya Mkufunzi
DocType: Purchase Order Item,Returned Qty,Nambari ya Kurudi
DocType: Student,Exit,Utgång
apps/erpnext/erpnext/accounts/doctype/account/account.py +156,Root Type is mandatory,Aina ya mizizi ni lazima
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29,Failed to install presets,Imeshindwa kufunga presets
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +44,"{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: Chapter,Non Profit Manager,Meneja Msaada
DocType: BOM,Total Cost(Company Currency),Gharama ya Jumla (Fedha la Kampuni)
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +321,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 +18,Suplier Name,Jina la Juu
apps/erpnext/erpnext/accounts/report/financial_statements.py +174,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 +134,Opening Entry Journal,Journal ya Kuingia ya Kuingia
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 +233,Probationary Period,Muda wa majaribio
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32,View {0},Tazama {0}
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: Employee Advance,Expense Approver,Msaidizi wa gharama
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Customer must be credit,Row {0}: Upendeleo dhidi ya Wateja lazima uwe mkopo
DocType: Project,Hourly,Kila Saa
apps/erpnext/erpnext/accounts/doctype/account/account.js +83,Non-Group to Group,Siyo Kikundi kwa Kundi
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Kundi ni lazima katika mstari {0}
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Ununuzi wa Receipt Item Inayolewa
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,Ili Ufikiaji
apps/erpnext/erpnext/config/selling.py +302,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/accounts/report/accounts_receivable/accounts_receivable.html +235,Printed On,Kuchapishwa
DocType: Item,Inspection Required before Delivery,Ukaguzi unahitajika kabla ya Utoaji
DocType: Item,Inspection Required before Purchase,Ukaguzi unahitajika kabla ya Ununuzi
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93,Pending Activities,Shughuli zinazosubiri
DocType: Patient Appointment,Reminded,Alikumbushwa
DocType: Patient,PID-,PID-
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 +106,Your Organization,Shirika lako
DocType: Fee Component,Fees Category,Ada ya Jamii
apps/erpnext/erpnext/hr/doctype/employee/employee.py +135,Please enter relieving date.,Tafadhali ingiza tarehe ya kufuta.
apps/erpnext/erpnext/controllers/trends.py +149,Amt,Am
DocType: Supplier Scorecard,Notify Employee,Wajulishe Waajiriwa
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 +38,Newspaper Publishers,Waandishi wa gazeti
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30,Select Fiscal Year,Chagua Mwaka wa Fedha
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115,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 +42,Reorder Level,Reorder Level
DocType: Company,Chart Of Accounts Template,Chati ya Kigezo cha Akaunti
DocType: Attendance,Attendance Date,Tarehe ya Kuhudhuria
apps/erpnext/erpnext/stock/get_item_details.py +352,Item Price updated for {0} in Price List {1},Item Bei iliyosasishwa kwa {0} katika Orodha ya Bei {1}
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 +128,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/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203,Mark Half Day,Mark Half Day
DocType: Sales Invoice,Sales Team,Timu ya Mauzo
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +87,Duplicate entry,Kuingia mara kwa mara
DocType: Program Enrollment Tool,Get Students,Pata Wanafunzi
DocType: Serial No,Under Warranty,Chini ya udhamini
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +516,[Error],[Hitilafu]
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 +14,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 +213,Limit Crossed,Upeo umevuka
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Imepangwa Upto
DocType: Woocommerce Settings,Secret,Siri
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55,Venture Capital,Capital Venture
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +40,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.
DocType: UOM,Must be Whole Number,Inapaswa kuwa Nambari Yote
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/selling/doctype/installation_note/installation_note.py +49,Serial No {0} does not exist,Serial Hakuna {0} haipo
DocType: Sales Invoice Item,Customer Warehouse (Optional),Ghala la Wateja (Hiari)
DocType: Pricing Rule,Discount Percentage,Asilimia ya Punguzo
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Reserved for sub contracting,Imehifadhiwa kwa kuambukizwa ndogo
DocType: Payment Reconciliation Invoice,Invoice Number,Nambari ya ankara
DocType: Shopping Cart Settings,Orders,Amri
DocType: Employee Leave Approver,Leave Approver,Acha Msaidizi
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +314,Please select a batch,Tafadhali chagua batch
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42,JournalLib,JournalLib
DocType: Assessment Group,Assessment Group Name,Jina la Kundi la Tathmini
DocType: Manufacturing Settings,Material Transferred for Manufacture,Nyenzo Iliyohamishwa kwa Utengenezaji
DocType: Landed Cost Item,Receipt Document Type,Aina ya Hati ya Rekodi
DocType: Daily Work Summary Settings,Select Companies,Chagua Makampuni
DocType: Antibiotic,Healthcare,Huduma ya afya
DocType: Target Detail,Target Detail,Maelezo ya Target
apps/erpnext/erpnext/stock/doctype/item/item.js +65,Single Variant,Tofauti moja
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24,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/accounts/report/trial_balance/trial_balance.js +49,Period Closing Entry,Uingiaji wa Kipindi cha Kipindi
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +72,Select Department...,Chagua Idara ...
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38,Cost Center with existing transactions can not be converted to group,Kituo cha Gharama na shughuli zilizopo haziwezi kubadilishwa kuwa kikundi
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374,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 +102,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 +49,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 +77,Avg. Selling Price List Rate,Mg. Orodha ya Bei ya Kuuza
DocType: Salary Component,Salary Component,Kipengele cha Mshahara
apps/erpnext/erpnext/accounts/utils.py +490,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
DocType: Leave Allocation,Leave Allocation,Acha Ugawaji
DocType: Payment Request,Recipient Message And Payment Details,Ujumbe wa mpokeaji na maelezo ya malipo
DocType: Training Event,Trainer Email,Barua ya Mkufunzi
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550,Material Requests {0} created,Maombi ya Nyenzo {0} yaliyoundwa
DocType: Restaurant Reservation,No of People,Hakuna Watu
apps/erpnext/erpnext/config/selling.py +164,Template of terms or contract.,Kigezo cha maneno au mkataba.
DocType: Purchase Invoice,Address and Contact,Anwani na Mawasiliano
DocType: Cheque Print Template,Is Account Payable,Ni Malipo ya Akaunti
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276,Stock cannot be updated against Purchase Receipt {0},Hifadhi haiwezi kurekebishwa dhidi ya Receipt ya Ununuzi {0}
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 +71,"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 +317,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)
apps/erpnext/erpnext/education/doctype/program/program.js +8,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
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11,This email is autogenerated,Barua pepe hii imejitokeza
DocType: Stock Settings,Freeze Stock Entries,Fungua Entries za Stock
DocType: Program Enrollment,Boarding Student,Kuogelea Mwanafunzi
DocType: Asset,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
,Stock Analytics,Analytics ya hisa
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +523,Operations cannot be left blank,Kazi haiwezi kushoto tupu
DocType: Maintenance Visit Purpose,Against Document Detail No,Dhidi ya Detail Document No
apps/erpnext/erpnext/regional/__init__.py +11,Deletion is not permitted for country {0},Ufuta hauruhusiwi kwa nchi {0}
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +110,Party Type is mandatory,Aina ya Chama ni lazima
DocType: Quality Inspection,Outgoing,Inatoka
DocType: Material Request,Requested For,Aliomba
DocType: Quotation Item,Against Doctype,Dhidi ya Doctype
apps/erpnext/erpnext/controllers/buying_controller.py +420,{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 +35,Net Cash from Investing,Fedha Nasi kutoka Uwekezaji
DocType: Work Order,Work-in-Progress Warehouse,Ghala ya Maendeleo ya Kazi
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111,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 +56,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 +354,Reference #{0} dated {1},Rejea # {0} dated {1}
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164,Depreciation Eliminated due to disposal of assets,Kushuka kwa thamani kumetolewa kutokana na uondoaji wa mali
DocType: Member,Member,Mwanachama
apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Dhibiti Anwani
DocType: Work Order Item,Work Order Item,Jedwali la Kazi ya Kazi
DocType: Pricing Rule,Item Code,Msimbo wa kipengee
DocType: Serial No,Warranty / AMC Details,Maelezo ya udhamini / AMC
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116,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: 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 +249,Closing (Dr),Kufungwa (Dk)
DocType: Cheque Print Template,Cheque Size,Angalia Ukubwa
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +238,Serial No {0} not in stock,Serial Hakuna {0} sio katika hisa
apps/erpnext/erpnext/config/selling.py +169,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 +27,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 +71,Qty Total,Uchina Jumla
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32,Against Employee Loan: {0},Dhidi ya Mkopo wa Wafanyakazi: {0}
DocType: Landed Cost Item,Receipt Document,Hati ya Receipt
DocType: Employee Education,School/University,Shule / Chuo Kikuu
DocType: Payment Request,Reference Details,Maelezo ya Kumbukumbu
apps/erpnext/erpnext/assets/doctype/asset/asset.py +56,Expected Value After Useful Life must be less than Gross Purchase Amount,Thamani inayotarajiwa Baada ya Maisha muhimu lazima iwe chini ya Kiasi cha Ununuzi wa Gross
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 +20,Billed Amount,Ulipa kiasi
DocType: Share Transfer,(including),(ikiwa ni pamoja na)
DocType: Asset,Double Declining Balance,Mizani miwili ya kupungua
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180,Closed order cannot be cancelled. Unclose to cancel.,Utaratibu wa kufungwa hauwezi kufutwa. Fungua kufuta.
DocType: Student Guardian,Father,Baba
apps/erpnext/erpnext/controllers/accounts_controller.py +627,'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 +7,Get Updates,Pata Marekebisho
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96,{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 +397,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 +166,Material Request {0} is cancelled or stopped,Ombi la Vifaa {0} limefutwa au kusimamishwa
apps/erpnext/erpnext/config/hr.py +314,Leave Management,Acha Usimamizi
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +120,Group by Account,Kundi na Akaunti
apps/erpnext/erpnext/education/doctype/instructor/instructor.py +21,Please select Employee,Tafadhali chagua Mfanyakazi
DocType: Sales Order,Fully Delivered,Kutolewa kikamilifu
DocType: Lead,Lower Income,Mapato ya chini
DocType: Restaurant Order Entry,Current Order,Utaratibu wa sasa
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +236,Source and target warehouse cannot be same for row {0},Chanzo na ghala la lengo haliwezi kuwa sawa kwa mstari {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +243,"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/employee_loan/employee_loan.py +107,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 +176,Go to Programs,Nenda kwenye Programu
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +205,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 +89,Purchase Order number required for Item {0},Nambari ya Order ya Ununuzi inahitajika kwa Bidhaa {0}
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date',&#39;Tarehe Tarehe&#39; lazima iwe baada ya &#39;Tarehe&#39;
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39,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 +444,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 +73,"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: Consultation,Patient,Mgonjwa
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47,Bypass credit check at Sales Order ,Kagua hundi ya mikopo kwa Order Order
DocType: Land Unit,Check if it is a hydroponic unit,Angalia kama ni sehemu ya hydroponic
apps/erpnext/erpnext/config/stock.py +113,Serial No and Batch,Serial Hakuna na Batch
DocType: Warranty Claim,From Company,Kutoka kwa Kampuni
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +52,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 +77,Please set Number of Depreciations Booked,Tafadhali weka Idadi ya Dhamana iliyopangwa
DocType: Supplier Scorecard Period,Calculations,Mahesabu
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +86,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 +449,Productions Orders cannot be raised for:,Amri za Uzalishaji haziwezi kuinuliwa kwa:
apps/erpnext/erpnext/utilities/user_progress.py +147,Minute,Dakika
apps/erpnext/erpnext/hr/doctype/employee/employee.py +24,Please setup Employee Naming System in Human Resource &gt; HR Settings,Tafadhali kuanzisha Mfumo wa Jina la Waajiriwa katika Rasilimali za Binadamu&gt; Mipangilio ya HR
DocType: Purchase Invoice,Purchase Taxes and Charges,Malipo na Malipo ya Ununuzi
DocType: Chapter,Meetup Embed HTML,Kukutana Embed HTML
apps/erpnext/erpnext/utilities/user_progress.py +121,Go to Suppliers,Nenda kwa Wauzaji
,Qty to Receive,Uchina Ili Kupokea
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 +49,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
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,Wilaya zote
DocType: Sales Partner,Retailer,Muzaji
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115,Credit To account must be a Balance Sheet account,Mikopo Kwa akaunti lazima iwe Hesabu ya Hesabu ya Hesabu
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +118,All Supplier Types,Aina zote za Wasambazaji
DocType: Donor,Donor,Msaidizi
DocType: Global Defaults,Disable In Words,Zimaza Maneno
apps/erpnext/erpnext/stock/doctype/item/item.py +60,Item Code is mandatory because Item is not automatically numbered,Msimbo wa kipengee ni lazima kwa sababu Kipengee hakijasaniwa
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +98,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 +105,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: Patient,Medical History,Historia ya Matibabu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157,Bank Overdraft Account,Akaunti ya Overdraft ya Benki
DocType: Patient,Patient ID,Kitambulisho cha Mgonjwa
DocType: Physician Schedule,Schedule Name,Jina la Ratiba
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +49,Make Salary Slip,Fanya Slip ya Mshahara
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +840,Add All Suppliers,Ongeza Wauzaji Wote
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +94,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Mstari # {0}: Kiasi kilichowekwa hawezi kuwa kikubwa zaidi kuliko kiasi kikubwa.
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75,Browse BOM,Tafuta BOM
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155,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 +101,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: Academic Term,Academic Year,Mwaka wa Elimu
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +79,Available Selling,Inapatikana Kuuza
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169,Opening Balance Equity,Kufungua Mizani Equity
DocType: Lead,CRM,CRM
DocType: Purchase Invoice,N,N
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,Inakaa
DocType: Appraisal,Appraisal,Tathmini
DocType: Purchase Invoice,GST Details,Maelezo ya GST
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +156,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 +9,Academic Year: ,Mwaka wa Chuo Kikuu:
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py +19,Not allow to set alternative item for the item {0},Usiruhusu kuweka kitu mbadala kwa kipengee {0}
DocType: Opportunity,OPTY-,OPTY-
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19,Date is repeated,Tarehe inarudiwa
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27,Authorized Signatory,Ishara iliyoidhinishwa
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +64,Create Fees,Unda ada
DocType: Project,Total Purchase Cost (via Purchase Invoice),Gharama ya Jumla ya Ununuzi (kupitia Invoice ya Ununuzi)
DocType: Training Event,Start Time,Anza Muda
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +421,Select Quantity,Chagua Wingi
DocType: Customs Tariff Number,Customs Tariff Number,Nambari ya Ushuru wa Forodha
DocType: Patient Appointment,Patient Appointment,Uteuzi wa Mgonjwa
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,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 +64,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 +830,Get Suppliers By,Pata Wauzaji
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +173,{0} not found for Item {1},{0} haipatikani kwa Bidhaa {1}
apps/erpnext/erpnext/utilities/user_progress.py +197,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 +17,"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 +28,Message Sent,Ujumbe uliotumwa
apps/erpnext/erpnext/accounts/doctype/account/account.py +98,Account with child nodes cannot be set as ledger,Akaunti yenye nodes za watoto haiwezi kuweka kama kiongozi
DocType: C-Form,II,II
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)
DocType: Physician,Physician Schedules,Ratiba ya daktari
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +215,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
DocType: Stock Settings,Item Naming By,Kipengele kinachojulikana
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46,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 +41,Account {0} does not exists,Akaunti {0} haipo
DocType: Project,Project Type,Aina ya Mradi
apps/erpnext/erpnext/projects/doctype/task/task.py +153,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/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48,DateLet,Tarehe ya Tarehe
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16,Either target qty or target amount is mandatory.,Vipi lengo la qty au kiasi lengo ni lazima.
apps/erpnext/erpnext/config/projects.py +56,Cost of various activities,Gharama ya shughuli mbalimbali
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +60,"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 +163,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 +140,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 +101,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
DocType: Driving License Category,Class,Darasa
DocType: Sales Order,Fully Billed,Imejazwa kikamilifu
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +426,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 +101,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.py +20,Cash In Hand,Fedha Katika Mkono
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137,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
apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in Education &gt; Education Settings,Tafadhali kuanzisha Msaidizi wa Kuita Mfumo katika Elimu&gt; Mipangilio ya Elimu
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 +20,"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 +45,"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: Hub Settings,Publish Items to Hub,Chapisha Vitu kwa Hub
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35,From value must be less than to value in row {0},Kutoka thamani lazima iwe chini kuliko ya thamani katika mstari {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182,Wire Transfer,Uhamisho wa Wire
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92,Check all,Angalia yote
,Issued Items Against Work Order,Vitu vinavyochaguliwa dhidi ya kazi
DocType: Vehicle Log,Invoice Ref,Invoice Ref
DocType: Company,Default Income Account,Akaunti ya Mapato ya Default
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32,Customer Group / Customer,Kundi la Wateja / Wateja
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37,Unclosed Fiscal Years Profit / Loss (Credit),Mikopo ya Mali isiyofunguliwa Faida / Kupoteza (Mikopo)
DocType: Sales Invoice,Time Sheets,Karatasi za Muda
DocType: Lab Test Template,Change In Item,Badilisha katika Item
DocType: Payment Gateway Account,Default Payment Request Message,Ujumbe wa Ombi wa Ulipaji wa Pesa
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 +338,Balance ({0}),Mizani ({0})
apps/erpnext/erpnext/config/accounts.py +134,Banking and Payments,Benki na Malipo
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py +99,Please enter API Consumer Key,Tafadhali ingiza Nambari ya Watumiaji wa API
,Welcome to ERPNext,Karibu kwenye ERPNext
apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,Cheza kwa Nukuu
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +34,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: Patient,A Negative,Hasi
apps/erpnext/erpnext/templates/includes/product_list.js +45,Nothing more to show.,Hakuna zaidi ya kuonyesha.
DocType: Lead,From Customer,Kutoka kwa Wateja
apps/erpnext/erpnext/demo/setup/setup_data.py +327,Calls,Wito
apps/erpnext/erpnext/utilities/user_progress.py +143,A Product,Bidhaa
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +233,Batches,Vita
apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34,Make Fee Schedule,Fanya ratiba ya ada
DocType: Purchase Order Item Supplied,Stock UOM,UOM ya hisa
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233,Purchase Order {0} is not submitted,Amri ya Ununuzi {0} haijawasilishwa
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)
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 +39,Projected,Imepangwa
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +228,Serial No {0} does not belong to Warehouse {1},Serial Hakuna {0} si ya Ghala {1}
apps/erpnext/erpnext/controllers/status_updater.py +177,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: Notification Control,Quotation Message,Ujumbe wa Nukuu
DocType: Employee Loan,Employee Loan Application,Maombi ya Mikopo ya Waajiriwa
DocType: Issue,Opening Date,Tarehe ya Ufunguzi
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +86,Please save the patient first,Tafadhali salama mgonjwa kwanza
apps/erpnext/erpnext/education/api.py +80,Attendance has been marked successfully.,Mahudhurio yamewekwa kwa mafanikio.
DocType: Program Enrollment,Public Transport,Usafiri wa Umma
DocType: Soil Texture,Silt Composition (%),Silt Muundo (%)
DocType: Journal Entry,Remark,Remark
DocType: Healthcare Settings,Avoid Confirmation,Epuka uthibitisho
DocType: Purchase Receipt Item,Rate and Amount,Kiwango na Kiasi
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +176,Account Type for {0} must be {1},Aina ya Akaunti ya {0} lazima iwe {1}
DocType: Healthcare Settings,Default income accounts to be used if not set in Physician to book Consultation charges.,Akaunti za kipato cha mapato zitatumiwa ikiwa haziwekwa katika Mganga wa kitabu cha mashtaka ya Ushauri.
apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Majani na Likizo
DocType: Education Settings,Current Academic Term,Kipindi cha sasa cha elimu
DocType: Sales Order,Not Billed,Si Billed
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +76,Both Warehouse must belong to same Company,Ghala zote mbili lazima ziwe na Kampuni moja
apps/erpnext/erpnext/public/js/templates/contact_list.html +34,No contacts added yet.,Hakuna anwani zilizoongezwa bado.
DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Kiwango cha Voucher ya Gharama
,Item Balance (Simple),Mizani ya Bidhaa (Rahisi)
apps/erpnext/erpnext/config/accounts.py +17,Bills raised by Suppliers.,Miradi iliyotolewa na Wauzaji.
DocType: POS Profile,Write Off Account,Andika Akaunti
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +227,Debit Note Amt,Kumbuka Debit Amt
apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5,Discount Amount,Kiasi cha Punguzo
DocType: Purchase Invoice,Return Against Purchase Invoice,Rudi dhidi ya ankara ya ununuzi
DocType: Item,Warranty Period (in days),Kipindi cha udhamini (katika siku)
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61,Failed to set defaults,Imeshindwa kuweka vifunguko
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Uhusiano na Guardian1
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +791,Please select BOM against item {0},Tafadhali chagua BOM dhidi ya kipengee {0}
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18,Make Invoices,Fanya ankara
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23,Net Cash from Operations,Fedha Nacho kutoka kwa Uendeshaji
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26,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 +30,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 +3,Student Group,Kikundi cha Wanafunzi
DocType: Shopping Cart Settings,Quotation Series,Mfululizo wa Nukuu
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +57,"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
apps/erpnext/erpnext/accounts/page/pos/pos.js +2037,Please select customer,Tafadhali chagua mteja
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
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +90,Customer {0} is created.,Mteja {0} ameundwa.
DocType: Stock Settings,Limit Percent,Percent Limit
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82, 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
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 +58,Missing Currency Exchange Rates for {0},Viwango vya Kubadilisha Fedha Hazipo kwa {0}
DocType: 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: C-Form,C-FORM-,C-FORM-
DocType: Vehicle,Insurance Details,Maelezo ya Bima
DocType: Account,Payable,Inalipwa
DocType: Share Balance,Share Type,Shiriki Aina
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113,Please enter Repayment Periods,Tafadhali ingiza Kipindi cha Malipo
apps/erpnext/erpnext/shopping_cart/cart.py +378,Debtors ({0}),Wadaiwa ({0})
DocType: Pricing Rule,Margin,Margin
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Wateja wapya
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74,Gross Profit %,Faida Pato%
DocType: Appraisal Goal,Weightage (%),Uzito (%)
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +512,Change POS Profile,Badilisha Profaili ya POS
DocType: Bank Reconciliation Detail,Clearance Date,Tarehe ya kufuta
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Ripoti ya Tathmini
apps/erpnext/erpnext/assets/doctype/asset/asset.py +59,Gross Purchase Amount is mandatory,Thamani ya Ununuzi wa Pato ni lazima
apps/erpnext/erpnext/setup/doctype/company/company.js +95,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 +113,Party is mandatory,Chama ni lazima
DocType: Journal Entry,JV-,JV-
apps/erpnext/erpnext/controllers/accounts_controller.py +714,Rows with duplicate due dates in other rows were found: {list},Inapanda kwa duplicate tarehe kutokana na safu zingine zilipatikana: {orodha}
DocType: Topic,Topic Name,Jina la Mada
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +37,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 +290,Select an employee to get the employee advance.,Chagua mfanyakazi ili aendelee mfanyakazi.
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +56,Please select a valid Date,Tafadhali chagua Tarehe halali
apps/erpnext/erpnext/public/js/setup_wizard.js +36,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 +86,Row #{0}: Duplicate entry in References {1} {2},Mstari # {0}: Kuingia kwa Duplicate katika Marejeleo {1} {2}
apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,Ambapo shughuli za utengenezaji zinafanywa.
apps/erpnext/erpnext/education/doctype/instructor/instructor.js +18,As Examiner,Kama Mchunguzi
DocType: Appointment Type,Default Duration,Muda wa Muda
DocType: Asset Movement,Source Warehouse,Ghala la Chanzo
DocType: Installation Note,Installation Date,Tarehe ya Usanidi
apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js +30,Share Ledger,Shirikisha Ledger
apps/erpnext/erpnext/controllers/accounts_controller.py +606,Row #{0}: Asset {1} does not belong to company {2},Row # {0}: Malipo {1} si ya kampuni {2}
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206,Sales Invoice {0} created,Invoice ya Mauzo {0} imeundwa
DocType: Employee,Confirmation Date,Tarehe ya uthibitisho
DocType: C-Form,Total Invoiced Amount,Kiasi kilichopakiwa
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +50,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: Employee Loan Application,Required by Date,Inahitajika kwa Tarehe
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: 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
DocType: Customer,CUST-,CUST-
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50,Idevise,Fanya
DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Pato la Pato la Jumla - Utoaji Jumla - Ulipaji wa Mikopo
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +29,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 +47,Salary Slip ID,Kitambulisho cha Mshahara wa Mshahara
apps/erpnext/erpnext/hr/doctype/employee/employee.py +119,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 +68,Multiple Variants,Vipengele vingi
DocType: Sales Invoice,Against Income Account,Dhidi ya Akaunti ya Mapato
apps/erpnext/erpnext/controllers/website_list_for_contact.py +117,{0}% Delivered,{0}% Ametolewa
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +107,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: Monthly Distribution Percentage,Monthly Distribution Percentage,Asilimia ya Usambazaji wa Kila mwezi
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +62,Please login as another user.,Tafadhali ingia kama mtumiaji mwingine.
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: Delivery Note,Transporter Info,Info Transporter
apps/erpnext/erpnext/accounts/utils.py +497,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 +33,Same supplier has been entered multiple times,Muuzaji sawa ameingizwa mara nyingi
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Faida ya Pato / Kupoteza
,Warehouse wise Item Balance Age and Value,Ghala la hekima jambo la kupima Umri na Thamani
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Nambari ya Utaratibu wa Ununuzi Inayotolewa
apps/erpnext/erpnext/public/js/setup_wizard.js +94,Company Name cannot be Company,Jina la Kampuni hawezi kuwa Kampuni
apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,Viongozi wa Barua kwa templates za kuchapisha.
apps/erpnext/erpnext/config/setup.py +32,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/accounts/doctype/payment_entry/payment_entry.js +218,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/templates/emails/recurring_document_failed.html +10,in the subscription,katika usajili
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100,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: Membership,Payment Details,Maelezo ya Malipo
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,Kiwango cha BOM
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +225,"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 +83,Please pull items from Delivery Note,Tafadhali puta vitu kutoka kwa Kumbuka Utoaji
apps/erpnext/erpnext/config/crm.py +92,"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 +170,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/physician_schedule/physician_schedule.js +10,Select Days,Chagua Siku
DocType: Academic Term,Term Name,Jina la Muda
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +332,Credit ({0}),Mikopo ({0})
DocType: Buying Settings,Purchase Order Required,Utaratibu wa Ununuzi Unahitajika
apps/erpnext/erpnext/public/js/projects/timer.js +5,Timer,Muda
,Item-wise Sales History,Historia Mauzo ya hekima
DocType: Expense Claim,Total Sanctioned Amount,Jumla ya Kizuizi
DocType: Land Unit,Land Unit,Kitengo cha Ardhi
,Purchase Analytics,Uchambuzi wa Ununuzi
DocType: Sales Invoice Item,Delivery Note Item,Nambari ya Kumbuka ya Utoaji
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 +76,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 +13,This is a root sales person and cannot be edited.,Huu ni mtu wa mauzo ya mizizi na hauwezi kuhaririwa.
DocType: Salary Detail,"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."
DocType: Asset Settings,Number of Days in Fiscal Year,Idadi ya Siku katika Mwaka wa Fedha
,Stock Ledger,Ledger ya hisa
apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},Kiwango: {0}
DocType: Company,Exchange Gain / Loss Account,Pata Akaunti ya Kupoteza / Kupoteza
apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Mfanyakazi na Mahudhurio
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +105,Purpose must be one of {0},Lengo lazima iwe moja ya {0}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +100,Fill the form and save it,Jaza fomu na uihifadhi
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Jumuiya ya Jumuiya
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52,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 +46,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: Company,Default Letter Head,Kichwa cha Kichwa cha Default
DocType: Purchase Order,Get Items from Open Material Requests,Pata Vitu kutoka kwa Maombi ya Vifaa vya Ufunguzi
DocType: Hotel Room Amenity,Billable,Inafaa
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 +77,Reorder Qty,Rekebisha Uchina
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28,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 +17,Write Off,Andika
DocType: Patient 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/support/doctype/warranty_claim/warranty_claim.py +16,{0}: From {1},{0}: Kutoka {1}
DocType: Task,depends_on,inategemea na
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +60,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.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26,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
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Wateja&gt; Kikundi cha Wateja&gt; Eneo
apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Nchi za hekima za Hitilafu za Hitilafu za Nchi
DocType: Water Analysis,Appearance,Mwonekano
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +77,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 +23,Member information.,Maelezo ya wanachama.
apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Fomu / Bidhaa / {0}) haipo nje ya hisa
apps/erpnext/erpnext/assets/doctype/asset/asset.js +58,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/accounts/party.py +320,Due / Reference Date cannot be after {0},Kutokana / Tarehe ya Kumbukumbu haiwezi kuwa baada ya {0}
apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Kuingiza Data na Kuagiza
DocType: Patient,Account Details,Maelezo ya Akaunti
DocType: Crop,Materials Required,Vifaa vinahitajika
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76,No students Found,Hakuna wanafunzi waliopatikana
DocType: Medical Department,Medical Department,Idara ya Matibabu
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 +55,Invoice Posting Date,Tarehe ya Kuagiza Invozi
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,Nunua
DocType: Purchase Invoice,Rounded Total,Imejaa Jumla
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 +39,Not permitted. Please disable the Test Template,Hairuhusiwi. Tafadhali afya Kigezo cha Mtihani
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Asilimia ya Ugawaji lazima iwe sawa na 100%
DocType: Crop Cycle,Linked Land Unit,Kitengo cha Ardhi kilichohusishwa
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584,Please select Posting Date before selecting Party,Tafadhali chagua Tarehe ya Kuweka kabla ya kuchagua Chama
DocType: Program Enrollment,School House,Shule ya Shule
DocType: Serial No,Out of AMC,Nje ya AMC
apps/erpnext/erpnext/assets/doctype/asset/asset.py +82,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
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Fanya Ziara ya Utunzaji
apps/erpnext/erpnext/selling/doctype/customer/customer.py +215,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
apps/erpnext/erpnext/config/accounts.py +62,Company (not Customer or Supplier) master.,Kampuni (si Wateja au Wafanyabiashara) Mwalimu.
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6,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 +178,No Students in,Hakuna Wanafunzi
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +179,Add more items or open full form,Ongeza vitu vingine au kufungua fomu kamili
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212,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 +259,Go to Users,Nenda kwa Watumiaji
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85,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 +78,{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 +130,Note: There is not enough leave balance for Leave Type {0},Kumbuka: Hakuna usawa wa kutosha wa kuondoka kwa Aina ya Kuondoka {0}
apps/erpnext/erpnext/regional/india/utils.py +16,Invalid GSTIN or Enter NA for Unregistered,GSTIN isiyo sahihi au Ingia NA kwa Usajili
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: Opportunity,Opportunity Type,Aina ya Fursa
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16,New Company,Kampuni mpya
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17,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 +21,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
DocType: Hub Settings,Publish Availability,Chapisha Upatikanaji
DocType: Company,Create Chart Of Accounts Based On,Unda Chati ya Hesabu za Akaunti
apps/erpnext/erpnext/projects/doctype/task/task.js +91,Cannot convert it to non-group. Child Tasks exist.,Haiwezi kuibadilisha kuwa sio kundi. Kazi za Watoto zipo.
apps/erpnext/erpnext/hr/doctype/employee/employee.py +113,Date of Birth cannot be greater than today.,Tarehe ya kuzaliwa haiwezi kuwa kubwa kuliko leo.
,Stock Ageing,Kuzaa hisa
apps/erpnext/erpnext/education/doctype/student/student.py +40,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 +39,Timesheet,Timesheet
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +243,Batch: ,Kundi:
DocType: Volunteer,Afternoon,Saa ya asubuhi
apps/erpnext/erpnext/controllers/accounts_controller.py +258,{0} '{1}' is disabled,{0} &#39;{1}&#39; imezimwa
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Weka kama Fungua
DocType: Cheque Print Template,Scanned Cheque,Angalia Angalia
DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Tuma barua pepe moja kwa moja kwa Wafanyabiashara juu ya Kuwasilisha shughuli.
DocType: Timesheet,Total Billable Amount,Kiasi cha Jumla cha Billable
DocType: Customer,Credit Limit and Payment Terms,Masharti ya Mikopo na Malipo
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,Kipengee 3
apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6,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 +102,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
apps/erpnext/erpnext/projects/doctype/project/project.py +70,Project {0} already exists,Mradi {0} tayari umepo
DocType: Medical Department,Nursing User,Mtumiaji wa Uuguzi
DocType: Plant Analysis,Plant Analysis Criterias,Criteria za Uchambuzi wa Kupanda
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239,Responsibilities,Majukumu
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125,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: 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 +54,Please enter atleast 1 invoice in the table,Tafadhali ingiza ankara 1 kwenye meza
apps/erpnext/erpnext/utilities/user_progress.py +247,Add Users,Ongeza Watumiaji
DocType: POS Item Group,Item Group,Kundi la Bidhaa
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +16,Student Group: ,Kikundi cha Wanafunzi:
apps/erpnext/erpnext/public/js/hub/hub_listing.js +388,Select Country,Chagua Nchi
DocType: Item,Safety Stock,Usalama wa Hifadhi
DocType: Healthcare Settings,Healthcare Settings,Mipangilio ya afya
apps/erpnext/erpnext/projects/doctype/task/task.py +54,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 +12,To {0},Kwa {0}
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Kodi na Malipo Aliongeza (Fedha za Kampuni)
apps/erpnext/erpnext/stock/doctype/item/item.py +476,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 +43,Item {0} must be a Fixed Asset Item,Kipengee {0} kinafaa kuwa kipengee cha Mali isiyohamishika
apps/erpnext/erpnext/stock/doctype/item/item.js +372,Make Variants,Fanya vigezo
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 +125,Debit Note Amount,Takwimu ya Kumbuka ya Debit
DocType: Project Update,Not Updated,Haijasasishwa
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +106,"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/setup/doctype/company/company.js +89,Please re-type company name to confirm,Tafadhali rejesha jina la kampuni ili kuthibitisha
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +228,Total Outstanding Amt,Jumla ya Amt
DocType: Journal Entry,Printing Settings,Mipangilio ya uchapishaji
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)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292,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 +11,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 +424,Variable,Inaweza kubadilika
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,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: Assessment Plan,From Time,Kutoka wakati
DocType: Hotel Settings,Hotel Settings,Mipangilio ya Hoteli
apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock: ,Katika Stock:
DocType: Notification Control,Custom Message,Ujumbe maalum
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33,Investment Banking,Benki ya Uwekezaji
DocType: Purchase Invoice,input,pembejeo
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79,Cash or Bank Account is mandatory for making payment entry,Akaunti au Akaunti ya Benki ni lazima kwa kuingia malipo
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Anwani ya Wanafunzi
DocType: Purchase Invoice,Price List Exchange Rate,Orodha ya Badilishaji ya Bei
apps/erpnext/erpnext/accounts/doctype/account/account.py +251,Account Number {0} already used in account {1},Nambari ya Akaunti {0} tayari kutumika katika akaunti {1}
DocType: GoCardless Mandate,Mandate,Mamlaka
DocType: POS Profile,POS Profile Name,Jina la Profaili ya POS
DocType: Hotel Room Reservation,Booked,Imeandaliwa
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45,CompAuxLib,CompAuxLib
DocType: Purchase Invoice Item,Rate,Kiwango
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104,Intern,Ndani
DocType: Delivery Stop,Address Name,Jina la Anwani
DocType: Stock Entry,From BOM,Kutoka BOM
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +639,Splitting {0} units of {1},Kupunja {0} vitengo vya {1}
DocType: Assessment Code,Assessment Code,Kanuni ya Tathmini
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73,Basic,Msingi
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,Ushirikiano wa hisa kabla ya {0} ni waliohifadhiwa
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219,Please click on 'Generate Schedule',Tafadhali bonyeza &#39;Generate Schedule&#39;
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122,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 +37,Error evaluating the criteria formula,Hitilafu ya kutathmini fomu ya vigezo
apps/erpnext/erpnext/hr/doctype/employee/employee.py +116,Date of Joining must be greater than Date of Birth,Tarehe ya kujiunga lazima iwe kubwa zaidi kuliko tarehe ya kuzaliwa
DocType: Salary Slip,Salary Structure,Mshahara wa Mshahara
DocType: Account,Bank,Benki
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9,Airline,Ndege
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +853,Issue Material,Matatizo ya Matatizo
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,An error occured while creating recurring,Hitilafu imetokea wakati wa kuunda mara kwa mara
DocType: Material Request Item,For Warehouse,Kwa Ghala
DocType: Employee,Offer Date,Tarehe ya Kutoa
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Quotations,Nukuu
apps/erpnext/erpnext/accounts/page/pos/pos.js +735,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/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,Hakuna Vikundi vya Wanafunzi vilivyoundwa.
DocType: Purchase Invoice Item,Serial No,Serial No
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119,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 +143,Please enter Maintaince Details first,Tafadhali ingiza maelezo ya Duka la kwanza
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56,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
DocType: Subscription,Next Schedule Date,Tarehe ya Ratiba iliyofuata
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/accounts/page/pos/pos.js +1964,Enter value must be positive,Ingiza thamani lazima iwe nzuri
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +446,All Territories,Wilaya zote
apps/erpnext/erpnext/projects/doctype/task/task_tree.js +49,Add Multiple Tasks,Ongeza Kazi nyingi
DocType: Purchase Invoice,Items,Vitu
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +34,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 +241,There are more holidays than working days this month.,Kuna sikukuu zaidi kuliko siku za kazi mwezi huu.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +100,PDC/LC Ref,PDC / LC Ref
DocType: Product Bundle Item,Product Bundle Item,Bidhaa ya Bundle Item
DocType: Sales Partner,Sales Partner Name,Jina la Mshirika wa Mauzo
apps/erpnext/erpnext/hooks.py +136,Request for Quotations,Ombi la Nukuu
DocType: Payment Reconciliation,Maximum Invoice Amount,Kiasi cha Invoice Kiasi
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50,Montantdevise,Montantdevise
apps/erpnext/erpnext/healthcare/setup.py +210,Haematology,Hematology
DocType: Normal Test Items,Normal Test Items,Vipimo vya kawaida vya Mtihani
DocType: Student Language,Student Language,Lugha ya Wanafunzi
apps/erpnext/erpnext/config/selling.py +23,Customers,Wateja
DocType: Cash Flow Mapping,Is Working Capital,"Je, ni Capital Capital"
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,Order / Quot%
apps/erpnext/erpnext/config/healthcare.py +25,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 +89,From and To dates required,Kutoka na Ili tarehe inahitajika
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46,Securities & Commodity Exchanges,Usalama &amp; Mchanganyiko wa Bidhaa
apps/erpnext/erpnext/stock/doctype/item/item.py +689,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: Delivery Note Item,From Warehouse,Kutoka kwa Ghala
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59,No employees for the mentioned criteria,Hakuna wafanyakazi kwa vigezo vilivyotajwa
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +955,No Items with Bill of Materials to Manufacture,Hakuna Vipengee Vipengee vya Vifaa vya Kutengeneza
DocType: Hotel Settings,Default Customer,Wateja wa Mteja
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
DocType: Program Enrollment Course,Program Enrollment Course,Kozi ya Usajili wa Programu
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +165,Make Sample Retention Stock Entry,Fanya Mfano wa Kuhifadhi Usajili wa hisa
DocType: Purchase Taxes and Charges,Valuation and Total,Kiwango na Jumla
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11,Scorecards,Makaratasi ya alama
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
DocType: Notification Control,Customize the Notification,Tengeneza Arifa
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24,Cash Flow from Operations,Mtoko wa Fedha kutoka Uendeshaji
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
apps/erpnext/erpnext/config/stock.py +150,Delivery Trip service tours to customers.,Utoaji wa huduma za safari ya huduma kwa wateja.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57,Total cannot be zero,Jumla haiwezi kuwa sifuri
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16,'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: Lab Test Template,Sensitivity,Sensitivity
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +941,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.py +55,Plants and Machineries,Mimea na Machineries
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Kiwango cha Ushuru Baada ya Kiasi Kikubwa
DocType: Daily Work Summary Settings,Daily Work Summary Settings,Mipangilio ya kila siku ya Kazi ya Kazi
apps/erpnext/erpnext/controllers/buying_controller.py +463,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 +19,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 +366,Please select Posting Date first,Tafadhali chagua Tarehe ya Kuweka kwanza
apps/erpnext/erpnext/public/js/account_tree_grid.js +209,Opening Date should be before Closing Date,Tarehe ya Ufunguzi lazima iwe kabla ya Tarehe ya Kufungwa
DocType: Leave Control Panel,Carry Forward,Endelea mbele
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cost Center with existing transactions can not be converted to ledger,Kituo cha Gharama na shughuli zilizopo haziwezi kugeuzwa kuwa kiongozi
DocType: Department,Days for which Holidays are blocked for this department.,Siku ambazo Likizo zimezuiwa kwa idara hii.
DocType: GoCardless Mandate,ERPNext Integrations,ERPNext Integrations
DocType: Crop Cycle,Detected Disease,Magonjwa yaliyoambukizwa
,Produced,Iliyotayarishwa
DocType: Item,Item Code for Suppliers,Kanuni ya Nambari ya Wafanyabiashara
DocType: Issue,Raised By (Email),Iliyotolewa na (Barua pepe)
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 +28,Last Communication,Mawasiliano ya Mwisho
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +372,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/stock/doctype/serial_no/serial_no.py +240,Serial Nos Required for Serialized Item {0},Serial Nos Inahitajika kwa Bidhaa Serialized {0}
apps/erpnext/erpnext/config/accounts.py +144,Match Payments with Invoices,Malipo ya mechi na ankara
DocType: Journal Entry,Bank Entry,Kuingia kwa Benki
DocType: Authorization Rule,Applicable To (Designation),Inafaa Kwa (Uteuzi)
,Profitability Analysis,Uchambuzi wa Faida
DocType: Fees,Student Email,Barua ya Wanafunzi
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.html +77,Add to Cart,Ongeza kwenye Cart
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,Kikundi Kwa
DocType: Guardian,Interests,Maslahi
apps/erpnext/erpnext/config/accounts.py +298,Enable / disable currencies.,Wezesha / afya ya fedha.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +105,Dr {0} on Half day Leave on {1},Dk {0} kwa siku ya nusu Acha {1}
DocType: Production Plan,Get Material Request,Pata Ombi la Nyenzo
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Postal Expenses,Malipo ya posta
apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Jumla (Amt)
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26,Entertainment & Leisure,Burudani &amp; Burudani
,Item Variant Details,Maelezo ya Toleo la Tofauti
DocType: Quality Inspection,Item Serial No,Kitu cha Serial No
apps/erpnext/erpnext/utilities/activation.py +135,Create Employee Records,Unda Kumbukumbu ya Wafanyakazi
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Present,Jumla ya Sasa
apps/erpnext/erpnext/config/accounts.py +105,Accounting Statements,Taarifa za Uhasibu
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 +793,Please select Qty against item {0},Tafadhali chagua Uchina dhidi ya bidhaa {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29,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/hr/doctype/leave_application/leave_application.py +114,You are not authorized to approve leaves on Block Dates,Huna mamlaka ya kupitisha majani kwenye Tarehe ya Kuzuia
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +394,All these items have already been invoiced,Vipengee hivi vyote tayari vinatumiwa
DocType: Company,Monthly Sales Target,Lengo la Mauzo ya Mwezi
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},Inaweza kupitishwa na {0}
DocType: Hotel Room,Hotel Room Type,Aina ya Chumba cha Hoteli
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 +13,Unknown,Haijulikani
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +954,Work Order not created,Kazi ya Kazi haijatengenezwa
DocType: Shipping Rule,Shipping Rule Conditions,Masharti ya Kanuni za Uhamisho
DocType: Purchase Invoice,Export Type,Aina ya Nje
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: Crop,Planting UOM,Kupanda UOM
DocType: Account,Tax,Kodi
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,Haijulikani
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1,Opening Invoices Summary,Kufungua Muhtasari wa ankara
DocType: Education Settings,Education Manager,Meneja wa Elimu
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
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","Kitambulisho cha Mchapishaji {0} hawezi kusasishwa kwa kutumia Upatanisho wa Stock, badala ya kutumia Uingizaji wa hisa"
DocType: Quality Inspection,Report Date,Tarehe ya Ripoti
DocType: Student,Middle Name,Jina la kati
DocType: C-Form,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/buying/doctype/supplier_quotation/supplier_quotation.py +84,"{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 +1184,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}.
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +125,Please Set Supplier Type in Buying Settings.,Tafadhali Weka Aina ya Wasambazaji katika Mipangilio ya Ununuzi.
DocType: Manufacturing Settings,Update BOM Cost Automatically,Sasisha Gharama ya BOM Moja kwa moja
DocType: Lab Test,Test Name,Jina la mtihani
apps/erpnext/erpnext/utilities/activation.py +99,Create Users,Unda Watumiaji
apps/erpnext/erpnext/utilities/user_progress.py +147,Gram,Gramu
DocType: Supplier Scorecard,Per Month,Kwa mwezi
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +433,Quantity to Manufacture must be greater than 0.,Wingi wa Utengenezaji lazima uwe mkubwa kuliko 0.
DocType: Asset Settings,Calculate Prorated Depreciation Schedule Based on Fiscal Year,Tathmini ratiba ya kushuka kwa thamani ya kupunguzwa kwa mujibu wa Mwaka wa Fedha
apps/erpnext/erpnext/config/maintenance.py +17,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: POS Customer Group,Customer Group,Kundi la Wateja
apps/erpnext/erpnext/stock/doctype/batch/batch.js +128,New Batch ID (Optional),Kitambulisho kipya cha chaguo (Hiari)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201,Expense account is mandatory for item {0},Akaunti ya gharama ni lazima kwa kipengee {0}
DocType: BOM,Website Description,Website Description
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +47,Net Change in Equity,Mabadiliko ya Net katika Equity
apps/erpnext/erpnext/assets/doctype/asset/asset.py +220,Please cancel Purchase Invoice {0} first,Tafadhali cancel ankara ya Ununuzi {0} kwanza
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43,"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
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +880,Receipt,Receipt
,Sales Register,Daftari ya Mauzo
DocType: Daily Work Summary Group,Send Emails At,Tuma Barua pepe Kwa
DocType: Quotation,Quotation Lost Reason,Sababu iliyopoteza Nukuu
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +381,Transaction reference no {0} dated {1},Rejea ya usafirishaji hakuna {0} dated {1}
apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Hakuna kitu cha kuhariri.
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +499,Form View,Tazama Fomu
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116,Summary for this month and pending activities,Muhtasari wa mwezi huu na shughuli zinazosubiri
apps/erpnext/erpnext/utilities/user_progress.py +248,"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/public/js/pos/pos.html +109,No Customers yet!,Hakuna Wateja bado!
apps/erpnext/erpnext/public/js/financial_statements.js +56,Cash Flow Statement,Taarifa ya Flow Flow
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +473,No material request created,Hakuna ombi la nyenzo lililoundwa
apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23,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 +22,License,Leseni
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +491,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: Physician,Phone (R),Simu (R)
apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +56,Time slots added,Muda wa muda umeongezwa
DocType: Item,Attributes,Sifa
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31,Enable Template,Wezesha Kigezo
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226,Please enter Write Off Account,Tafadhali ingiza Akaunti ya Kuandika Akaunti
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,Tarehe ya mwisho ya tarehe
DocType: Patient,B Negative,B mbaya
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25,Maintenance Status has to be Cancelled or Completed to Submit,Hali ya Matengenezo inapaswa kufutwa au Imekamilika Kuwasilisha
DocType: Hotel Room,Hotel Room,Chumba cha hoteli
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47,Account {0} does not belongs to company {1},Akaunti {0} sio ya kampuni {1}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +884,Serial Numbers in row {0} does not match with Delivery Note,Nambari za Serial katika mstari {0} haifani na Kumbuka Utoaji
DocType: Student,Guardian Details,Maelezo ya Guardian
DocType: C-Form,C-Form,Fomu ya C
apps/erpnext/erpnext/config/hr.py +18,Mark Attendance for multiple employees,Mark Attendance kwa wafanyakazi wengi
DocType: Agriculture Task,Start Day,Siku ya Mwanzo
DocType: Vehicle,Chassis No,Chassis No
DocType: Payment Request,Initiated,Ilianzishwa
DocType: Production Plan Item,Planned Start Date,Tarehe ya Kuanza Iliyopangwa
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +622,Please select a BOM,Tafadhali chagua BOM
DocType: Purchase Invoice,Availed ITC Integrated Tax,Taasisi iliyoingizwa ya ITC iliyopatikana
DocType: Serial No,Creation Document Type,Aina ya Hati ya Uumbaji
DocType: Project Task,View Timesheet,Angalia Timesheet
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54,End date must be greater than start date,Tarehe ya mwisho lazima iwe kubwa kuliko tarehe ya kuanza
DocType: Leave Type,Is Encash,Ni Encash
DocType: Leave Allocation,New Leaves Allocated,Majani mapya yamewekwa
apps/erpnext/erpnext/controllers/trends.py +269,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 +30,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: Appraisal Template,Appraisal Template Title,Kitambulisho cha Kigezo cha Kigezo
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39,From Date {0} for Employee {1} cannot be before employee's joining Date {2},Tarehe Tarehe {0} kwa Mfanyakazi {1} haiwezi kuwa kabla ya tarehe ya kujiunga na mfanyakazi {2}
apps/erpnext/erpnext/utilities/user_progress_utils.py +29,Commercial,Biashara
DocType: Patient,Alcohol Current Use,Pombe Sasa Matumizi
DocType: Student Admission Program,Student Admission Program,Mpango wa Uingizaji wa Wanafunzi
DocType: Payment Entry,Account Paid To,Akaunti Ililipwa
DocType: Item Alternative,Alternative Item Name,Jina la Mchapishaji
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24,Parent Item {0} must not be a Stock Item,Item ya Mzazi {0} haipaswi kuwa Item ya Hifadhi
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +466,"Could not submit any Salary Slip <br>\
			Possible reasons: <br>\
			1. Net pay is less than 0. <br>\
			2. Company Email Address specified in employee master is not valid. <br>",Haikuweza kuwasilisha Mpangilio wa Mshahara <br> Sababu zinazowezekana: <br> \ 1. Net kulipa ni chini ya 0. <br> \ 2. Kampuni ya barua pepe ya Kampuni iliyoelezwa katika bwana wa mfanyakazi si sahihi. <br>
apps/erpnext/erpnext/config/selling.py +57,All Products or Services.,Bidhaa zote au Huduma.
DocType: Expense Claim,More Details,Maelezo zaidi
DocType: Supplier Quotation,Supplier Address,Anwani ya Wasambazaji
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128,{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/accounts/doctype/purchase_invoice/purchase_invoice.py +695,Row {0}# Account must be of type 'Fixed Asset',Akaunti {0} # Akaunti lazima iwe ya aina &#39;Mali isiyohamishika&#39;
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,Nje ya Uchina
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,and unchcked Disabled in the,na Walemavu wasiozuiwa katika
apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +41,Series is mandatory,Mfululizo ni lazima
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28,Financial Services,Huduma za Fedha
DocType: Student Sibling,Student ID,Kitambulisho cha Mwanafunzi
apps/erpnext/erpnext/public/js/hub/hub_form.js +445,Supplier Email,Barua ya Wasambazaji
apps/erpnext/erpnext/config/projects.py +51,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: Complaint,Complaint,Malalamiko
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +462,Warehouse required for stock Item {0},Ghala inayotakiwa kwa kipengee cha hisa {0}
DocType: Leave Allocation,Unused leaves,Majani yasiyotumika
DocType: Patient,Alcohol Past Use,Pombe Matumizi ya Kale
DocType: Fertilizer Content,Fertilizer Content,Maudhui ya Mbolea
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +187,Cr,Cr
DocType: Project Update,Problematic/Stuck,Tatizo / Kuzidi
DocType: Tax Rule,Billing State,Hali ya kulipia
DocType: Share Transfer,Transfer,Uhamisho
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252,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 +917,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 +137,Due Date is mandatory,Tarehe ya Kutokana ni ya lazima
apps/erpnext/erpnext/controllers/item_variant.py +82,Increment for Attribute {0} cannot be 0,Uingizaji wa Kushikilia {0} hauwezi kuwa 0
apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19,Rooms Booked,Vyumba vimeandikwa
apps/erpnext/erpnext/crm/doctype/lead/lead.py +57,Ends On date cannot be before Next Contact Date.,Mwisho wa tarehe haiwezi kuwa kabla ya Tarehe ya Mawasiliano ya Ijayo.
DocType: Journal Entry,Pay To / Recd From,Kulipa / Recd Kutoka
DocType: Naming Series,Setup Series,Mipangilio ya kuanzisha
DocType: Payment Reconciliation,To Invoice Date,Kwa tarehe ya ankara
DocType: Shareholder,Contact HTML,Wasiliana HTML
apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py +19,Registration fee can not be Zero,Halafu ya usajili haiwezi kuwa Zero
DocType: Disease,Treatment Period,Kipindi cha Matibabu
apps/erpnext/erpnext/education/api.py +338,Result already Submitted,Matokeo yaliyotolewa tayari
apps/erpnext/erpnext/controllers/buying_controller.py +170,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 +28,Please wait 3 days before resending the reminder.,Tafadhali subiri siku 3 kabla ya kurekebisha kukumbusha.
DocType: Landed Cost Voucher,LCV,LCV
DocType: Landed Cost Voucher,Purchase Receipts,Receipts ya Ununuzi
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29,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 +28,Retail,Uuzaji
DocType: Student Attendance,Absent,Haipo
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591,Product Bundle,Bundle ya Bidhaa
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38,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 +212,Row {0}: Invalid reference {1},Row {0}: kumbukumbu isiyo sahihi {1}
DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Kiguli cha Malipo na Chaguzi
DocType: Timesheet,TS-,TS-
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61,{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: Hotel Room Amenity,Hotel Room Amenity,Ushauri wa chumba cha Hoteli
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: Journal Entry,Write Off Based On,Andika Msaada
apps/erpnext/erpnext/utilities/activation.py +65,Make Lead,Fanya Kiongozi
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112,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 +809,Send Supplier Emails,Tuma barua pepe za Wasambazaji
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +96,"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: Chapter Member,Leave Reason,Acha Sababu
DocType: Guardian Interest,Guardian Interest,Maslahi ya Guardian
DocType: Volunteer,Availability,Upatikanaji
apps/erpnext/erpnext/config/accounts.py +319,Setup default values for POS Invoices,Weka maadili ya msingi ya POS ankara
apps/erpnext/erpnext/config/hr.py +182,Training,Mafunzo
DocType: Project,Time to send,Muda wa kutuma
DocType: Timesheet,Employee Detail,Maelezo ya Waajiriwa
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1 Barua ya barua pepe
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68,Next Date's day and Repeat on Day of Month must be equal,Siku ya Tarehe inayofuata na kurudia siku ya mwezi lazima iwe sawa
DocType: Lab Prescription,Test Code,Kanuni ya mtihani
apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Mipangilio ya ukurasa wa nyumbani wa wavuti
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +40,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQs haziruhusiwi kwa {0} kutokana na msimamo wa alama ya {1}
DocType: Job Offer,Awaiting Response,Inasubiri Jibu
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +82,Above,Juu
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1489,Total Amount {0},Jumla ya Kiasi {0}
apps/erpnext/erpnext/controllers/item_variant.py +306,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 +25,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 +67,Row {0}: Cost center is required for an item {1},Row {0}: Kituo cha gharama kinahitajika kwa kipengee {1}
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43,EcritureDate,Uandishi
apps/erpnext/erpnext/healthcare/doctype/physician/physician_dashboard.py +6,This is based on transactions against this Physician.,Hii inategemea shughuli za Daktari.
DocType: Training Event Employee,Optional,Hiari
DocType: Salary Slip,Earning & Deduction,Kufikia &amp; Kupunguza
DocType: Agriculture Analysis Criteria,Water Analysis,Uchambuzi wa Maji
DocType: Chapter,Region,Mkoa
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38,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 +110,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 +7,Reload Linked Analysis,Rejesha Upya Uchambuzi
DocType: Fiscal Year,"For e.g. 2012, 2012-13","Kwa mfano 2012, 2012-13"
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96,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 +32,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 +62,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
apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py +15,No record found,Hakuna rekodi iliyopatikana
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140,Cost of Scrapped Asset,Gharama ya Kutolewa kwa Mali
apps/erpnext/erpnext/controllers/stock_controller.py +236,{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 +686,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 +72,Split,Split
DocType: GL Entry,Is Advance,Ni Mapema
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,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 +157,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 +29,Last Communication Date,Tarehe ya Mawasiliano ya Mwisho
DocType: Sales Team,Contact No.,Wasiliana Na.
DocType: Bank Reconciliation,Payment Entries,Entries ya Malipo
DocType: Land Unit,Land Unit Details,Maelezo ya Kitengo cha Ardhi
DocType: Land Unit,Latitude,Latitude
DocType: Work Order,Scrap Warehouse,Ghala la Ghala
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/learn.py +263,Publish Items on Website,Chapisha Items kwenye tovuti
apps/erpnext/erpnext/utilities/activation.py +126,Group your students in batches,Shirikisha wanafunzi wako katika makundi
DocType: Authorization Rule,Authorization Rule,Sheria ya Uidhinishaji
DocType: POS Profile,Offline POS Section,Sehemu ya Nje ya POS
DocType: Sales Invoice,Terms and Conditions Details,Masharti na Masharti Maelezo
apps/erpnext/erpnext/templates/generators/item.html +100,Specifications,Specifications
DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Kigezo cha Malipo na Malipo
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68,Total (Credit),Jumla (Mikopo)
DocType: Repayment Schedule,Payment Date,Tarehe ya Malipo
apps/erpnext/erpnext/stock/doctype/batch/batch.js +122,New Batch Qty,Uchina Mpya
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10,Apparel & Accessories,Nguo &amp; Accessories
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91,Could not solve weighted score function. Make sure the formula is valid.,Haikuweza kutatua kazi ya alama ya uzito. Hakikisha fomu hiyo halali.
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67,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 +28,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/stock/report/stock_balance/stock_balance.py +68,Opening Value,Thamani ya Ufunguzi
DocType: Salary Detail,Formula,Mfumo
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +48,Serial #,Serial #
DocType: Lab Test Template,Lab Test Template,Kigezo cha Mtihani wa Lab
apps/erpnext/erpnext/setup/doctype/company/company.py +181,Sales Account,Akaunti ya Mauzo
DocType: Purchase Invoice Item,Total Weight,Uzito wote
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94,Commission on Sales,Tume ya Mauzo
DocType: Job Offer Term,Value / Description,Thamani / Maelezo
apps/erpnext/erpnext/controllers/accounts_controller.py +630,"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 +134,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debit na Mikopo si sawa kwa {0} # {1}. Tofauti ni {2}.
DocType: Asset Maintenance Task,Assign To Name,Weka kwa jina
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98,Entertainment Expenses,Gharama za Burudani
DocType: Hub Settings,Enabled Users,Watumiaji waliowezeshwa
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +99,Make Material Request,Fanya ombi la Nyenzo
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20,Open Item {0},Fungua Toleo {0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222,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: Consultation,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 +84,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/config/hr.py +60,Applications for leave.,Maombi ya kuondoka.
apps/erpnext/erpnext/accounts/doctype/account/account.py +164,Account with existing transaction can not be deleted,Akaunti na shughuli zilizopo haziwezi kufutwa
DocType: Vehicle,Last Carbon Check,Check Carbon Mwisho
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102,Legal Expenses,Gharama za Kisheria
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +145,Please select quantity on row ,Tafadhali chagua kiasi kwenye mstari
apps/erpnext/erpnext/config/accounts.py +277,Make Opening Sales and Purchase Invoices,Fanya Mauzo ya Kufungua na Ununuzi
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.py +118,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 +131,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.py +79,Direct Expenses,Malipo ya moja kwa moja
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Mapato ya Wateja Mpya
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119,Travel Expenses,Gharama za kusafiri
DocType: Maintenance Visit,Breakdown,Kuvunja
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50,Add custom field Subscription in the doctype {0},Ongeza usajili wa desturi kwenye mafundisho {0}
apps/erpnext/erpnext/controllers/accounts_controller.py +822,Account: {0} with currency: {1} can not be selected,Akaunti: {0} kwa fedha: {1} haiwezi kuchaguliwa
DocType: Purchase Receipt Item,Sample Quantity,Mfano Wingi
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: Bank Reconciliation Detail,Cheque Date,Tarehe ya Kuangalia
apps/erpnext/erpnext/accounts/doctype/account/account.py +50,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 +106,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 +27,As on Date,Kama tarehe
DocType: Appraisal,HR,HR
DocType: Program 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 +100,Probation,Probation
apps/erpnext/erpnext/config/hr.py +115,Salary Components,Vipengele vya Mshahara
DocType: Program Enrollment Tool,New Academic Year,Mwaka Mpya wa Elimu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +811,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 +124,Total Paid Amount,Jumla ya kulipwa
DocType: GST Settings,B2C Limit,Mpaka wa B2C
DocType: Work Order Item,Transferred Qty,Uchina uliotumwa
apps/erpnext/erpnext/config/learn.py +11,Navigating,Inasafiri
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188,Planning,Kupanga
DocType: Share Balance,Issued,Iliyotolewa
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14,Student Activity,Shughuli ya Wanafunzi
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80,Supplier Id,Idha ya Wasambazaji
DocType: Payment Request,Payment Gateway Details,Maelezo ya Gateway ya Malipo
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +276,Quantity should be greater than 0,Wingi wanapaswa kuwa mkubwa kuliko 0
DocType: Journal Entry,Cash Entry,Kuingia kwa Fedha
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17,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: Leave Application,Half Day Date,Tarehe ya Nusu ya Siku
DocType: Academic Year,Academic Year Name,Jina la Mwaka wa Elimu
DocType: Sales Partner,Contact Desc,Wasiliana Desc
apps/erpnext/erpnext/config/hr.py +65,"Type of leaves like casual, sick etc.","Aina ya majani kama vile kawaida, wagonjwa nk."
DocType: Email Digest,Send regular summary reports via Email.,Tuma taarifa za muhtasari wa mara kwa mara kupitia barua pepe.
DocType: Payment Entry,PE-,PE-
DocType: Assessment Result,Student Name,Jina la Mwanafunzi
DocType: Brand,Item Manager,Meneja wa Bidhaa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Payroll Payable,Mishahara ya kulipa
DocType: Buying Settings,Default Supplier Type,Aina ya Wasambazaji wa Default
DocType: Plant Analysis,Collection Datetime,Mkusanyiko wa Tarehe
DocType: Work Order,Total Operating Cost,Gharama ya Uendeshaji Yote
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171,Note: Item {0} entered multiple times,Kumbuka: Kipengee {0} kiliingizwa mara nyingi
apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Mawasiliano Yote.
apps/erpnext/erpnext/public/js/setup_wizard.js +71,Company Abbreviation,Hali ya Kampuni
apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +47,User {0} does not exist,Mtumiaji {0} haipo
DocType: Payment Term,Day(s) after invoice date,Siku (s) baada ya tarehe ya ankara
DocType: Payment Schedule,Payment Schedule,Ratiba ya Malipo
DocType: Subscription,SUB-,SUB-
DocType: Item Attribute Value,Abbreviation,Hali
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +195,Payment Entry already exists,Kuingia kwa Malipo tayari kuna
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,Sio kuchapishwa tangu {0} inapozidi mipaka
apps/erpnext/erpnext/config/hr.py +110,Salary template master.,Mshauri wa template mshahara.
apps/erpnext/erpnext/healthcare/setup.py +241,Pathology,Patholojia
DocType: Restaurant Order Entry,Restaurant Table,Jedwali la Mgahawa
DocType: Hotel Room,Hotel Manager,Meneja wa Hoteli
DocType: Leave Type,Max Days Leave Allowed,Siku za Max Zimekwisha Kuruhusiwa
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63,Set Tax Rule for shopping cart,Weka Kanuni ya Ushuru kwa gari la ununuzi
DocType: Purchase Invoice,Taxes and Charges Added,Kodi na Malipo Aliongeza
,Sales Funnel,Funnel ya Mauzo
apps/erpnext/erpnext/setup/doctype/company/company.py +49,Abbreviation is mandatory,Hali ni lazima
DocType: Project,Task Progress,Maendeleo ya Kazi
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7,Cart,Kadi
,Qty to Transfer,Uchina kwa Uhamisho
apps/erpnext/erpnext/config/selling.py +13,Quotes to Leads or Customers.,Quotes Kuongoza au Wateja.
DocType: Stock Settings,Role Allowed to edit frozen stock,Kazi Imeruhusiwa kuhariri hisa zilizohifadhiwa
,Territory Target Variance Item Group-Wise,Ugawanyiko wa Target Kikundi Kikundi-Hekima
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143,All Customer Groups,Vikundi vyote vya Wateja
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114,Accumulated Monthly,Imekusanywa kila mwezi
apps/erpnext/erpnext/controllers/accounts_controller.py +783,{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/accounts/doctype/tax_rule/tax_rule.py +44,Tax Template is mandatory.,Kigezo cha Kodi ni lazima.
apps/erpnext/erpnext/accounts/doctype/account/account.py +44,Account {0}: Parent account {1} does not exist,Akaunti {0}: Akaunti ya Mzazi {1} haipo
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
DocType: Lab Prescription,Test Created,Mtihani Umeundwa
DocType: Healthcare Settings,Custom Signature in Print,Sahihi ya Sahihi katika Kuchapa
DocType: Account,Temporary,Muda
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +114,Customer LPO No.,LPO ya Wateja
DocType: Program,Courses,Mafunzo
DocType: Monthly Distribution Percentage,Percentage Allocation,Asilimia ya Ugawaji
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128,Secretary,Katibu
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: 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/sales_invoice/sales_invoice.js +1295,Please set Company,Tafadhali weka Kampuni
DocType: Pricing Rule,Buying,Ununuzi
apps/erpnext/erpnext/config/agriculture.py +24,Diseases & Fertilizers,Magonjwa &amp; Fertilizers
DocType: HR Settings,Employee Records to be created by,Kumbukumbu za Waajiri zitaundwa na
DocType: Patient,AB Negative,AB Hasila
DocType: Sample Collection,SMPL-,SMPL-
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.py +140,Creditors,Wakopaji
DocType: Assessment Plan,Assessment Name,Jina la Tathmini
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +94,Show PDC in Print,Onyesha PDC katika Print
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +97,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
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,Job Offer,Kazi ya Kazi
apps/erpnext/erpnext/public/js/setup_wizard.js +71,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 +1082,Supplier Quotation,Nukuu ya Wafanyabiashara
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 +164,Quantity ({0}) cannot be a fraction in row {1},Wingi ({0}) hawezi kuwa sehemu ya mstari {1}
DocType: Consultation,C-,C-
DocType: Attendance,ATT-,ATT-
apps/erpnext/erpnext/stock/doctype/item/item.py +492,Barcode {0} already used in Item {1},Barcode {0} tayari kutumika katika Item {1}
apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,Sheria ya kuongeza gharama za meli.
DocType: Hotel Room,Extra Bed Capacity,Uwezo wa kitanda cha ziada
DocType: Item,Opening Stock,Ufunguzi wa Hifadhi
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Wateja inahitajika
DocType: Lab Test,Result Date,Tarehe ya matokeo
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +99,PDC/LC Date,Tarehe PDC / LC
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20,{0} is mandatory for Return,{0} ni lazima kwa Kurudi
DocType: Purchase Order,To Receive,Kupokea
apps/erpnext/erpnext/utilities/user_progress.py +252,user@example.com,user@example.com
DocType: Asset,Asset Owner,Mmiliki wa Mali
DocType: Employee,Personal Email,Barua pepe ya kibinafsi
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57,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/setup/setup_wizard/data/industry_type.py +15,Brokerage,Uhamisho
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +195,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
apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,Amri iliyotolewa kwa ajili ya uzalishaji.
apps/erpnext/erpnext/public/js/account_tree_grid.js +65,Select Fiscal Year...,Chagua Mwaka wa Fedha ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +567,POS Profile required to make POS Entry,Profaili ya POS inahitajika ili ufanye POS Entry
DocType: Program Enrollment Tool,Enroll Students,Jiandikisha Wanafunzi
DocType: Lab Test,Approved Date,Tarehe iliyoidhinishwa
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Uuzaji wa kawaida
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +205,Atleast one warehouse is mandatory,Atleast ghala moja ni lazima
DocType: Serial No,Out of Warranty,Nje ya udhamini
DocType: BOM Update Tool,Replace,Badilisha
apps/erpnext/erpnext/templates/includes/product_list.js +42,No products found.,Hakuna bidhaa zilizopatikana.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360,{0} against Sales Invoice {1},{0} dhidi ya ankara ya mauzo {1}
DocType: Antibiotic,Laboratory User,Mtumiaji wa Maabara
DocType: Sales Invoice,SINV-,SINV-
DocType: Request for Quotation Item,Project Name,Jina la Mradi
DocType: Customer,Mention if non-standard receivable account,Eleza kama akaunti isiyo ya kawaida ya kupokea
DocType: Journal Entry Account,If Income or Expense,Kama Mapato au Gharama
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +288,Select interest income account in employee loan {0},Chagua akaunti ya mapato ya riba katika mkopo wa mfanyakazi {0}
DocType: Work Order,Required Items,Vitu vinavyotakiwa
DocType: Stock Ledger Entry,Stock Value Difference,Thamani ya Thamani ya Hifadhi
apps/erpnext/erpnext/config/learn.py +229,Human Resource,Rasilimali watu
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Malipo ya Upatanisho wa Malipo
DocType: Disease,Treatment Task,Kazi ya Matibabu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38,Tax Assets,Mali ya Kodi
DocType: BOM Item,BOM No,BOM Hapana
DocType: Instructor,INS/,INS /
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +160,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
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.py +46,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 +49,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/config/hr.py +29,Upload attendance from a .csv file,Pakia mahudhurio kutoka faili ya .csv
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45,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]
apps/erpnext/erpnext/controllers/accounts_controller.py +600,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Row # {0}: Mali ni lazima kwa ajili ya kununua fasta / kuuza mali
DocType: Asset Maintenance Team,Maintenance Team Name,Jina la Timu ya Matengenezo
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42,"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/crm/doctype/opportunity/opportunity.py +197,Customer is mandatory if 'Opportunity From' is selected as Customer,Mteja ni lazima ikiwa &#39;Mfunguo Kutoka&#39; huchaguliwa kama Mteja
apps/erpnext/erpnext/controllers/trends.py +36,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/config/hr.py +137,Types of Expense Claim.,Aina ya Madai ya Madai.
apps/erpnext/erpnext/controllers/selling_controller.py +148,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: Item,Taxes,Kodi
DocType: Purchase Invoice,capital goods,bidhaa kuu
DocType: Purchase Invoice Item,Weight Per Unit,Uzito Kwa Kitengo
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344,Paid and Not Delivered,Ilipwa na Haijaokolewa
DocType: Project,Default Cost Center,Kituo cha Ghali cha Default
DocType: Bank Guarantee,End Date,Tarehe ya Mwisho
apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,Ushirikiano wa hisa
DocType: Budget,Budget Accounts,Hesabu za Bajeti
DocType: Employee,Internal Work History,Historia ya Kazi ya Kazi
DocType: Depreciation Schedule,Accumulated Depreciation Amount,Kukusanya kiasi cha kushuka kwa thamani
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42,Private Equity,Private Equity
DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Scorecard ya Wafanyabiashara Inaweza kubadilika
DocType: Employee Loan,Fully Disbursed,Kutengwa kabisa
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 +54,Score cannot be greater than Maximum Score,Alama haiwezi kuwa kubwa zaidi kuliko alama ya Maximum
apps/erpnext/erpnext/utilities/user_progress.py +129,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: Hotel Room Reservation,Invoiced,Imesajiliwa
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98,Syntax error in formula or condition: {0},Hitilafu ya Syntax katika fomu au hali: {0}
DocType: Daily Work Summary Settings Company,Daily Work Summary Settings Company,Mtaalam wa Mipangilio ya Kazi ya Kila siku
apps/erpnext/erpnext/stock/utils.py +125,Item {0} ignored since it is not a stock item,Kipengee {0} kinachunguzwa kwani si kitu cha hisa
DocType: Appraisal,APRSL,APRSL
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23,"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
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27,Jobs,Kazi
,Sales Order Trends,Mwelekeo wa Utaratibu wa Mauzo
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,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 +36,Production Item,Bidhaa ya Uzalishaji
,Employee Information,Taarifa ya Waajiriwa
DocType: Stock Entry Detail,Additional Cost,Gharama za ziada
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +48,"Can not filter based on Voucher No, if grouped by Voucher","Haiwezi kuchuja kulingana na Voucher No, ikiwa imewekwa na Voucher"
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +918,Make Supplier Quotation,Fanya Nukuu ya Wasambazaji
DocType: Quality Inspection,Incoming,Inakuja
apps/erpnext/erpnext/setup/doctype/company/company.js +70,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 +57,Assessment Result record {0} already exists.,Tathmini ya Matokeo ya Tathmini {0} tayari imepo.
DocType: BOM,Materials Required (Exploded),Vifaa vinavyotakiwa (Imelipuka)
apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60,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 +66,Posting Date cannot be future date,Tarehe ya Kuchapisha haiwezi kuwa tarehe ya baadaye
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +102,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: Serial No {1} hailingani na {2} {3}
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,for generating the recurring,kwa kuzalisha mara kwa mara
DocType: Stock Entry,Target Warehouse Address,Anwani ya Wakala ya Ghala
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86,Casual Leave,Kuondoka kwa kawaida
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 +380,Note: {0},Kumbuka: {0}
,Delivery Note Trends,Mwelekeo wa Kumbuka Utoaji
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112,This Week's Summary,Muhtasari wa wiki hii
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +22,In Stock Qty,Katika Stock
DocType: Delivery Trip,Calculate Estimated Arrival Times,Tumia Hesabu ya Kufika Iliyohesabiwa
apps/erpnext/erpnext/accounts/general_ledger.py +113,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: GL Entry,Party,Chama
DocType: Healthcare Settings,Patient Name,Jina la subira
DocType: Variant Field,Variant Field,Field Variant
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: 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."
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103,Piecework,Piecework
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Avg. Buying Rate,Mg. Kiwango cha kununua
DocType: Share Balance,From No,Kutoka Hapana
DocType: Task,Actual Time (in Hours),Muda halisi (katika Masaa)
DocType: Employee,History In Company,Historia Katika Kampuni
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +270,New Message from {sender},Ujumbe mpya kutoka {mtumaji}
DocType: Customer,Customer Primary Address,Anwani ya Msingi ya Wateja
apps/erpnext/erpnext/config/learn.py +107,Newsletters,Majarida
DocType: Drug Prescription,Description/Strength,Maelezo / Nguvu
DocType: Share Balance,Is Company,Ni Kampuni
DocType: Stock Ledger Entry,Stock Ledger Entry,Kuingia kwa Ledger Entry
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83,Same item has been entered multiple times,Kitu kimoja kimeingizwa mara nyingi
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 +192,Item {0} is not setup for Serial Nos. Column must be blank,Kipengee {0} sio kuanzisha kwa Nakala Zetu. Sawa lazima iwe tupu
DocType: Accounts Settings,Accounts Settings,Mipangilio ya Akaunti
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11,Approve,Thibitisha
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +69,"Malformatted address for {0}, please fix to continue.","Anwani isiyofaa ya {0}, tafadhali tengeneza ili uendelee."
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28,"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
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151,No Result to submit,Hakuna matokeo ya kuwasilisha
DocType: Customer,Sales Partner and Commission,Mshirika wa Mauzo na Tume
DocType: Employee 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 +79,"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;"
DocType: Opportunity,To Discuss,Kujadili
DocType: Loan Type,Rate of Interest (%) Yearly,Kiwango cha Maslahi (%) Kila mwaka
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71,Temporary Accounts,Akaunti ya Muda
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207,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 +132,{0} items produced,{0} vitu vilivyotengenezwa
apps/erpnext/erpnext/utilities/user_progress.py +58,Learn More,Jifunze zaidi
DocType: Cheque Print Template,Distance from top edge,Umbali kutoka makali ya juu
apps/erpnext/erpnext/stock/get_item_details.py +367,Price List {0} is disabled or does not exist,Orodha ya Bei {0} imezimwa au haipo
DocType: Purchase Invoice,Return,Rudi
DocType: Pricing Rule,Disable,Zima
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +180,Mode of payment is required to make a payment,Njia ya kulipa inahitajika kufanya malipo
DocType: Project Task,Pending Review,Mapitio Yasubiri
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14,"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"
apps/erpnext/erpnext/healthcare/doctype/physician/physician_dashboard.py +10,Appointments and Consultations,Uteuzi na Ushauri
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41,{0} - {1} is not enrolled in the Batch {2},{0} - {1} haijasajiliwa katika Batch {2}
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113,"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 +84,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 +177,Mark Absent,Weka alama
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40,Failed to setup company,Imeshindwa kuanzisha kampuni
DocType: Asset Repair,Asset Repair,Ukarabati wa Mali
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +143,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 +585,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 +204,Fleet Management,Usimamizi wa Fleet
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1080,Add items from,Ongeza vitu kutoka
apps/erpnext/erpnext/config/agriculture.py +7,Crops & Lands,Mazao na Nchi
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 +20,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: Account,Asset,Mali
DocType: Project Task,Task ID,Kitambulisho cha Task
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84,Stock cannot exist for Item {0} since has variants,Hifadhi haipatikani kwa Item {0} tangu ina tofauti
DocType: Lab Test,Mobile,Rununu
,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 +73,Warehouse {0} does not exist,Ghala {0} haipo
DocType: Monthly Distribution,Monthly Distribution Percentages,Asilimia ya Usambazaji wa Kila mwezi
apps/erpnext/erpnext/stock/doctype/batch/batch.py +110,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
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 +87,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 +158,Explore Sales Cycle,Pitia Mzunguko wa Mauzo
DocType: Assessment Plan,Supervisor,Msimamizi
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +869,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
,Work Order Stock Report,Ripoti ya Kazi ya Kazi ya Kazi
DocType: Assessment Result Tool,Assessment Result Tool,Kitabu cha Matokeo ya Tathmini
apps/erpnext/erpnext/education/doctype/instructor/instructor.js +24,As Supervisor,Kama Msimamizi
apps/erpnext/erpnext/public/js/hub/hub_form.js +376,Suggest Category,Panga Jamii
DocType: BOM Scrap Item,BOM Scrap Item,BOM Kipengee cha Bidhaa
apps/erpnext/erpnext/accounts/page/pos/pos.js +895,Submitted orders can not be deleted,Maagizo yaliyowasilishwa hayawezi kufutwa
apps/erpnext/erpnext/accounts/doctype/account/account.py +114,"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/setup/setup_wizard/operations/install_fixtures.py +118,Quality Management,Usimamizi wa Ubora
apps/erpnext/erpnext/assets/doctype/asset/asset.py +41,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: Employee Loan,Repay Fixed Amount per Period,Rejesha Kiasi kilichopangwa kwa Kipindi
DocType: Employee,Health Insurance No,Bima ya Afya Bila
apps/erpnext/erpnext/buying/utils.py +47,Please enter quantity for Item {0},Tafadhali ingiza kiasi cha Bidhaa {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +227,Credit Note Amt,Kumbuka Mkopo Amt
DocType: Employee External Work History,Employee External Work History,Historia ya Kazi ya Wafanyakazi wa Nje
DocType: Opening Invoice Creation Tool,Purchase,Ununuzi
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,Kiwango cha usawa
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20,Goals cannot be empty,Malengo hayawezi kuwa tupu
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +15,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 +21,{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 +39,Cost Centers,Vituo vya Gharama
DocType: Land Unit,Linked Plant Analysis,Uchunguzi wa Plant unaohusishwa
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
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,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: Training Event Employee,Invited,Alialikwa
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +178,Multiple active Salary Structures found for employee {0} for the given dates,Miundo ya Mishahara yenye kazi nyingi inayopatikana kwa mfanyakazi {0} kwa tarehe zilizopewa
apps/erpnext/erpnext/config/accounts.py +308,Setup Gateway accounts.,Akaunti za Kuweka Gateway.
DocType: Employee,Employment Type,Aina ya Ajira
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42,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
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25,Combined invoice portion must equal 100%,Sehemu ya ankara ya pamoja lazima iwe sawa na 100%
DocType: Item Group,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 +53,Student Email ID,Kitambulisho cha Barua ya Wanafunzi
DocType: Employee,Notice (days),Angalia (siku)
DocType: Tax Rule,Sales Tax Template,Kigezo cha Kodi ya Mauzo
apps/erpnext/erpnext/accounts/page/pos/pos.js +2506,Select items to save the invoice,Chagua vitu ili uhifadhi ankara
DocType: Employee,Encashment Date,Tarehe ya Kuingiza
DocType: Training Event,Internet,Internet
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 +34,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/config/accounts.py +471,List of all share transactions,Orodha ya shughuli zote za kushiriki
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Upinzani wa Opp
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +244,Please find attached {0} #{1},Tafadhali pata masharti {0} # {1}
apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py +52,Average Rate,Kiwango cha wastani
apps/erpnext/erpnext/controllers/accounts_controller.py +730,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/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,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: Buying Settings,"If enabled, last purchase details of items will not be fetched from previous purchase order or purchase receipt","Ikiwa imewezeshwa, maelezo ya mwisho ya ununuzi ya vitu hayatafutwa kutoka kwa amri ya ununuzi uliopita au risiti ya ununuzi"
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 +42,Serial No is mandatory for Item {0},Hapana ya Serial ni ya lazima kwa Bidhaa {0}
DocType: Item Variant Attribute,Attribute,Sifa
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43,Please specify from/to range,Tafadhali taja kutoka / kwa kuenea
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28,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 +55,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 +153,Default settings for selling transactions.,Mipangilio ya mipangilio ya kuuza shughuli.
DocType: Guardian,Guardian Of ,Mlezi wa
DocType: Grading Scale Interval,Threshold,Kizuizi
DocType: BOM Update Tool,Current BOM,BOM ya sasa
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +32,Balance (Dr - Cr),Mizani (Dr - Cr)
apps/erpnext/erpnext/public/js/utils.js +55,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 +22,Warranty,Warranty
DocType: Purchase Invoice,Debit Note Issued,Kumbuka ya Debit imeondolewa
DocType: Work Order,Warehouses,Maghala
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} mali haiwezi kuhamishwa
DocType: Hotel Room Pricing,Hotel Room Pricing,Bei ya chumba cha Hoteli
apps/erpnext/erpnext/stock/doctype/item/item.js +80,This Item is a Variant of {0} (Template).,Ncha hii ni Tofauti ya {0} (Kigezo).
DocType: Workstation,per hour,kwa saa
apps/erpnext/erpnext/config/buying.py +7,Purchasing,Ununuzi
DocType: Announcement,Announcement,Tangazo
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +106,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 +50,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 +25,Distribution,Usambazaji
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 +43,Volunteer information.,Maelezo ya kujitolea.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133,Project Manager,Meneja wa mradi
,Quoted Item Comparison,Ilipendekeza Kulinganishwa kwa Bidhaa
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34,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 +114,Dispatch,Tangaza
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +74,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 +176,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 +308,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.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +990,Select Items to Manufacture,Chagua Vitu Ili Kukuza
DocType: Delivery Stop,Delivery Stop,Utoaji wa Kuacha
apps/erpnext/erpnext/accounts/page/pos/pos.js +963,"Master data syncing, it might take some time","Usawazishaji wa data ya Mwalimu, inaweza kuchukua muda"
DocType: Item,Material Issue,Matatizo ya Nyenzo
DocType: Employee Education,Qualification,Ustahili
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +42,View Salary Slips,Angalia Slips za Mshahara
DocType: Item Price,Item Price,Item Bei
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48,Soap & Detergent,Sabuni &amp; Daktari
DocType: BOM,Show Items,Onyesha Vitu
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30,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 +92,Do you want to notify all the customers by email?,Unataka kuwajulisha wateja wote kwa barua pepe?
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36,Motion Picture & Video,Picha na Video ya Mwendo
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Amri
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51,Resume,Rejea
DocType: Hub Settings,Hub Username,Jina la mtumiaji wa Hub
DocType: Salary Detail,Component,Kipengele
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 +252,Accrual Journal Entry for salaries from {0} to {1},Usajili wa Taarifa ya Mishahara kutoka kwa {0} hadi {1}
apps/erpnext/erpnext/assets/doctype/asset/asset.py +72,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 +30,Please enter Approving Role or Approving User,Tafadhali ingiza Uwezeshaji au Kuidhinisha Mtumiaji
DocType: Journal Entry,Write Off Entry,Andika Entry Entry
DocType: BOM,Rate Of Materials Based On,Kiwango cha Vifaa vya msingi
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Analtyics ya msaada
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102,Uncheck all,Futa yote
DocType: POS Profile,Terms and Conditions,Sheria na Masharti
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49,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"
DocType: Leave Block List,Applies to Company,Inahitajika kwa Kampuni
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +231,Cannot cancel because submitted Stock Entry {0} exists,Haiwezi kufuta kwa sababu In Entry In Stock {0} ipo
DocType: Employee Loan,Disbursement Date,Tarehe ya Malipo
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80,'Recipients' not specified,&#39;Waliopokea&#39; sio maalum
DocType: BOM Update Tool,Update latest price in all BOMs,Sasisha bei ya hivi karibuni katika BOM zote
apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +23,Medical Record,Rekodi ya Matibabu
DocType: Vehicle,Vehicle,Gari
DocType: Purchase Invoice,In Words,Katika Maneno
apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15,{0} must be submitted,{0} lazima iwasilishwa
DocType: POS Profile,Item Groups,Makala ya Vikundi
apps/erpnext/erpnext/hr/doctype/employee/employee.py +222,Today is {0}'s birthday!,Leo ni siku ya kuzaliwa ya {0}!
DocType: Sales Order Item,For Production,Kwa Uzalishaji
DocType: Payment Request,payment_url,malipo_url
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +186,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/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +154,Period Closing Journal,Nyakati ya Kufunga Juma
DocType: Project Task,View Task,Tazama Kazi
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Upinzani / Kiongozi%
DocType: Material Request,MREQ-,MREQ-
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 +370,Amount {0} {1} transferred from {2} to {3},Kiasi {0} {1} kilichohamishwa kutoka {2} hadi {3}
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 +19,"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;"
DocType: Production Plan,Include Subcontracted Items,Jumuisha Vipengee vidogo
apps/erpnext/erpnext/projects/doctype/project/project.py +220,Join,Jiunge
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21,Shortage Qty,Uchina wa Ufupi
apps/erpnext/erpnext/stock/doctype/item/item.py +672,Cannot change Variant properties after stock transction. You will have to make a new Item to do this.,Haiwezi kubadilisha mali tofauti baada ya kupitishwa kwa hisa. Utahitaji kufanya kitu kipya cha kufanya hivyo.
apps/erpnext/erpnext/stock/doctype/item/item.py +714,Item variant {0} exists with same attributes,Tofauti ya kipengee {0} ipo na sifa sawa
DocType: Employee Loan,Repay from Salary,Malipo kutoka kwa Mshahara
DocType: Leave Application,LAP/,LAP /
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +360,Requesting payment against {0} {1} for amount {2},Inalipa malipo dhidi ya {0} {1} kwa kiasi {2}
DocType: Salary Slip,Salary Slip,Kulipwa kwa Mshahara
DocType: Lead,Lost Quotation,Nukuu iliyopotea
apps/erpnext/erpnext/utilities/user_progress.py +221,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 +48,'To Date' is required,&#39;Tarehe&#39; inahitajika
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: Salary Slip,Total Interest Amount,Kiasi cha Maslahi
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +124,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: Notification Control,"When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.","Wakati shughuli zozote zilizotajwa zimepewa &quot;Kutumwa&quot;, barua pepe ya pop-up imefunguliwa moja kwa moja ili kutuma barua pepe kwa &quot;Mawasiliano&quot; inayohusishwa katika shughuli hiyo, pamoja na shughuli kama kiambatisho. Mtumiaji anaweza au hawezi kutuma barua pepe."
apps/erpnext/erpnext/config/setup.py +14,Global Settings,Mipangilio ya Global
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
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53,Duplicate item group found in the item group table,Kundi la kipengee cha kipengee kilichopatikana kwenye meza ya kikundi cha bidhaa
DocType: Land Unit,Parent Land Unit,Kitengo cha Ardhi cha Mzazi
apps/erpnext/erpnext/public/js/controllers/transaction.js +1114,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 +217,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: 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 +1352,Delete permanently?,Futa kwa kudumu?
DocType: Expense Claim,Total Claimed Amount,Kiasi kilichodaiwa
apps/erpnext/erpnext/config/crm.py +17,Potential opportunities for selling.,Uwezo wa fursa za kuuza.
DocType: Shareholder,Folio no.,Uliopita.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +246,Invalid {0},Inalidhika {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90,Sick Leave,Kuondoka kwa mgonjwa
DocType: Email Digest,Email Digest,Barua pepe ya Digest
DocType: Delivery Note,Billing Address Name,Jina la Anwani ya Kulipa
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22,Department Stores,Idara ya maduka
,Item Delivery Date,Tarehe ya Utoaji wa Item
DocType: Production Plan,Material Requested,Nyenzo Iliombwa
DocType: Warehouse,PIN,PIN
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +116,Error '{0}' occured. Arguments {1}.,Hitilafu &#39;{0}&#39; ilitokea. Majadiliano {1}.
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 +304,No accounting entries for the following warehouses,Hakuna kuingizwa kwa uhasibu kwa maghala yafuatayo
apps/erpnext/erpnext/projects/doctype/project/project.js +95,Save the document first.,Hifadhi hati kwanza.
apps/erpnext/erpnext/shopping_cart/cart.py +74,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
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py +66,Pay {0} {1},Kulipa {0} {1}
DocType: Expense Claim Detail,Expense Date,Tarehe ya gharama
DocType: Item,Max Discount (%),Max Discount (%)
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30,Credit Days cannot be a negative number,Siku za Mikopo haiwezi kuwa nambari hasi
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,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 +275," {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: Delivery Stop,Email Sent To,Imepelekwa kwa barua pepe
DocType: Budget,Warn,Tahadhari
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +108,Are you sure you want to unregister?,Una uhakika unataka kusajili?
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +926,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: C-Form,Series,Mfululizo
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +282,Currency of the price list {0} must be {1} or {2},Fedha ya orodha ya bei {0} lazima iwe {1} au {2}
DocType: Appraisal,Appraisal Template,Kigezo cha Uhakiki
DocType: Soil Texture,Ternary Plot,Plot ya Ternary
DocType: Item Group,Item Classification,Uainishaji wa Bidhaa
DocType: Driver,License Number,Nambari ya Leseni
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131,Business Development Manager,Meneja wa Maendeleo ya Biashara
DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Matengenezo ya Kutembelea Kusudi
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19,Invoice Patient Registration,Usajili wa Msajili wa Msajili
DocType: Crop,Period,Kipindi
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +27,General Ledger,Mkuu Ledger
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33,Employee {0} on Leave on {1},Mfanyakazi {0} juu ya Acha kwenye {1}
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Angalia Waongoza
DocType: Program Enrollment Tool,New Program,Programu mpya
DocType: Item Attribute Value,Attribute Value,Thamani ya Thamani
,Itemwise Recommended Reorder Level,Inemwise Inapendekezwa Mpangilio wa Mpangilio
DocType: Salary Detail,Salary Detail,Maelezo ya Mshahara
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1070,Please select {0} first,Tafadhali chagua {0} kwanza
DocType: Appointment Type,Physician,Daktari
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1005,Batch {0} of Item {1} has expired.,Kipengee {0} cha Bidhaa {1} kimekamilika.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11,Consultations,Majadiliano
DocType: Sales Invoice,Commission,Tume
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +187,{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}
apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Karatasi ya Muda kwa ajili ya utengenezaji.
apps/erpnext/erpnext/templates/pages/cart.html +37,Subtotal,jumla ndogo
apps/erpnext/erpnext/config/erpnext_integrations.py +18,GoCardless SEPA Mandate,Mandhari ya SEPA ya GoCardless
DocType: Physician,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 +95,Warehouse not found in the system,Ghala haipatikani kwenye mfumo
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115,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 +25,`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/utilities/user_progress.py +48,Set a sales goal you'd like to achieve for your company.,Weka lengo la mauzo ungependa kufikia kwa kampuni yako.
,Project wise Stock Tracking,Ufuatiliaji wa Hitilafu wa Mradi
DocType: GST HSN Code,Regional,Mkoa
apps/erpnext/erpnext/config/healthcare.py +40,Laboratory,Maabara
DocType: Stock Entry Detail,Actual Qty (at source/target),Uchina halisi (katika chanzo / lengo)
DocType: Item Customer Detail,Ref Code,Kanuni ya Ref
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75,Customer Group is Required in POS Profile,Kundi la Wateja Inahitajika katika POS Profile
apps/erpnext/erpnext/config/hr.py +12,Employee records.,Rekodi za waajiriwa.
apps/erpnext/erpnext/assets/doctype/asset/asset.py +98,Please set Next Depreciation Date,Tafadhali weka Tarehe ya Utoaji wa Dhamana
DocType: HR Settings,Payroll Settings,Mipangilio ya Mishahara
apps/erpnext/erpnext/config/accounts.py +146,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 +16,Place Order,Agiza
DocType: Email Digest,New Purchase Orders,Amri mpya ya Ununuzi
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24,Root cannot have a parent cost center,Mizizi haiwezi kuwa na kituo cha gharama ya wazazi
apps/erpnext/erpnext/public/js/stock_analytics.js +54,Select Brand...,Chagua Brand ...
apps/erpnext/erpnext/public/js/setup_wizard.js +32,Non Profit (beta),Sio faida (beta)
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18,Training Events/Results,Mafunzo ya Matukio / Matokeo
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152,Accumulated Depreciation as on,Kushuka kwa thamani kwa wakati
DocType: Sales Invoice,C-Form Applicable,Fomu ya C inahitajika
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +438,Operation Time must be greater than 0 for Operation {0},Muda wa Uendeshaji lazima uwe mkubwa kuliko 0 kwa Uendeshaji {0}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +107,Warehouse is mandatory,Ghala ni lazima
DocType: Shareholder,Address and Contacts,Anwani na Mawasiliano
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67,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/stock/doctype/purchase_receipt/purchase_receipt.js +924,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/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52,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
DocType: Bank Guarantee,Start Date,Tarehe ya Mwanzo
apps/erpnext/erpnext/config/hr.py +75,Allocate leaves for a period.,Shirikisha majani kwa muda.
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Cheques and Deposits incorrectly cleared,Cheki na Deposits zimeondolewa kwa usahihi
apps/erpnext/erpnext/accounts/doctype/account/account.py +46,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 +72,Create customer quotes,Unda nukuu za wateja
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 +38,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: Sample Collection,Collected By,Imekusanywa na
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +35,Assessment Result,Matokeo ya Tathmini
DocType: Hotel Room Package,Hotel Room Package,Kituo cha Chumba cha Hoteli
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,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 +963,Work Order already created for all items with BOM,Kazi ya Kazi imeundwa tayari kwa vitu vyote na BOM
apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant Details Report,Ripoti ya Taarifa ya Variant
DocType: Setup Progress Action,Setup Progress Action,Hatua ya Kuanzisha Programu
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +36,Buying Price List,Kununua Orodha ya Bei
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49,Remove item if charges is not applicable to that item,Ondoa kipengee ikiwa mashtaka haifai kwa bidhaa hiyo
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21,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 +34,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
apps/erpnext/erpnext/templates/pages/rfq.html +75,Quotations: ,Nukuu:
DocType: Maintenance Visit,Fully Completed,Imekamilishwa kikamilifu
apps/erpnext/erpnext/projects/doctype/project/project_list.js +6,{0}% Complete,{0}% Kamili
DocType: Employee,Educational Qualification,Ufanisi wa Elimu
DocType: Workstation,Operating Costs,Gharama za uendeshaji
DocType: Budget,Action if Accumulated Monthly Budget Exceeded,Hatua kama Bajeti ya Mwezi Yote Ilipatikana
DocType: Subscription,Submit on creation,Wasilisha kwenye uumbaji
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +483,Currency for {0} must be {1},Fedha ya {0} lazima iwe {1}
DocType: Asset,Disposal Date,Tarehe ya kupoteza
DocType: Daily Work Summary Settings,"Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.","Barua pepe zitatumwa kwa Wafanyakazi wote wa Kampuni katika saa iliyotolewa, ikiwa hawana likizo. Muhtasari wa majibu itatumwa usiku wa manane."
DocType: Employee Leave Approver,Employee Leave Approver,Msaidizi wa Kuondoa Waajiri
apps/erpnext/erpnext/stock/doctype/item/item.py +510,Row {0}: An Reorder entry already exists for this warehouse {1},Row {0}: Kuingilia upya tayari kunapo kwa ghala hili {1}
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99,"Cannot declare as lost, because Quotation has been made.","Haiwezi kutangaza kama kupotea, kwa sababu Nukuu imefanywa."
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16,Training Feedback,Mafunzo ya Mafunzo
DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Vigezo vya Scorecard za Wasambazaji
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149,Please select Start Date and End Date for Item {0},Tafadhali chagua tarehe ya kuanza na tarehe ya mwisho ya kipengee {0}
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55,Course is mandatory in row {0},Kozi ni lazima katika mstari {0}
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16,To date cannot be before from date,Hadi sasa haiwezi kuwa kabla kabla ya tarehe
DocType: Supplier Quotation Item,Prevdoc DocType,Prevdoc DocType
DocType: Cash Flow Mapper,Section Footer,Sehemu ya Sehemu
apps/erpnext/erpnext/stock/doctype/item/item.js +304,Add / Edit Prices,Ongeza / Hariri Bei
DocType: Batch,Parent Batch,Kundi cha Mzazi
DocType: Cheque Print Template,Cheque Print Template,Angalia Kigezo cha Print
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36,Chart of Cost Centers,Chati ya Vituo vya Gharama
DocType: Lab Test 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: BOM,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 +150,Something went wrong!,Kitu kilichokosa!
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +105,Warning: Leave application contains following block dates,Onyo: Acha programu ina tarehe zifuatazo za kuzuia
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +275,Sales Invoice {0} has already been submitted,Invozi ya Mauzo {0} imetumwa tayari
DocType: Supplier Scorecard Scoring Criteria,Score,Score
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,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: Agriculture Analysis Criteria,Agriculture User,Mtumiaji wa Kilimo
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38,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/config/hr.py +238,Organization unit (department) master.,Shirika la kitengo (idara) bwana.
DocType: Shipping Rule,Shipping Rule Type,Aina ya Rule ya Utoaji
apps/erpnext/erpnext/utilities/user_progress.py +239,Go to Rooms,Nenda kwenye Vyumba
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,Tafadhali ingiza ujumbe kabla ya kutuma
DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DUPLICATE KWA MFASHAJI
DocType: Email Digest,Pending Quotations,Nukuu zinazopendu
apps/erpnext/erpnext/config/accounts.py +318,Point-of-Sale Profile,Ushauri wa Maandishi ya Uhakika
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +25,{0} should be a value between 0 and 100,{0} lazima iwe thamani kati ya 0 na 100
apps/erpnext/erpnext/assets/doctype/asset/asset.py +94,Next Depreciation Date cannot be before Available-for-use Date,Tarehe ya Kuondoa Upya ifuatavyo haiwezi kuwa kabla ya Tarehe inapatikana kwa kutumia
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156,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: Maintenance Schedule Detail,Scheduled Date,Tarehe iliyopangwa
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +226,Total Paid Amt,Jumla ya malipo ya Amt
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
DocType: Hub Settings,Company and Seller Profile,Kampuni na Profaili ya Wauzaji
,GST Itemised Sales Register,GST Register Itemized Sales Register
DocType: Soil Texture,Silt Loam,Silt Loam
,Serial No Service Contract Expiry,Serial Hakuna Mpangilio wa Mkataba wa Huduma
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299,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 +53,Total weightage assigned should be 100%. It is {0},Jumla ya uzito uliopangwa lazima iwe 100%. Ni {0}
apps/erpnext/erpnext/utilities/user_progress.py +109,Your Suppliers,Wauzaji wako
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,Please correct the,Tafadhali sahihisha
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80,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/accounts/doctype/purchase_invoice/purchase_invoice.js +382,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/hub_form.js +197,Anonymous,Haijulikani
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +377,Received From,Imepokea Kutoka
DocType: Lead,Converted,Ilibadilishwa
DocType: Item,Has Serial No,Ina Serial No
DocType: Employee,Date of Issue,Tarehe ya Suala
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222,"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 +167,Row #{0}: Set Supplier for item {1},Row # {0}: Weka wauzaji kwa kipengee {1}
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121,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 +195,Website Image {0} attached to Item {1} cannot be found,Image ya tovuti {0} iliyoambatana na Item {1} haiwezi kupatikana
DocType: Issue,Content Type,Aina ya Maudhui
DocType: Asset,Assets,Mali
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17,Computer,Kompyuta
DocType: Item,List this Item in multiple groups on the website.,Andika kitu hiki katika makundi mengi kwenye tovuti.
DocType: Payment Term,Due Date Based On,Kutokana na Tarehe ya Kuzingatia
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +82,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 +214,{0} {1} does not exist,{0} {1} haipo
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323,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 +88,Item: {0} does not exist in the system,Item: {0} haipo katika mfumo
apps/erpnext/erpnext/accounts/doctype/account/account.py +106,You are not authorized to set Frozen value,Huna mamlaka ya kuweka thamani iliyosafishwa
DocType: Payment Reconciliation,Get Unreconciled Entries,Pata Maingiliano yasiyotambulika
DocType: Payment Reconciliation,From Invoice Date,Kutoka tarehe ya ankara
DocType: Healthcare Settings,Laboratory Settings,Mazingira ya Maabara
DocType: Patient Appointment,Service Unit,Kitengo cha Huduma
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +97,Successfully Set Supplier,Tengeneza Wasambazaji kwa Ufanisi
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75,Leave Encashment,Acha Acha
apps/erpnext/erpnext/public/js/setup_wizard.js +114,What does it do?,Inafanya nini?
DocType: Crop,Byproducts,Bidhaa
apps/erpnext/erpnext/stock/doctype/batch/batch.js +84,To Warehouse,Kwa Ghala
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26,All Student Admissions,Uingizaji wa Wanafunzi wote
,Average Commission Rate,Wastani wa Tume ya Kiwango
DocType: Share Balance,No of Shares,Hakuna ya Hisa
apps/erpnext/erpnext/stock/doctype/item/item.py +448,'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 +59,Select Status,Chagua Hali
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41,Attendance can not be marked for future dates,Mahudhurio hayawezi kutambuliwa kwa tarehe za baadaye
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: Purchase Taxes and Charges,Account Head,Kichwa cha Akaunti
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153,Electrical,Umeme
apps/erpnext/erpnext/utilities/activation.py +100,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: Grant Application,Requested Amount,Kiasi kilichoombwa
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348,Row {0}: Exchange Rate is mandatory,Row {0}: Kiwango cha Exchange ni lazima
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27,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
apps/erpnext/erpnext/hr/doctype/employee/employee.py +221,Birthday Reminder for {0},Kikumbusho cha Kuzaliwa kwa {0}
DocType: Asset Maintenance Task,Last Completion Date,Tarehe ya mwisho ya kukamilika
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72,Days Since Last Order,Siku Tangu Toleo la Mwisho
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +365,Debit To account must be a Balance Sheet account,Debit Kwa akaunti lazima iwe Hesabu ya Hesabu ya Hesabu
DocType: Buying Settings,Naming Series,Mfululizo wa majina
DocType: GoCardless Settings,GoCardless Settings,Mipangilio ya GoCardless
DocType: Leave Block List,Leave Block List Name,Acha jina la orodha ya kuzuia
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14,Insurance Start date should be less than Insurance End date,Tarehe ya kuanza kwa bima inapaswa kuwa chini ya tarehe ya mwisho ya Bima
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,Mali ya Hifadhi
DocType: Restaurant,Active Menu,Menyu ya Kazi
DocType: Target Detail,Target Qty,Uchina wa Target
DocType: Shopping Cart Settings,Checkout Settings,Mipangilio ya Checkout
DocType: Student Attendance,Present,Sasa
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37,Delivery Note {0} must not be submitted,Kumbuka Utoaji {0} haipaswi kuwasilishwa
DocType: Notification Control,Sales Invoice Message,Ujumbe wa Invoice ya Mauzo
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,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 +325,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 +744,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 +930,BOM does not contain any stock item,BOM haina kitu chochote cha hisa
DocType: Chapter,Chapter Head,Mlango Mkuu
DocType: Payment Term,Month(s) after the end of the invoice month,Mwezi (s) baada ya mwisho wa mwezi wa ankara
apps/erpnext/erpnext/config/projects.py +24,Project activity / task.,Shughuli ya mradi / kazi.
DocType: Vehicle Log,Refuelling Details,Maelezo ya Refueling
apps/erpnext/erpnext/config/hr.py +104,Generate Salary Slips,Kuzalisha Slips za Mshahara
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +25,Lab result datetime cannot be before testing datetime,Siku ya tarehe ya matokeo ya Lab haiwezi kuwa kabla ya tarehe ya kupima
DocType: POS Profile,Allow user to edit Discount,Ruhusu mtumiaji kuhariri Discount
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +55,Get customers from,Pata wateja kutoka
DocType: Purchase Invoice Item,Include Exploded Items,Jumuisha Vipengee Vipengee
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +45,"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 +40,Discount must be less than 100,Punguzo lazima liwe chini ya 100
DocType: Shipping Rule,Restrict to Countries,Uzuia Nchi
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 +572,Default BOM for {0} not found,BOM ya default kwa {0} haipatikani
apps/erpnext/erpnext/stock/doctype/item/item.py +514,Row #{0}: Please set reorder quantity,Row # {0}: Tafadhali weka upya kiasi
apps/erpnext/erpnext/public/js/pos/pos.html +20,Tap items to add them here,Gonga vitu ili uziweze hapa
DocType: Fees,Program Enrollment,Uandikishaji wa Programu
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/public/js/queries.js +39,Please set {0},Tafadhali weka {0}
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} ni mwanafunzi asiye na kazi
DocType: Employee,Health Details,Maelezo ya Afya
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,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
DocType: Payment Entry,Allocate Payment Amount,Weka Kiwango cha Malipo
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 +236,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} inahusishwa na {2}, lakini Akaunti ya Chama ni {3}"
apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7,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 +82,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 +122,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 +156,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: 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 +616,BOM and Manufacturing Quantity are required,BOM na Uzalishaji wa Wingi huhitajika
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +50,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 +28,Installing presets,Inaweka presets
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +85,No Delivery Note selected for Customer {},Hakuna Kumbukumbu ya Utoaji iliyochaguliwa kwa Wateja {}
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +25,BOM replaced,BOM imebadilishwa
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1053,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 +127,Available {0},Inapatikana {0}
,Prospects Engaged But Not Converted,Matarajio yaliyotumika lakini haijaongozwa
DocType: Manufacturing Settings,Manufacturing Settings,Mipangilio ya Uzalishaji
apps/erpnext/erpnext/config/setup.py +56,Setting up Email,Kuweka Barua pepe
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,Guardian1 Simu ya Mkono Hakuna
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106,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 +109,Daily Reminders,Kumbukumbu za kila siku
DocType: Products Settings,Home Page is Products,Ukurasa wa Kwanza ni Bidhaa
,Asset Depreciation Ledger,Msanidi wa Upungufu wa Mali
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +91,Tax Rule Conflicts with {0},Migogoro ya Kanuni za Ushuru na {0}
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25,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 +115,Customer Service,Huduma kwa wateja
DocType: BOM,Thumbnail,Picha ndogo
DocType: Item Customer Detail,Item Customer Detail,Maelezo ya Wateja wa Bidhaa
apps/erpnext/erpnext/config/hr.py +50,Offer candidate a Job.,Kutoa mgombea Job.
DocType: Notification Control,Prompt for Email on Submission of,Ombi kwa Barua pepe juu ya Uwasilishaji wa
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88,Total allocated leaves are more than days in the period,Majani yote yaliyotengwa ni zaidi ya siku katika kipindi
DocType: Land Unit,Linked Soil Analysis,Uchunguzi wa ardhi uliohusishwa
DocType: Pricing Rule,Percentage,Asilimia
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70,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/config/accounts.py +288,Default settings for accounting transactions.,Mipangilio ya mipangilio ya shughuli za uhasibu.
DocType: Maintenance Visit,MV,MV
DocType: Restaurant,Default Tax Template,Kigezo cha Ushuru cha Default
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +66,{0} Students have been enrolled,{0} Wanafunzi wamejiandikisha
DocType: Fees,Student Details,Maelezo ya Wanafunzi
DocType: Purchase Invoice Item,Stock Qty,Kiwanda
DocType: Employee Loan,Repayment Period in Months,Kipindi cha ulipaji kwa Miezi
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26,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 +78,{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: Sales Order,Printing Details,Maelezo ya Uchapishaji
DocType: Task,Closing Date,Tarehe ya kufunga
DocType: Sales Order Item,Produced Quantity,Waliyotokana na Wingi
DocType: Timesheet,Work Detail,Maelezo ya Kazi
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126,Engineer,Mhandisi
DocType: Journal Entry,Total Amount Currency,Jumla ya Fedha ya Fedha
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Tafuta Sub Assemblies
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171,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 +154,Go to Items,Nenda kwa Vitu
DocType: Sales Partner,Partner Type,Aina ya Washirika
DocType: Purchase Taxes and Charges,Actual,Kweli
DocType: Restaurant Menu,Restaurant Manager,Meneja wa Mgahawa
DocType: Authorization Rule,Customerwise Discount,Ugawaji wa Wateja
apps/erpnext/erpnext/config/projects.py +46,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 +282,Installation Note {0} has already been submitted,Maelezo ya Usanidi {0} tayari imewasilishwa
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/setup/doctype/email_digest/email_digest.js +9,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
apps/erpnext/erpnext/projects/doctype/project/project.js +54,Gantt Chart,Chati ya Gantt
DocType: Crop Cycle,Cycle Type,Aina ya Mzunguko
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99,Part-time,Wakati wa sehemu
DocType: Employee,Applicable Holiday List,Orodha ya likizo ya kuhitajika
DocType: Employee,Cheque,Angalia
DocType: Training Event,Employee Emails,Barua za Waajiriwa
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +60,Series Updated,Mfululizo umehifadhiwa
apps/erpnext/erpnext/accounts/doctype/account/account.py +159,Report Type is mandatory,Aina ya Ripoti ni lazima
DocType: Item,Serial Number Series,Serial Number Series
apps/erpnext/erpnext/buying/utils.py +68,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 +45,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
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +90,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
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +113,Clearance Date updated,Tarehe ya kufuta imewekwa
apps/erpnext/erpnext/stock/doctype/batch/batch.js +146,Split Batch,Piga Kundi
DocType: Stock Settings,Batch Identification,Kitambulisho cha Bundi
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +132,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
apps/erpnext/erpnext/config/non_profit.py +63,Donor Type information.,Aina ya Msaidizi wa habari.
DocType: Request for Quotation,Supplier Detail,Maelezo ya Wasambazaji
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100,Error in formula or condition: {0},Hitilafu katika fomu au hali: {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +106,Invoiced Amount,Kiasi kilichopishwa
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47,Criteria weights must add up to 100%,Vipimo vya vigezo lazima kuongeza hadi 100%
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7,Attendance,Mahudhurio
apps/erpnext/erpnext/public/js/pos/pos.html +115,Stock Items,Vitu vya hisa
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/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +111,Creating {0},Kujenga {0}
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Hifadhi ya Chanzo na Target haiwezi kuwa sawa
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +628,Posting date and posting time is mandatory,Tarehe ya kuchapisha na muda wa kuchapisha ni lazima
apps/erpnext/erpnext/config/buying.py +76,Tax template for buying transactions.,Template ya kodi kwa kununua shughuli.
,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: Woocommerce Settings,Endpoint,Mwisho
DocType: Period Closing Voucher,Period Closing Voucher,Voucher ya kufunga ya muda
DocType: Consultation,Review Details,Tathmini maelezo
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +185,The shareholder does not belong to this company,Mbia sio kampuni hii
DocType: Dosage Form,Dosage Form,Fomu ya Kipimo
apps/erpnext/erpnext/config/selling.py +67,Price List master.,Orodha ya bei ya bwana.
DocType: Task,Review Date,Tarehe ya Marekebisho
DocType: BOM,Allow Alternative Item,Ruhusu Nakala Mbadala
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
DocType: Purchase Taxes and Charges,On Net Total,Juu ya Net Jumla
apps/erpnext/erpnext/controllers/item_variant.py +92,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: Restaurant Reservation,Waitlisted,Inastahiliwa
apps/erpnext/erpnext/accounts/doctype/account/account.py +124,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: Company,Round Off Account,Ondoa Akaunti
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93,Administrative Expenses,Gharama za Utawala
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18,Consulting,Ushauri
DocType: Customer Group,Parent Customer Group,Kundi la Wateja wa Mzazi
DocType: Journal Entry,Subscription,Usajili
DocType: Purchase Invoice,Contact Email,Mawasiliano ya barua pepe
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Uumbaji wa Ada Inasubiri
DocType: Appraisal Goal,Score Earned,Score Ilipatikana
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +241,Notice Period,Kipindi cha Taarifa
DocType: Asset Category,Asset Category Name,Jina la Jamii ya Mali
apps/erpnext/erpnext/setup/doctype/territory/territory.js +13,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 +5,New Sales Person Name,Jina la mtu mpya wa mauzo
DocType: Packing Slip,Gross Weight UOM,Uzito wa Pato UOM
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 +156,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
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43,EcritureNum,UandishiNum
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 +500,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 +57,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: 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: Hub Settings,Company Logo,Logo ya Kampuni
apps/erpnext/erpnext/stock/doctype/item/item.py +709,Please specify Attribute Value for attribute {0},Tafadhali taja Thamani ya Attribut kwa sifa {0}
DocType: Item,Default Warehouse,Ghala la Ghalafa
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45,Budget cannot be assigned against Group Account {0},Bajeti haipatikani dhidi ya Akaunti ya Kundi {0}
DocType: Healthcare Settings,Patient Registration,Usajili wa Mgonjwa
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22,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 +57,Depreciation Date,Tarehe ya kushuka kwa thamani
,Work Orders in Progress,Kazi ya Kazi katika Maendeleo
DocType: Issue,Support Team,Timu ya Kusaidia
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36,Expiry (In Days),Mwisho (Katika Siku)
DocType: Appraisal,Total Score (Out of 5),Jumla ya alama (Kati ya 5)
DocType: Fee Structure,FS.,FS.
DocType: Student Attendance Tool,Batch,Kundi
DocType: Donor,Donor Type,Aina ya wafadhili
apps/erpnext/erpnext/stock/doctype/item/item.js +27,Balance,Mizani
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66,Please select the Company,Tafadhali chagua Kampuni
DocType: Room,Seating Capacity,Kuweka uwezo
DocType: Issue,ISS-,ISS-
DocType: Lab Test Groups,Lab Test Groups,Makundi ya Majaribio ya Lab
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 +16,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: Journal Entry,Debit Note,Kumbuka Debit
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py +102,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 +7,Not Expired,Haikuzimia
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +49,ValidDate,ValidDate
DocType: Student Log,Achievement,Mafanikio
DocType: Batch,Source Document Type,Aina ya Hati ya Chanzo
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24,Following course schedules were created,Kufuatia ratiba ya kozi iliundwa
DocType: Journal Entry,Total Debit,Debit Jumla
DocType: Manufacturing Settings,Default Finished Goods Warehouse,Ghala la Wafanyabiashara wa Malifadi
apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +108,Please select Patient,Tafadhali chagua Mgonjwa
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76,Sales Person,Mtu wa Mauzo
DocType: Hotel Room Package,Amenities,Huduma
apps/erpnext/erpnext/config/accounts.py +233,Budget and Cost Center,Kituo cha Bajeti na Gharama
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65,Multiple default mode of payment is not allowed,Njia ya malipo ya malipo ya kuruhusiwa haiwezi kuruhusiwa
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,for the,kwa
,Appointment Analytics,Uchambuzi wa Uteuzi
DocType: Vehicle Service,Half Yearly,Nusu ya mwaka
DocType: Lead,Blog Subscriber,Msajili wa Blog
DocType: Guardian,Alternate Number,Nambari mbadala
DocType: Healthcare Settings,Consultations in valid days,Majadiliano katika siku halali
DocType: Assessment Plan Criteria,Maximum Score,Upeo wa alama
apps/erpnext/erpnext/config/setup.py +83,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 +49, Group Roll No,Roll No. ya Kikundi
DocType: Batch,Manufacturing Date,Tarehe ya Uzalishaji
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Uumbaji wa Ada Imeshindwa
DocType: Opening Invoice Creation Tool,Create Missing Party,Unda Chama Chache
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/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js +25,"Apps using current key won't be able to access, are you sure?","Programu za kutumia kitufe cha sasa hazitaweza kufikia, una uhakika?"
DocType: Purchase Invoice,Total Advance,Jumla ya Advance
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27,Change Template Code,Badilisha Msimbo wa Kigezo
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +23,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 +19,Quot Count,Hesabu ya Quot
,BOM Stock Report,Ripoti ya hisa ya BOM
DocType: Stock Reconciliation Item,Quantity Difference,Tofauti Tofauti
DocType: Employee Advance,EA-,EA-
DocType: Opportunity Item,Basic Rate,Kiwango cha Msingi
DocType: GL Entry,Credit Amount,Mikopo
DocType: Cheque Print Template,Signatory Position,Hali ya Ishara
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +173,Set as Lost,Weka kama Imepotea
DocType: Timesheet,Total Billable Hours,Masaa Yote ya Billable
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4,Payment Receipt Note,Kumbuka Receipt Kumbuka
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,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/accounts/doctype/payment_reconciliation/payment_reconciliation.py +162,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: 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
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Panga magogo ya wakati nje ya Masaa ya kazi ya Kazini.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +115,Dr {0} does not have a Physician Schedule. Add it in Physician master,Dr {0} hana Ratiba ya Matibabu. Ongeza kwenye Bwana wa Mbaguzi
apps/erpnext/erpnext/public/js/pos/pos.html +98,Customers in Queue,Wateja katika foleni
DocType: Driver,Issuing Date,Tarehe ya Kutuma
DocType: Student,Nationality,Urithi
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +109,Submit this Work Order for further processing.,Tuma Order hii Kazi ya usindikaji zaidi.
,Items To Be Requested,Vitu Ili Kuombwa
DocType: Purchase Order,Get Last Purchase Rate,Pata Kiwango cha Ununuzi wa Mwisho
DocType: Company,Company Info,Maelezo ya Kampuni
apps/erpnext/erpnext/accounts/page/pos/pos.js +1385,Select or add new customer,Chagua au kuongeza mteja mpya
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +173,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.py +9,Application of Funds (Assets),Matumizi ya Fedha (Mali)
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6,This is based on the attendance of this Employee,Hii inategemea mahudhurio ya Waajiriwa
DocType: Assessment Result,Summary,Muhtasari
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Mark Attendance
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +494,Debit Account,Akaunti ya Debit
DocType: Fiscal Year,Year Start Date,Tarehe ya Mwanzo wa Mwaka
DocType: Attendance,Employee Name,Jina la Waajiriwa
DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Mgahawa wa Uagizaji wa Kuagiza
DocType: Purchase Invoice,Rounded Total (Company Currency),Jumla ya mviringo (Fedha la Kampuni)
apps/erpnext/erpnext/accounts/doctype/account/account.py +96,Cannot covert to Group because Account Type is selected.,Haiwezi kufunika kwa Kundi kwa sababu Aina ya Akaunti imechaguliwa.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260,{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.
DocType: Asset Maintenance Team,Maintenance Team Members,Washirika wa Timu ya Matengenezo
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63,Purchase Amount,Ununuzi wa Kiasi
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +261,Supplier Quotation {0} created,Nukuu ya Wafanyabiashara {0} imeundwa
apps/erpnext/erpnext/accounts/report/financial_statements.py +103,End Year cannot be before Start Year,Mwaka wa Mwisho hauwezi kuwa kabla ya Mwaka wa Mwanzo
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234,Employee Benefits,Faida ya Waajiriwa
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +264,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 +78,The shares don't exist with the {0},Hifadhi haipo na {0}
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64,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 +243,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 +30,{0}: {1} does not exists,{0}: {1} haipo
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76,Select Batch Numbers,Chagua Hesabu za Batch
apps/erpnext/erpnext/config/accounts.py +12,Bills raised to Customers.,Miradi iliyotolewa kwa Wateja.
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,Id ya Mradi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +534,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/public/js/utils/serial_no_batch_selector.js +295,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/page/pos/pos.js +1717,Price List not found or disabled,Orodha ya Bei haipatikani au imezimwa
DocType: Student Applicant,Approved,Imekubaliwa
apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15,Price,Bei
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +267,Employee relieved on {0} must be set as 'Left',Wafanyakazi waliondolewa kwenye {0} lazima waweke kama &#39;kushoto&#39;
DocType: Hub Settings,Last Sync On,Mwisho Sync On
DocType: Guardian,Guardian,Mlezi
DocType: Item Alternative,Item Alternative,Njia Mbadala
DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,Unda mteja aliyepotea au muuzaji.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,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
apps/erpnext/erpnext/public/js/pos/pos.html +89,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 +51,Monthly Sales Target (,Lengo la Mauzo ya Mwezi (
DocType: Physician Service Unit Schedule,Physician Service Unit Schedule,Ratiba ya Kitengo cha Wataalamu
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9,modified,ilibadilishwa
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43,"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
DocType: Asset Repair,Repair Status,Hali ya Ukarabati
apps/erpnext/erpnext/config/accounts.py +67,Accounting journal entries.,Injili ya mwandishi wa habari.
DocType: Delivery Note Item,Available Qty at From Warehouse,Uchina Inapatikana Kutoka Kwenye Ghala
DocType: POS Profile,Account for Change Amount,Akaunti ya Kiasi cha Mabadiliko
DocType: Purchase Invoice,input service,huduma ya pembejeo
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217,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: 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 +13,Course Code: ,Msimbo wa Kozi:
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +240,Please enter Expense Account,Tafadhali ingiza Akaunti ya gharama
DocType: Account,Stock,Stock
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1095,"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: Serial No,Purchase / Manufacture Details,Maelezo ya Ununuzi / Utengenezaji
DocType: Assessment Group,Assessment Group,Kundi la Tathmini
apps/erpnext/erpnext/config/stock.py +333,Batch Inventory,Orodha ya Kundi
DocType: Employee,Contract End Date,Tarehe ya Mwisho wa Mkataba
DocType: Sales Order,Track this Sales Order against any Project,Fuatilia Utaratibu huu wa Mauzo dhidi ya Mradi wowote
DocType: Sales Invoice Item,Discount and Margin,Punguzo na Margin
DocType: Lab Test,Prescription,Dawa
DocType: Project,Second Email,Barua ya pili
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +111,Not Available,Haipatikani
DocType: Pricing Rule,Min Qty,Nini
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36,Disable Template,Zima Kigezo
DocType: GL Entry,Transaction Date,Tarehe ya ushirikiano
DocType: Production Plan Item,Planned Qty,Uliopita
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Jumla ya Ushuru
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +245,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)
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py +14,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: Notification Control,Purchase Receipt Message,Ujumbe wa Receipt ya Ununuzi
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/config/manufacturing.py +18,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 +62,Set default mode of payment,Weka hali ya malipo ya default
DocType: Grant Application,Withdrawn,Imeondolewa
DocType: Hub Settings,Hub Settings,Mipangilio ya Hub
DocType: Project,Gross Margin %,Margin ya Pato%
DocType: BOM,With Operations,Na Uendeshaji
apps/erpnext/erpnext/accounts/party.py +259,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 Detail,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
apps/erpnext/erpnext/config/stock.py +145,Fulfilment,Utekelezaji
DocType: Purchase Taxes and Charges,On Previous Row Amount,Kwenye Mshahara Uliopita
DocType: Item,Has Expiry Date,Ina Tarehe ya Muda
apps/erpnext/erpnext/assets/doctype/asset/asset.js +282,Transfer Asset,Weka Malipo
DocType: POS Profile,POS Profile,Profaili ya POS
DocType: Training Event,Event Name,Jina la Tukio
DocType: Physician,Phone (Office),Simu (Ofisi)
apps/erpnext/erpnext/hooks.py +151,Admission,Uingizaji
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29,Admissions for {0},Kukubali kwa {0}
apps/erpnext/erpnext/config/accounts.py +257,"Seasonality for setting budgets, targets etc.","Msimu wa kuweka bajeti, malengo nk."
DocType: Supplier Scorecard Scoring Variable,Variable Name,Jina linalofautiana
apps/erpnext/erpnext/stock/get_item_details.py +144,"Item {0} is a template, please select one of its variants","Kipengee {0} ni template, tafadhali chagua moja ya vipengele vyake"
DocType: Asset,Asset Category,Jamii ya Mali
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31,Net pay cannot be negative,Mshahara wa Net hauwezi kuwa hasi
DocType: Purchase Order,Advance Paid,Ilipwa kulipwa
DocType: Item,Item Tax,Kodi ya Item
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +883,Material to Supplier,Nyenzo kwa Wafanyabiashara
DocType: Soil Texture,Loamy Sand,Loamy Sand
DocType: Production Plan,Material Request Planning,Mipango ya Kuomba Nyenzo
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +676,Excise Invoice,Ankara ya ushuru
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16,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.py +138,Current Liabilities,Madeni ya sasa
apps/erpnext/erpnext/public/js/projects/timer.js +138,Timer exceeded the given hours.,Muda ulizidi masaa uliyopewa.
apps/erpnext/erpnext/config/selling.py +297,Send mass SMS to your contacts,Tuma SMS ya wingi kwa anwani zako
DocType: Patient,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/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +158,No Reference,Hakuna Kumbukumbu
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,Uhakika halisi ni lazima
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92,"{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
DocType: Employee Loan,Loan Type,Aina ya Mikopo
DocType: Scheduling Tool,Scheduling Tool,Kitabu cha Mpangilio
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180,Credit Card,Kadi ya Mikopo
DocType: BOM,Item to be manufactured or repacked,Kipengee cha kutengenezwa au kupakiwa
DocType: Employee Education,Major/Optional Subjects,Majukumu makubwa / Chaguo
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
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23,From Currency and To Currency cannot be same,Kutoka kwa Fedha na Fedha haiwezi kuwa sawa
DocType: Stock Entry,Repack,Piga
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,Lazima Uhifadhi fomu kabla ya kuendelea
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113,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 +56,Attach Logo,Ambatisha Alama
apps/erpnext/erpnext/stock/doctype/batch/batch.js +51,Stock Levels,Ngazi za hisa
DocType: Customer,Commission Rate,Kiwango cha Tume
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187,Created {0} scorecards for {1} between: ,Iliunda {0} alama za alama kwa {1} kati ya:
apps/erpnext/erpnext/stock/doctype/item/item.js +527,Make Variant,Fanya Tofauti
apps/erpnext/erpnext/config/hr.py +87,Block leave applications by department.,Zima maombi ya kuondoka na idara.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +155,"Payment Type must be one of Receive, Pay and Internal Transfer","Aina ya Malipo lazima iwe moja ya Kupokea, Kulipa na Uhamisho wa Ndani"
apps/erpnext/erpnext/config/selling.py +184,Analytics,Analytics
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25,Cart is Empty,Cart ni tupu
DocType: Vehicle,Model,Mfano
DocType: Work Order,Actual Operating Cost,Gharama halisi ya uendeshaji
DocType: Payment Entry,Cheque/Reference No,Angalia / Kumbukumbu Hapana
DocType: Soil Texture,Clay Loam,Clay Loam
apps/erpnext/erpnext/accounts/doctype/account/account.py +81,Root cannot be edited.,Mizizi haiwezi kuhaririwa.
DocType: Item,Units of Measure,Units of Measure
DocType: Manufacturing Settings,Allow Production on Holidays,Ruhusu Uzalishaji kwenye Likizo
DocType: Sales Invoice,Customer's Purchase Order Date,Tarehe ya Utunzaji wa Wateja
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +163,Capital Stock,Capital Stock
DocType: Shopping Cart Settings,Show Public Attachments,Onyesha Viambatisho vya Umma
DocType: Packing Slip,Package Weight Details,Maelezo ya Ufuatiliaji wa Pakiti
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
apps/erpnext/erpnext/controllers/buying_controller.py +88,"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/upload_attendance/upload_attendance.py +103,Please select a csv file,Tafadhali chagua faili ya csv
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 +461,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/templates/pages/home.html +14,Featured Products,Bidhaa zilizojitokeza
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136,Designer,Muumbaji
apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Masharti na Masharti Kigezo
DocType: Serial No,Delivery Details,Maelezo ya utoaji
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +495,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: Program,Program Code,Kanuni ya Programu
DocType: Terms and Conditions,Terms and Conditions Help,Masharti na Masharti Msaada
,Item-wise Purchase Register,Rejista ya Ununuzi wa hekima
DocType: Driver,Expiry Date,Tarehe ya mwisho wa matumizi
DocType: Healthcare Settings,Employee name and designation in print,Jina la mfanyakazi na sifa katika kuchapishwa
,accounts-browser,mshambuliaji wa akaunti
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368,Please select Category first,Tafadhali chagua Jamii kwanza
apps/erpnext/erpnext/config/projects.py +13,Project master.,Mradi wa mradi.
apps/erpnext/erpnext/controllers/status_updater.py +212,"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.","Ili kuruhusu zaidi ya kulipa au kuagiza zaidi, sasisha &quot;Ruzuku&quot; katika Mipangilio ya Hifadhi au Bidhaa."
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/leave_application/leave_application.py +431, (Half Day),Nusu Siku
DocType: Payment Term,Credit Days,Siku za Mikopo
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +145,Please select Patient to get Lab Tests,Tafadhali chagua Mgonjwa kupata Majaribio ya Lab
apps/erpnext/erpnext/utilities/activation.py +128,Make Student Batch,Fanya Kundi la Mwanafunzi
DocType: Fee Schedule,FRQ.,FRQ.
DocType: Leave Type,Is Carry Forward,Inaendelea mbele
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +841,Get Items from BOM,Pata Vitu kutoka kwa BOM
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40,Lead Time Days,Siku za Kiongozi
DocType: Cash Flow Mapping,Is Income Tax Expense,"Je, gharama ya Kodi ya Mapato"
apps/erpnext/erpnext/controllers/accounts_controller.py +621,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.
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125,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 +54,Transfer an asset from one warehouse to another,Tumia mali kutoka kwa ghala moja hadi nyingine
DocType: Vehicle,Petrol,Petroli
apps/erpnext/erpnext/config/learn.py +217,Bill of Materials,Sheria ya Vifaa
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105,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}
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94,Ref Date,Tarehe ya Marehemu
DocType: Employee,Reason for Leaving,Sababu ya Kuacha
DocType: BOM Operation,Operating Cost(Company Currency),Gharama za Uendeshaji (Fedha la Kampuni)
DocType: Employee 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
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196,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 +177,Account {0} does not exist,Akaunti {0} haipo
DocType: Training Event,Training Program,Programu ya Mafunzo
DocType: Account,Cash,Fedha
DocType: Employee,Short biography for website and other publications.,Wasifu mfupi wa tovuti na machapisho mengine.
