diff --git a/erpnext/translations/uz.csv b/erpnext/translations/uz.csv
index 7b12899..55a8460 100644
--- a/erpnext/translations/uz.csv
+++ b/erpnext/translations/uz.csv
@@ -3,12 +3,12 @@
 DocType: Patient,Divorced,Ajrashgan
 DocType: Buying Settings,Allow Item to be added multiple times in a transaction,Ob&#39;ektga bir amalda bir necha marta qo&#39;shilishiga ruxsat bering
 apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,Ushbu kafolat talabnomasini bekor qilishdan avval materialni bekor qilish {0} ga tashrif buyuring
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +19,Consumer Products,Iste&#39;molchi mahsulotlari
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19,Consumer Products,Iste&#39;molchi mahsulotlari
 DocType: Purchase Receipt,Subscription Detail,Obuna batafsil
 DocType: Supplier Scorecard,Notify Supplier,Yetkazib beruvchini xabardor qiling
 DocType: Item,Customer Items,Xaridor elementlari
 DocType: Project,Costing and Billing,Xarajatlar va billing
-apps/erpnext/erpnext/accounts/doctype/account/account.py +52,Account {0}: Parent account {1} can not be a ledger,Hisob {0}: Ota-hisob {1} hisob kitobi bo&#39;lishi mumkin emas
+apps/erpnext/erpnext/accounts/doctype/account/account.py +48,Account {0}: Parent account {1} can not be a ledger,Hisob {0}: Ota-hisob {1} hisob kitobi bo&#39;lishi mumkin emas
 DocType: Item,Publish Item to hub.erpnext.com,Ob&#39;ektni hub.erpnext.com ga joylashtiring
 apps/erpnext/erpnext/config/setup.py +88,Email Notifications,Email bayonnomalari
 apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26,Evaluation,Baholash
@@ -20,10 +20,9 @@
 DocType: Restaurant Order Entry,Click Enter To Add,Qo&#39;shish uchun Enter ni bosing
 DocType: Employee,Rented,Ijaraga olingan
 DocType: Purchase Order,PO-,PO-
-DocType: POS Profile,Applicable for User,Foydalanuvchining uchun amal qiladi
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +196,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","To&#39;xtatilgan ishlab chiqarish tartibi bekor qilinishi mumkin emas, bekor qilish uchun avval uni to&#39;xtatib turish"
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +216,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","To&#39;xtatilgan ishlab chiqarish tartibi bekor qilinishi mumkin emas, bekor qilish uchun avval uni to&#39;xtatib turish"
 DocType: Vehicle Service,Mileage,Yugurish
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +220,Do you really want to scrap this asset?,Haqiqatan ham ushbu obyektni yo&#39;qotmoqchimisiz?
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +240,Do you really want to scrap this asset?,Haqiqatan ham ushbu obyektni yo&#39;qotmoqchimisiz?
 DocType: Drug Prescription,Update Schedule,Jadvalni yangilash
 apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44,Select Default Supplier,Standart etkazib beruvchini tanlang
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37,Currency is required for Price List {0},Narxlar ro&#39;yxati uchun valyuta talab qilinadi {0}
@@ -32,8 +31,8 @@
 DocType: Patient Appointment,Check availability,Mavjudligini tekshirib ko&#39;ring
 DocType: Job Applicant,Job Applicant,Ish beruvchi
 apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6,This is based on transactions against this Supplier. See timeline below for details,Bu Ta&#39;minotchi bilan tuzilgan bitimlarga asoslanadi. Tafsilotlar uchun quyidagi jadvalga qarang
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +34,Legal,Huquqiy
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,Actual type tax cannot be included in Item rate in row {0},Haqiqiy turdagi soliqni {0} qatoridagi Item Rate ga qo&#39;shish mumkin emas
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120,Legal,Huquqiy
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191,Actual type tax cannot be included in Item rate in row {0},Haqiqiy turdagi soliqni {0} qatoridagi Item Rate ga qo&#39;shish mumkin emas
 DocType: Bank Guarantee,Customer,Xaridor
 DocType: Purchase Receipt Item,Required By,Kerakli
 DocType: Delivery Note,Return Against Delivery Note,Xatoga qarshi qaytib kelish Eslatma
@@ -41,79 +40,91 @@
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43,Exchange Rate must be same as {0} {1} ({2}),Ayirboshlash kursi {0} {1} ({2})
 DocType: Sales Invoice,Customer Name,Xaridor nomi
 DocType: Vehicle,Natural Gas,Tabiiy gaz
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +120,Bank account cannot be named as {0},Bank hisobi {0}
+apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64,Bank account cannot be named as {0},Bank hisobi {0}
 DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,Buxgalteriya yozuvlari yozilgan va muvozanatlar saqlanib turadigan rahbarlar (yoki guruhlar).
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196,Outstanding for {0} cannot be less than zero ({1}),{0} uchun ustunlik noldan kam bo&#39;lishi mumkin emas ({1})
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +357,There are no submitted Salary Slips to process.,Jarayon uchun hech qanday taqdim etilmagan Ish haqi slipslari mavjud emas.
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +343,There are no submitted Salary Slips to process.,Jarayon uchun hech qanday taqdim etilmagan Ish haqi slipslari mavjud emas.
 DocType: Manufacturing Settings,Default 10 mins,Standart 10 daqiqa
 DocType: Leave Type,Leave Type Name,Tovar nomi qoldiring
 apps/erpnext/erpnext/templates/pages/projects.js +62,Show open,Ko&#39;rish ochiq
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8,It is necessary to take this action today itself for the above mentioned recurring,Ushbu harakatni bugungi kunda yuqorida eslatib o&#39;tilgan davrda olish kerak
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +151,Series Updated Successfully,Series muvaffaqiyatli yangilandi
 apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +18,Checkout,Tekshirib ko&#39;rmoq
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +175,Accural Journal Entry Submitted,Accural jurnalining taqdimoti
 DocType: Pricing Rule,Apply On,Ilova
 DocType: Item Price,Multiple Item prices.,Bir nechta mahsulot narxi.
 ,Purchase Order Items To Be Received,Buyurtma buyurtmalarini olish uchun
 DocType: SMS Center,All Supplier Contact,Barcha yetkazib beruvchi bilan aloqa
 DocType: Support Settings,Support Settings,Yordam sozlamalari
-apps/erpnext/erpnext/projects/doctype/project/project.py +70,Expected End Date can not be less than Expected Start Date,Kutilayotgan yakunlangan sana kutilgan boshlanish sanasidan kam bo&#39;lishi mumkin emas
+apps/erpnext/erpnext/projects/doctype/project/project.py +72,Expected End Date can not be less than Expected Start Date,Kutilayotgan yakunlangan sana kutilgan boshlanish sanasidan kam bo&#39;lishi mumkin emas
 apps/erpnext/erpnext/utilities/transaction_base.py +110,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Row # {0}: Baho {1}: {2} ({3} / {4})
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +282,New Leave Application,Yangi ishga tushirish
 ,Batch Item Expiry Status,Partiya mahsulotining amal qilish muddati
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +180,Bank Draft,Bank loyihasi
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184,Bank Draft,Bank loyihasi
+DocType: Membership,membership validaty section,a&#39;zolik qoidalari
 DocType: Mode of Payment Account,Mode of Payment Account,To&#39;lov shakli hisob
 DocType: Consultation,Consultation,Maslamat
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +21,Sales and Returns,Sotish va qaytarish
+DocType: Accounts Settings,Show Payment Schedule in Print,Chop etish uchun to&#39;lov jadvalini ko&#39;rsating
+apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19,Sales and Returns,Sotish va qaytarish
 apps/erpnext/erpnext/stock/doctype/item/item.js +56,Show Variants,Varyantlarni ko&#39;rsatish
 DocType: Academic Term,Academic Term,Akademik atamalar
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,Materiallar
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +670,Quantity,Miqdor
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546,Accounts table cannot be blank.,Hisoblar jadvali bo&#39;sh bo&#39;lishi mumkin emas.
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66,Making website,Veb-sayt yaratish
+DocType: Opening Invoice Creation Tool Item,Quantity,Miqdor
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +544,Accounts table cannot be blank.,Hisoblar jadvali bo&#39;sh bo&#39;lishi mumkin emas.
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154,Loans (Liabilities),Kreditlar (majburiyatlar)
 DocType: Employee Education,Year of Passing,O&#39;tish yili
 DocType: Item,Country of Origin,Ishlab chiqaruvchi mamlakat; ta&#39;minotchi mamlakat
+DocType: Soil Texture,Soil Texture Criteria,Tuproq to&#39;qimalarining mezonlari
 apps/erpnext/erpnext/templates/includes/product_page.js +24,In Stock,Omborda mavjud; sotuvda mavjud
+apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16,Primary Contact Details,Birlamchi aloqa ma&#39;lumotlari
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46,Open Issues,Muammolarni ochish
 DocType: Production Plan Item,Production Plan Item,Ishlab chiqarish rejasi elementi
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +144,User {0} is already assigned to Employee {1},{0} {0} {{{}} foydalanuvchisi allaqachon tayinlangan
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +149,User {0} is already assigned to Employee {1},{0} {0} {{{}} foydalanuvchisi allaqachon tayinlangan
 DocType: Lab Test Groups,Add new line,Yangi qator qo&#39;shing
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +31,Health Care,Sog&#39;liqni saqlash
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31,Health Care,Sog&#39;liqni saqlash
 apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,Delay in payment (Days),To&#39;lovni kechiktirish (kunlar)
+DocType: Payment Terms Template Detail,Payment Terms Template Detail,To&#39;lov shartlari shablonini batafsil
 DocType: Lab Prescription,Lab Prescription,Laboratoriya retsepti
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +185,Sort by Price,Narx bo&#39;yicha saralash
 apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26,Service Expense,Xizmat ketadi
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +888,Serial Number: {0} is already referenced in Sales Invoice: {1},Seriya raqami: {0} savdo faturasında zikr qilingan: {1}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +849,Invoice,Billing
-DocType: Maintenance Schedule Item,Periodicity,Muntazamlik
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +893,Serial Number: {0} is already referenced in Sales Invoice: {1},Seriya raqami: {0} savdo faturasında zikr qilingan: {1}
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874,Invoice,Billing
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +109,Make Retention Stock Entry,Saqlashni o&#39;z ichiga oladi
+DocType: Purchase Invoice Item,Item Weight Details,Og&#39;irligi haqida ma&#39;lumot
+DocType: Asset Maintenance Log,Periodicity,Muntazamlik
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21,Fiscal Year {0} is required,Moliyaviy yil {0} talab qilinadi
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +21,Defense,Mudofaa
+DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,Eng yaxshi o&#39;sish uchun o&#39;simliklar qatorlari orasidagi minimal masofa
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21,Defense,Mudofaa
 DocType: Salary Component,Abbr,Abbr
 DocType: Appraisal Goal,Score (0-5),Skor (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} {3} bilan mos emas
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +223,Row {0}: {1} {2} does not match with {3},Row {0}: {1} {2} {3} bilan mos emas
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +75,Row # {0}:,# {0} qatori:
 DocType: Timesheet,Total Costing Amount,Jami xarajat summasi
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Xaridor&gt; Mijozlar guruhi&gt; Zonasi
 DocType: Delivery Note,Vehicle No,Avtomobil raqami
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +160,Please select Price List,"Iltimos, narxlar ro&#39;yxatini tanlang"
 DocType: Accounts Settings,Currency Exchange Settings,Valyuta almashinuvi sozlamalari
 apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +78,Row #{0}: Payment document is required to complete the trasaction,Row # {0}: Taqsimotni to&#39;ldirish uchun to&#39;lov hujjati talab qilinadi
 DocType: Production Order Operation,Work In Progress,Ishlar davom etmoqda
-apps/erpnext/erpnext/schools/report/absent_student_report/absent_student_report.py +13,Please select date,"Iltimos, tarixni tanlang"
+apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13,Please select date,"Iltimos, tarixni tanlang"
 DocType: Employee,Holiday List,Dam olish ro&#39;yxati
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +123,Accountant,Hisobchi
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127,Accountant,Hisobchi
 DocType: Hub Settings,Selling Price List,Sotuvlar narxlari
 DocType: Patient,Tobacco Current Use,Tamaki foydalanish
+apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +21,Selling Rate,Sotish darajasi
 DocType: Cost Center,Stock User,Tayyor foydalanuvchi
+DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
 DocType: Company,Phone No,Telefon raqami
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +50,Course Schedules created:,Yaratilgan kurs jadvali:
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +237,New {0}: #{1},Yangi {0}: # {1}
+DocType: Delivery Trip,Initial Email Notification Sent,Dastlabki elektron pochta xabari yuborildi
 ,Sales Partners Commission,Savdo hamkorlari komissiyasi
+DocType: Soil Texture,Sandy Clay Loam,Sandy Clay Loam
 DocType: Purchase Invoice,Rounding Adjustment,Yumaloq regulyatsiya
 apps/erpnext/erpnext/setup/doctype/company/company.py +45,Abbreviation cannot have more than 5 characters,Qisqartirishda 5dan ortiq belgi bo&#39;lishi mumkin emas
 DocType: Physician Schedule Time Slot,Physician Schedule Time Slot,Shifokor rejasi vaqtli uyasi
 DocType: Payment Request,Payment Request,To&#39;lov talabi
 DocType: Asset,Value After Depreciation,Amortizatsiyadan keyin qiymat
-DocType: Employee,O+,O +
+DocType: Student,O+,O +
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt_dashboard.py +18,Related,Bilan bog&#39;liq
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43,Attendance date can not be less than employee's joining date,Davomiylik sanasi xodimning ishtirok etish kunidan kam bo&#39;lmasligi kerak
 DocType: Grading Scale,Grading Scale Name,Baholash o&#39;lchovi nomi
@@ -126,149 +137,154 @@
 apps/erpnext/erpnext/accounts/utils.py +73,{0} {1} not in any active Fiscal Year.,{0} {1} har qanday faol Moliya yilida emas.
 DocType: Packed Item,Parent Detail docname,Ota-ona batafsil docname
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69,"Reference: {0}, Item Code: {1} and Customer: {2}","Malumot: {0}, mahsulot kodi: {1} va mijoz: {2}"
-apps/erpnext/erpnext/utilities/user_progress.py +125,Kg,Kg
+apps/erpnext/erpnext/utilities/user_progress.py +143,Kg,Kg
 apps/erpnext/erpnext/config/hr.py +45,Opening for a Job.,Ish uchun ochilish.
-apps/erpnext/erpnext/schools/doctype/assessment_result_tool/assessment_result_tool.js +147,{0} Result submittted,{0} natijalar yuborildi
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +103,BOM is not specified for subcontracting item {0} at row {1},{1} qatorida {0} subpudratchilar uchun BOM ko&#39;rsatilgan emas
+apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149,{0} Result submittted,{0} natijalar yuborildi
 DocType: Item Attribute,Increment,Ortiqcha
 apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +61,Timespan,Timespan
 apps/erpnext/erpnext/public/js/stock_analytics.js +61,Select Warehouse...,QXI tanlang ...
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +6,Advertising,Reklama
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6,Advertising,Reklama
 apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22,Same Company is entered more than once,Xuddi shu kompaniya bir necha marta kiritilgan
 DocType: Patient,Married,Turmushga chiqdi
 apps/erpnext/erpnext/accounts/party.py +44,Not permitted for {0},{0} uchun ruxsat berilmagan
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +568,Get items from,Elementlarni oling
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +457,Stock cannot be updated against Delivery Note {0},Stokni etkazib berishga qarshi yangilanib bo&#39;lmaydi. {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593,Get items from,Elementlarni oling
+DocType: Price List,Price Not UOM Dependant,Narx UOMga qaram emas
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +461,Stock cannot be updated against Delivery Note {0},Stokni etkazib berishga qarshi yangilanib bo&#39;lmaydi. {0}
 apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},Mahsulot {0}
 apps/erpnext/erpnext/templates/generators/item_group.html +43,No items listed,Ro&#39;yxatda hech narsa yo&#39;q
+DocType: Asset Repair,Error Description,Xato tavsifi
 DocType: Payment Reconciliation,Reconcile,Muvaqqatlik
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +30,Grocery,Bakkallar
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30,Grocery,Bakkallar
 DocType: Quality Inspection Reading,Reading 1,O&#39;qish 1
-DocType: Process Payroll,Make Bank Entry,Bank kartasiga kirish
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +40,Pension Funds,Pensiya jamg&#39;armalari
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +88,Next Depreciation Date cannot be before Purchase Date,Keyingi Amortizatsiya tarixi sotib olish sanasidan oldin bo&#39;la olmaydi
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40,Pension Funds,Pensiya jamg&#39;armalari
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +88,Next Depreciation Date cannot be before Purchase Date,Keyingi Amortizatsiya tarixi sotib olish sanasidan oldin bo&#39;la olmaydi
+DocType: Crop,Perennial,Ko&#39;p yillik
 DocType: Consultation,Consultation Date,Maslahatlashuv sanasi
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +131,Product listing and discovery for ERPNext users,Mahsulot ro&#39;yxati va ERPNext foydalanuvchilari uchun kashfiyot
 DocType: SMS Center,All Sales Person,Barcha Sotuvdagi Shaxs
 DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,"** Oylik tarqatish ** sizning biznesingizda mevsimlik mavjud bo&#39;lsa, byudjet / maqsadni oylar davomida tarqatishga yordam beradi."
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1727,Not items found,Ma&#39;lumotlar topilmadi
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1742,Not items found,Ma&#39;lumotlar topilmadi
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183,Salary Structure Missing,Ish haqi tuzilmasi to&#39;liqsiz
 DocType: Lead,Person Name,Shaxs ismi
 DocType: Sales Invoice Item,Sales Invoice Item,Savdo Billing elementi
 DocType: Account,Credit,Kredit
 DocType: POS Profile,Write Off Cost Center,Malumot markazini yozing
-apps/erpnext/erpnext/public/js/setup_wizard.js +114,"e.g. ""Primary School"" or ""University""","Masalan, &quot;Boshlang&#39;ich maktab&quot; yoki &quot;Universitet&quot;"
-apps/erpnext/erpnext/config/stock.py +32,Stock Reports,Birja yangiliklari
+apps/erpnext/erpnext/public/js/setup_wizard.js +117,"e.g. ""Primary School"" or ""University""","Masalan, &quot;Boshlang&#39;ich maktab&quot; yoki &quot;Universitet&quot;"
+apps/erpnext/erpnext/config/stock.py +28,Stock Reports,Birja yangiliklari
 DocType: Warehouse,Warehouse Detail,QXI detali
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +164,Credit limit has been crossed for customer {0} {1}/{2},{0} {1} / {2} mijoz uchun kredit cheklovi kesib o&#39;tdi
-apps/erpnext/erpnext/schools/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.,"Davrning tugash sanasi atamalar bilan bog&#39;liq bo&#39;lgan Akademik yilning Yil oxiri sanasidan (Akademik yil) {} o&#39;tishi mumkin emas. Iltimos, sanalarni tahrirlang va qaytadan urinib ko&#39;ring."
-apps/erpnext/erpnext/stock/doctype/item/item.py +479,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","&quot;Ruxsat etilgan aktivlar&quot; ni belgilash mumkin emas, chunki ob&#39;ektga nisbatan Asset yozuvi mavjud"
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +192,Credit limit has been crossed for customer {0} {1}/{2},{0} {1} / {2} mijoz uchun kredit cheklovi kesib o&#39;tdi
+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.,"Davrning tugash sanasi atamalar bilan bog&#39;liq bo&#39;lgan Akademik yilning Yil oxiri sanasidan (Akademik yil) {} o&#39;tishi mumkin emas. Iltimos, sanalarni tahrirlang va qaytadan urinib ko&#39;ring."
+apps/erpnext/erpnext/stock/doctype/item/item.py +258,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","&quot;Ruxsat etilgan aktivlar&quot; ni belgilash mumkin emas, chunki ob&#39;ektga nisbatan Asset yozuvi mavjud"
+DocType: Delivery Trip,Departure Time,Chiqish vaqti
 DocType: Vehicle Service,Brake Oil,Tormoz yog&#39;i
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Xaridor&gt; Mijozlar guruhi&gt; Zonasi
 DocType: Tax Rule,Tax Type,Soliq turi
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +555,Taxable Amount,Soliq summasi
+apps/erpnext/erpnext/controllers/taxes_and_totals.py +561,Taxable Amount,Soliq summasi
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160,You are not authorized to add or update entries before {0},{0} dan oldin kiritilgan yozuvlarni qo&#39;shish yoki yangilash uchun ruxsat yo&#39;q
 DocType: BOM,Item Image (if not slideshow),Mavzu tasvir (agar slayd-shou bo&#39;lmasa)
 DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,(Soat / 60) * Haqiqiy operatsiya vaqti
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1050,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,# {0} satri: Hujjatning Hujjat turi xarajat shikoyati yoki jurnali kiritmasidan biri bo&#39;lishi kerak
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +917,Select BOM,BOM-ni tanlang
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1076,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,# {0} satri: Hujjatning Hujjat turi xarajat shikoyati yoki jurnali kiritmasidan biri bo&#39;lishi kerak
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +964,Select BOM,BOM-ni tanlang
 DocType: SMS Log,SMS Log,SMS-jurnali
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Etkazib beriladigan mahsulotlarning narxi
+apps/erpnext/erpnext/config/hr.py +127,Manage advance amount given to the Employee,Xodimga berilgan avans miqdorini boshqaring
 apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38,The holiday on {0} is not between From Date and To Date,{0} bayrami sanasi va sanasi o&#39;rtasidagi emas
 DocType: Student Log,Student Log,Talabalar jurnali
 DocType: Quality Inspection,Get Specification Details,Shartnoma ma&#39;lumotlarini oling
 apps/erpnext/erpnext/config/buying.py +165,Templates of supplier standings.,Yetkazib beruvchi reytinglarining namunalari.
 DocType: Lead,Interested,Qiziquvchan
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +171,Opening,Ochilish
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +28,From {0} to {1},{0} dan {1} gacha
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +219,Opening,Ochilish
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +29,From {0} to {1},{0} dan {1} gacha
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50,Failed to setup taxes,Soliqlarni o&#39;rnatish amalga oshmadi
 DocType: Item,Copy From Item Group,Mavzu guruhidan nusxa olish
+DocType: Delivery Trip,Delivery Notification,Etkazib berish bayonoti
 DocType: Journal Entry,Opening Entry,Kirish ochish
 apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25,Account Pay Only,Hisob faqatgina to&#39;laydi
 DocType: Employee Loan,Repay Over Number of Periods,Davr sonini qaytaring
 DocType: Stock Entry,Additional Costs,Qo&#39;shimcha xarajatlar
-apps/erpnext/erpnext/accounts/doctype/account/account.py +141,Account with existing transaction can not be converted to group.,Mavjud tranzaktsiyadagi hisobni guruhga aylantirish mumkin emas.
+apps/erpnext/erpnext/accounts/doctype/account/account.py +140,Account with existing transaction can not be converted to group.,Mavjud tranzaktsiyadagi hisobni guruhga aylantirish mumkin emas.
 DocType: Lead,Product Enquiry,Mahsulot so&#39;rovnomasi
-DocType: Academic Term,Schools,Maktablar
-DocType: School Settings,Validate Batch for Students in Student Group,Talaba guruhidagi talabalar uchun partiyani tasdiqlash
+DocType: Education Settings,Validate Batch for Students in Student Group,Talaba guruhidagi talabalar uchun partiyani tasdiqlash
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35,No leave record found for employee {0} for {1},{1} uchun xodimlar uchun {0} yozuvi yo&#39;q
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23,Please enter company first,"Iltimos, kompaniyani birinchi kiriting"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +358,Please select Company first,"Iltimos, kompaniyani tanlang"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366,Please select Company first,"Iltimos, kompaniyani tanlang"
 DocType: Employee Education,Under Graduate,Magistr darajasida
 apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27,Target On,Nishonni yoqing
 DocType: BOM,Total Cost,Jami xarajat
+DocType: Soil Analysis,Ca/K,Ca / K
 DocType: Journal Entry Account,Employee Loan,Xodimlarning qarzlari
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +108,Activity Log:,Faoliyat jurnali:
 DocType: Fee Schedule,Send Payment Request Email,To&#39;lov uchun so&#39;rov yuborish uchun E-mail
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +256,Item {0} does not exist in the system or has expired,{0} mahsuloti tizimda mavjud emas yoki muddati tugagan
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +44,Real Estate,Ko `chmas mulk
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +259,Item {0} does not exist in the system or has expired,{0} mahsuloti tizimda mavjud emas yoki muddati tugagan
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44,Real Estate,Ko `chmas mulk
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,Hisob qaydnomasi
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +41,Pharmaceuticals,Dori vositalari
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41,Pharmaceuticals,Dori vositalari
 DocType: Purchase Invoice Item,Is Fixed Asset,Ruxsat etilgan aktiv
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +234,"Available qty is {0}, you need {1}","Mavjud qty {0} bo&#39;lsa, siz {1}"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +251,"Available qty is {0}, you need {1}","Mavjud qty {0} bo&#39;lsa, siz {1}"
 DocType: Expense Claim Detail,Claim Amount,Da&#39;vo miqdori
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +51,Duplicate customer group found in the cutomer group table,Cutomer guruhi jadvalida topilgan mijozlar guruhini takrorlash
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56,Duplicate customer group found in the cutomer group table,Cutomer guruhi jadvalida topilgan mijozlar guruhini takrorlash
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31,Supplier Type / Supplier,Yetkazib beruvchi turi / yetkazib beruvchi
 DocType: Naming Series,Prefix,Prefiks
 apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7,Event Location,Voqealar joylashuvi
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +64,Consumable,Sarflanadigan
-DocType: Employee,B-,B-
-DocType: Upload Attendance,Import Log,Import jurnali
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68,Consumable,Sarflanadigan
+DocType: Student,B-,B-
 DocType: Production Planning Tool,Pull Material Request of type Manufacture based on the above criteria,Pull Materiallar turi Talebi Yuqoridagi mezonlarga asosan ishlab chiqarish
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +100,Successfully unregistered.,Muvaffaqiyatsiz ro&#39;yxatdan o&#39;tkazilmagan.
-DocType: Training Result Employee,Grade,Baholash
+DocType: Assessment Result,Grade,Baholash
 DocType: Restaurant Table,No of Seats,O&#39;rindiqlar soni
 DocType: Subscription,"To add dynamic subject, use jinja tags like
 
 <div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>","Dinamik mavzuni qo'shish uchun, kabi jinja teglaridan foydalaning <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>"
 DocType: Sales Invoice Item,Delivered By Supplier,Yetkazib beruvchining etkazib beruvchisi
+DocType: Asset Maintenance Task,Asset Maintenance Task,Assotsiatsiyalash bo&#39;yicha topshiriq
 DocType: SMS Center,All Contact,Barcha aloqa
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +905,Production Order already created for all items with BOM,Ishlab chiqarish tartibi BOM bilan barcha elementlar uchun yaratilgan
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +220,Annual Salary,Yillik ish haqi
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +952,Production Order already created for all items with BOM,Ishlab chiqarish tartibi BOM bilan barcha elementlar uchun yaratilgan
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +230,Annual Salary,Yillik ish haqi
 DocType: Daily Work Summary,Daily Work Summary,Kundalik ish xulosasi
 DocType: Period Closing Voucher,Closing Fiscal Year,Moliyaviy yil yakuni
-apps/erpnext/erpnext/accounts/party.py +368,{0} {1} is frozen,{0} {1} muzlatilgan
-apps/erpnext/erpnext/setup/doctype/company/company.py +132,Please select Existing Company for creating Chart of Accounts,Hisoblar jadvali yaratish uchun mavjud Kompaniya-ni tanlang
+apps/erpnext/erpnext/accounts/party.py +380,{0} {1} is frozen,{0} {1} muzlatilgan
+apps/erpnext/erpnext/setup/doctype/company/company.py +129,Please select Existing Company for creating Chart of Accounts,Hisoblar jadvali yaratish uchun mavjud Kompaniya-ni tanlang
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80,Stock Expenses,Aksiyadorlik xarajatlari
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +96,Select Target Warehouse,Maqsadli omborni tanlang
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +103,Select Target Warehouse,Maqsadli omborni tanlang
 apps/erpnext/erpnext/hr/doctype/employee/employee.js +80,Please enter Preferred Contact Email,"Marhamat qilib, tanlangan aloqa elektron pochta manzilini kiriting"
-DocType: Program Enrollment,School Bus,Maktab avtobusi
 DocType: Journal Entry,Contra Entry,Contra kirish
 DocType: Journal Entry Account,Credit in Company Currency,Kompaniya valyutasida kredit
 DocType: Lab Test UOM,Lab Test UOM,Laborator tekshiruvi UOM
 DocType: Delivery Note,Installation Status,O&#39;rnatish holati
-apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +135,"Do you want to update attendance?<br>Present: {0}\
+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}",Ishtirokchilarni yangilashni xohlaysizmi? <br> Hozirgi: {0} \ <br> Yo'q: {1}
-apps/erpnext/erpnext/controllers/buying_controller.py +325,Accepted + Rejected Qty must be equal to Received quantity for Item {0},"Qabul qilingan + Rad etilgan Qty, {0}"
+apps/erpnext/erpnext/controllers/buying_controller.py +326,Accepted + Rejected Qty must be equal to Received quantity for Item {0},"Qabul qilingan + Rad etilgan Qty, {0}"
 DocType: Request for Quotation,RFQ-,RFQ-
 DocType: Item,Supply Raw Materials for Purchase,Xarid qilish uchun xom ashyo etkazib berish
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +149,At least one mode of payment is required for POS invoice.,POS-faktura uchun kamida bitta to&#39;lov tartibi talab qilinadi.
+DocType: Agriculture Analysis Criteria,Fertilizer,Go&#39;ng
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +150,At least one mode of payment is required for POS invoice.,POS-faktura uchun kamida bitta to&#39;lov tartibi talab qilinadi.
 DocType: Products Settings,Show Products as a List,Mahsulotlarni ro&#39;yxat sifatida ko&#39;rsatish
-DocType: Upload Attendance,"Download the Template, fill appropriate data and attach the modified file.
-All dates and employee combination in the selected period will come in the template, with existing attendance records","Shabloni yuklab oling, tegishli ma&#39;lumotlarni to&#39;ldiring va o&#39;zgartirilgan fayllarni biriktiring. Tanlangan davr mobaynida barcha sanalar va ishchilarning tarkibi shablonga tushadi va mavjud yozuvlar mavjud"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +482,Item {0} is not active or end of life has been reached,{0} elementi faol emas yoki umrining oxiriga yetdi
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +507,Item {0} is not active or end of life has been reached,{0} elementi faol emas yoki umrining oxiriga yetdi
 DocType: Student Admission Program,Minimum Age,Minimal yosh
-apps/erpnext/erpnext/utilities/user_progress.py +169,Example: Basic Mathematics,Misol: Asosiy matematik
-apps/erpnext/erpnext/controllers/accounts_controller.py +657,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included",Mavzu kursiga {0} qatoridagi soliqni kiritish uchun qatorlar {1} da soliqlar ham kiritilishi kerak
-apps/erpnext/erpnext/config/hr.py +218,Settings for HR Module,HR moduli uchun sozlamalar
+apps/erpnext/erpnext/utilities/user_progress.py +187,Example: Basic Mathematics,Misol: Asosiy matematik
+apps/erpnext/erpnext/controllers/accounts_controller.py +769,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included",Mavzu kursiga {0} qatoridagi soliqni kiritish uchun qatorlar {1} da soliqlar ham kiritilishi kerak
+apps/erpnext/erpnext/config/hr.py +223,Settings for HR Module,HR moduli uchun sozlamalar
 DocType: SMS Center,SMS Center,SMS markazi
 DocType: Sales Invoice,Change Amount,Miqdorni o&#39;zgartirish
 DocType: BOM Update Tool,New BOM,Yangi BOM
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +117,Please enter Delivery Date,"Iltimos, etkazib berish sanasi kiriting"
+DocType: Driver,Driving License Categories,Haydovchilik guvohnomasi kategoriyalari
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118,Please enter Delivery Date,"Iltimos, etkazib berish sanasi kiriting"
 DocType: Depreciation Schedule,Make Depreciation Entry,Amortizatsiyani kiritish
 DocType: Appraisal Template Goal,KRA,KRA
 DocType: Lead,Request Type,So&#39;rov turi
 apps/erpnext/erpnext/hr/doctype/offer_letter/offer_letter.js +17,Make Employee,Xodim yarat
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +14,Broadcasting,Radioeshittirish
-apps/erpnext/erpnext/config/accounts.py +321,Setup mode of POS (Online / Offline),POSning sozlash rejimi (Onlayn / Offlayn)
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +187,Execution,Ijroiya
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14,Broadcasting,Radioeshittirish
+apps/erpnext/erpnext/config/accounts.py +313,Setup mode of POS (Online / Offline),POSning sozlash rejimi (Onlayn / Offlayn)
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191,Execution,Ijroiya
 apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Faoliyatning tafsilotlari.
-DocType: Serial No,Maintenance Status,Xizmat holati
+DocType: Asset Maintenance Log,Maintenance Status,Xizmat holati
+apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10,Membership Details,Registratsiya tafsilotlari
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Yetkazib beruvchi to&#39;lash kerak hisobiga {2}
 apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,Mahsulotlar va narxlanish
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2,Total hours: {0},Umumiy soatlar: {0}
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,From Date should be within the Fiscal Year. Assuming From Date = {0},Sana boshlab Moliya yilida bo&#39;lishi kerak. Sana = {0}
 DocType: Drug Prescription,Interval,Interval
-DocType: Customer,Individual,Individual
-DocType: Interest,Academics User,Akademiklar foydalanuvchisi
+DocType: Grant Application,Individual,Individual
+DocType: Academic Term,Academics User,Akademiklar foydalanuvchisi
 DocType: Cheque Print Template,Amount In Figure,Shaklidagi miqdor
 DocType: Employee Loan Application,Loan Info,Kredit haqida ma&#39;lumot
 apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,Ta&#39;minot tashriflari rejasi.
@@ -281,17 +297,19 @@
 apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,Narxlar ro&#39;yxati Buyurtma yoki Sotish uchun tegishli bo&#39;lishi kerak
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79,Installation date cannot be before delivery date for Item {0},O&#39;rnatish sanasi {0} mahsuloti uchun etkazib berish tarixidan oldin bo&#39;lishi mumkin emas
 DocType: Pricing Rule,Discount on Price List Rate (%),Narxlar ro&#39;yxati narxiga chegirma (%)
-apps/erpnext/erpnext/healthcare/setup.py +214,Biochemistry,Biokimyo
+apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112,Item Template,Mavzu shablonni
+apps/erpnext/erpnext/healthcare/setup.py +215,Biochemistry,Biokimyo
 DocType: Offer Letter,Select Terms and Conditions,Qoidalar va shartlarni tanlang
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +60,Out Value,Chiqish qiymati
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70,Out Value,Chiqish qiymati
 DocType: Production Planning Tool,Sales Orders,Savdo buyurtmalarini
 DocType: Purchase Taxes and Charges,Valuation,Baholash
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +373,Set as Default,Standart sifatida belgilash
 ,Purchase Order Trends,Buyurtma tendentsiyalarini sotib olish
 apps/erpnext/erpnext/utilities/user_progress.py +75,Go to Customers,Mijozlarga o&#39;ting
 apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7,The request for quotation can be accessed by clicking on the following link,Qo&#39;shtirnoq so&#39;roviga quyidagi havolani bosish orqali kirish mumkin
 apps/erpnext/erpnext/config/hr.py +81,Allocate leaves for the year.,Yil barglarini ajratib turing.
 DocType: SG Creation Tool Course,SG Creation Tool Course,SG yaratish vositasi kursi
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +236,Insufficient Stock,Qimmatli qog&#39;ozlar yetarli emas
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +253,Insufficient Stock,Qimmatli qog&#39;ozlar yetarli emas
 DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Imkoniyatlarni rejalashtirishni va vaqtni kuzatishni o&#39;chirib qo&#39;yish
 DocType: Email Digest,New Sales Orders,Yangi Sotuvdagi Buyurtma
 DocType: Bank Guarantee,Bank Account,Bank hisob raqami
@@ -299,67 +317,69 @@
 apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13,You cannot delete Project Type 'External',Siz &quot;Tashqi&quot; loyiha turini o&#39;chira olmaysiz
 DocType: Employee,Create User,Foydalanuvchi yarat
 DocType: Selling Settings,Default Territory,Default Territory
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +53,Television,Televizor
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53,Television,Televizor
 DocType: Production Order Operation,Updated via 'Time Log',&quot;Time log&quot; orqali yangilangan
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +427,Advance amount cannot be greater than {0} {1},Avans miqdori {0} {1} dan ortiq bo&#39;lishi mumkin emas
+apps/erpnext/erpnext/controllers/taxes_and_totals.py +428,Advance amount cannot be greater than {0} {1},Avans miqdori {0} {1} dan ortiq bo&#39;lishi mumkin emas
 DocType: Naming Series,Series List for this Transaction,Ushbu tranzaksiya uchun Series ro&#39;yxati
 DocType: Company,Enable Perpetual Inventory,Doimiy inventarizatsiyani yoqish
 DocType: Company,Default Payroll Payable Account,Ish haqi to&#39;lanadigan hisob qaydnomasi
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +51,Update Email Group,E-pochta guruhini yangilang
+apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51,Update Email Group,E-pochta guruhini yangilang
 DocType: Sales Invoice,Is Opening Entry,Kirish ochilmoqda
 DocType: Lab Test Template,"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Agar belgilanmagan bo&#39;lsa, mahsulot Sotuvdagi Billing-da ko&#39;rinmaydi, ammo guruh testlaridan foydalanishda foydalanish mumkin."
 DocType: Customer Group,Mention if non-standard receivable account applicable,Standart bo&#39;lmagan debitorlik hisob-varag&#39;i qo&#39;llanishi mumkin
 DocType: Course Schedule,Instructor Name,O&#39;qituvchi ismi
 DocType: Supplier Scorecard,Criteria Setup,Kriterlarni o&#39;rnatish
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +179,For Warehouse is required before Submit,Yuborishdan oldin ombor uchun talab qilinadi
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +199,For Warehouse is required before Submit,Yuborishdan oldin ombor uchun talab qilinadi
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8,Received On,Qabul qilingan
 DocType: Sales Partner,Reseller,Reseller
 DocType: Codification Table,Medical Code,Tibbiy kod
 DocType: Production Planning Tool,"If checked, Will include non-stock items in the Material Requests.","Belgilangan bo&#39;lsa, moddiy buyurtmalarga tegishli bo&#39;lmagan mahsulotlarni o&#39;z ichiga oladi."
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20,Please enter Company,"Iltimos, kompaniyani kiriting"
 DocType: Delivery Note Item,Against Sales Invoice Item,Sotuvdagi schyot-fakturaga qarshi
+DocType: Agriculture Analysis Criteria,Linked Doctype,Bog&#39;langan Doctype
 ,Production Orders in Progress,Ishlab chiqarish buyurtmalarining davomi
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +39,Net Cash from Financing,Moliyadan aniq pul
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2313,"LocalStorage is full , did not save","LocalStorage to&#39;liq, saqlanmadi"
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2332,"LocalStorage is full , did not save","LocalStorage to&#39;liq, saqlanmadi"
 DocType: Lead,Address & Contact,Manzil &amp; Kontakt
 DocType: Leave Allocation,Add unused leaves from previous allocations,Oldindan ajratilgan mablag&#39;lardan foydalanilmagan barglarni qo&#39;shing
 DocType: Sales Partner,Partner website,Hamkorlik veb-sayti
 DocType: Restaurant Order Entry,Add Item,Mavzu qo&#39;shish
 DocType: Lab Test,Custom Result,Maxsus natija
-apps/erpnext/erpnext/utilities/user_progress.py +71,Contact Name,Kontakt nomi
+DocType: Delivery Stop,Contact Name,Kontakt nomi
 DocType: Course Assessment Criteria,Course Assessment Criteria,Kurs baholash mezonlari
-DocType: Process Payroll,Creates salary slip for above mentioned criteria.,Yuqorida keltirilgan mezonlarga ish haqi slipini yaratadi.
 DocType: POS Customer Group,POS Customer Group,Qalin xaridorlar guruhi
+DocType: Land Unit,Land Unit describing various land assets,Turli er mulklarini tavsiflovchi er uchastkasi
 DocType: Cheque Print Template,Line spacing for amount in words,So&#39;zdagi so&#39;zlar uchun qator oralig&#39;i
 DocType: Vehicle,Additional Details,Qo&#39;shimcha tafsilotlar
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Assessment Plan: ,Baholash rejasi:
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Assessment Plan: ,Baholash rejasi:
 apps/erpnext/erpnext/templates/generators/bom.html +85,No description given,Tavsif berilmagan
 apps/erpnext/erpnext/config/buying.py +13,Request for purchase.,Sotib olish talabi.
 DocType: Lab Test,Submitted Date,O&#39;tkazilgan sana
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6,This is based on the Time Sheets created against this project,Ushbu loyihaga qarshi yaratilgan vaqt jadvallariga asoslanadi
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +390,Net Pay cannot be less than 0,Net ulush 0 dan kam bo&#39;lmasligi kerak
+DocType: Payment Term,Credit Months,Kredit oylari
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +409,Net Pay cannot be less than 0,Net ulush 0 dan kam bo&#39;lmasligi kerak
 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",Tizimdan takroriy xato xabardorlarini jo&#39;natishni to&#39;xtatish uchun obunadagi &quot;O&#39;chirish&quot; maydonini tekshirdik
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +224,Only the selected Leave Approver can submit this Leave Application,Faqatgina tanlangan Leave Approver bu Taqdimotnomani topshirishi mumkin
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +116,Relieving Date must be greater than Date of Joining,Ajratish sanasi qo&#39;shilish sanasidan katta bo&#39;lishi kerak
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +228,Leaves per Year,Yillar davomida barglar
-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}: agar bu oldindan yoziladigan bo&#39;lsa, {1} hisobiga &quot;Ish haqi&quot; ni tekshiring."
-apps/erpnext/erpnext/stock/utils.py +212,Warehouse {0} does not belong to company {1},{0} ombori {1} kompaniyasiga tegishli emas
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +121,Relieving Date must be greater than Date of Joining,Ajratish sanasi qo&#39;shilish sanasidan katta bo&#39;lishi kerak
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238,Leaves per Year,Yillar davomida barglar
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +128,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Row {0}: agar bu oldindan yoziladigan bo&#39;lsa, {1} hisobiga &quot;Ish haqi&quot; ni tekshiring."
+apps/erpnext/erpnext/stock/utils.py +217,Warehouse {0} does not belong to company {1},{0} ombori {1} kompaniyasiga tegishli emas
 DocType: Email Digest,Profit & Loss,Qor va ziyon
-apps/erpnext/erpnext/utilities/user_progress.py +126,Litre,Litr
+apps/erpnext/erpnext/utilities/user_progress.py +144,Litre,Litr
 DocType: Task,Total Costing Amount (via Time Sheet),Jami xarajat summasi (vaqt jadvalidan)
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.py +63,Please setup Students under Student Groups,Talabalar uchun Talabalar Guruhi ostida tanlansin
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +69,Please setup Students under Student Groups,Talabalar uchun Talabalar Guruhi ostida tanlansin
 DocType: Item Website Specification,Item Website Specification,Veb-saytning spetsifikatsiyasi
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +477,Leave Blocked,Blokdan chiqing
-apps/erpnext/erpnext/stock/doctype/item/item.py +723,Item {0} has reached its end of life on {1},{0} elementi {1} da umrining oxiriga yetdi
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +88,Bank Entries,Bank yozuvlari
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +119,Annual,Yillik
+apps/erpnext/erpnext/stock/doctype/item/item.py +709,Item {0} has reached its end of life on {1},{0} elementi {1} da umrining oxiriga yetdi
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +99,Bank Entries,Bank yozuvlari
+DocType: Crop,Annual,Yillik
 DocType: Stock Reconciliation Item,Stock Reconciliation Item,Qimmatli qog&#39;ozlar bitimining elementi
 DocType: Stock Entry,Sales Invoice No,Sotuvdagi hisob-faktura №
 DocType: Material Request Item,Min Order Qty,Eng kam Buyurtma miqdori
 DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Isoning shogirdi guruhini yaratish vositasi kursi
 DocType: Lead,Do Not Contact,Aloqa qilmang
-apps/erpnext/erpnext/utilities/user_progress.py +189,People who teach at your organisation,Tashkilotingizda ta&#39;lim beradigan odamlar
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +131,Software Developer,Dastur ishlab chiqaruvchisi
+apps/erpnext/erpnext/utilities/user_progress.py +207,People who teach at your organisation,Tashkilotingizda ta&#39;lim beradigan odamlar
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135,Software Developer,Dastur ishlab chiqaruvchisi
 DocType: Item,Minimum Order Qty,Minimal Buyurtma miqdori
 DocType: Pricing Rule,Supplier Type,Yetkazib beruvchi turi
 DocType: Course Scheduling Tool,Course Start Date,Kurs boshlanishi
@@ -368,58 +388,64 @@
 DocType: Item,Publish in Hub,Hubda nashr qiling
 DocType: Student Admission,Student Admission,Talabalarni qabul qilish
 ,Terretory,Teror
-apps/erpnext/erpnext/stock/doctype/item/item.py +743,Item {0} is cancelled,{0} mahsuloti bekor qilindi
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +923,Material Request,Materiallar talabi
+apps/erpnext/erpnext/stock/doctype/item/item.py +729,Item {0} is cancelled,{0} mahsuloti bekor qilindi
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +948,Material Request,Materiallar talabi
 DocType: Bank Reconciliation,Update Clearance Date,Bo&#39;shatish tarixini yangilash
 DocType: Item,Purchase Details,Xarid haqida ma&#39;lumot
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +357,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Buyurtma {1} da &quot;Xom moddalar bilan ta&#39;minlangan&quot; jadvalidagi {0} mahsuloti topilmadi
-DocType: Patient Relation,Relation,Aloqalar
-DocType: Shipping Rule,Worldwide Shipping,Xalqaro yuk tashish
-DocType: Patient Relation,Mother,Ona
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +382,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Buyurtma {1} da &quot;Xom moddalar bilan ta&#39;minlangan&quot; jadvalidagi {0} mahsuloti topilmadi
+DocType: Salary Slip,Total Principal Amount,Asosiy jami miqdori
+DocType: Student Guardian,Relation,Aloqalar
+DocType: Student Guardian,Mother,Ona
 DocType: Restaurant Reservation,Reservation End Time,Rezervasyon tugash vaqti
+DocType: Crop,Biennial,Biennale
 apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Xaridorlarning buyurtmalari tasdiqlangan.
 DocType: Purchase Receipt Item,Rejected Quantity,Rad qilingan miqdor
-apps/erpnext/erpnext/schools/doctype/fees/fees.py +80,Payment request {0} created,To&#39;lov talabi {0} yaratildi
-apps/erpnext/erpnext/healthcare/setup.py +254,Low Sensitivity,Kam sezgirlik
+apps/erpnext/erpnext/education/doctype/fees/fees.py +80,Payment request {0} created,To&#39;lov talabi {0} yaratildi
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Open Orders,Ochiq buyurtmalar
+apps/erpnext/erpnext/healthcare/setup.py +255,Low Sensitivity,Kam sezgirlik
 DocType: Notification Control,Notification Control,Xabarnoma nazorati
 apps/erpnext/erpnext/templates/emails/training_event.html +17,Please confirm once you have completed your training,Ta&#39;limingizni tugatganingizdan keyin tasdiqlang
 DocType: Lead,Suggestions,Takliflar
 DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,"Ushbu hududdagi Mavzu guruhiga oid byudjetlarni belgilash. Shuningdek, tarqatishni o&#39;rnatish orqali mavsumiylikni ham qo&#39;shishingiz mumkin."
+DocType: Payment Term,Payment Term Name,To&#39;lov muddatining nomi
 DocType: Healthcare Settings,Create documents for sample collection,Namuna to&#39;plash uchun hujjatlarni yaratish
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276,Payment against {0} {1} cannot be greater than Outstanding Amount {2},{0} {1} ga nisbatan to&#39;lov Olingan miqdordan ortiq bo&#39;lmasligi mumkin {2}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +274,Payment against {0} {1} cannot be greater than Outstanding Amount {2},{0} {1} ga nisbatan to&#39;lov Olingan miqdordan ortiq bo&#39;lmasligi mumkin {2}
 DocType: Supplier,Address HTML,HTML-manzil
 DocType: Lead,Mobile No.,Mobil telefon raqami
 DocType: Maintenance Schedule,Generate Schedule,Jadvalni yarating
 DocType: Purchase Invoice Item,Expense Head,Xarajatlar boshlig&#39;i
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +146,Please select Charge Type first,"Marhamat qilib, oldin Zaryadlovchi turi-ni tanlang"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +163,Please select Charge Type first,"Marhamat qilib, oldin Zaryadlovchi turi-ni tanlang"
+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.. ","Siz bu ekin uchun zarur bo&#39;lgan barcha vazifalarni belgilashingiz mumkin. Kun maydonida topshiriqni bajarish kerak bo&#39;lgan kuni, 1 kun va boshqalar."
 DocType: Student Group Student,Student Group Student,Isoning shogirdi guruhi shogirdi
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,Oxirgi
+DocType: Asset Maintenance Task,2 Yearly,2 yil
+DocType: Education Settings,Education Settings,Ta&#39;lim sozlamalari
 DocType: Vehicle Service,Inspection,Tekshiruv
 DocType: Supplier Scorecard Scoring Standing,Max Grade,Maks daraja
 DocType: Email Digest,New Quotations,Yangi takliflar
 DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,Xodimga ish haqi elektron pochtasi xodimiga tanlangan e-pochtaga asoslanib yuboriladi
 DocType: Employee,The first Leave Approver in the list will be set as the default Leave Approver,"Ro&#39;yxatdagi birinchi Approverni jo&#39;natsangiz, asl qiymati &quot;Approver qoldiring&quot; deb belgilanadi"
 DocType: Tax Rule,Shipping County,Yuk tashish hududi
-apps/erpnext/erpnext/config/desktop.py +159,Learn,O&#39;rganish
+apps/erpnext/erpnext/config/desktop.py +167,Learn,O&#39;rganish
 DocType: Asset,Next Depreciation Date,Keyingi Amortizatsiya sanasi
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Xodimga ko&#39;ra harajatlar
 DocType: Accounts Settings,Settings for Accounts,Hisob sozlamalari
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +663,Supplier Invoice No exists in Purchase Invoice {0},Yetkazib beruvchi hisob-fakturasi yo&#39;q {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +667,Supplier Invoice No exists in Purchase Invoice {0},Yetkazib beruvchi hisob-fakturasi yo&#39;q {0}
 apps/erpnext/erpnext/config/selling.py +118,Manage Sales Person Tree.,Sotuvdagi shaxslar daraxti boshqaruvi.
 DocType: Job Applicant,Cover Letter,Biriktirilgan xat
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37,Outstanding Cheques and Deposits to clear,Olinadigan chexlar va depozitlar
 DocType: Item,Synced With Hub,Hub bilan sinxronlangan
-DocType: Vehicle,Fleet Manager,Filo menejeri
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +517,Row #{0}: {1} can not be negative for item {2},{{0} qatori: {1} element {2} uchun salbiy bo&#39;lishi mumkin emas
+DocType: Driver,Fleet Manager,Filo menejeri
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542,Row #{0}: {1} can not be negative for item {2},{{0} qatori: {1} element {2} uchun salbiy bo&#39;lishi mumkin emas
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59,Wrong Password,Noto&#39;g&#39;ri parol
 DocType: Item,Variant Of,Variant Of
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +367,Completed Qty can not be greater than 'Qty to Manufacture',Tugallangan Miqdor &quot;Katta ishlab chiqarish&quot; dan katta bo&#39;lishi mumkin emas
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +387,Completed Qty can not be greater than 'Qty to Manufacture',Tugallangan Miqdor &quot;Katta ishlab chiqarish&quot; dan katta bo&#39;lishi mumkin emas
 DocType: Period Closing Voucher,Closing Account Head,Hisob boshini yopish
 DocType: Employee,External Work History,Tashqi ish tarixi
 DocType: Physician,Time per Appointment,Uchrashuv uchun vaqt
 apps/erpnext/erpnext/projects/doctype/task/task.py +110,Circular Reference Error,Dairesel mos yozuvlar xatosi
 DocType: Appointment Type,Is Inpatient,Statsionarmi?
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Guardian1 Ismi
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Guardian1 Ismi
 DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,Etkazib berish eslatmasini saqlaganingizdan so&#39;ng so&#39;zlar (eksport) ko&#39;rinadi.
 DocType: Cheque Print Template,Distance from left edge,Chap tomondan masofa
 DocType: Lead,Industry,Sanoat
@@ -427,20 +453,22 @@
 DocType: BOM Item,Rate & Amount,Bahosi va miqdori
 apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6,This is based on transactions against this Company. See timeline below for details,Bu kompaniya bilan tuzilgan bitimlarga asoslanadi. Tafsilotlar uchun quyidagi jadvalga qarang
 DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Avtomatik Materializatsiya so&#39;rovini yaratish haqida E-mail orqali xabar bering
-apps/erpnext/erpnext/healthcare/setup.py +258,Resistant,Chidamli
+apps/erpnext/erpnext/healthcare/setup.py +259,Resistant,Chidamli
 DocType: Journal Entry,Multi Currency,Ko&#39;p valyuta
-DocType: Payment Reconciliation Invoice,Invoice Type,Faktura turi
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +865,Delivery Note,Yetkazib berish eslatmasi
+DocType: Opening Invoice Creation Tool,Invoice Type,Faktura turi
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +933,Delivery Note,Yetkazib berish eslatmasi
 DocType: Consultation,Encounter Impression,Ta&#39;sir bilan taaluqli
 apps/erpnext/erpnext/config/learn.py +82,Setting up Taxes,Soliqni o&#39;rnatish
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +131,Cost of Sold Asset,Sotilgan aktivlarning qiymati
-apps/erpnext/erpnext/accounts/utils.py +345,Payment Entry has been modified after you pulled it. Please pull it again.,"To&#39;lov kirish kiritilgandan keyin o&#39;zgartirildi. Iltimos, yana torting."
-apps/erpnext/erpnext/stock/doctype/item/item.py +448,{0} entered twice in Item Tax,{0} - mahsulotni soliqqa ikki marta kirgan
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134,Cost of Sold Asset,Sotilgan aktivlarning qiymati
+DocType: Volunteer,Morning,Ertalab
+apps/erpnext/erpnext/accounts/utils.py +347,Payment Entry has been modified after you pulled it. Please pull it again.,"To&#39;lov kirish kiritilgandan keyin o&#39;zgartirildi. Iltimos, yana torting."
+apps/erpnext/erpnext/stock/doctype/item/item.py +464,{0} entered twice in Item Tax,{0} - mahsulotni soliqqa ikki marta kirgan
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113,Summary for this week and pending activities,Bu hafta uchun xulosa va kutilayotgan tadbirlar
 DocType: Student Applicant,Admitted,Qabul qilingan
 DocType: Workstation,Rent Cost,Ijara haqi
 apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81,Amount After Depreciation,Amortizatsiyadan keyin jami miqdor
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97,Upcoming Calendar Events,Kelgusi taqvim tadbirlari
+apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1,Variant Attributes,Variant xususiyatlari
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85,Please select month and year,"Iltimos, oy va yilni tanlang"
 DocType: Employee,Company Email,Kompaniyaning elektron pochta manzili
 DocType: GL Entry,Debit Amount in Account Currency,Hisob valyutasidagi hisob raqamining miqdori
@@ -449,33 +477,35 @@
 apps/erpnext/erpnext/config/accounts.py +27,Bank/Cash transactions against party or for internal transfer,Bank / Partiyaga qarshi yoki ichki pul o&#39;tkazish uchun pul o&#39;tkazish
 DocType: Shipping Rule,Valid for Countries,Mamlakatlar uchun amal qiladi
 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,"Ushbu maqola shablon bo&#39;lib, operatsiyalarda mavjud emas. &quot;No Copy&quot; parametri belgilanmagan bo&#39;lsa, element identifikatorlari variantlarga ko&#39;chiriladi"
+DocType: Grant Application,Grant Application,Grantga ariza
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69,Total Order Considered,Ko&#39;rib umumiy Buyurtma
-apps/erpnext/erpnext/config/hr.py +238,"Employee designation (e.g. CEO, Director etc.).","Xodimning nomi (masalan, Bosh direktor, Direktor va boshqalar)."
+apps/erpnext/erpnext/config/hr.py +243,"Employee designation (e.g. CEO, Director etc.).","Xodimning nomi (masalan, Bosh direktor, Direktor va boshqalar)."
 DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,Xaridor valyutasi mijozning asosiy valyutasiga aylantirilgan tarif
 DocType: Course Scheduling Tool,Course Scheduling Tool,Kursni rejalashtirish vositasi
-apps/erpnext/erpnext/controllers/accounts_controller.py +558,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Row # {0}: Xarid-faktura mavjud mavjudotga qarshi {1}
+apps/erpnext/erpnext/controllers/accounts_controller.py +602,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Row # {0}: Xarid-faktura mavjud mavjudotga qarshi {1}
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +255,[Urgent] Error while creating recurring %s for %s,[Urgent]% s uchun takrorlanuvchi% s yaratishda xato
+DocType: Land Unit,LInked Analysis,Inked Analiz
 DocType: Item Tax,Tax Rate,Soliq stavkasi
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59,{0} already allocated for Employee {1} for period {2} to {3},{2} dan {3} gacha bo&#39;lgan xodim uchun {1} uchun ajratilgan {0}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +890,Select Item,Mavzu-ni tanlang
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +915,Select Item,Mavzu-ni tanlang
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +140,Purchase Invoice {0} is already submitted,Xaridni taqdim etgan {0} allaqachon yuborilgan
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +91,Row # {0}: Batch No must be same as {1} {2},# {0} satrida: {1} {2}
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52,Convert to non-Group,Guruhga o&#39;tkazilmasin
-apps/erpnext/erpnext/config/stock.py +127,Batch (lot) of an Item.,Ob&#39;ektning partiyasi (lot).
 DocType: C-Form Invoice Detail,Invoice Date,Faktura sanasi
 DocType: GL Entry,Debit Amount,Debet miqdori
-apps/erpnext/erpnext/accounts/party.py +253,There can only be 1 Account per Company in {0} {1},{0} {1} da Kompaniyaga 1 Hisob faqatgina bo&#39;lishi mumkin
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +407,Please see attachment,"Iltimos, ilova-ga qarang"
+apps/erpnext/erpnext/accounts/party.py +251,There can only be 1 Account per Company in {0} {1},{0} {1} da Kompaniyaga 1 Hisob faqatgina bo&#39;lishi mumkin
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +426,Please see attachment,"Iltimos, ilova-ga qarang"
 DocType: Purchase Order,% Received,Qabul qilingan
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Talabalar guruhini yaratish
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +21,Setup Already Complete!!,O&#39;rnatish allaqachon yakunlandi!
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Talabalar guruhini yaratish
+DocType: Volunteer,Weekends,Dam olish kunlari
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Credit Note Amount,Kredit eslatma miqdori
 DocType: Setup Progress Action,Action Document,Hujjat
+DocType: Chapter Member,Website URL,Veb-sayt manzili
 ,Finished Goods,Tayyor mahsulotlar
 DocType: Delivery Note,Instructions,Ko&#39;rsatmalar
 DocType: Quality Inspection,Inspected By,Nazorat ostida
-DocType: Maintenance Visit,Maintenance Type,Xizmat turi
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +45,{0} - {1} is not enrolled in the Course {2},{0} - {1} kursi {2}
+DocType: Asset Maintenance Log,Maintenance Type,Xizmat turi
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45,{0} - {1} is not enrolled in the Course {2},{0} - {1} kursi {2}
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Serial No {0} does not belong to Delivery Note {1},No {0} seriyali etkazib berish eslatmasi {1}
 apps/erpnext/erpnext/templates/pages/demo.html +47,ERPNext Demo,ERPNekst demo
 apps/erpnext/erpnext/public/js/utils/item_selector.js +20,Add Items,Ma&#39;lumotlar qo&#39;shish
@@ -486,31 +516,33 @@
 DocType: Packed Item,Packed Item,Paket qo&#39;yilgan
 apps/erpnext/erpnext/config/buying.py +65,Default settings for buying transactions.,Jurnallarni sotib olish uchun standart sozlamalar.
 apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29,Activity Cost exists for Employee {0} against Activity Type - {1},Faoliyatning turi {1} uchun Ta&#39;minotchi uchun {0} ishchi uchun mavjud.
-apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +14,Mandatory field - Get Students From,Majburiy maydon - Talabalarni qabul qiling
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +14,Mandatory field - Get Students From,Majburiy maydon - Talabalarni qabul qiling
 DocType: Program Enrollment,Enrolled courses,O&#39;qilgan kurslar
 DocType: Currency Exchange,Currency Exchange,Valyuta almashinuvi
-DocType: Asset,Item Name,Mavzu nomi
+DocType: Opening Invoice Creation Tool Item,Item Name,Mavzu nomi
 DocType: Authorization Rule,Approving User  (above authorized value),Foydalanuvchi tasdiqlash (yuqorida ko&#39;rsatilgan qiymat)
 DocType: Email Digest,Credit Balance,Kredit balansi
 DocType: Employee,Widowed,Yigit
 DocType: Request for Quotation,Request for Quotation,Buyurtma uchun so&#39;rov
 DocType: Healthcare Settings,Require Lab Test Approval,Laboratoriya tekshiruvini tasdiqlashni talab qiling
 DocType: Salary Slip Timesheet,Working Hours,Ish vaqti
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +10,Total Outstanding,Umumiy natija
 DocType: Naming Series,Change the starting / current sequence number of an existing series.,Mavjud ketma-ketlikning boshlang&#39;ich / to`g`ri qatorini o`zgartirish.
 DocType: Dosage Strength,Strength,Kuch-quvvat
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1508,Create a new Customer,Yangi xaridorni yarating
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1523,Create a new Customer,Yangi xaridorni yarating
 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.","Agar bir nechta narx qoidalari ustunlik qila boshlasa, foydalanuvchilardan nizoni hal qilish uchun birinchi o&#39;ringa qo&#39;l o&#39;rnatish talab qilinadi."
 apps/erpnext/erpnext/utilities/activation.py +90,Create Purchase Orders,Buyurtma buyurtmalarini yaratish
 ,Purchase Register,Xarid qilish Register
-DocType: Course Scheduling Tool,Rechedule,Qayta nashr
+DocType: Scheduling Tool,Rechedule,Qayta nashr
 DocType: Landed Cost Item,Applicable Charges,Amalga oshiriladigan harajatlar
 DocType: Workstation,Consumable Cost,Sarflanadigan narx
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +220,{0} ({1}) must have role 'Leave Approver',{0} ({1}) roli &quot;Approver qoldiring&quot;
 DocType: Purchase Receipt,Vehicle Date,Avtomobil tarixi
 DocType: Student Log,Medical,Tibbiy
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +177,Reason for losing,Yo&#39;qotish sababi
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +41,Lead Owner cannot be same as the Lead,Qo&#39;rg&#39;oshin egasi qo&#39;rg&#39;oshin bilan bir xil bo&#39;lishi mumkin emas
-apps/erpnext/erpnext/accounts/utils.py +351,Allocated amount can not greater than unadjusted amount,Ajratilgan miqdordan tuzatilmaydigan miqdordan ortiq bo&#39;lmaydi
+apps/erpnext/erpnext/accounts/doctype/account/account.js +52,Update Account Number,Hisob raqami yangilang
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +42,Lead Owner cannot be same as the Lead,Qo&#39;rg&#39;oshin egasi qo&#39;rg&#39;oshin bilan bir xil bo&#39;lishi mumkin emas
+apps/erpnext/erpnext/accounts/utils.py +353,Allocated amount can not greater than unadjusted amount,Ajratilgan miqdordan tuzatilmaydigan miqdordan ortiq bo&#39;lmaydi
 DocType: Announcement,Receiver,Qabul qiluvchisi
 apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83,Workstation is closed on the following dates as per Holiday List: {0},Ish stantsiyasi quyidagi holatlarda Dam olish Ro&#39;yxatiga binoan yopiladi: {0}
 apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32,Opportunities,Imkoniyatlar
@@ -526,7 +558,7 @@
 DocType: Lab Test Template,No Result,Natija yo&#39;q
 DocType: Purchase Invoice Item,Quantity and Rate,Miqdor va foiz
 DocType: Delivery Note,% Installed,O&#39;rnatilgan
-apps/erpnext/erpnext/utilities/user_progress.py +209,Classrooms/ Laboratories etc where lectures can be scheduled.,Darslar / laboratoriyalar va boshqalar.
+apps/erpnext/erpnext/utilities/user_progress.py +227,Classrooms/ Laboratories etc where lectures can be scheduled.,Darslar / laboratoriyalar va boshqalar.
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46,Please enter company name first,Avval kompaniya nomini kiriting
 DocType: Purchase Invoice,Supplier Name,Yetkazib beruvchi nomi
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25,Read the ERPNext Manual,ERPNext qo&#39;llanmasini o&#39;qing
@@ -534,40 +566,45 @@
 DocType: Email Digest,Pending Purchase Orders,Buyurtma buyurtmalarini kutish
 DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,FIFO asosida avtomatik ravishda Serial Nosni sozlang
 DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,Taqdim etuvchi Billing raqami yagonaligini tekshiring
+apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34,Primary Address Details,Birlamchi manzil ma&#39;lumotlari
 DocType: Vehicle Service,Oil Change,Yog &#39;o&#39;zgarishi
+DocType: Asset Maintenance Log,Asset Maintenance Log,Ob&#39;ektni saqlash jadvali
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.',&quot;Ishga doir&quot; &quot;Aslida&quot; dan kam bo&#39;lishi mumkin emas.
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +142,Non Profit,Qor bo&#39;lmagan
+DocType: Chapter,Non Profit,Qor bo&#39;lmagan
 DocType: Production Order,Not Started,Boshlanmadi
 DocType: Lead,Channel Partner,Kanal hamkori
 DocType: Account,Old Parent,Eski ota-ona
-apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +18,Mandatory field - Academic Year,Majburiy maydon - Akademik yil
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +18,Mandatory field - Academic Year,Majburiy maydon - Akademik yil
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,{0} {1} is not associated with {2} {3},{0} {1} {2} {3} bilan bog&#39;lanmagan
 DocType: Notification Control,Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,Ushbu e-pochtaning bir qismi sifatida kiritilgan kirish matnini moslashtiring. Har bir bitim alohida kirish matnga ega.
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +157,Please set default payable account for the company {0},"Iltimos, {0} kompaniyangiz uchun to&#39;langan pulli hisobni tanlang"
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +182,Please set default payable account for the company {0},"Iltimos, {0} kompaniyangiz uchun to&#39;langan pulli hisobni tanlang"
 DocType: Setup Progress Action,Min Doc Count,Min Doc Count
 apps/erpnext/erpnext/config/manufacturing.py +84,Global settings for all manufacturing processes.,Barcha ishlab chiqarish jarayonlari uchun global sozlamalar.
 DocType: Accounts Settings,Accounts Frozen Upto,Hisoblar muzlatilgan
 DocType: SMS Log,Sent On,Yuborildi
-apps/erpnext/erpnext/stock/doctype/item/item.py +685,Attribute {0} selected multiple times in Attributes Table,Xususiyat {0} xususiyati bir nechta marta Attributes jadvalida tanlangan
+apps/erpnext/erpnext/stock/doctype/item/item.py +671,Attribute {0} selected multiple times in Attributes Table,Xususiyat {0} xususiyati bir nechta marta Attributes jadvalida tanlangan
 DocType: HR Settings,Employee record is created using selected field. ,Ishchi yozuvi tanlangan maydon yordamida yaratiladi.
 DocType: Sales Order,Not Applicable,Taalluqli emas
 apps/erpnext/erpnext/config/hr.py +70,Holiday master.,Dam olish ustasi.
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +77,Opening Invoice Item,Billing elementini ochish
 DocType: Request for Quotation Item,Required Date,Kerakli sana
 DocType: Delivery Note,Billing Address,Murojaat manzili
 DocType: BOM,Costing,Xarajatlar
 DocType: Tax Rule,Billing County,Billing shahari
 DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Belgilangan bo&#39;lsa, soliq miqdori allaqachon Chop etish / Chop etish miqdori kiritilgan deb hisoblanadi"
 DocType: Request for Quotation,Message for Supplier,Yetkazib beruvchiga xabar
+DocType: Driver,DRIVER-.#####,DRIVER - #####
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Total Qty,Jami Miqdor
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2 Email identifikatori
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2 Email identifikatori
 DocType: Item,Show in Website (Variant),Saytda ko&#39;rsatish (variant)
 DocType: Employee,Health Concerns,Sog&#39;liq muammolari
-DocType: Process Payroll,Select Payroll Period,Ajratish davrini tanlang
+DocType: Payroll Entry,Select Payroll Period,Ajratish davrini tanlang
 DocType: Purchase Invoice,Unpaid,Bepul emas
 apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49,Reserved for sale,Savdo uchun ajratilgan
 DocType: Packing Slip,From Package No.,To&#39;plam №
 DocType: Item Attribute,To Range,Oralig&#39;ida
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29,Securities and Deposits,Qimmatli Qog&#39;ozlar va depozitlar
-apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +44,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Baholash usulini o&#39;zgartira olmaydi, chunki o&#39;z baholash uslubiga ega bo&#39;lmagan ayrim narsalarga nisbatan operatsiyalar mavjud"
+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","Baholash usulini o&#39;zgartira olmaydi, chunki o&#39;z baholash uslubiga ega bo&#39;lmagan ayrim narsalarga nisbatan operatsiyalar mavjud"
 apps/erpnext/erpnext/config/healthcare.py +133,Test Sample Master.,Viktorina namunasi ustasi.
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82,Total leaves allocated is mandatory,Berilgan barglarning barchasi majburiydir
 DocType: Patient,AB Positive,Evropa Ittifoqi ijobiy
@@ -589,35 +626,39 @@
 DocType: Training Event,Workshop,Seminar
 DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Sotib olish buyurtmalarini ogohlantiring
 apps/erpnext/erpnext/utilities/user_progress.py +64,List a few of your customers. They could be organizations or individuals.,Mijozlaringizning bir qismini ro&#39;yxatlang. Ular tashkilotlar yoki shaxslar bo&#39;lishi mumkin.
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Yetkazib beruvchi&gt; Yetkazib beruvchi turi
 apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +21,Enough Parts to Build,Qurilish uchun yetarli qismlar
 DocType: POS Profile User,POS Profile User,Qalin Foydalanuvchining profili
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128,Direct Income,To&#39;g&#39;ridan-to&#39;g&#39;ri daromad
 DocType: Patient Appointment,Date TIme,Sana TIme
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +36,"Can not filter based on Account, if grouped by Account","Hisob asosida guruhlangan bo&#39;lsa, hisob qaydnomasi asosida filtrlay olmaydi"
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +126,Administrative Officer,Ma&#39;muriy xodim
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +22,Please select Course,"Iltimos, kursni tanlang"
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +130,Administrative Officer,Ma&#39;muriy xodim
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39,Setting up company and taxes,Kompaniya va soliqlarni o&#39;rnatish
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,"Iltimos, kursni tanlang"
 DocType: Codification Table,Codification Table,Kodlashtirish jadvali
 DocType: Timesheet Detail,Hrs,Hr
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +342,Please select Company,"Iltimos, Kompaniya-ni tanlang"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +350,Please select Company,"Iltimos, Kompaniya-ni tanlang"
 DocType: Stock Entry Detail,Difference Account,Farq hisob
 DocType: Purchase Invoice,Supplier GSTIN,Yetkazib beruvchi GSTIN
 apps/erpnext/erpnext/projects/doctype/task/task.py +47,Cannot close task as its dependant task {0} is not closed.,"Vazifani yopib bo&#39;lmaydi, chunki unga bog&#39;liq {0} vazifasi yopilmaydi."
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +433,Please enter Warehouse for which Material Request will be raised,"Iltimos, Materiallar talabi ko&#39;tariladigan omborga kiriting"
 DocType: Production Order,Additional Operating Cost,Qo&#39;shimcha operatsion narx
 DocType: Lab Test Template,Lab Routine,Laboratoriya muntazamligi
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +20,Cosmetics,Kosmetika
-apps/erpnext/erpnext/stock/doctype/item/item.py +545,"To merge, following properties must be same for both items",Birlashtirish uchun quyidagi xususiyatlar ikkala element uchun bir xil bo&#39;lishi kerak
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20,Cosmetics,Kosmetika
+apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18,Please select Completion Date for Completed Asset Maintenance Log,Tugallangan aktivlarga xizmat ko&#39;rsatish jurnalining tugallangan kunini tanlang
+apps/erpnext/erpnext/stock/doctype/item/item.py +526,"To merge, following properties must be same for both items",Birlashtirish uchun quyidagi xususiyatlar ikkala element uchun bir xil bo&#39;lishi kerak
 DocType: Shipping Rule,Net Weight,Sof og&#39;irlik
 DocType: Employee,Emergency Phone,Favqulodda telefon
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29,Buy,Xarid qiling
 ,Serial No Warranty Expiry,Seriya No Kafolatining amal qilish muddati
 DocType: Sales Invoice,Offline POS Name,Oflayn qalin nomi
-apps/erpnext/erpnext/utilities/user_progress.py +159,Student Application,Talabalar uchun ariza
-apps/erpnext/erpnext/schools/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,"Marhamat, esda tuting: 0%"
+apps/erpnext/erpnext/utilities/user_progress.py +177,Student Application,Talabalar uchun ariza
+apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,"Marhamat, esda tuting: 0%"
 DocType: Sales Order,To Deliver,Taqdim etish uchun
 DocType: Purchase Invoice Item,Item,Mavzu
-apps/erpnext/erpnext/healthcare/setup.py +255,High Sensitivity,Oliy sezuvchanlik
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2493,Serial no item cannot be a fraction,Serial hech bir element qisman bo&#39;lolmaydi
+apps/erpnext/erpnext/healthcare/setup.py +256,High Sensitivity,Oliy sezuvchanlik
+apps/erpnext/erpnext/config/non_profit.py +48,Volunteer Type information.,Ixtiyoriy ma&#39;lumot turi.
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2512,Serial no item cannot be a fraction,Serial hech bir element qisman bo&#39;lolmaydi
 DocType: Journal Entry,Difference (Dr - Cr),Farq (shifokor - Cr)
 DocType: Account,Profit and Loss,Qor va ziyon
 DocType: Patient,Risk Factors,Xavf omillari
@@ -626,6 +667,7 @@
 apps/erpnext/erpnext/config/stock.py +330,Managing Subcontracting,Subpudrat shartnomasini boshqarish
 DocType: Vital Signs,Body Temperature,Tana harorati
 DocType: Project,Project will be accessible on the website to these users,Ushbu foydalanuvchilarning veb-saytida loyihaga kirish mumkin bo&#39;ladi
+DocType: Detected Disease,Disease,Kasallik
 apps/erpnext/erpnext/config/projects.py +24,Define Project type.,Loyiha turini belgilang.
 DocType: Supplier Scorecard,Weighting Function,Og&#39;irligi funktsiyasi
 DocType: Physician,OP Consulting Charge,OP maslaxatchisi uchun to&#39;lov
@@ -634,27 +676,29 @@
 apps/erpnext/erpnext/setup/doctype/company/company.py +62,Account {0} does not belong to company: {1},{0} hisobiga kompaniya tegishli emas: {1}
 apps/erpnext/erpnext/setup/doctype/company/company.py +51,Abbreviation already used for another company,Qisqartma boshqa kompaniya uchun ishlatilgan
 DocType: Selling Settings,Default Customer Group,Standart xaridorlar guruhi
+DocType: Asset Repair,ARLOG-,ARLOG-
 DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Agar o&#39;chirib qo&#39;yilsa, &quot;Rounded Total&quot; maydoni hech qanday operatsiyada ko&#39;rinmaydi"
 DocType: BOM,Operating Cost,Operatsion xarajatlar
+DocType: Crop,Produced Items,Ishlab chiqarilgan narsalar
 DocType: Sales Order Item,Gross Profit,Yalpi foyda
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49,Increment cannot be 0,Artish 0 bo&#39;lishi mumkin emas
 DocType: Production Planning Tool,Material Requirement,Moddiy talablar
 DocType: Company,Delete Company Transactions,Kompaniya jarayonini o&#39;chirish
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +350,Reference No and Reference Date is mandatory for Bank transaction,Bank bo&#39;yicha bitim uchun Yo&#39;naltiruvchi Yo&#39;naltiruvchi va Yo&#39;nalish sanasi majburiy hisoblanadi
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +351,Reference No and Reference Date is mandatory for Bank transaction,Bank bo&#39;yicha bitim uchun Yo&#39;naltiruvchi Yo&#39;naltiruvchi va Yo&#39;nalish sanasi majburiy hisoblanadi
 DocType: Purchase Receipt,Add / Edit Taxes and Charges,Soliqlarni va to&#39;lovlarni qo&#39;shish / tahrirlash
 DocType: Payment Entry Reference,Supplier Invoice No,Yetkazib beruvchi hisob raqami №
 DocType: Territory,For reference,Malumot uchun
 DocType: Healthcare Settings,Appointment Confirmation,Uchrashuvni tasdiqlash
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158,"Cannot delete Serial No {0}, as it is used in stock transactions","Serial No {0} o&#39;chirib tashlanmaydi, chunki u birja bitimlarida qo&#39;llaniladi"
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +246,Closing (Cr),Yakunlovchi (Cr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +253,Closing (Cr),Yakunlovchi (Cr)
 apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1,Hello,Salom
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +110,Move Item,Ob&#39;ektni siljiting
 DocType: Serial No,Warranty Period (Days),Kafolat muddati (kunlar)
 DocType: Installation Note Item,Installation Note Item,O&#39;rnatish Eslatma elementi
 DocType: Production Plan Item,Pending Qty,Kutilayotgan son
 DocType: Budget,Ignore,E&#39;tibor bering
-apps/erpnext/erpnext/accounts/party.py +372,{0} {1} is not active,{0} {1} faol emas
-apps/erpnext/erpnext/config/accounts.py +285,Setup cheque dimensions for printing,Bosib chiqarishni tekshirish registrlarini sozlang
+apps/erpnext/erpnext/accounts/party.py +384,{0} {1} is not active,{0} {1} faol emas
+apps/erpnext/erpnext/config/accounts.py +272,Setup cheque dimensions for printing,Bosib chiqarishni tekshirish registrlarini sozlang
 DocType: Salary Slip,Salary Slip Timesheet,Ish staji vaqt jadvalini
 apps/erpnext/erpnext/controllers/buying_controller.py +157,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Yetkazib beruvchi ombori subpudratli sotib olish uchun ariza uchun majburiydir
 DocType: Pricing Rule,Valid From,Darvoqe
@@ -662,19 +706,21 @@
 DocType: Pricing Rule,Sales Partner,Savdo hamkori
 apps/erpnext/erpnext/config/buying.py +150,All Supplier scorecards.,Barcha etkazib beruvchi kartalari.
 DocType: Buying Settings,Purchase Receipt Required,Qabul qilish pulligizga.Albatta talab qilinadi
-apps/erpnext/erpnext/stock/doctype/item/item.py +142,Valuation Rate is mandatory if Opening Stock entered,Ochiq aktsiyadorlik jamg&#39;armasi kiritilgan taqdirda baholash mezonlari majburiydir
+apps/erpnext/erpnext/stock/doctype/item/item.py +144,Valuation Rate is mandatory if Opening Stock entered,Ochiq aktsiyadorlik jamg&#39;armasi kiritilgan taqdirda baholash mezonlari majburiydir
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +142,No records found in the Invoice table,Billing-jadvalida yozuvlar topilmadi
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +17,Please select Company and Party Type first,Marhamat qilib Kompaniya va Partiya turini tanlang
-apps/erpnext/erpnext/config/accounts.py +301,Financial / accounting year.,Moliyaviy / hisobot yili.
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31,"Already set default in pos profile {0} for user {1}, kindly disabled default",{0} uchun {0} profilidagi profilni sukut saqlab qo&#39;ygansiz
+apps/erpnext/erpnext/config/accounts.py +293,Financial / accounting year.,Moliyaviy / hisobot yili.
 apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9,Accumulated Values,Biriktirilgan qiymatlar
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162,"Sorry, Serial Nos cannot be merged","Kechirasiz, Serial Nos birlashtirilmaydi"
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +63,Territory is Required in POS Profile,Territory qalin rejimida talab qilinadi
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +68,Territory is Required in POS Profile,Territory qalin rejimida talab qilinadi
 DocType: Supplier,Prevent RFQs,RFQlarni oldini olish
 apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Savdo buyurtmasini bajaring
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168,Salary Slip submitted for period from {0} to {1},Ish staji {0} dan {1} gacha bo&#39;lgan muddatga taqdim etildi
 DocType: Project Task,Project Task,Loyiha vazifasi
 ,Lead Id,Qurilish no
 DocType: C-Form Invoice Detail,Grand Total,Jami
-DocType: Training Event,Course,Kurs
+DocType: Assessment Plan,Course,Kurs
 DocType: Timesheet,Payslip,Payslip
 apps/erpnext/erpnext/public/js/pos/pos.html +4,Item Cart,Mahsulot savatchasi
 apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38,Fiscal Year Start Date should not be greater than Fiscal Year End Date,Moliya yili boshlanish sanasi Moliyaviy yil tugash sanasidan katta bo&#39;lmasligi kerak
@@ -687,7 +733,9 @@
 DocType: Job Applicant,Resume Attachment,Atamani qayta tiklash
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Iste&#39;molchilarni takrorlang
 DocType: Leave Control Panel,Allocate,Ajratish
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +804,Sales Return,Sotishdan qaytish
+apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108,Create Variant,Variant yaratish
+DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Billingni ochish vositasini ochish
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +851,Sales Return,Sotishdan qaytish
 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,Eslatma: Ajratilgan jami {0} barglari davr uchun tasdiqlangan {1} barglaridan kam bo&#39;lmasligi kerak
 ,Total Stock Summary,Jami Qisqacha Xulosa
 DocType: Announcement,Posted By,Muallif tomonidan
@@ -698,40 +746,45 @@
 apps/erpnext/erpnext/config/selling.py +28,Customer database.,Mijozlar bazasi.
 DocType: Quotation,Quotation To,Qabul qilish
 DocType: Lead,Middle Income,O&#39;rta daromad
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +218,Opening (Cr),Ochilish (Cr)
-apps/erpnext/erpnext/stock/doctype/item/item.py +849,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.,"{0} elementi uchun standart o&#39;lchov birligi bevosita o&#39;zgartirilmaydi, chunki siz boshqa UOM bilan ba&#39;zi bitimlar (tranzaktsiyalar) qildingiz. Boshqa bir standart UOM dan foydalanish uchun yangi element yaratishingiz lozim."
-apps/erpnext/erpnext/accounts/utils.py +349,Allocated amount can not be negative,Ajratilgan mablag&#39; salbiy bo&#39;lishi mumkin emas
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +225,Opening (Cr),Ochilish (Cr)
+apps/erpnext/erpnext/stock/doctype/item/item.py +835,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.,"{0} elementi uchun standart o&#39;lchov birligi bevosita o&#39;zgartirilmaydi, chunki siz boshqa UOM bilan ba&#39;zi bitimlar (tranzaktsiyalar) qildingiz. Boshqa bir standart UOM dan foydalanish uchun yangi element yaratishingiz lozim."
+apps/erpnext/erpnext/accounts/utils.py +351,Allocated amount can not be negative,Ajratilgan mablag&#39; salbiy bo&#39;lishi mumkin emas
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,"Iltimos, kompaniyani tanlang"
 DocType: Purchase Order Item,Billed Amt,Billing qilingan Amt
 DocType: Training Result Employee,Training Result Employee,Ta&#39;lim natijalari Xodim
 DocType: Warehouse,A logical Warehouse against which stock entries are made.,Qimmatbaho qog&#39;ozlar kiritilgan mantiqiy ombor.
 DocType: Repayment Schedule,Principal Amount,Asosiy miqdori
 DocType: Employee Loan Application,Total Payable Interest,To&#39;lanadigan foiz
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.js +59,Total Outstanding: {0},Umumiy natija: {0}
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +60,Total Outstanding: {0},Umumiy natija: {0}
 DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Sotuvdagi taqdim etgan vaqt jadvalini
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118,Reference No & Reference Date is required for {0},Yo&#39;naltiruvchi Yo&#39;naltiruvchi va Yo&#39;naltiruvchi {0}
-DocType: Process Payroll,Select Payment Account to make Bank Entry,Bank hisobini yuritish uchun Hisobni tanlang
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +116,Reference No & Reference Date is required for {0},Yo&#39;naltiruvchi Yo&#39;naltiruvchi va Yo&#39;naltiruvchi {0}
+DocType: Payroll Entry,Select Payment Account to make Bank Entry,Bank hisobini yuritish uchun Hisobni tanlang
 apps/erpnext/erpnext/utilities/activation.py +136,"Create Employee records to manage leaves, expense claims and payroll","Barglarni, xarajat da&#39;vatlarini va ish haqini boshqarish uchun xodimlar yozuvlarini yarating"
 apps/erpnext/erpnext/config/healthcare.py +118,Prescription Period,Reçeteleme davri
 DocType: Restaurant Reservation,Restaurant Reservation,Restoran rezervasyoni
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +186,Proposal Writing,Takliflarni Yozish
+DocType: Land Unit,Land Unit Name,Er uchastkasining nomi
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190,Proposal Writing,Takliflarni Yozish
 DocType: Payment Entry Deduction,Payment Entry Deduction,To&#39;lovni to&#39;lashni kamaytirish
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14,Wrapping up,Tiklash
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35,Notify Customers via Email,E-pochta orqali mijozlarni xabardor qilish
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,Another Sales Person {0} exists with the same Employee id,Boshqa bir Sotuvdagi Shaxs {0} bir xil xodim identifikatori mavjud
+DocType: Employee Advance,Claimed Amount,Da&#39;vo qilingan miqdori
 DocType: Production Planning Tool,"If checked, raw materials for items that are sub-contracted will be included in the Material Requests","Agar belgilansa, subpudratchi moddalar uchun xom ashyo materiallari talablariga kiritiladi"
 apps/erpnext/erpnext/config/healthcare.py +61,Masters,Masters
 DocType: Assessment Plan,Maximum Assessment Score,Maksimal baholash skori
-apps/erpnext/erpnext/config/accounts.py +146,Update Bank Transaction Dates,Bankning jurnali kunlarini yangilash
+apps/erpnext/erpnext/config/accounts.py +138,Update Bank Transaction Dates,Bankning jurnali kunlarini yangilash
 apps/erpnext/erpnext/config/projects.py +36,Time Tracking,Vaqtni kuzatish
 DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,TRANSPORTERGA DUPLIKAT
+apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49,Row {0}# Paid Amount cannot be greater than requested advance amount,Row {0} # To&#39;langan pul miqdori so&#39;ralgan avans miqdoridan ortiq bo&#39;lishi mumkin emas
 DocType: Fiscal Year Company,Fiscal Year Company,Moliyaviy yil Kompaniya
 DocType: Packing Slip Item,DN Detail,DN batafsil
 DocType: Training Event,Conference,Konferentsiya
 DocType: Timesheet,Billed,To&#39;lov
 DocType: Batch,Batch Description,Ommaviy tavsif
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Talabalar guruhlarini yaratish
-apps/erpnext/erpnext/accounts/utils.py +721,"Payment Gateway Account not created, please create one manually.","To&#39;lov shlyuzi hisobini yaratib bo&#39;lmadi, iltimos, bir qo&#39;lda yarating."
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Talabalar guruhlarini yaratish
+apps/erpnext/erpnext/accounts/utils.py +724,"Payment Gateway Account not created, please create one manually.","To&#39;lov shlyuzi hisobini yaratib bo&#39;lmadi, iltimos, bir qo&#39;lda yarating."
 DocType: Supplier Scorecard,Per Year,Bir yilda
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.py +51,Not eligible for the admission in this program as per DOB,Ushbu dasturda DOBga mos kelmasligi mumkin
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51,Not eligible for the admission in this program as per DOB,Ushbu dasturda DOBga mos kelmasligi mumkin
 DocType: Sales Invoice,Sales Taxes and Charges,Sotishdan olinadigan soliqlar va yig&#39;imlar
 DocType: Employee,Organization Profile,Tashkilot profili
 DocType: Vital Signs,Height (In Meter),Balandligi (metrda)
@@ -739,25 +792,25 @@
 DocType: Vehicle Service,Vehicle Service,Avtomobil xizmati
 apps/erpnext/erpnext/config/setup.py +101,Automatically triggers the feedback request based on conditions.,Qoidalarga asoslangan qayta tiklanish so&#39;rovini avtomatik ravishda ishga tushiradi.
 DocType: Employee,Reason for Resignation,Istefoning sababi
-apps/erpnext/erpnext/config/hr.py +147,Template for performance appraisals.,Ishlashni baholash uchun shablon.
+apps/erpnext/erpnext/config/hr.py +152,Template for performance appraisals.,Ishlashni baholash uchun shablon.
 DocType: Sales Invoice,Credit Note Issued,Kredit notasi chiqarildi
 DocType: Project Task,Weight,Og&#39;irligi
 DocType: Payment Reconciliation,Invoice/Journal Entry Details,Faktura / jurnali kirish ma&#39;lumotlari
 apps/erpnext/erpnext/accounts/utils.py +83,{0} '{1}' not in Fiscal Year {2},{0} &#39;{1}&#39; moliya yilida emas {2}
 DocType: Buying Settings,Settings for Buying Module,Modulni sotib olish sozlamalari
-apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +21,Asset {0} does not belong to company {1},Asset {0} kompaniyaga tegishli emas {1}
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +21,Asset {0} does not belong to company {1},Asset {0} kompaniyaga tegishli emas {1}
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70,Please enter Purchase Receipt first,Avval Qabul Qabulnomasini kiriting
 DocType: Buying Settings,Supplier Naming By,Yetkazib beruvchi nomini berish
 DocType: Activity Type,Default Costing Rate,Standart narxlash darajasi
 DocType: Maintenance Schedule,Maintenance Schedule,Xizmat jadvali
 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.","Keyin narxlash qoidalari xaridorlar, xaridorlar guruhi, hududi, yetkazib beruvchisi, yetkazib beruvchi turi, aksiya, savdo bo&#39;yicha hamkor va boshqalar asosida filtrlanadi."
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24,Net Change in Inventory,Inventarizatsiyada aniq o&#39;zgarishlar
-apps/erpnext/erpnext/config/hr.py +157,Employee Loan Management,Xodimlarning qarzlarini boshqarish
+apps/erpnext/erpnext/config/hr.py +162,Employee Loan Management,Xodimlarning qarzlarini boshqarish
 DocType: Employee,Passport Number,Pasport raqami
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,Guardian2 bilan aloqalar
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +120,Manager,Menejer
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,Guardian2 bilan aloqalar
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124,Manager,Menejer
 DocType: Payment Entry,Payment From / To,To&#39;lov / To
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +127,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Yangi kredit limiti mijoz uchun mavjud summasidan kamroq. Kredit cheklovi atigi {0} bo&#39;lishi kerak
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +155,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Yangi kredit limiti mijoz uchun mavjud summasidan kamroq. Kredit cheklovi atigi {0} bo&#39;lishi kerak
 apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,&#39;Based On&#39; va &#39;Group By&#39; bir xil bo&#39;lishi mumkin emas
 DocType: Sales Person,Sales Person Targets,Sotuvdagi shaxsning maqsadlari
 DocType: Installation Note,IN-,IN-
@@ -766,43 +819,46 @@
 DocType: Lab Test Template,Compound,Murakkab
 DocType: Student Batch Name,Batch Name,Partiya nomi
 DocType: Fee Validity,Max number of visit,Tashrifning maksimal soni
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +319,Timesheet created:,Tuzilish sahifasi:
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +908,Please set default Cash or Bank account in Mode of Payment {0},"Iltimos, odatdagi Cash yoki Bank hisobini {0} To&#39;lov tartibi rejimida tanlang."
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +24,Enroll,Ro&#39;yxatga olish
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +339,Timesheet created:,Tuzilish sahifasi:
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +920,Please set default Cash or Bank account in Mode of Payment {0},"Iltimos, odatdagi Cash yoki Bank hisobini {0} To&#39;lov tartibi rejimida tanlang."
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24,Enroll,Ro&#39;yxatga olish
 DocType: GST Settings,GST Settings,GST sozlamalari
 DocType: Selling Settings,Customer Naming By,Xaridor tomonidan nomlash
 DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,"Isoning shogirdi, shogirdning oylik ishtirok hisobotida ishtirok etishini ko&#39;rsatadi"
 DocType: Depreciation Schedule,Depreciation Amount,Amortizatsiya summasi
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56,Convert to Group,Guruhga aylantirilsin
+DocType: Delivery Trip,TOUR-.#####,TOUR - #####
 DocType: Activity Cost,Activity Type,Faollik turi
 DocType: Request for Quotation,For individual supplier,Shaxsiy yetkazib beruvchilar uchun
 DocType: BOM Operation,Base Hour Rate(Company Currency),Asosiy soatingiz (Kompaniya valyutasi)
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Amount,Miqdori topshirilgan
-DocType: Supplier,Fixed Days,Ruxsat etilgan kunlar
-apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14,Lab Tests,Lab sinovlari
+DocType: Company,Fixed Days,Ruxsat etilgan kunlar
 DocType: Quotation Item,Item Balance,Mavzu balansi
 DocType: Sales Invoice,Packing List,O&#39;rama bo&#39;yicha hisob-kitob hujjati; Yuk-mol hujjati
 apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,Yetkazib beruvchilarga berilgan buyurtmalar.
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +43,Publishing,Nashriyot
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43,Publishing,Nashriyot
 DocType: Activity Cost,Projects User,Foydalanuvchi bilan aloqa Foydalanuvchining
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Consumed,Iste&#39;mol qilingan
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +157,{0}: {1} not found in Invoice Details table,{0}: {1} - &quot;Billing Details&quot; jadvalida topilmadi
+DocType: Asset,Asset Owner Company,Asset Sohibi Kompaniya
 DocType: Company,Round Off Cost Center,Dumaloq Narxlar markazi
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +227,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,"Ushbu Savdo Buyurtmani bekor qilishdan oldin, tashrif {0} tashrifi bekor qilinishi kerak"
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,"Ushbu Savdo Buyurtmani bekor qilishdan oldin, tashrif {0} tashrifi bekor qilinishi kerak"
+DocType: Asset Maintenance Log,AML-,AML-
 DocType: Item,Material Transfer,Materiallarni uzatish
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24,Could not find path for ,Yo&#39;l topilmadi
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +211,Opening (Dr),Ochilish (doktor)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +218,Opening (Dr),Ochilish (doktor)
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39,Posting timestamp must be after {0},Vaqt tamg&#39;asini yuborish {0}
 apps/erpnext/erpnext/config/accounts.py +39,To make recurring documents,Takroriy hujjatlar yaratish
 ,GST Itemised Purchase Register,GST mahsulotini sotib olish registratsiyasi
+DocType: Course Scheduling Tool,Reschedule,Qaytadan rejalashtirish
 DocType: Employee Loan,Total Interest Payable,To&#39;lanadigan foizlar
 DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Foydali soliqlar va yig&#39;imlar
 DocType: Production Order Operation,Actual Start Time,Haqiqiy boshlash vaqti
 DocType: BOM Operation,Operation Time,Foydalanish muddati
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +293,Finish,Tugatish
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +395,Base,Asosiy
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +315,Finish,Tugatish
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412,Base,Asosiy
 DocType: Timesheet,Total Billed Hours,Jami hisoblangan soat
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1351,Write Off Amount,Miqdorni yozing
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1438,Write Off Amount,Miqdorni yozing
 DocType: Leave Block List Allow,Allow User,Foydalanuvchiga ruxsat berish
 DocType: Journal Entry,Bill No,Bill №
 DocType: Company,Gain/Loss Account on Asset Disposal,Aktivni yo&#39;qotish bo&#39;yicha daromad / yo&#39;qotish hisobi
@@ -816,33 +872,38 @@
 DocType: Student Attendance,Student Attendance,Isoning shogirdi ishtiroki
 DocType: Sales Invoice Timesheet,Time Sheet,Vaqt varaqasi
 DocType: Manufacturing Settings,Backflush Raw Materials Based On,Chuqur xomashyo asosida ishlab chiqarilgan
-DocType: Interest,Interest,Foiz
+DocType: Lead,Lead is an Organization,Qo&#39;rg&#39;oshin tashkilot
+DocType: Guardian Interest,Interest,Foiz
 apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Old savdo
 DocType: Purchase Receipt,Other Details,Boshqa tafsilotlar
 apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,Suplier
 DocType: Lab Test,Test Template,Viktorina shablonni
 DocType: Restaurant Order Entry Item,Served,Xizmat qildi
+apps/erpnext/erpnext/config/non_profit.py +13,Chapter information.,Bo&#39;lim haqida ma&#39;lumot.
 DocType: Account,Accounts,Hisoblar
 DocType: Vehicle,Odometer Value (Last),Odometer qiymati (oxirgi)
 apps/erpnext/erpnext/config/buying.py +160,Templates of supplier scorecard criteria.,Yetkazib beruvchilar koeffitsienti mezonlari namunalari.
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +105,Marketing,Marketing
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109,Marketing,Marketing
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +290,Payment Entry is already created,To&#39;lov kirish allaqachon yaratilgan
 DocType: Request for Quotation,Get Suppliers,Yetkazuvchilarni qabul qiling
 DocType: Purchase Receipt Item Supplied,Current Stock,Joriy aktsiyalar
-apps/erpnext/erpnext/controllers/accounts_controller.py +545,Row #{0}: Asset {1} does not linked to Item {2},{0} qator: Asset {1} {2}
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +377,Preview Salary Slip,Preview ish haqi slip
+apps/erpnext/erpnext/controllers/accounts_controller.py +589,Row #{0}: Asset {1} does not linked to Item {2},{0} qator: Asset {1} {2}
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +394,Preview Salary Slip,Preview ish haqi slip
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54,Account {0} has been entered multiple times,{0} hisobi bir necha marta kiritilgan
 DocType: Account,Expenses Included In Valuation,Baholashda ishtirok etish xarajatlari
+apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +23,You can only renew if your membership expires within 30 days,Sizning a&#39;zoning 30 kun ichida amal qilish muddati tugaguncha yangilanishi mumkin
+DocType: Land Unit,Longitude,Uzunlik
 ,Absent Student Report,Isoning shogirdi hisoboti yo&#39;q
+DocType: Crop,Crop Spacing UOM,O&#39;simliklar oralig&#39;i UOM
 DocType: Email Digest,Next email will be sent on:,Keyingi elektron pochta orqali yuboriladi:
 DocType: Offer Letter Term,Offer Letter Term,Harf muddatini taklif qilish
 DocType: Supplier Scorecard,Per Week,Haftasiga
-apps/erpnext/erpnext/stock/doctype/item/item.py +658,Item has variants.,Mavzu variantlarga ega.
-apps/erpnext/erpnext/schools/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,Jami talabalar
+apps/erpnext/erpnext/stock/doctype/item/item.py +639,Item has variants.,Mavzu variantlarga ega.
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,Jami talabalar
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65,Item {0} not found,{0} elementi topilmadi
 DocType: Bin,Stock Value,Qimmatli qog&#39;ozlar qiymati
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.js +41,Fee records will be created in the background. In case of any error the error message will be updated in the Schedule.,Ish haqi yozuvlari fonda yaratiladi. Xatolik yuz berganda xato xabari Jadvalda yangilanadi.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +26,Company {0} does not exist,Kompaniya {0} mavjud emas
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +42,Fee records will be created in the background. In case of any error the error message will be updated in the Schedule.,Ish haqi yozuvlari fonda yaratiladi. Xatolik yuz berganda xato xabari Jadvalda yangilanadi.
+apps/erpnext/erpnext/accounts/doctype/account/account.py +241,Company {0} does not exist,Kompaniya {0} mavjud emas
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40,{0} has fee validity till {1},{0} {1} ga qadar pullik amal qiladi
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +57,Tree Type,Daraxt turi
 DocType: BOM Explosion Item,Qty Consumed Per Unit,Har bir birlikda iste&#39;mol miqdori
@@ -850,42 +911,46 @@
 DocType: Material Request Item,Quantity and Warehouse,Miqdor va ombor
 DocType: Hub Settings,Unregister,Ro&#39;yhatdan o&#39;tish
 DocType: Sales Invoice,Commission Rate (%),Komissiya darajasi (%)
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +24,Please select Program,"Iltimos, Dasturni tanlang"
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24,Please select Program,"Iltimos, Dasturni tanlang"
 DocType: Project,Estimated Cost,Bashoratli narxlar
 DocType: Purchase Order,Link to material requests,Materiallar so&#39;rovlariga havola
 DocType: Hub Settings,Publish,Nashr qiling
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +7,Aerospace,Aerokosmos
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7,Aerospace,Aerokosmos
 DocType: Journal Entry,Credit Card Entry,Kredit kartalarini rasmiylashtirish
 apps/erpnext/erpnext/config/accounts.py +57,Company and Accounts,Kompaniya va Hisoblar
 apps/erpnext/erpnext/config/healthcare.py +108,Appointment Type Master,Uchrashuv turi Magistr
-apps/erpnext/erpnext/config/stock.py +22,Goods received from Suppliers.,Yetkazib beruvchilar tomonidan olinadigan tovarlar.
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +58,In Value,Qiymatida
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68,In Value,Qiymatida
 DocType: Lead,Campaign Name,Kampaniya nomi
 DocType: Selling Settings,Close Opportunity After Days,Kunlardan keyin imkoniyatni yoqing
 ,Reserved,Rezervlangan
+DocType: Driver,License Details,Litsenziya ma&#39;lumotlari
 DocType: Purchase Order,Supply Raw Materials,Xom-ashyo etkazib berish
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,Joriy aktivlar
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +94,{0} is not a stock Item,{0} - bu aksiya elementi emas
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +99,{0} is not a stock Item,{0} - bu aksiya elementi emas
 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',"&quot;Ta&#39;lim bo&#39;yicha hisobot&quot; ni bosing, so&#39;ngra &quot;Yangi&quot;"
 DocType: Mode of Payment Account,Default Account,Standart hisob
+apps/erpnext/erpnext/stock/doctype/item/item.py +262,Please select Sample Retention Warehouse in Stock Settings first,Avval Stok Sozlamalarida Sample Retention Warehouse-ni tanlang
 DocType: Payment Entry,Received Amount (Company Currency),Qabul qilingan summalar (Kompaniya valyutasi)
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192,Lead must be set if Opportunity is made from Lead,"Imkoniyat Qo&#39;rg&#39;oshin qilinsa, qo&#39;rg&#39;oshin o&#39;rnatilishi kerak"
 apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29,Please select weekly off day,Haftalik yopiq kunni tanlang
 DocType: Patient,O Negative,O salbiy
 DocType: Production Order Operation,Planned End Time,Rejalashtirilgan muddat
 ,Sales Person Target Variance Item Group-Wise,Sotuvdagi shaxs Maqsad Varyans elementi Guruh-dono
-apps/erpnext/erpnext/accounts/doctype/account/account.py +96,Account with existing transaction cannot be converted to ledger,Mavjud bitim bilan hisob qaydnomasiga o&#39;tkazilmaydi
+apps/erpnext/erpnext/accounts/doctype/account/account.py +95,Account with existing transaction cannot be converted to ledger,Mavjud bitim bilan hisob qaydnomasiga o&#39;tkazilmaydi
+apps/erpnext/erpnext/config/non_profit.py +33,Memebership Type Details,Xodimlar haqida ma&#39;lumot
 DocType: Delivery Note,Customer's Purchase Order No,Xaridorning Buyurtma no
 DocType: Budget,Budget Against,Byudjetga qarshi
 DocType: Employee,Cell Number,Hujayra raqami
-apps/erpnext/erpnext/stock/reorder_item.py +177,Auto Material Requests Generated,Avtomatik material talablari yaratildi
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +445,There's no employee for the given criteria. Check that Salary Slips have not already been created.,Ushbu mezon bo&#39;yicha xodimlar yo&#39;q. Ish haqi tovarlarining hali yaratilmaganligini tekshiring.
+apps/erpnext/erpnext/stock/reorder_item.py +190,Auto Material Requests Generated,Avtomatik material talablari yaratildi
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,Yo&#39;qotilgan
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +152,You can not enter current voucher in 'Against Journal Entry' column,&quot;Jurnalga qarshi&quot; ustunidan hozirgi kvotani kirita olmaysiz
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +150,You can not enter current voucher in 'Against Journal Entry' column,&quot;Jurnalga qarshi&quot; ustunidan hozirgi kvotani kirita olmaysiz
 apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,Ishlab chiqarish uchun ajratilgan
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +25,Energy,Energiya
+DocType: Soil Texture,Sand,Qum
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25,Energy,Energiya
 DocType: Opportunity,Opportunity From,Imkoniyatdan foydalanish
 apps/erpnext/erpnext/config/hr.py +98,Monthly salary statement.,Oylik oylik maoshi.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +876,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Row {0}: {1} Serial raqamlari {2} uchun kerak. Siz {3} ni taqdim qildingiz.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +881,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Row {0}: {1} Serial raqamlari {2} uchun kerak. Siz {3} ni taqdim qildingiz.
 apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79,Please select a table,"Iltimos, jadval tanlang"
 DocType: BOM,Website Specifications,Veb-saytning texnik xususiyatlari
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78,{0} is an invalid email address in 'Recipients',{0} - &quot;Qabul qiluvchilar&quot; bo&#39;limida noto&#39;g&#39;ri e-pochta manzili
@@ -893,12 +958,13 @@
 apps/erpnext/erpnext/config/healthcare.py +143,Antibiotic.,Antibiotik.
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24,{0}: From {0} of type {1},{0}: {1} dan {0} dan
 DocType: Warranty Claim,CI-,CI-
-apps/erpnext/erpnext/controllers/buying_controller.py +291,Row {0}: Conversion Factor is mandatory,Row {0}: Konvertatsiya qilish omillari majburiydir
-DocType: Employee,A+,A +
+apps/erpnext/erpnext/controllers/buying_controller.py +292,Row {0}: Conversion Factor is mandatory,Row {0}: Konvertatsiya qilish omillari majburiydir
+DocType: Student,A+,A +
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +326,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Ko&#39;p narx qoidalari bir xil mezonlarga ega, iltimos, birinchi o&#39;ringa tayinlash orqali mojaroni hal qiling. Narxlar qoidalari: {0}"
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +501,Cannot deactivate or cancel BOM as it is linked with other BOMs,BOMni boshqa BOMlar bilan bog&#39;langanidek o&#39;chirib qo&#39;yish yoki bekor qilish mumkin emas
-DocType: Opportunity,Maintenance,Xizmat
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +504,Cannot deactivate or cancel BOM as it is linked with other BOMs,BOMni boshqa BOMlar bilan bog&#39;langanidek o&#39;chirib qo&#39;yish yoki bekor qilish mumkin emas
+DocType: Asset,Maintenance,Xizmat
 DocType: Item Attribute Value,Item Attribute Value,Mavzu xususiyati qiymati
+DocType: Item,Maximum sample quantity that can be retained,Tutilishi mumkin bo&#39;lgan maksimal namuna miqdori
 apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Savdo kampaniyalari.
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +117,Make Timesheet,Vaqt jadvalini tuzish
 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.
@@ -929,21 +995,25 @@
 DocType: Expense Claim Detail,Expense Claim Type,Xarajat shikoyati turi
 DocType: Shopping Cart Settings,Default settings for Shopping Cart,Savatga savatni uchun standart sozlamalar
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +26,Add Timeslots,Timeslots-ni qo&#39;shish
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +138,Asset scrapped via Journal Entry {0},Aktivlar jurnal jurnali orqali {0}
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138,Asset scrapped via Journal Entry {0},Aktivlar jurnal jurnali orqali {0}
 DocType: Employee Loan,Interest Income Account,Foiz daromadi hisob
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +13,Biotechnology,Biotexnologiya
+apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58,Review Invitation Sent,Taklifni ko&#39;rib chiqish yuborildi
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13,Biotechnology,Biotexnologiya
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Office Maintenance Expenses,Xizmat uchun xizmat xarajatlari
 apps/erpnext/erpnext/utilities/user_progress.py +51,Go to ,Boring
 apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,E-pochta qayd yozuvini sozlash
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.js +114,Please enter Item first,"Iltimos, avval Elementni kiriting"
+DocType: Asset Repair,Downtime,Chaqiruv
 DocType: Account,Liability,Javobgarlik
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +186,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sanktsiyalangan pul miqdori {0} qatorida da&#39;vo miqdori qiymatidan katta bo&#39;lmasligi kerak.
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +234,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sanktsiyalangan pul miqdori {0} qatorida da&#39;vo miqdori qiymatidan katta bo&#39;lmasligi kerak.
 DocType: Salary Detail,Do not include in total,Hammaga qo&#39;shmang
 DocType: Company,Default Cost of Goods Sold Account,Sotilgan hisoblangan tovarlarning qiymati
-apps/erpnext/erpnext/stock/get_item_details.py +319,Price List not selected,Narxlar ro&#39;yxati tanlanmagan
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +964,Sample quantity {0} cannot be more than received quantity {1},{0} o&#39;rnak miqdori qabul qilingan miqdordan ortiq bo&#39;lishi mumkin emas {1}
+apps/erpnext/erpnext/stock/get_item_details.py +362,Price List not selected,Narxlar ro&#39;yxati tanlanmagan
 DocType: Employee,Family Background,Oila fondi
 DocType: Request for Quotation Supplier,Send Email,Elektron pochta yuborish
-apps/erpnext/erpnext/stock/doctype/item/item.py +216,Warning: Invalid Attachment {0},Ogohlantirish: yaroqsiz {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +218,Warning: Invalid Attachment {0},Ogohlantirish: yaroqsiz {0}
+DocType: Item,Max Sample Quantity,Maksimal namunalar miqdori
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +764,No Permission,Izoh yo&#39;q
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +438,Quote Requested,So&#39;ralgan
 DocType: Vital Signs,Heart Rate / Pulse,Yurak urishi / zarba
@@ -951,32 +1021,34 @@
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +50,"To filter based on Party, select Party Type first",Partiyaga asoslangan filtrni belgilash uchun birinchi navbatda Partiya turini tanlang
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48,'Update Stock' can not be checked because items are not delivered via {0},"&quot;Yangilash kabinetga&quot; tekshirilishi mumkin emas, chunki elementlar {0}"
 DocType: Vehicle,Acquisition Date,Qabul qilish sanasi
-apps/erpnext/erpnext/utilities/user_progress.py +125,Nos,Nos
+apps/erpnext/erpnext/utilities/user_progress.py +143,Nos,Nos
 DocType: Item,Items with higher weightage will be shown higher,Yuqori vaznli narsalar yuqoriroq bo&#39;ladi
+apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14,Lab Tests and Vital Signs,Laboratoriya testlari va hayotiy belgilar
 DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Bank kelishuvi batafsil
-apps/erpnext/erpnext/controllers/accounts_controller.py +549,Row #{0}: Asset {1} must be submitted,# {0} satri: Asset {1} yuborilishi kerak
+apps/erpnext/erpnext/controllers/accounts_controller.py +593,Row #{0}: Asset {1} must be submitted,# {0} satri: Asset {1} yuborilishi kerak
 apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40,No employee found,Hech qanday xodim topilmadi
 DocType: Subscription,Stopped,To&#39;xtadi
 DocType: Item,If subcontracted to a vendor,Agar sotuvchiga subpudrat berilsa
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +111,Student Group is already updated.,Talabalar guruhi allaqachon yangilangan.
+apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111,Student Group is already updated.,Talabalar guruhi allaqachon yangilangan.
 DocType: SMS Center,All Customer Contact,Barcha xaridorlar bilan bog&#39;laning
-apps/erpnext/erpnext/config/stock.py +158,Upload stock balance via csv.,Csv orqali kabinetga balansini yuklang.
-DocType: Warehouse,Tree Details,Daraxt detallari
+DocType: Land Unit,Tree Details,Daraxt detallari
 DocType: Training Event,Event Status,Voqealar holati
+DocType: Volunteer,Availability Timeslot,Mavjudligi: Timeslot
 ,Support Analytics,Analytics-ni qo&#39;llab-quvvatlash
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +352,"If you have any questions, please get back to us.","Savollaringiz bo&#39;lsa, iltimos, bizga murojaat qiling."
 DocType: Item,Website Warehouse,Veb-sayt ombori
 DocType: Payment Reconciliation,Minimum Invoice Amount,Minimal Billing miqdori
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: xarajatlar markazi {2} Kompaniyaga tegishli emas {3}
+apps/erpnext/erpnext/utilities/user_progress.py +89,Upload your letter head (Keep it web friendly as 900px by 100px),Maktubingiz boshini yuklang (veb-sahifani do&#39;stingiz sifatida 900px sifatida 100px sifatida saqlang)
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88,{0} {1}: Account {2} cannot be a Group,{0} {1}: Hisob {2} guruh bo&#39;lolmaydi
 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,Mahsulot satr {idx}: {doctype} {docname} yuqoridagi &quot;{doctype}&quot; jadvalida mavjud emas
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +289,Timesheet {0} is already completed or cancelled,Vaqt jadvalining {0} allaqachon tugallangan yoki bekor qilingan
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +291,Timesheet {0} is already completed or cancelled,Vaqt jadvalining {0} allaqachon tugallangan yoki bekor qilingan
 apps/erpnext/erpnext/templates/pages/projects.html +42,No tasks,Vazifalar yo&#39;q
 DocType: Item Variant Settings,Copy Fields to Variant,Maydonlarni Variantlarga nusxalash
 DocType: Asset,Opening Accumulated Depreciation,Biriktirilgan amortizatsiyani ochish
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49,Score must be less than or equal to 5,Ballar 5dan kam yoki teng bo&#39;lishi kerak
 DocType: Program Enrollment Tool,Program Enrollment Tool,Dasturlarni ro&#39;yxatga olish vositasi
-apps/erpnext/erpnext/config/accounts.py +343,C-Form records,C-formasi yozuvlari
+apps/erpnext/erpnext/config/accounts.py +335,C-Form records,C-formasi yozuvlari
 apps/erpnext/erpnext/config/selling.py +311,Customer and Supplier,Xaridor va yetkazib beruvchi
 DocType: Email Digest,Email Digest Settings,E-pochtada elektron pochta sozlamalari
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +354,Thank you for your business!,Ishingiz uchun tashakkur!
@@ -987,43 +1059,48 @@
 DocType: HR Settings,Retirement Age,Pensiya yoshi
 DocType: Bin,Moving Average Rate,O&#39;rtacha tezlikni ko&#39;tarish
 DocType: Production Planning Tool,Select Items,Elementlarni tanlang
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372,{0} against Bill {1} dated {2},{1} {2} kuni {0}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +370,{0} against Bill {1} dated {2},{1} {2} kuni {0}
 apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Institution,O&#39;rnatish tashkiloti
 DocType: Program Enrollment,Vehicle/Bus Number,Avtomobil / avtobus raqami
-apps/erpnext/erpnext/schools/doctype/course/course.js +17,Course Schedule,Kurs jadvali
+apps/erpnext/erpnext/education/doctype/course/course.js +17,Course Schedule,Kurs jadvali
 DocType: Request for Quotation Supplier,Quote Status,Iqtibos holati
 DocType: Maintenance Visit,Completion Status,Tugatish holati
 DocType: HR Settings,Enter retirement age in years,Yildan pensiya yoshiga o&#39;ting
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +252,Target Warehouse,Nishon ombori
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +118,Please select a warehouse,"Iltimos, omborni tanlang"
+DocType: Crop,Target Warehouse,Nishon ombori
+DocType: Payroll Employee Detail,Payroll Employee Detail,Bordro bo&#39;yicha mutaxassis batafsil
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128,Please select a warehouse,"Iltimos, omborni tanlang"
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,"Iltimos, Setup&gt; Numbering Series orqali tomosha qilish uchun raqamlar seriyasini sozlang"
 DocType: Cheque Print Template,Starting location from left edge,Manzilni chap tomondan boshlash
 DocType: Item,Allow over delivery or receipt upto this percent,Bu foizga yetkazib berish yoki uni olish haqida ruxsat bering
 DocType: Stock Entry,STE-,STE-
 DocType: Upload Attendance,Import Attendance,Importni davom ettirish
 apps/erpnext/erpnext/public/js/pos/pos.html +113,All Item Groups,Barcha elementlar guruhlari
-DocType: Process Payroll,Activity Log,Faoliyat jurnali
 apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Net Profit / Loss,Net qor / ziyon
 apps/erpnext/erpnext/config/setup.py +89,Automatically compose message on submission of transactions.,Transaktsiyalarni topshirish haqida xabarni avtomatik tuzish.
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +201,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,"Iltimos, {0} uchun nomlash seriyasini Sozlamalar&gt; Sozlamalar&gt; Naming Series orqali sozlang"
 DocType: Production Order,Item To Manufacture,Mahsulot ishlab chiqarish
 apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},{0} {1} holat {2}
+DocType: Water Analysis,Collection Temperature ,To&#39;plamning harorati
 DocType: Employee,Provide Email Address registered in company,Kompaniyada ro&#39;yxatdan o&#39;tgan elektron pochta manzilini taqdim eting
 DocType: Shopping Cart Settings,Enable Checkout,To&#39;lovni yoqish
 apps/erpnext/erpnext/config/learn.py +202,Purchase Order to Payment,To&#39;lovni sotib olish tartibi
 apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,Loyihalangan son
 DocType: Sales Invoice,Payment Due Date,To&#39;lov sanasi
 DocType: Drug Prescription,Interval UOM,Intervalli UOM
-apps/erpnext/erpnext/stock/doctype/item/item.js +363,Item Variant {0} already exists with same attributes,Mavzu Variant {0} allaqachon bir xil atributlarga ega
+apps/erpnext/erpnext/stock/doctype/item/item.js +489,Item Variant {0} already exists with same attributes,Mavzu Variant {0} allaqachon bir xil atributlarga ega
 DocType: Item,Hub Publishing Details,Hub nashriyot tafsilotlari
 apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +115,'Opening',&quot;Ochilish&quot;
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,To Do To Do
 DocType: Notification Control,Delivery Note Message,Yetkazib berish eslatmasi
 DocType: Lab Test Template,Result Format,Natijada formati
 DocType: Expense Claim,Expenses,Xarajatlar
+DocType: Delivery Stop,Delivery Notes,Etkazib berish eslatmalar
 DocType: Item Variant Attribute,Item Variant Attribute,Variant xususiyati
 ,Purchase Receipt Trends,Qabul rejasi xaridlari
-DocType: Process Payroll,Bimonthly,Ikki oyda
+DocType: Payroll Entry,Bimonthly,Ikki oyda
 DocType: Vehicle Service,Brake Pad,Tormoz paneli
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +115,Research & Development,Tadqiqot va Loyihalash
+DocType: Fertilizer,Fertilizer Contents,Go&#39;ng tarkibi
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119,Research & Development,Tadqiqot va Loyihalash
 apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20,Amount to Bill,Bill miqdori
 DocType: Company,Registration Details,Ro&#39;yxatga olish ma&#39;lumotlari
 DocType: Timesheet,Total Billed Amount,To&#39;lov miqdori
@@ -1035,16 +1112,18 @@
 DocType: Sales Team,Incentives,Rag&#39;batlantirish
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +64,Register for Hub,Hub uchun ro&#39;yxatdan o&#39;ting
 DocType: SMS Log,Requested Numbers,Talab qilingan raqamlar
+DocType: Volunteer,Evening,Oqshom
 DocType: Production Planning Tool,Only Obtain Raw Materials,Faqat xom ashyolarni olish
-apps/erpnext/erpnext/config/hr.py +142,Performance appraisal.,Ishlashni baholash.
+DocType: Customer,Bypass credit limit check at Sales Order,Sotish tartibi bo&#39;yicha kredit cheklovlarini tekshirib o&#39;tish
+apps/erpnext/erpnext/config/hr.py +147,Performance appraisal.,Ishlashni baholash.
 apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +97,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart",Xarid qilish vositasi yoqilganligi uchun &quot;Savatga savatni ishlatish&quot; funksiyasini yoqish va savat uchun kamida bitta Soliq qoidasi bo&#39;lishi kerak
-apps/erpnext/erpnext/controllers/accounts_controller.py +347,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","To&#39;lov usuli {0} Buyurtmani {1} buyrug&#39;iga binoan bog&#39;langan, ushbu hisob-fakturada avans sifatida ko&#39;rib chiqilishi kerakligini tekshiring."
+apps/erpnext/erpnext/controllers/accounts_controller.py +391,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","To&#39;lov usuli {0} Buyurtmani {1} buyrug&#39;iga binoan bog&#39;langan, ushbu hisob-fakturada avans sifatida ko&#39;rib chiqilishi kerakligini tekshiring."
 DocType: Sales Invoice Item,Stock Details,Aksiya haqida ma&#39;lumot
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Loyiha qiymati
 apps/erpnext/erpnext/config/selling.py +321,Point-of-Sale,Sotuv nuqtasi
 DocType: Fee Schedule,Fee Creation Status,Narxlarni yaratish holati
 DocType: Vehicle Log,Odometer Reading,Odometr o&#39;qish
-apps/erpnext/erpnext/accounts/doctype/account/account.py +119,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'",Hisob balansida allaqachon Kreditda &#39;Balans Must Be&#39; deb ataladigan &#39;Debit&#39;
+apps/erpnext/erpnext/accounts/doctype/account/account.py +118,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'",Hisob balansida allaqachon Kreditda &#39;Balans Must Be&#39; deb ataladigan &#39;Debit&#39;
 DocType: Account,Balance must be,Balans bo&#39;lishi kerak
 DocType: Hub Settings,Publish Pricing,Raqobatchani chop eting
 DocType: Notification Control,Expense Claim Rejected Message,Daromad da&#39;volari rad etildi
@@ -1053,12 +1132,15 @@
 DocType: Purchase Invoice Item,Rejected Qty,Rad etilgan Qty
 DocType: Setup Progress Action,Action Field,Faoliyat maydoni
 DocType: Healthcare Settings,Manage Customer,Xaridorni boshqaring
+DocType: Delivery Trip,Delivery Stops,Yetkazib berish to&#39;xtaydi
 DocType: Salary Slip,Working Days,Ish kunlari
 DocType: Serial No,Incoming Rate,Kiruvchi foiz
 DocType: Packing Slip,Gross Weight,Brutto vazni
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47,Enable Hub,Uyani yoqish
-apps/erpnext/erpnext/public/js/setup_wizard.js +107,The name of your company for which you are setting up this system.,Ushbu tizimni o&#39;rnatayotgan kompaniyangizning nomi.
+apps/erpnext/erpnext/public/js/setup_wizard.js +110,The name of your company for which you are setting up this system.,Ushbu tizimni o&#39;rnatayotgan kompaniyangizning nomi.
 DocType: HR Settings,Include holidays in Total no. of Working Days,Dam olish kunlari jami no. Ish kunlari
+apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +108,Setup your Institute in ERPNext,Institutni ERP-matnida sozlang
+DocType: Agriculture Analysis Criteria,Plant Analysis,O&#39;simliklar tahlili
 DocType: Job Applicant,Hold,Ushlab turing
 DocType: Employee,Date of Joining,Ishtirok etish sanasi
 DocType: Naming Series,Update Series,Yangilash turkumi
@@ -1066,27 +1148,31 @@
 DocType: Restaurant Table,Minimum Seating,Minimal yashash joyi
 DocType: Item Attribute,Item Attribute Values,Xususiyatning qiymatlari
 DocType: Examination Result,Examination Result,Test natijalari
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +817,Purchase Receipt,Xarid qilish arizasi
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +843,Purchase Receipt,Xarid qilish arizasi
 ,Received Items To Be Billed,Qabul qilinadigan buyumlar
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +173,Submitted Salary Slips,Ish haqi to`plami taqdim etildi
-apps/erpnext/erpnext/config/accounts.py +311,Currency exchange rate master.,Ayirboshlash kursi ustasi.
+apps/erpnext/erpnext/config/accounts.py +303,Currency exchange rate master.,Ayirboshlash kursi ustasi.
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +198,Reference Doctype must be one of {0},Malumot Doctype {0} dan biri bo&#39;lishi kerak
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +302,Unable to find Time Slot in the next {0} days for Operation {1},Operatsion {1} uchun keyingi {0} kunda Time Slotni topib bo&#39;lmadi
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +322,Unable to find Time Slot in the next {0} days for Operation {1},Operatsion {1} uchun keyingi {0} kunda Time Slotni topib bo&#39;lmadi
 DocType: Production Order,Plan material for sub-assemblies,Sub-assemblies uchun rejalashtirilgan material
 apps/erpnext/erpnext/config/selling.py +97,Sales Partners and Territory,Savdo hamkorlari va hududi
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +581,BOM {0} must be active,BOM {0} faol bo&#39;lishi kerak
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +585,BOM {0} must be active,BOM {0} faol bo&#39;lishi kerak
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +221,Closing (Opening + Total),Yakunlovchi (ochilish + jami)
 DocType: Journal Entry,Depreciation Entry,Amortizatsiyani kiritish
 apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +36,Please select the document type first,"Iltimos, avval hujjat turini tanlang"
 apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,Materialni bekor qilish Bu Xizmat tashrifini bekor qilishdan avval {0} tashrif
+DocType: Crop Cycle,ISO 8016 standard,ISO 8016 standarti
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,Serial No {0} does not belong to Item {1},No {0} seriyasi {1} mahsulotiga tegishli emas
 DocType: Purchase Receipt Item Supplied,Required Qty,Kerakli son
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +127,Warehouses with existing transaction can not be converted to ledger.,Mavjud bitimlarga ega bo&#39;lgan omborlar kitobga o&#39;tkazilmaydi.
 DocType: Bank Reconciliation,Total Amount,Umumiy hisob
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +32,Internet Publishing,Internet-nashriyot
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32,Internet Publishing,Internet-nashriyot
 DocType: Prescription Duration,Number,Raqam
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25,Creating {0} Invoice,{0} Billingni yaratish
 DocType: Medical Code,Medical Code Standard,Tibbiyot kodeksi
+DocType: Soil Texture,Clay Composition (%),Gil tarkibi (%)
 DocType: Production Planning Tool,Production Orders,Ishlab chiqarish buyurtmasi
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +62,Balance Value,Balans qiymati
+apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81,Please save before assigning task.,"Iltimos, vazifani tayinlashdan oldin saqlab qo&#39;ying."
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72,Balance Value,Balans qiymati
 DocType: Lab Test,Lab Technician,Laboratoriya bo&#39;yicha mutaxassis
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,Sotuvlar narxlari ro&#39;yxati
 DocType: Healthcare Settings,"If checked, a customer will be created, mapped to Patient.
@@ -1098,31 +1184,33 @@
 DocType: Supplier,Default Payable Accounts,To&#39;lanadigan qarz hisoblari
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49,Employee {0} is not active or does not exist,Xodim {0} faol emas yoki mavjud emas
 DocType: Fee Structure,Components,Komponentlar
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +251,Please enter Asset Category in Item {0},"Iltimos, {0} dagi Asset kategoriyasi kiriting"
-apps/erpnext/erpnext/stock/doctype/item/item.py +653,Item Variants {0} updated,Mavzu Variantlari {0} yangilandi
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +272,Please enter Asset Category in Item {0},"Iltimos, {0} dagi Asset kategoriyasi kiriting"
+apps/erpnext/erpnext/stock/doctype/item/item.py +634,Item Variants {0} updated,Mavzu Variantlari {0} yangilandi
 DocType: Quality Inspection Reading,Reading 6,O&#39;qish 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","ishlab chiqariladi. Kechiktirilsa, siz &quot;Oyning kuni bilan takrorlang&quot; maydonini qo&#39;lda o&#39;zgartiring"
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +919,Cannot {0} {1} {2} without any negative outstanding invoice,{0} {1} {2} hech qanday salbiy taqdim etgan holda taqdim etilmaydi
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +945,Cannot {0} {1} {2} without any negative outstanding invoice,{0} {1} {2} hech qanday salbiy taqdim etgan holda taqdim etilmaydi
 DocType: Purchase Invoice Advance,Purchase Invoice Advance,Xarid-faktura avansini sotib oling
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199,Row {0}: Credit entry can not be linked with a {1},Row {0}: kredit yozuvini {1} bilan bog&#39;lash mumkin emas
-apps/erpnext/erpnext/config/accounts.py +254,Define budget for a financial year.,Moliyaviy yil uchun byudjetni belgilang.
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +197,Row {0}: Credit entry can not be linked with a {1},Row {0}: kredit yozuvini {1} bilan bog&#39;lash mumkin emas
+apps/erpnext/erpnext/config/accounts.py +246,Define budget for a financial year.,Moliyaviy yil uchun byudjetni belgilang.
 DocType: Mode of Payment Account,Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,"Ushbu rejim tanlangach, Standart Bank / Cash hisob qaydnomasi avtomatik ravishda qalin hisob-fakturada yangilanadi."
 DocType: Lead,LEAD-,LEAD-
 DocType: Employee,Permanent Address Is,Doimiy manzil
 DocType: Production Order Operation,Operation completed for how many finished goods?,Xo&#39;sh qancha tayyor mahsulotni ishlab chiqarish tugallandi?
-apps/erpnext/erpnext/public/js/setup_wizard.js +47,The Brand,Tovar
+DocType: Payment Terms Template,Payment Terms Template,To&#39;lov shartlari shablonni
+apps/erpnext/erpnext/public/js/setup_wizard.js +51,The Brand,Tovar
 DocType: Employee,Exit Interview Details,Suhbatlashuv ma&#39;lumotidan chiqish
 DocType: Item,Is Purchase Item,Sotib olish elementi
-DocType: Asset,Purchase Invoice,Xarajatlarni xarid qiling
+DocType: Journal Entry Account,Purchase Invoice,Xarajatlarni xarid qiling
 DocType: Stock Ledger Entry,Voucher Detail No,Voucher batafsil No
-apps/erpnext/erpnext/accounts/page/pos/pos.js +765,New Sales Invoice,Yangi Sotuvdagi Billing
+apps/erpnext/erpnext/accounts/page/pos/pos.js +780,New Sales Invoice,Yangi Sotuvdagi Billing
 DocType: Stock Entry,Total Outgoing Value,Jami chiquvchi qiymat
 DocType: Physician,Appointments,Uchrashuvlar
 apps/erpnext/erpnext/public/js/account_tree_grid.js +224,Opening Date and Closing Date should be within same Fiscal Year,Ochilish sanasi va Yakunlovchi sanasi bir xil Moliya yili ichida bo&#39;lishi kerak
 DocType: Lead,Request for Information,Ma&#39;lumot uchun ma&#39;lumot
 ,LeaderBoard,LeaderBoard
-apps/erpnext/erpnext/accounts/page/pos/pos.js +778,Sync Offline Invoices,Oflayn xaritalarni sinxronlash
+DocType: Sales Invoice Item,Rate With Margin (Company Currency),Ayirboshlash kursi (Kompaniya valyutasi)
+apps/erpnext/erpnext/accounts/page/pos/pos.js +793,Sync Offline Invoices,Oflayn xaritalarni sinxronlash
 DocType: Payment Request,Paid,To&#39;langan
 DocType: Program Fee,Program Fee,Dastur haqi
 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.
@@ -1132,13 +1220,14 @@
 DocType: Guardian,Guardian Name,Guardian nomi
 DocType: Cheque Print Template,Has Print Format,Bosib chiqarish formati mavjud
 DocType: Employee Loan,Sanctioned,Sanktsiya
-apps/erpnext/erpnext/accounts/page/pos/pos.js +73, is mandatory. Maybe Currency Exchange record is not created for ,"majburiydir. Ehtimol, valyuta ayirboshlash yozuvi yaratilmagan bo&#39;lishi mumkin"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +112,Row #{0}: Please specify Serial No for Item {1},"Row # {0}: Iltimos, mahsulot uchun {1}"
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +622,"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.","&quot;Paket ro&#39;yxati&quot; jadvalidan &#39;Mahsulot paketi&#39; elementlari, QXI, seriya raqami va lotin raqami ko&#39;rib chiqilmaydi. Qimmatli qog&#39;ozlar va partiyalar raqami &quot;mahsulot paketi&quot; elementi uchun barcha qadoqlash buyumlari uchun bir xil bo&#39;lsa, ushbu qiymatlar asosiy element jadvaliga kiritilishi mumkin, qadriyatlar &#39;Paket ro&#39;yxati&#39; jadvaliga ko&#39;chiriladi."
-DocType: Job Opening,Publish on website,Saytda e&#39;lon qiling
-apps/erpnext/erpnext/config/stock.py +17,Shipments to customers.,Mijozlarga yuklar.
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +641,Supplier Invoice Date cannot be greater than Posting Date,Yetkazib beruvchi hisob-fakturasi sanasi yuborish kunidan kattaroq bo&#39;lishi mumkin emas
+apps/erpnext/erpnext/accounts/page/pos/pos.js +75, is mandatory. Maybe Currency Exchange record is not created for ,"majburiydir. Ehtimol, valyuta ayirboshlash yozuvi yaratilmagan bo&#39;lishi mumkin"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +117,Row #{0}: Please specify Serial No for Item {1},"Row # {0}: Iltimos, mahsulot uchun {1}"
+DocType: Crop Cycle,Crop Cycle,O&#39;simlik aylanishi
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +632,"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.","&quot;Paket ro&#39;yxati&quot; jadvalidan &#39;Mahsulot paketi&#39; elementlari, QXI, seriya raqami va lotin raqami ko&#39;rib chiqilmaydi. Qimmatli qog&#39;ozlar va partiyalar raqami &quot;mahsulot paketi&quot; elementi uchun barcha qadoqlash buyumlari uchun bir xil bo&#39;lsa, ushbu qiymatlar asosiy element jadvaliga kiritilishi mumkin, qadriyatlar &#39;Paket ro&#39;yxati&#39; jadvaliga ko&#39;chiriladi."
+DocType: Student Admission,Publish on website,Saytda e&#39;lon qiling
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +645,Supplier Invoice Date cannot be greater than Posting Date,Yetkazib beruvchi hisob-fakturasi sanasi yuborish kunidan kattaroq bo&#39;lishi mumkin emas
 DocType: Purchase Invoice Item,Purchase Order Item,Buyurtma Buyurtma Buyurtma
+DocType: Agriculture Task,Agriculture Task,Qishloq xo&#39;jaligi masalalari
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,Indirect Income,Bilvosita daromad
 DocType: Student Attendance Tool,Student Attendance Tool,Isoning shogirdi qatnashish vositasi
 DocType: Restaurant Menu,Price List (Auto created),Narxlar ro&#39;yxati (Avtomatik yaratilgan)
@@ -1146,55 +1235,60 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48,Variance,Varyans
 ,Company Name,kopmaniya nomi
 DocType: SMS Center,Total Message(s),Jami xabar (lar)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +888,Select Item for Transfer,Transfer uchun ob&#39;ektni tanlang
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +913,Select Item for Transfer,Transfer uchun ob&#39;ektni tanlang
 DocType: Purchase Invoice,Additional Discount Percentage,Qo&#39;shimcha imtiyozli foiz
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24,View a list of all the help videos,Barcha yordam videoslarining ro&#39;yxatini ko&#39;ring
+DocType: Agriculture Analysis Criteria,Soil Texture,Tuproq to&#39;qimalari
 DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,Hisobni topshirgan bank boshlig&#39;ini tanlang.
 DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Foydalanuvchilarda narx-navo saviyasini operatsiyalarda o&#39;zgartirishga ruxsat bering
 DocType: Pricing Rule,Max Qty,Maks Qty
 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}: Faktura {1} haqiqiy emas, bekor qilinishi mumkin / mavjud emas. \ Iltimos, to&#39;g&#39;ri hisob-fakturani kiriting"
-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}: Sotuvga / sotib olish buyrug&#39;iga qarshi to&#39;lov har doim oldindan belgilanishi kerak
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +16,Chemical,Kimyoviy
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Row {0}: Sotuvga / sotib olish buyrug&#39;iga qarshi to&#39;lov har doim oldindan belgilanishi kerak
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16,Chemical,Kimyoviy
 DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,"Ushbu rejim tanlangach, odatiy Bank / Cash hisob qaydnomasi avtomatik ravishda ish haqi jurnali kiritilishida yangilanadi."
 DocType: BOM,Raw Material Cost(Company Currency),Xomashyo narxlari (Kompaniya valyutasi)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +732,All items have already been transferred for this Production Order.,Barcha buyumlar allaqachon ushbu ishlab chiqarish tartibi uchun topshirilgan.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +758,All items have already been transferred for this Production Order.,Barcha buyumlar allaqachon ushbu ishlab chiqarish tartibi uchun topshirilgan.
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +87,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Row # {0}: Rate {1} {2} da ishlatiladigan kursdan kattaroq bo&#39;la olmaydi
-apps/erpnext/erpnext/utilities/user_progress.py +126,Meter,Metr
+apps/erpnext/erpnext/utilities/user_progress.py +144,Meter,Metr
 DocType: Workstation,Electricity Cost,Elektr narx
 DocType: HR Settings,Don't send Employee Birthday Reminders,Xodimlarga Tug&#39;ilgan kun eslatmalarini yubormang
+DocType: Expense Claim,Total Advance Amount,Umumiy avans miqdori
+DocType: Delivery Stop,Estimated Arrival,Bashoratli vorisi
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +34,Save Settings,Sozlamalarni saqlash
+DocType: Delivery Stop,Notified by Email,E-pochta orqali xabar berildi
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +683,Requested Products,Talab qilingan mahsulotlar
 DocType: Item,Inspection Criteria,Tekshiruv mezonlari
 apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Transfered,O&#39;tkazildi
 DocType: BOM Website Item,BOM Website Item,BOM veb-sayt elementi
-apps/erpnext/erpnext/public/js/setup_wizard.js +48,Upload your letter head and logo. (you can edit them later).,Sizning xat boshingizni va logotipingizni yuklang. (keyinchalik ularni tahrirlashingiz mumkin).
+apps/erpnext/erpnext/public/js/setup_wizard.js +52,Upload your letter head and logo. (you can edit them later).,Sizning xat boshingizni va logotipingizni yuklang. (keyinchalik ularni tahrirlashingiz mumkin).
 DocType: Timesheet Detail,Bill,Bill
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +85,Next Depreciation Date is entered as past date,Keyingi Amortizatsiya tarixi o&#39;tgan sana sifatida kiritiladi
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +204,White,Oq rang
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +85,Next Depreciation Date is entered as past date,Keyingi Amortizatsiya tarixi o&#39;tgan sana sifatida kiritiladi
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208,White,Oq rang
 DocType: SMS Center,All Lead (Open),Barcha qo&#39;rg&#39;oshin (ochiq)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +231,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Row {0}: ({2} {3}) kirish vaqtida {1} omborida {4} uchun mavjud emas
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +248,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Row {0}: ({2} {3}) kirish vaqtida {1} omborida {4} uchun mavjud emas
 DocType: Purchase Invoice,Get Advances Paid,Avanslarni to&#39;lang
 DocType: Item,Automatically Create New Batch,Avtomatik ravishda yangi guruh yaratish
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +782,Make ,Qilish
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +808,Make ,Qilish
 DocType: Student Admission,Admission Start Date,Qabul boshlash sanasi
 DocType: Journal Entry,Total Amount in Words,So&#39;zlarning umumiy miqdori
+apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29,New Employee,Yangi xodim
 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.,"Xatolik yuz berdi. Buning bir sababi, ariza saqlanmagan bo&#39;lishi mumkin. Muammo davom etsa, iltimos, support@erpnext.com bilan bog&#39;laning."
 apps/erpnext/erpnext/templates/pages/cart.html +5,My Cart,Mening savatim
-apps/erpnext/erpnext/controllers/selling_controller.py +158,Order Type must be one of {0},Buyurtma turi {0} dan biri bo&#39;lishi kerak
+apps/erpnext/erpnext/controllers/selling_controller.py +126,Order Type must be one of {0},Buyurtma turi {0} dan biri bo&#39;lishi kerak
 DocType: Lead,Next Contact Date,Keyingi aloqa kuni
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Opening Qty,Miqdorni ochish
 DocType: Healthcare Settings,Appointment Reminder,Uchrashuv eslatmasi
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +468,Please enter Account for Change Amount,O&#39;zgarish uchun Hisobni kiriting
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +472,Please enter Account for Change Amount,O&#39;zgarish uchun Hisobni kiriting
 DocType: Student Batch Name,Student Batch Name,Isoning shogirdi nomi
 DocType: Consultation,Doctor,Doktor
 DocType: Holiday List,Holiday List Name,Dam olish ro&#39;yxati nomi
 DocType: Repayment Schedule,Balance Loan Amount,Kreditning qoldig&#39;i
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.js +13,Schedule Course,Jadval kursi
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +224,Stock Options,Aksiyadorlik imkoniyatlari
+apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,Jadval kursi
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234,Stock Options,Aksiyadorlik imkoniyatlari
 DocType: Journal Entry Account,Expense Claim,Xarajat shikoyati
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +234,Do you really want to restore this scrapped asset?,"Chindan ham, bu eskirgan obyektni qayta tiklashni xohlaysizmi?"
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +358,Qty for {0},{0} uchun son
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +254,Do you really want to restore this scrapped asset?,"Chindan ham, bu eskirgan obyektni qayta tiklashni xohlaysizmi?"
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +380,Qty for {0},{0} uchun son
 DocType: Leave Application,Leave Application,Ilovani qoldiring
 DocType: Patient,Patient Relation,Kasal munosabatlar
 apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,Tahsis vositasini qoldiring
@@ -1210,18 +1304,22 @@
 apps/erpnext/erpnext/public/js/queries.js +96,Please specify a {0},"Iltimos, {0}"
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +71,Removed items with no change in quantity or value.,Sifat yoki qiymat o&#39;zgarmasdan chiqarilgan elementlar.
 DocType: Delivery Note,Delivery To,Etkazib berish
-apps/erpnext/erpnext/stock/doctype/item/item.py +682,Attribute table is mandatory,Xususiyat jadvali majburiydir
+apps/erpnext/erpnext/stock/doctype/item/item.js +384,Variant creation has been queued.,Variantni yaratish navbatga qo&#39;yildi.
+apps/erpnext/erpnext/stock/doctype/item/item.py +668,Attribute table is mandatory,Xususiyat jadvali majburiydir
 DocType: Production Planning Tool,Get Sales Orders,Savdo buyurtmalarini oling
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +67,{0} can not be negative,{0} salbiy bo&#39;lishi mumkin emas
 DocType: Training Event,Self-Study,O&#39;z-o&#39;zini tadqiq qilish
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +480,Discount,Dasturi
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +537,Discount,Dasturi
+DocType: Membership,Membership,A&#39;zolik
 DocType: Asset,Total Number of Depreciations,Amortismanlarning umumiy soni
 DocType: Sales Invoice Item,Rate With Margin,Marj bilan baholang
 DocType: Workstation,Wages,Ish haqi
-DocType: Task,Urgent,Shoshilinch
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +157,Please specify a valid Row ID for row {0} in table {1},Iltimos {1} jadvalidagi {0} qatoriga tegishli joriy qatorni identifikatorini ko&#39;rsating
+DocType: Asset Maintenance,Maintenance Manager Name,Xizmat menejeri nomi
+DocType: Agriculture Task,Urgent,Shoshilinch
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,Please specify a valid Row ID for row {0} in table {1},Iltimos {1} jadvalidagi {0} qatoriga tegishli joriy qatorni identifikatorini ko&#39;rsating
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84,Unable to find variable: ,Argumentlar topilmadi:
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +664,Please select a field to edit from numpad,"Iltimos, numpad dan tahrir qilish uchun maydonni tanlang"
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +723,Please select a field to edit from numpad,"Iltimos, numpad dan tahrir qilish uchun maydonni tanlang"
+apps/erpnext/erpnext/stock/doctype/item/item.py +253,Cannot be a fixed asset item as Stock Ledger is created.,"Qimmatli qog&#39;ozlar bazasi yaratilganligi sababli, asosiy vosita bo&#39;lishi mumkin emas."
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,Ish stoliga o&#39;ting va ERPNext dasturini ishga tushiring
 DocType: Item,Manufacturer,Ishlab chiqaruvchi
 DocType: Landed Cost Item,Purchase Receipt Item,Qabulnoma nusxasini xarid qiling
@@ -1230,12 +1328,11 @@
 DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Savdo Buyurtma va tugagan tovarlar omborida zaxiralangan ombor
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Selling Amount,Sotish miqdori
 DocType: Repayment Schedule,Interest Amount,Foiz miqdori
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +109,You are the Expense Approver for this record. Please Update the 'Status' and Save,"Siz ushbu yozuv uchun sizning xarajatlaringizni tasdiqlovchisiz. Iltimos, &quot;Status&quot; ni va Saqlash-ni yangilang"
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +120,You are the Expense Approver for this record. Please Update the 'Status' and Save,"Siz ushbu yozuv uchun sizning xarajatlaringizni tasdiqlovchisiz. Iltimos, &quot;Status&quot; ni va Saqlash-ni yangilang"
 DocType: Serial No,Creation Document No,Yaratilish hujjati №
 DocType: Issue,Issue,Nashr
 apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11,Records,Yozuvlar
 DocType: Asset,Scrapped,Chiqindi
-apps/erpnext/erpnext/config/stock.py +200,"Attributes for Item Variants. e.g Size, Color etc.","Variantlar uchun obyektlar. Masalan, hajmi, rangi va boshqalar."
 DocType: Purchase Invoice,Returns,Qaytishlar
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +42,WIP Warehouse,WIP ombori
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195,Serial No {0} is under maintenance contract upto {1},No {0} seriyali parvarish shartnoma bo&#39;yicha {1}
@@ -1244,7 +1341,8 @@
 DocType: Tax Rule,Shipping State,Yuk tashish holati
 ,Projected Quantity as Source,Bashoratli miqdori manba sifatida
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,Item must be added using 'Get Items from Purchase Receipts' button,Buyumni &quot;Xarid qilish arizalaridan olish&quot; tugmachasi yordamida qo&#39;shib qo&#39;yish kerak
-DocType: Employee,A-,A-
+DocType: Delivery Trip,Delivery Trip,Etkazib berish
+DocType: Student,A-,A-
 DocType: Production Planning Tool,Include non-stock items,Qimmatli bo&#39;lmagan narsalarni qo&#39;shish
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Sales Expenses,Savdo xarajatlari
 DocType: Consultation,Diagnosis,Tashxis
@@ -1252,8 +1350,8 @@
 DocType: GL Entry,Against,Qarshi
 DocType: Item,Default Selling Cost Center,Standart sotish narxlari markazi
 DocType: Sales Partner,Implementation Partner,Dasturni amalga oshirish bo&#39;yicha hamkor
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1598,ZIP Code,Pochta indeksi
-apps/erpnext/erpnext/controllers/selling_controller.py +271,Sales Order {0} is {1},Savdo Buyurtma {0} - {1}
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1613,ZIP Code,Pochta indeksi
+apps/erpnext/erpnext/controllers/selling_controller.py +245,Sales Order {0} is {1},Savdo Buyurtma {0} - {1}
 DocType: Opportunity,Contact Info,Aloqa ma&#39;lumotlari
 apps/erpnext/erpnext/config/stock.py +315,Making Stock Entries,Aktsiyalarni kiritish
 DocType: Packing Slip,Net Weight UOM,Og&#39;irligi UOM
@@ -1265,18 +1363,21 @@
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33,End Date can not be less than Start Date,Tugash sanasi Boshlanish sanasidan past bo&#39;lishi mumkin emas
 DocType: Sales Person,Select company name first.,Avval kompaniya nomini tanlang.
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +181,Low to High,Yuqoridan pastga
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +202,Email sent to {0},{0} ga yuborilgan elektron pochta
 apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Ta&#39;minlovchilar tomonidan olingan takliflar.
 apps/erpnext/erpnext/config/manufacturing.py +74,Replace BOM and update latest price in all BOMs,BOMni almashtiring va barcha BOM&#39;lardagi eng so&#39;nggi narxni yangilang
 apps/erpnext/erpnext/controllers/selling_controller.py +24,To {0} | {1} {2},{0} uchun {1} {2}
+DocType: Delivery Trip,Driver Name,Haydovchilar nomi
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,O&#39;rtacha yoshi
-DocType: School Settings,Attendance Freeze Date,Ishtirok etishni to&#39;xtatish sanasi
-apps/erpnext/erpnext/utilities/user_progress.py +89,List a few of your suppliers. They could be organizations or individuals.,Ta&#39;minlovchilaringizning bir qismini ro&#39;yxatlang. Ular tashkilotlar yoki shaxslar bo&#39;lishi mumkin.
+DocType: Education Settings,Attendance Freeze Date,Ishtirok etishni to&#39;xtatish sanasi
+apps/erpnext/erpnext/utilities/user_progress.py +107,List a few of your suppliers. They could be organizations or individuals.,Ta&#39;minlovchilaringizning bir qismini ro&#39;yxatlang. Ular tashkilotlar yoki shaxslar bo&#39;lishi mumkin.
 apps/erpnext/erpnext/templates/pages/home.html +31,View All Products,Barcha mahsulotlari ko&#39;rish
 apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Minimal qo&#39;rg&#39;oshin yoshi (kunlar)
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +57,All BOMs,Barcha BOMlar
 DocType: Patient,Default Currency,Standart valyuta
 DocType: Expense Claim,From Employee,Ishchidan
-apps/erpnext/erpnext/controllers/accounts_controller.py +407,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Ogohlantirish: tizim {1} da {0} uchun pul miqdori nol bo&#39;lgani uchun tizim ortiqcha miqdorda tekshirilmaydi
+DocType: Driver,Cellphone Number,Mobil telefon raqami
+apps/erpnext/erpnext/controllers/accounts_controller.py +451,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Ogohlantirish: tizim {1} da {0} uchun pul miqdori nol bo&#39;lgani uchun tizim ortiqcha miqdorda tekshirilmaydi
 DocType: Journal Entry,Make Difference Entry,Farqlarni kiritish
 DocType: Upload Attendance,Attendance From Date,Sana boshlab ishtirok etish
 DocType: Appraisal Template Goal,Key Performance Area,Asosiy ishlash maydoni
@@ -1285,20 +1386,22 @@
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +229,{0} {1} must be submitted,{0} {1} yuborilishi kerak
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +151,Quantity must be less than or equal to {0},Miqdori {0} dan kam yoki unga teng bo&#39;lishi kerak
 DocType: SMS Center,Total Characters,Jami belgilar
+DocType: Employee Advance,Claimed,Da&#39;vo qilingan
+DocType: Crop,Row Spacing,Qator oralig&#39;i
 apps/erpnext/erpnext/controllers/buying_controller.py +161,Please select BOM in BOM field for Item {0},"Iltimos, {0} uchun BOM maydonida BOM-ni tanlang"
 DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-formasi faktura detallari
 DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,To&#39;lovni tasdiqlash uchun schyot-faktura
 apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +42,Contribution %,Qatnashish%
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +212,"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}","Buyurtma buyurtma qilish sharti bilan sotib olish buyurtmasi bo&#39;yicha == &#39;YES&#39; bo&#39;lsa, u holda Xarid-fakturani yaratishda foydalanuvchi avval {0}"
+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}","Buyurtma buyurtma qilish sharti bilan sotib olish buyurtmasi bo&#39;yicha == &#39;YES&#39; bo&#39;lsa, u holda Xarid-fakturani yaratishda foydalanuvchi avval {0}"
 DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Malumot uchun kompaniya raqamlarini ro&#39;yxatdan o&#39;tkazish. Soliq raqamlari va h.k.
 DocType: Sales Partner,Distributor,Distribyutor
 DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Xarid qilish savatni Yuk tashish qoidalari
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +233,Production Order {0} must be cancelled before cancelling this Sales Order,Ushbu Savdo Buyurtmani bekor qilishdan oldin ishlab chiqarish Buyurtmani {0} bekor qilinishi kerak
-apps/erpnext/erpnext/public/js/controllers/transaction.js +68,Please set 'Apply Additional Discount On',"Iltimos, &quot;Qo&#39;shimcha chegirmalarni yoqish&quot;"
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252,Production Order {0} must be cancelled before cancelling this Sales Order,Ushbu Savdo Buyurtmani bekor qilishdan oldin ishlab chiqarish Buyurtmani {0} bekor qilinishi kerak
+apps/erpnext/erpnext/public/js/controllers/transaction.js +71,Please set 'Apply Additional Discount On',"Iltimos, &quot;Qo&#39;shimcha chegirmalarni yoqish&quot;"
 ,Ordered Items To Be Billed,Buyurtma qilingan narsalar to&#39;lanishi kerak
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46,From Range has to be less than To Range,Qatordan oraliq oralig&#39;idan kam bo&#39;lishi kerak
 DocType: Global Defaults,Global Defaults,Global standartlar
-apps/erpnext/erpnext/projects/doctype/project/project.py +215,Project Collaboration Invitation,Loyiha hamkorlik taklifi
+apps/erpnext/erpnext/projects/doctype/project/project.py +226,Project Collaboration Invitation,Loyiha hamkorlik taklifi
 DocType: Salary Slip,Deductions,Tahlikalar
 DocType: Leave Allocation,LAL/,LAL /
 DocType: Setup Progress Action,Action Name,Ro&#39;yxatdan o&#39;tish nomi
@@ -1306,48 +1409,51 @@
 apps/erpnext/erpnext/regional/india/utils.py +24,First 2 digits of GSTIN should match with State number {0},GSTINning birinchi 2 ta raqami {0}
 DocType: Purchase Invoice,Start date of current invoice's period,Joriy hisob-kitob davri boshlanish sanasi
 DocType: Salary Slip,Leave Without Pay,To&#39;lovsiz qoldiring
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +346,Capacity Planning Error,Imkoniyatlarni rejalashtirish xatosi
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +366,Capacity Planning Error,Imkoniyatlarni rejalashtirish xatosi
 ,Trial Balance for Party,Tomonlar uchun sinov balansi
 DocType: Lead,Consultant,Konsultant
 DocType: Salary Slip,Earnings,Daromadlar
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +391,Finished Item {0} must be entered for Manufacture type entry,Ishlab chiqarish turi uchun {0} tugagan elementni kiritish kerak
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +416,Finished Item {0} must be entered for Manufacture type entry,Ishlab chiqarish turi uchun {0} tugagan elementni kiritish kerak
 apps/erpnext/erpnext/config/learn.py +87,Opening Accounting Balance,Buxgalteriya balansini ochish
 ,GST Sales Register,GST Sotuvdagi Ro&#39;yxatdan
 DocType: Sales Invoice Advance,Sales Invoice Advance,Sotuvdagi schyot-faktura Advance
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550,Nothing to request,So&#39;raladigan hech narsa yo&#39;q
+apps/erpnext/erpnext/public/js/setup_wizard.js +18,Select your Domains,Domenlaringizni tanlang
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34,Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3},Moliyaviy yil uchun {1} &quot;{2}&quot; ga qarshi &quot;{0}&quot; yana bir byudjet rekordi {3}
+DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Maydonlar faqat yaratilish vaqtida nusxalanadi.
 apps/erpnext/erpnext/projects/doctype/task/task.py +41,'Actual Start Date' can not be greater than 'Actual End Date',&quot;Haqiqiy boshlanish sanasi&quot; &quot;haqiqiy tugatish sanasi&quot; dan katta bo&#39;lishi mumkin emas
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +113,Management,Boshqarish
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117,Management,Boshqarish
 DocType: Cheque Print Template,Payer Settings,To&#39;lovchining sozlamalari
 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""","Bunga Variantning Mahsulot kodiga qo&#39;shiladi. Misol uchun, qisqartma &quot;SM&quot; bo&#39;lsa va element kodi &quot;T-SHIRT&quot; bo&#39;lsa, variantning element kodi &quot;T-SHIRT-SM&quot;"
 DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,"Ish haqi miqdorini saqlaganingizdan so&#39;ng, aniq to&#39;lov (so&#39;zlar bilan) ko&#39;rinadi."
 DocType: Purchase Invoice,Is Return,Qaytish
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +80,Caution,E&#39;tibor bering
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +787,Return / Debit Note,Qaytaring / Debet Eslatma
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +81,Caution,E&#39;tibor bering
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +813,Return / Debit Note,Qaytaring / Debet Eslatma
 DocType: Price List Country,Price List Country,Narxlar ro&#39;yxati
 DocType: Item,UOMs,UOMlar
-apps/erpnext/erpnext/stock/utils.py +205,{0} valid serial nos for Item {1},{1} uchun {0} joriy ketma-ket nos
+apps/erpnext/erpnext/stock/utils.py +210,{0} valid serial nos for Item {1},{1} uchun {0} joriy ketma-ket nos
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57,Item Code cannot be changed for Serial No.,Mahsulot kodini ketma-ket kod uchun o&#39;zgartirish mumkin emas.
-DocType: Sales Invoice Item,UOM Conversion Factor,UOM ishlab chiqarish omili
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +23,Please enter Item Code to get Batch Number,Partiya raqami olish uchun mahsulot kodini kiriting
+DocType: Purchase Invoice Item,UOM Conversion Factor,UOM ishlab chiqarish omili
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40,Please enter Item Code to get Batch Number,Partiya raqami olish uchun mahsulot kodini kiriting
 DocType: Stock Settings,Default Item Group,Standart element guruhi
 DocType: Employee Loan,Partially Disbursed,Qisman to&#39;langan
+apps/erpnext/erpnext/config/non_profit.py +73,Grant information.,Grant haqida ma&#39;lumot.
 apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Yetkazib beruvchi ma&#39;lumotlar bazasi.
 DocType: Account,Balance Sheet,Balanslar varaqasi
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +701,Cost Center For Item with Item Code ',Xarajat markazi Mahsulot kodi bo&#39;lgan mahsulot uchun &#39;
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +748,Cost Center For Item with Item Code ',Xarajat markazi Mahsulot kodi bo&#39;lgan mahsulot uchun &#39;
 DocType: Fee Validity,Valid Till,Tilligacha amal qiling
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2454,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.",To&#39;lov tartibi sozlanmagan. Hisobni to&#39;lov usulida yoki Qalin profilda o&#39;rnatganligini tekshiring.
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2473,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.",To&#39;lov tartibi sozlanmagan. Hisobni to&#39;lov usulida yoki Qalin profilda o&#39;rnatganligini tekshiring.
 apps/erpnext/erpnext/buying/utils.py +74,Same item cannot be entered multiple times.,Xuddi shu element bir necha marta kiritilmaydi.
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28,"Further accounts can be made under Groups, but entries can be made against non-Groups","Boshqa hisoblar Guruhlar ostida amalga oshirilishi mumkin, lekin guruhlar bo&#39;lmagan guruhlarga qarshi yozuvlar kiritilishi mumkin"
+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","Boshqa hisoblar Guruhlar ostida amalga oshirilishi mumkin, lekin guruhlar bo&#39;lmagan guruhlarga qarshi yozuvlar kiritilishi mumkin"
 DocType: Lead,Lead,Qo&#39;rg&#39;oshin
 DocType: Email Digest,Payables,Qarzlar
 DocType: Course,Course Intro,Kursni tanishtir
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,"Iltimos, Setup&gt; Numbering Series orqali tomosha qilish uchun raqamlar seriyasini sozlang"
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +90,Stock Entry {0} created,Stock Entry {0} yaratildi
-apps/erpnext/erpnext/controllers/buying_controller.py +297,Row #{0}: Rejected Qty can not be entered in Purchase Return,# {0} qatori: Rad etilgan Qty Xarid qilishni qaytarib bo&#39;lmaydi
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +97,Stock Entry {0} created,Stock Entry {0} yaratildi
+apps/erpnext/erpnext/controllers/buying_controller.py +298,Row #{0}: Rejected Qty can not be entered in Purchase Return,# {0} qatori: Rad etilgan Qty Xarid qilishni qaytarib bo&#39;lmaydi
 ,Purchase Order Items To Be Billed,Buyurtma buyurtmalarini sotib olish uchun to&#39;lovlar
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +45,Updating estimated arrival times.,Bashoratli borar vaqtlarini yangilash.
 DocType: Purchase Invoice Item,Net Rate,Sof kurs
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +151,Please select a customer,"Iltimos, mijozni tanlang"
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +147,Please select a customer,"Iltimos, mijozni tanlang"
 DocType: Purchase Invoice Item,Purchase Invoice Item,Xarajatlarni taqdim etish elementi
 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,Qimmatli qog&#39;ozlar bilan bog&#39;liq yozuvlar va GL yozuvlari tanlangan xarid q&#39;abolari uchun qayta joylashtiriladi
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,1-band
@@ -1360,28 +1466,31 @@
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Buyurtma soni
 DocType: Global Defaults,Current Fiscal Year,Joriy moliya yili
 DocType: Purchase Order,Group same items,Guruhlarga bir xil narsalar
-DocType: Global Defaults,Disable Rounded Total,Rounded Totalni o&#39;chirib qo&#39;yish
+DocType: Purchase Invoice,Disable Rounded Total,Rounded Totalni o&#39;chirib qo&#39;yish
 DocType: Employee Loan Application,Repayment Info,To&#39;lov ma&#39;lumoti
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448,'Entries' cannot be empty,&quot;Yozuvlar&quot; bo&#39;sh bo&#39;lishi mumkin emas
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +446,'Entries' cannot be empty,&quot;Yozuvlar&quot; bo&#39;sh bo&#39;lishi mumkin emas
+DocType: Maintenance Team Member,Maintenance Role,Xizmat roli
 apps/erpnext/erpnext/utilities/transaction_base.py +81,Duplicate row {0} with same {1},Shu {1} bilan {0} qatorini nusxalash
 ,Trial Balance,Sinov balansi
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +449,Fiscal Year {0} not found,Moliyaviy yil {0} topilmadi
-apps/erpnext/erpnext/config/hr.py +300,Setting up Employees,Xodimlarni o&#39;rnatish
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +438,Fiscal Year {0} not found,Moliyaviy yil {0} topilmadi
+apps/erpnext/erpnext/config/hr.py +305,Setting up Employees,Xodimlarni o&#39;rnatish
 DocType: Sales Order,SO-,SO-
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +153,Please select prefix first,"Iltimos, avval prefiksni tanlang"
-DocType: Employee,O-,O-
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +185,Research,Tadqiqot
+DocType: Student,O-,O-
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189,Research,Tadqiqot
 DocType: Maintenance Visit Purpose,Work Done,Ish tugadi
 apps/erpnext/erpnext/controllers/item_variant.py +33,Please specify at least one attribute in the Attributes table,"Iltimos, atributlar jadvalidagi kamida bitta xususiyatni ko&#39;rsating"
 DocType: Announcement,All Students,Barcha talabalar
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +45,Item {0} must be a non-stock item,{0} elementi qimmatli bo&#39;lmagan mahsulot bo&#39;lishi kerak
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +45,Item {0} must be a non-stock item,{0} elementi qimmatli bo&#39;lmagan mahsulot bo&#39;lishi kerak
 apps/erpnext/erpnext/stock/doctype/batch/batch.js +18,View Ledger,Ledger-ni ko&#39;rib chiqing
 DocType: Grading Scale,Intervals,Intervallar
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Eng qadimgi
-apps/erpnext/erpnext/stock/doctype/item/item.py +519,"An Item Group exists with same name, please change the item name or rename the item group","Mavzu guruhi bir xil nom bilan mavjud bo&#39;lib, element nomini o&#39;zgartiring yoki element guruhini o&#39;zgartiring"
-apps/erpnext/erpnext/schools/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Talabalar uchun mobil telefon raqami
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +367,Rest Of The World,Dunyoning qolgan qismi
+apps/erpnext/erpnext/stock/doctype/item/item.py +500,"An Item Group exists with same name, please change the item name or rename the item group","Mavzu guruhi bir xil nom bilan mavjud bo&#39;lib, element nomini o&#39;zgartiring yoki element guruhini o&#39;zgartiring"
+DocType: Crop Cycle,Less than a year,Bir yildan kamroq
+apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Talabalar uchun mobil telefon raqami
+apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +105,Rest Of The World,Dunyoning qolgan qismi
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,The Item {0} cannot have Batch,{0} bandda partiyalar mavjud emas
+DocType: Crop,Yield UOM,Hosildorlik
 ,Budget Variance Report,Byudjet o&#39;zgaruvchilari hisoboti
 DocType: Salary Slip,Gross Pay,Brüt to&#39;lov
 DocType: Item,Is Item from Hub,Uyadan uydir
@@ -1400,7 +1509,6 @@
 DocType: Student,STUD.,STUD.
 DocType: Production Order,Qty To Manufacture,Ishlab chiqarish uchun miqdori
 DocType: Email Digest,New Income,Yangi daromad
-DocType: School Settings,School Settings,Maktab sozlamalari
 DocType: Buying Settings,Maintain same rate throughout purchase cycle,Xarid qilish davrida bir xil tezlikni saqlang
 DocType: Opportunity Item,Opportunity Item,Imkoniyat elementi
 ,Student and Guardian Contact Details,Isoning shogirdi va Guardian bilan aloqa ma&#39;lumotlarini
@@ -1412,24 +1520,25 @@
 DocType: Patient Appointment,More Info,Qo&#39;shimcha ma&#39;lumot
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +178,Valuation Rate required for Item in row {0},{0} qatoridagi element uchun baholanish darajasi
 DocType: Supplier Scorecard,Scorecard Actions,Scorecard faoliyati
-apps/erpnext/erpnext/utilities/user_progress.py +148,Example: Masters in Computer Science,Misol: Kompyuter fanlari magistri
+apps/erpnext/erpnext/utilities/user_progress.py +166,Example: Masters in Computer Science,Misol: Kompyuter fanlari magistri
 DocType: Purchase Invoice,Rejected Warehouse,Rad etilgan ombor
 DocType: GL Entry,Against Voucher,Voucherga qarshi
 DocType: Item,Default Buying Cost Center,Standart xarid maskani markazi
 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.","ERPNext-dan eng yaxshisini olish uchun, sizga biroz vaqt ajratib, ushbu yordam videoslarini tomosha qilishingizni tavsiya qilamiz."
-apps/erpnext/erpnext/accounts/page/pos/pos.js +74, to ,uchun
+apps/erpnext/erpnext/accounts/page/pos/pos.js +76, to ,uchun
 DocType: Supplier Quotation Item,Lead Time in days,Bir necha kun ichida yetkazish vaqti
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +58,Accounts Payable Summary,To&#39;lanadigan qarz hisoboti
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +337,Payment of salary from {0} to {1},{0} dan {1} ga qadar ish haqini to&#39;lash
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +321,Payment of salary from {0} to {1},{0} dan {1} ga qadar ish haqini to&#39;lash
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213,Not authorized to edit frozen Account {0},Muzlatilgan hisobni tahrirlash uchun vakolatli emas {0}
 DocType: Journal Entry,Get Outstanding Invoices,Katta foyda olish
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +70,Sales Order {0} is not valid,Savdo Buyurtmani {0} haqiqiy emas
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +84,Sales Order {0} is not valid,Savdo Buyurtmani {0} haqiqiy emas
 DocType: Supplier Scorecard,Warn for new Request for Quotations,Takliflar uchun yangi so&#39;rov uchun ogohlantir
 apps/erpnext/erpnext/utilities/activation.py +91,Purchase orders help you plan and follow up on your purchases,Xarid qilish buyurtmalari xaridlarni rejalashtirish va kuzatib borishingizga yordam beradi
-apps/erpnext/erpnext/setup/doctype/company/company.py +218,"Sorry, companies cannot be merged","Kechirasiz, kompaniyalar birlashtirilmaydi"
+apps/erpnext/erpnext/setup/doctype/company/company.py +215,"Sorry, companies cannot be merged","Kechirasiz, kompaniyalar birlashtirilmaydi"
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151,Lab Test Prescriptions,Laboratoriya testlari retseptlari
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +193,Small,Kichik
-DocType: Employee,Employee Number,Xodimlarning soni
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197,Small,Kichik
+DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Billingni yaratish vositasi elementini ochish
+DocType: Education Settings,Employee Number,Xodimlarning soni
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67,Case No(s) already in use. Try from Case No {0},Hech qanday holatlar mavjud emas. Hech qanday {0}
 DocType: Project,% Completed,% Bajarildi
 ,Invoiced Amount (Exculsive Tax),Xarajatlar miqdori (ortiqcha soliqlar)
@@ -1439,17 +1548,20 @@
 DocType: Item,Auto re-order,Avtomatik buyurtma
 apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Achieved,Jami erishildi
 DocType: Employee,Place of Issue,Kim tomonidan berilgan
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +97,Contract,Shartnoma
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101,Contract,Shartnoma
+DocType: Plant Analysis,Laboratory Testing Datetime,Laboratoriya sinovlari Datetime
 DocType: Email Digest,Add Quote,Iqtibos qo&#39;shish
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +869,UOM coversion factor required for UOM: {0} in Item: {1},UOM uchun UOM koversion faktorlari talab qilinadi: {0}: {1}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +932,UOM coversion factor required for UOM: {0} in Item: {1},UOM uchun UOM koversion faktorlari talab qilinadi: {0}: {1}
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92,Indirect Expenses,Bilvosita xarajatlar
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +83,Row {0}: Qty is mandatory,Row {0}: Miqdor majburiydir
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +8,Agriculture,Qishloq xo&#39;jaligi
-apps/erpnext/erpnext/accounts/page/pos/pos.js +770,Sync Master Data,Master ma&#39;lumotlarini sinxronlash
-apps/erpnext/erpnext/utilities/user_progress.py +117,Your Products or Services,Sizning Mahsulotlaringiz yoki Xizmatlaringiz
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +88,Row {0}: Qty is mandatory,Row {0}: Miqdor majburiydir
+DocType: Agriculture Analysis Criteria,Agriculture,Qishloq xo&#39;jaligi
+apps/erpnext/erpnext/accounts/page/pos/pos.js +785,Sync Master Data,Master ma&#39;lumotlarini sinxronlash
+DocType: Asset Repair,Repair Cost,Ta&#39;mirlash qiymati
+apps/erpnext/erpnext/utilities/user_progress.py +135,Your Products or Services,Sizning Mahsulotlaringiz yoki Xizmatlaringiz
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15,Failed to login,Kirish amalga oshmadi
 DocType: Special Test Items,Special Test Items,Maxsus test buyumlari
 DocType: Mode of Payment,Mode of Payment,To&#39;lov tartibi
-apps/erpnext/erpnext/stock/doctype/item/item.py +190,Website Image should be a public file or website URL,Veb-sayt rasmiy umumiy fayl yoki veb-sayt URL bo&#39;lishi kerak
+apps/erpnext/erpnext/stock/doctype/item/item.py +192,Website Image should be a public file or website URL,Veb-sayt rasmiy umumiy fayl yoki veb-sayt URL bo&#39;lishi kerak
 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.,Bu ildiz elementlar guruhidir va tahrirlanmaydi.
@@ -1457,49 +1569,52 @@
 DocType: Vehicle,Fuel UOM,Yoqilg&#39;i UOM
 DocType: Warehouse,Warehouse Contact Info,Qoidalarga oid aloqa ma&#39;lumotlari
 DocType: Payment Entry,Write Off Difference Amount,Foiz miqdorini yozing
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +415,"{0}: Employee email not found, hence email not sent","{0}: Xodimlarning elektron pochta manzili topilmadi, shuning uchun elektron pochta orqali yuborilmadi"
+DocType: Volunteer,Volunteer Name,Ko&#39;ngilli ism
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +434,"{0}: Employee email not found, hence email not sent","{0}: Xodimlarning elektron pochta manzili topilmadi, shuning uchun elektron pochta orqali yuborilmadi"
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85,Shipping rule not applicable for country {0},{0} mamlakat uchun yuk qoidalari qo&#39;llanilmaydi
 DocType: Item,Foreign Trade Details,Tashqi savdo tafsilotlari
 ,Assessment Plan Status,Baholash rejasining holati
 DocType: Email Digest,Annual Income,Yillik daromad
 DocType: Serial No,Serial No Details,Seriya No Details
 DocType: Purchase Invoice Item,Item Tax Rate,Soliq to&#39;lovi stavkasi
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +67,Please select Physician and Date,"Iltimos, shifokor va Sana-ni tanlang"
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +75,Please select Physician and Date,"Iltimos, shifokor va Sana-ni tanlang"
 DocType: Student Group Student,Group Roll Number,Guruh Rulksi raqami
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145,"For {0}, only credit accounts can be linked against another debit entry",{0} uchun faqat kredit hisoblari boshqa to&#39;lov usullariga bog&#39;liq bo&#39;lishi mumkin
-apps/erpnext/erpnext/projects/doctype/project/project.py +78,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,"Barcha topshiriqlarning umumiy og&#39;irligi 1 bo&#39;lishi kerak. Iltimos, barcha loyiha vazifalarining vaznini mos ravishda moslang"
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +578,Delivery Note {0} is not submitted,Yetkazib berish eslatmasi {0} yuborilmadi
-apps/erpnext/erpnext/stock/get_item_details.py +151,Item {0} must be a Sub-contracted Item,{0} mahsuloti sub-shartnoma qo&#39;yilgan bo&#39;lishi kerak
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +143,"For {0}, only credit accounts can be linked against another debit entry",{0} uchun faqat kredit hisoblari boshqa to&#39;lov usullariga bog&#39;liq bo&#39;lishi mumkin
+apps/erpnext/erpnext/projects/doctype/project/project.py +80,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,"Barcha topshiriqlarning umumiy og&#39;irligi 1 bo&#39;lishi kerak. Iltimos, barcha loyiha vazifalarining vaznini mos ravishda moslang"
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +582,Delivery Note {0} is not submitted,Yetkazib berish eslatmasi {0} yuborilmadi
+apps/erpnext/erpnext/stock/get_item_details.py +146,Item {0} must be a Sub-contracted Item,{0} mahsuloti sub-shartnoma qo&#39;yilgan bo&#39;lishi kerak
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43,Capital Equipments,Kapital uskunalar
 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.","Raqobatchilarimiz qoidasi &quot;Apply O&#39;n&quot; maydoniga asoslanib tanlangan, bular Item, Item Group yoki Tovar bo&#39;lishi mumkin."
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +223,Please set the Item Code first,Avval Mahsulot kodini o&#39;rnating
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +245,Please set the Item Code first,Avval Mahsulot kodini o&#39;rnating
 DocType: Item,ITEM-,ITEM-
-apps/erpnext/erpnext/controllers/selling_controller.py +151,Total allocated percentage for sales team should be 100,Savdo jamoasi uchun jami ajratilgan foiz 100 bo&#39;lishi kerak
+apps/erpnext/erpnext/controllers/selling_controller.py +119,Total allocated percentage for sales team should be 100,Savdo jamoasi uchun jami ajratilgan foiz 100 bo&#39;lishi kerak
 DocType: Sales Invoice Item,Edit Description,Tartibga solish tavsifi
 DocType: Antibiotic,Antibiotic,Antibiotik
 ,Team Updates,Jamoa yangiliklari
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +885,For Supplier,Yetkazib beruvchiga
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +910,For Supplier,Yetkazib beruvchiga
 DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Hisobni sozlashni sozlash operatsiyalarda ushbu hisobni tanlashda yordam beradi.
 DocType: Purchase Invoice,Grand Total (Company Currency),Grand Total (Kompaniya valyutasi)
 apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Create Print Format,Chop etish formatini yaratish
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule_list.js +5,Fee Created,Ish haqi yaratildi
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5,Fee Created,Ish haqi yaratildi
 apps/erpnext/erpnext/utilities/bot.py +39,Did not find any item called {0},{0} nomli biron-bir element topilmadi
 DocType: Supplier Scorecard Criteria,Criteria Formula,Mezon formulasi
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Total Outgoing,Jami chiqish
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +47,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""",Faqatgina &quot;qiymat&quot; qiymati uchun 0 yoki bo&#39;sh qiymat bilan bitta &quot;Yuk tashish qoidasi&quot; sharti bo&#39;lishi mumkin.
+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""",Faqatgina &quot;qiymat&quot; qiymati uchun 0 yoki bo&#39;sh qiymat bilan bitta &quot;Yuk tashish qoidasi&quot; sharti bo&#39;lishi mumkin.
 DocType: Authorization Rule,Transaction,Jurnal
 DocType: Patient Appointment,Duration,Muddati
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Eslatma: Ushbu xarajatlar markazi - bu guruh. Guruhlarga nisbatan buxgalteriya yozuvlarini kiritib bo&#39;lmaydi.
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +54,Child warehouse exists for this warehouse. You can not delete this warehouse.,Ushbu ombor uchun bolalar ombori mavjud. Ushbu omborni o&#39;chira olmaysiz.
 DocType: Item,Website Item Groups,Veb-sayt elementlari guruhlari
 DocType: Purchase Invoice,Total (Company Currency),Jami (Kompaniya valyutasi)
-apps/erpnext/erpnext/stock/utils.py +200,Serial number {0} entered more than once,Seriya raqami {0} bir necha marta kiritilgan
-DocType: Depreciation Schedule,Journal Entry,Jurnalga kirish
+apps/erpnext/erpnext/stock/utils.py +205,Serial number {0} entered more than once,Seriya raqami {0} bir necha marta kiritilgan
+DocType: Journal Entry,Journal Entry,Jurnalga kirish
+DocType: Expense Claim Advance,Unclaimed amount,Talab qilinmagan miqdor
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +148,{0} items in progress,Joriy {0} ta element
 DocType: Workstation,Workstation Name,Ish stantsiyasining nomi
 DocType: Grading Scale Interval,Grade Code,Sinf kodi
 DocType: POS Item Group,POS Item Group,Qalin modda guruhi
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17,Email Digest:,E-pochtasi:
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +587,BOM {0} does not belong to Item {1},BOM {0} {1} mahsulotiga tegishli emas
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +591,BOM {0} does not belong to Item {1},BOM {0} {1} mahsulotiga tegishli emas
 DocType: Sales Partner,Target Distribution,Nishon tarqatish
 DocType: Salary Slip,Bank Account No.,Bank hisob raqami
 DocType: Naming Series,This is the number of the last created transaction with this prefix,"Bu, bu old qo&#39;shimchadagi oxirgi yaratilgan bitimning sonidir"
@@ -1514,11 +1629,11 @@
 DocType: BOM Operation,Workstation,Ish stantsiyani
 DocType: Request for Quotation Supplier,Request for Quotation Supplier,Buyurtma beruvchi etkazib beruvchisi
 DocType: Healthcare Settings,Registration Message,Ro&#39;yxatdan o&#39;tish xabar
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +150,Hardware,Uskuna
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154,Hardware,Uskuna
 DocType: Prescription Dosage,Prescription Dosage,Reçetesiz dozaj
 DocType: Attendance,HR Manager,Kadrlar bo&#39;yicha menejer
-apps/erpnext/erpnext/accounts/party.py +177,Please select a Company,"Iltimos, kompaniyani tanlang"
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +88,Privilege Leave,Privilege Leave
+apps/erpnext/erpnext/accounts/party.py +178,Please select a Company,"Iltimos, kompaniyani tanlang"
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92,Privilege Leave,Privilege Leave
 DocType: Purchase Invoice,Supplier Invoice Date,Yetkazib beruvchi hisob-fakturasi sanasi
 apps/erpnext/erpnext/templates/includes/product_page.js +18,per,boshiga
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90,You need to enable Shopping Cart,Savatga savatni faollashtirishingiz kerak
@@ -1530,14 +1645,14 @@
 ,BOM Browser,BOM brauzeri
 apps/erpnext/erpnext/templates/emails/training_event.html +13,Please update your status for this training event,"Iltimos, ushbu mashg&#39;ulot uchun statusingizni yangilang"
 DocType: Purchase Taxes and Charges,Add or Deduct,Qo&#39;shish yoki cheklash
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +82,Overlapping conditions found between:,Quyidagilar orasida o&#39;zaro kelishilgan shartlar:
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148,Overlapping conditions found between:,Quyidagilar orasida o&#39;zaro kelishilgan shartlar:
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187,Against Journal Entry {0} is already adjusted against some other voucher,Journal Entryga qarshi {0} da allaqachon boshqa bir kvotaga nisbatan o&#39;rnatilgan
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68,Total Order Value,Umumiy Buyurtma qiymati
 apps/erpnext/erpnext/demo/setup/setup_data.py +328,Food,Ovqat
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +51,Ageing Range 3,Qarish oralig&#39;i 3
 DocType: Maintenance Schedule Item,No of Visits,Tashriflar soni
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +118,Do you want to publish your Items to Hub ?,Ma&#39;lumotlaringiz uyasiga nashr qilmoqchimisiz?
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +36,Enrolling student,Talabgorni ro&#39;yxatga olish
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36,Enrolling student,Talabgorni ro&#39;yxatga olish
 apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33,Currency of the Closing Account must be {0},Yakuniy hisob raqamining valyutasi {0} bo&#39;lishi kerak
 apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},Barcha maqsadlar uchun ball yig&#39;indisi 100 bo&#39;lishi kerak. Bu {0}
 DocType: Project,Start and End Dates,Boshlanish va tugash sanalari
@@ -1549,7 +1664,7 @@
 DocType: Rename Tool,Utilities,Kommunal xizmatlar
 DocType: POS Profile,Accounting,Hisob-kitob
 DocType: Employee,EMP/,EMP /
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +123,Please select batches for batched item ,"Iltimos, yig&#39;ilgan element uchun partiyalarni tanlang"
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133,Please select batches for batched item ,"Iltimos, yig&#39;ilgan element uchun partiyalarni tanlang"
 DocType: Asset,Depreciation Schedules,Amortizatsiya jadvallari
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +89,Application period cannot be outside leave allocation period,Ariza soatlari tashqaridan ajratilgan muddatning tashqarisida bo&#39;lishi mumkin emas
 DocType: Activity Cost,Projects,Loyihalar
@@ -1562,7 +1677,7 @@
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,Avg Daily Outgoing
 DocType: POS Profile,Campaign,Kampaniya
 DocType: Supplier,Name and Type,Ismi va turi
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +64,Approval Status must be 'Approved' or 'Rejected',Tasdiqlash maqomi &quot;Tasdiqlangan&quot; yoki &quot;Rad etilgan&quot; bo&#39;lishi kerak
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +66,Approval Status must be 'Approved' or 'Rejected',Tasdiqlash maqomi &quot;Tasdiqlangan&quot; yoki &quot;Rad etilgan&quot; bo&#39;lishi kerak
 DocType: Physician,Contacts and Address,Kontaktlar va manzil
 DocType: Purchase Invoice,Contact Person,Bog&#39;lanish uchun shahs
 apps/erpnext/erpnext/projects/doctype/task/task.py +38,'Expected Start Date' can not be greater than 'Expected End Date',&quot;Bashoratli boshlanish sanasi&quot; kutilgan &quot;tugash sanasi&quot; dan kattaroq bo&#39;la olmaydi
@@ -1570,14 +1685,15 @@
 DocType: Holiday List,Holidays,Bayramlar
 DocType: Sales Order Item,Planned Quantity,Rejalashtirilgan miqdori
 DocType: Purchase Invoice Item,Item Tax Amount,Soliq summasi summasi
+DocType: Water Analysis,Water Analysis Criteria,Suv tahlil mezonlari
 DocType: Item,Maintain Stock,Qimmatli qog&#39;ozlar bozori
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +212,Stock Entries already created for Production Order ,Ishlab chiqarish tartibi uchun yaratilgan aktsiyalar
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +217,Stock Entries already created for Production Order ,Ishlab chiqarish tartibi uchun yaratilgan aktsiyalar
 DocType: Employee,Prefered Email,Tanlangan elektron pochta
 DocType: Student Admission,Eligibility and Details,Imtiyoz va tafsilotlar
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +33,Net Change in Fixed Asset,Ruxsat etilgan aktivlardagi aniq o&#39;zgarish
 DocType: Leave Control Panel,Leave blank if considered for all designations,Barcha belgilar uchun hisobga olingan holda bo&#39;sh qoldiring
-apps/erpnext/erpnext/controllers/accounts_controller.py +663,Charge of type 'Actual' in row {0} cannot be included in Item Rate,{0} qatoridagi &quot;Haqiqiy&quot; turidagi to&#39;lovni &quot;Oddiy qiymat&quot; ga qo&#39;shish mumkin emas
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +359,Max: {0},Maks: {0}
+apps/erpnext/erpnext/controllers/accounts_controller.py +775,Charge of type 'Actual' in row {0} cannot be included in Item Rate,{0} qatoridagi &quot;Haqiqiy&quot; turidagi to&#39;lovni &quot;Oddiy qiymat&quot; ga qo&#39;shish mumkin emas
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +381,Max: {0},Maks: {0}
 apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,Datetime&#39;dan
 DocType: Email Digest,For Company,Kompaniya uchun
 apps/erpnext/erpnext/config/support.py +17,Communication log.,Aloqa yozuvi.
@@ -1586,18 +1702,19 @@
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +73,Buying Amount,Xarid qilish miqdori
 DocType: Sales Invoice,Shipping Address Name,Yuk tashish manzili nomi
 DocType: Material Request,Terms and Conditions Content,Shartlar va shartlar tarkibi
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +555,cannot be greater than 100,100 dan ortiq bo&#39;lishi mumkin emas
-apps/erpnext/erpnext/stock/doctype/item/item.py +734,Item {0} is not a stock Item,{0} elementi aktsiyalar elementi emas
+apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18,There were errors creating Course Schedule,Dars jadvali yaratishda xatolar yuz berdi
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +580,cannot be greater than 100,100 dan ortiq bo&#39;lishi mumkin emas
+apps/erpnext/erpnext/stock/doctype/item/item.py +720,Item {0} is not a stock Item,{0} elementi aktsiyalar elementi emas
 DocType: Maintenance Visit,Unscheduled,Rejalashtirilmagan
 DocType: Employee,Owned,Egasi
 DocType: Salary Detail,Depends on Leave Without Pay,Pulsiz qoldiring
 DocType: Pricing Rule,"Higher the number, higher the priority","Raqamni ko&#39;paytirish, ustunlikning ustunligi"
 ,Purchase Invoice Trends,Billing yo&#39;nalishlarini xarid qiling
 DocType: Employee,Better Prospects,Yaxshi istiqbolga ega
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +115,"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","# {0} qatori: {1} guruhida faqat {2} qty bor. Iltimos, {3} qty mavjud bo&#39;lgan boshqa qatorni tanlang yoki bir nechta partiyalardan etkazib berish uchun qatorni bir necha qatorga bo&#39;linib ko&#39;rsating"
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +119,"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","# {0} qatori: {1} guruhida faqat {2} qty bor. Iltimos, {3} qty mavjud bo&#39;lgan boshqa qatorni tanlang yoki bir nechta partiyalardan etkazib berish uchun qatorni bir necha qatorga bo&#39;linib ko&#39;rsating"
 DocType: Vehicle,License Plate,Plitalar
 DocType: Appraisal,Goals,Maqsadlar
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +326,Select POS Profile,Qalin profilni tanlang
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +343,Select POS Profile,Qalin profilni tanlang
 DocType: Warranty Claim,Warranty / AMC Status,Kafolat / AMC Status
 ,Accounts Browser,Hisoblar brauzeri
 DocType: Payment Entry Reference,Payment Entry Reference,To&#39;lov uchun ariza namunasi
@@ -1606,24 +1723,27 @@
 ,Batch-Wise Balance History,Batch-Wise Balance History
 apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73,Print settings updated in respective print format,Chop etish moslamalari tegishli bosib chiqarish formatida yangilanadi
 DocType: Package Code,Package Code,Paket kodi
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +101,Apprentice,Chiragcha
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105,Apprentice,Chiragcha
 DocType: Purchase Invoice,Company GSTIN,Kompaniya GSTIN
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +103,Negative Quantity is not allowed,Salbiy miqdorda ruxsat berilmaydi
 DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
 Used for Taxes and Charges",Element ustasidan magistral sifatida olib kelingan va ushbu sohada saqlangan soliq batafsil jadvali. Soliqlar va yig&#39;imlar uchun ishlatiladi
 DocType: Supplier Scorecard Period,SSC-,SSC-
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +154,Employee cannot report to himself.,Xodim o&#39;z oldiga hisobot bera olmaydi.
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +159,Employee cannot report to himself.,Xodim o&#39;z oldiga hisobot bera olmaydi.
 DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Agar hisob buzilgan bo&#39;lsa, kirishlar cheklangan foydalanuvchilarga ruxsat etiladi."
 DocType: Email Digest,Bank Balance,Bank balansi
-apps/erpnext/erpnext/accounts/party.py +245,Accounting Entry for {0}: {1} can only be made in currency: {2},{0} uchun buxgalteriya yozuvi: {1} faqatgina valyutada bo&#39;lishi mumkin: {2}
+apps/erpnext/erpnext/accounts/party.py +243,Accounting Entry for {0}: {1} can only be made in currency: {2},{0} uchun buxgalteriya yozuvi: {1} faqatgina valyutada bo&#39;lishi mumkin: {2}
 DocType: Job Opening,"Job profile, qualifications required etc.","Ishchi profil, talablar va boshqalar."
 DocType: Journal Entry Account,Account Balance,Hisob balansi
-apps/erpnext/erpnext/config/accounts.py +191,Tax Rule for transactions.,Bitim uchun soliq qoidalari.
+apps/erpnext/erpnext/config/accounts.py +183,Tax Rule for transactions.,Bitim uchun soliq qoidalari.
 DocType: Rename Tool,Type of document to rename.,Qayta nom berish uchun hujjatning turi.
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53,{0} {1}: Customer is required against Receivable account {2},"{0} {1}: Xaridor, oladigan hisobiga qarshi {2}"
 DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Jami soliqlar va yig&#39;imlar (Kompaniya valyutasi)
+DocType: Weather,Weather Parameter,Ob-havo parametrlari
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60,Show unclosed fiscal year's P&L balances,Yoqmagan moliyaviy yilgi P &amp; L balanslarini ko&#39;rsating
 DocType: Lab Test Template,Collection Details,To&#39;plash tafsilotlari
+DocType: POS Profile,Allow Print Before Pay,Pul to&#39;lashdan avval chop etishga ruxsat
+DocType: Land Unit,Linked Soil Texture,Bog&#39;langan tuproq to&#39;qimalari
 DocType: Shipping Rule,Shipping Account,Yuk tashish qaydnomasi
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92,{0} {1}: Account {2} is inactive,{0} {1}: Hisob {2} faol emas
 apps/erpnext/erpnext/utilities/activation.py +82,Make Sales Orders to help you plan your work and deliver on-time,Sizning ishingizni rejalashtirish va vaqtida yetkazib berishga yordam berish uchun Sotuvdagi buyurtma berish
@@ -1631,44 +1751,48 @@
 DocType: Stock Entry,Total Additional Costs,Jami qo&#39;shimcha xarajatlar
 DocType: Course Schedule,SH,Sh
 DocType: BOM,Scrap Material Cost(Company Currency),Hurda Materiallar narxi (Kompaniya valyutasi)
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +62,Sub Assemblies,Quyi majlislar
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66,Sub Assemblies,Quyi majlislar
 DocType: Asset,Asset Name,Asset nomi
 DocType: Project,Task Weight,Vazifa og&#39;irligi
 DocType: Shipping Rule Condition,To Value,Qiymati uchun
 DocType: Asset Movement,Stock Manager,Aktsiyadorlar direktori
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +144,Source warehouse is mandatory for row {0},Resurs ombori {0} qatoriga kiritilishi shart
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +809,Packing Slip,Qoplamali sumkasi
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +149,Source warehouse is mandatory for row {0},Resurs ombori {0} qatoriga kiritilishi shart
+apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38,The Payment Term at row {0} is possibly a duplicate.,"{0} qatoridagi to&#39;lov muddati, ehtimol, ikki nusxadir."
+apps/erpnext/erpnext/public/js/setup_wizard.js +30,Agriculture (beta),Qishloq xo&#39;jaligi (beta)
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +856,Packing Slip,Qoplamali sumkasi
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Office Rent,Ofis ijarasi
 apps/erpnext/erpnext/config/setup.py +111,Setup SMS gateway settings,SMS-gateway sozlamalarini to&#39;g&#39;rilash
+DocType: Disease,Common Name,Umumiy nom
 apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61,Import Failed!,Import amalga oshmadi!
 apps/erpnext/erpnext/public/js/templates/address_list.html +20,No address added yet.,Hech qanday manzil hali qo&#39;shilmagan.
 DocType: Workstation Working Hour,Workstation Working Hour,Ish stantsiyani ish vaqti
 DocType: Vital Signs,Blood Pressure,Qon bosimi
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +121,Analyst,Tahlilchi
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125,Analyst,Tahlilchi
 DocType: Item,Inventory,Inventarizatsiya
 DocType: Item,Sales Details,Sotish tafsilotlari
 DocType: Quality Inspection,QI-,QI-
 DocType: Opportunity,With Items,Mahsulotlar bilan
+DocType: Asset Maintenance,Maintenance Team,Xizmat jamoasi
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,In Qty,Miqdorda
-DocType: School Settings,Validate Enrolled Course for Students in Student Group,Talaba guruhidagi talabalar uchun ro&#39;yxatdan o&#39;tgan kursni tasdiqlash
+DocType: Education Settings,Validate Enrolled Course for Students in Student Group,Talaba guruhidagi talabalar uchun ro&#39;yxatdan o&#39;tgan kursni tasdiqlash
 DocType: Notification Control,Expense Claim Rejected,Eksport e&#39;tirishi rad etildi
 DocType: Item,Item Attribute,Mavzu tavsifi
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +143,Government,Hukumat
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147,Government,Hukumat
 apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40,Expense Claim {0} already exists for the Vehicle Log,Avtomobil logi uchun {0} xarajat talabi allaqachon mavjud
-apps/erpnext/erpnext/public/js/setup_wizard.js +60,Institute Name,Institutning nomi
+apps/erpnext/erpnext/public/js/setup_wizard.js +64,Institute Name,Institutning nomi
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117,Please enter repayment Amount,To&#39;lov miqdorini kiriting
 apps/erpnext/erpnext/config/stock.py +305,Item Variants,Variant variantlari
-DocType: Company,Services,Xizmatlar
+apps/erpnext/erpnext/public/js/setup_wizard.js +29,Services,Xizmatlar
 DocType: HR Settings,Email Salary Slip to Employee,E-pochtani ish haqi xodimiga aylantirish
 DocType: Cost Center,Parent Cost Center,Ota-xarajatlar markazi
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1017,Select Possible Supplier,Mumkin etkazib beruvchini tanlang
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1039,Select Possible Supplier,Mumkin etkazib beruvchini tanlang
 DocType: Sales Invoice,Source,Manba
 apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,Yopiq ko&#39;rsatilsin
 DocType: Leave Type,Is Leave Without Pay,To&#39;lovsiz qoldirish
-apps/erpnext/erpnext/stock/doctype/item/item.py +248,Asset Category is mandatory for Fixed Asset item,Assot kategoriyasi Ruxsat etilgan obyektlar uchun majburiydir
+apps/erpnext/erpnext/stock/doctype/item/item.py +250,Asset Category is mandatory for Fixed Asset item,Assot kategoriyasi Ruxsat etilgan obyektlar uchun majburiydir
 DocType: Fee Validity,Fee Validity,Ish haqi amal qilish muddati
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +145,No records found in the Payment table,To&#39;lov jadvalida yozuvlar topilmadi
-apps/erpnext/erpnext/schools/utils.py +19,This {0} conflicts with {1} for {2} {3},{0} {2} {3} uchun {1} bilan nizolar
+apps/erpnext/erpnext/education/utils.py +19,This {0} conflicts with {1} for {2} {3},{0} {2} {3} uchun {1} bilan nizolar
 DocType: Student Attendance Tool,Students HTML,Talabalar HTML
 DocType: POS Profile,Apply Discount,Dasturni qo&#39;llash
 DocType: GST HSN Code,GST HSN Code,GST HSN kodi
@@ -1683,16 +1807,18 @@
 apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Taken,Qabul qilingan
 DocType: Student,Date of Leaving,Tug&#39;ilgan sanasi
 DocType: Pricing Rule,For Price List,Narxlar ro&#39;yxati uchun
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +27,Executive Search,Ijrochi Izlash
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27,Executive Search,Ijrochi Izlash
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55,Setting defaults,Standartni belgilash
 apps/erpnext/erpnext/utilities/activation.py +63,Create Leads,Yaratmalar yaratish
 DocType: Maintenance Schedule,Schedules,Jadvallar
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +331,POS Profile is required to use Point-of-Sale,Sotish nuqtasini ishlatish uchun qalin profil talab qilinadi
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +451,POS Profile is required to use Point-of-Sale,Sotish nuqtasini ishlatish uchun qalin profil talab qilinadi
 DocType: Purchase Invoice Item,Net Amount,Net miqdori
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +138,{0} {1} has not been submitted so the action cannot be completed,"{0} {1} yuborilmadi, shuning uchun amal bajarilmaydi"
 DocType: Purchase Order Item Supplied,BOM Detail No,BOM batafsil
 DocType: Landed Cost Voucher,Additional Charges,Qo&#39;shimcha ish haqi
 DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Qo&#39;shimcha chegirma miqdori (Kompaniya valyutasi)
 DocType: Supplier Scorecard,Supplier Scorecard,Yetkazib beruvchi Kuzatuv kartasi
+DocType: Plant Analysis,Result Datetime,Natijada Datetime
 apps/erpnext/erpnext/accounts/doctype/account/account.js +21,Please create new account from Chart of Accounts.,"Iltimos, Hisob jadvalidan yangi hisob yarating."
 ,Support Hour Distribution,Qo&#39;llash vaqtini taqsimlash
 DocType: Maintenance Visit,Maintenance Visit,Xizmat tashrifi
@@ -1702,10 +1828,12 @@
 apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Update Print Format,Bosib chiqarish formatini yangilang
 DocType: Landed Cost Voucher,Landed Cost Help,Yo&#39;lga tushgan xarajatli yordam
 DocType: Purchase Invoice,Select Shipping Address,Yuk tashish manzilini tanlang
+apps/erpnext/erpnext/config/non_profit.py +28,Memebership Details,Imzolar haqida ma&#39;lumot
 DocType: Leave Block List,Block Holidays on important days.,Muhim kunlardagi dam olish kunlari.
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +71,Accounts Receivable Summary,Qabul qilinadigan hisobvaraqlarning qisqacha bayoni
 DocType: Employee Loan,Monthly Repayment Amount,Oylik to&#39;lov miqdori
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +191,Please set User ID field in an Employee record to set Employee Role,"Iltimos, foydalanuvchi identifikatorini Xodimlar roliga o&#39;rnatish uchun Xodimlar ro&#39;yxatiga qo&#39;ying"
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9,Opening Invoices,Xarajatlarni ochish
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +195,Please set User ID field in an Employee record to set Employee Role,"Iltimos, foydalanuvchi identifikatorini Xodimlar roliga o&#39;rnatish uchun Xodimlar ro&#39;yxatiga qo&#39;ying"
 DocType: UOM,UOM Name,UOM nomi
 DocType: GST HSN Code,HSN Code,HSN kodi
 apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +43,Contribution Amount,Qatnashchining miqdori
@@ -1713,25 +1841,25 @@
 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.,Ushbu vosita tizimdagi aktsiyalar miqdorini va qiymatini yangilashga yordam beradi. Odatda tizim qiymatlarini va sizning omborlaringizda mavjud bo&#39;lgan narsalarni sinxronlashtirish uchun foydalaniladi.
 DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,Ta&#39;minot eslatmasini saqlaganingizdan so&#39;ng So&#39;zlar ko&#39;rinadi.
 DocType: Expense Claim,EXP,EXP
-apps/erpnext/erpnext/config/stock.py +205,Brand master.,Brend ustasi.
-apps/erpnext/erpnext/schools/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Isoning shogirdi {0} - {1} qatori {2} &amp; {3}
+DocType: Water Analysis,Container,Idish
+apps/erpnext/erpnext/education/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Isoning shogirdi {0} - {1} qatori {2} &amp; {3}
 DocType: Healthcare Settings,Manage Sample Collection,Namuna to&#39;plamini boshqaring
 DocType: Program Enrollment Tool,Program Enrollments,Dasturlarni ro&#39;yxatga olish
 DocType: Patient,Tobacco Past Use,Tamaki iste&#39;mol qilish
 DocType: Sales Invoice Item,Brand Name,Brendning nomi
 DocType: Purchase Receipt,Transporter Details,Tashuvchi ma&#39;lumoti
 apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +65,User {0} is already assigned to Physician {1},{0} {{} {1} shifokoriga allaqachon tayinlangan
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2638,Default warehouse is required for selected item,Tanlangan element uchun odatiy ombor kerak
-apps/erpnext/erpnext/utilities/user_progress.py +125,Box,Box
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1014,Possible Supplier,Mumkin bo&#39;lgan yetkazib beruvchi
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2657,Default warehouse is required for selected item,Tanlangan element uchun odatiy ombor kerak
+apps/erpnext/erpnext/utilities/user_progress.py +143,Box,Box
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1036,Possible Supplier,Mumkin bo&#39;lgan yetkazib beruvchi
 DocType: Budget,Monthly Distribution,Oylik tarqatish
 apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68,Receiver List is empty. Please create Receiver List,"Qabul qiladiganlar ro&#39;yxati bo&#39;sh. Iltimos, qabul qiluvchi ro&#39;yxatini yarating"
-apps/erpnext/erpnext/public/js/setup_wizard.js +29,Healthcare (beta),Sog&#39;liqni saqlash (beta)
+apps/erpnext/erpnext/public/js/setup_wizard.js +31,Healthcare (beta),Sog&#39;liqni saqlash (beta)
 DocType: Production Plan Sales Order,Production Plan Sales Order,Ishlab chiqarish rejasini sotish tartibi
 DocType: Sales Partner,Sales Partner Target,Savdo hamkorining maqsadi
 DocType: Loan Type,Maximum Loan Amount,Maksimal kredit summasi
 DocType: Pricing Rule,Pricing Rule,Raqobatchilar qoidasi
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Talabalar uchun {0}
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Talabalar uchun {0}
 DocType: Budget,Action if Annual Budget Exceeded,Agar yillik byudjetdan oshib ketgan bo&#39;lsa
 apps/erpnext/erpnext/config/learn.py +197,Material Request to Purchase Order,Buyurtma buyurtmasiga buyurtma berish
 DocType: Shopping Cart Settings,Payment Success URL,To&#39;lov muvaffaqiyati URL manzili
@@ -1749,45 +1877,51 @@
 apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59,Leaves Allocated Successfully for {0},{0} uchun muvaffaqiyatli tarzda ajratilgan qoldirilganlar
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42,No Items to pack,To&#39;plam uchun hech narsa yo&#39;q
 DocType: Shipping Rule Condition,From Value,Qiymatdan
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +555,Manufacturing Quantity is mandatory,Ishlab chiqarish miqdori majburiydir
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +581,Manufacturing Quantity is mandatory,Ishlab chiqarish miqdori majburiydir
 DocType: Employee Loan,Repayment Method,Qaytarilish usuli
 DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Agar belgilansa, Bosh sahifa veb-sayt uchun standart elementlar guruhi bo&#39;ladi"
 DocType: Quality Inspection Reading,Reading 4,O&#39;qish 4
-apps/erpnext/erpnext/config/hr.py +127,Claims for company expense.,Kompaniya xarajatlari uchun da&#39;vo.
+apps/erpnext/erpnext/config/hr.py +132,Claims for company expense.,Kompaniya xarajatlari uchun da&#39;vo.
 apps/erpnext/erpnext/utilities/activation.py +118,"Students are at the heart of the system, add all your students","Talabalar tizimning markazida bo&#39;lib, barcha talabalarni qo&#39;shib qo&#39;yasiz"
 apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +81,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},# {0} satrida: {1} bo&#39;shatish kuni oldin tekshirilish sanasi {2}
+DocType: Asset Maintenance Task,Certificate Required,Sertifikat kerak
 DocType: Company,Default Holiday List,Standart dam olish ro&#39;yxati
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +190,Row {0}: From Time and To Time of {1} is overlapping with {2},Row {0}: {1} dan vaqt va vaqtdan {2}
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145,Stock Liabilities,Qarz majburiyatlari
 DocType: Purchase Invoice,Supplier Warehouse,Yetkazib beruvchi ombori
 DocType: Opportunity,Contact Mobile No,Mobil raqami bilan bog&#39;laning
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +356,Select Company,Kompaniya-ni tanlang
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +382,Select Company,Kompaniya-ni tanlang
 ,Material Requests for which Supplier Quotations are not created,Yetkazib beruvchi kotirovkalari yaratilmagan moddiy talablar
+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.,{0} foydalanuvchida hech qanday standart qalin profil mavjud emas. Ushbu foydalanuvchi uchun Row {1} -dan standartni tekshiring.
 DocType: Student Group,Set 0 for no limit,Hech qanday chegara uchun 0-ni tanlang
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +141,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,Dam olish uchun ariza topshirgan kun (lar) bayramdir. Siz ta&#39;tilga ariza berishingiz shart emas.
+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,Roy {idx}: {field} Opening {invoice_type} Xarajatlarni yaratish uchun talab qilinadi
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20,Resend Payment Email,To&#39;lov E-pochtasini qayta yuboring
 apps/erpnext/erpnext/templates/pages/projects.html +27,New task,Yangi topshiriq
 DocType: Consultation,Appointment,Uchrashuv
 apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,Qabul qiling
 apps/erpnext/erpnext/config/selling.py +216,Other Reports,Boshqa hisobotlar
+apps/erpnext/erpnext/public/js/setup_wizard.js +39,Please select at least one domain.,"Iltimos, kamida bitta domenni tanlang."
 DocType: Dependent Task,Dependent Task,Qaram vazifa
-apps/erpnext/erpnext/stock/doctype/item/item.py +414,Conversion factor for default Unit of Measure must be 1 in row {0},Birlamchi o&#39;lchov birligi uchun ishlab chiqarish omili {0} qatorida 1 bo&#39;lishi kerak
+apps/erpnext/erpnext/stock/doctype/item/item.py +430,Conversion factor for default Unit of Measure must be 1 in row {0},Birlamchi o&#39;lchov birligi uchun ishlab chiqarish omili {0} qatorida 1 bo&#39;lishi kerak
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +208,Leave of type {0} cannot be longer than {1},{0} tipidagi qoldiring {1} dan uzun bo&#39;lishi mumkin emas
 DocType: Manufacturing Settings,Try planning operations for X days in advance.,X kun oldin rejalashtirilgan operatsiyalarni sinab ko&#39;ring.
 DocType: HR Settings,Stop Birthday Reminders,Tug&#39;ilgan kunlar eslatmalarini to&#39;xtatish
 DocType: SMS Center,Receiver List,Qabul qiluvchi ro&#39;yxati
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1068,Search Item,Qidiruv vositasi
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1083,Search Item,Qidiruv vositasi
+DocType: Payment Schedule,Payment Amount,To&#39;lov miqdori
 DocType: Patient Appointment,Referring Physician,Shifokorga murojaat qilish
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,Iste&#39;mol qilingan summalar
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +98,Net Change in Cash,Naqd pulning aniq o&#39;zgarishi
 DocType: Assessment Plan,Grading Scale,Baholash o&#39;lchovi
-apps/erpnext/erpnext/stock/doctype/item/item.py +409,Unit of Measure {0} has been entered more than once in Conversion Factor Table,O&#39;lchov birligi {0} bir necha marta kiritilgan
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +612,Already completed,To&#39;liq bajarildi
+apps/erpnext/erpnext/stock/doctype/item/item.py +425,Unit of Measure {0} has been entered more than once in Conversion Factor Table,O&#39;lchov birligi {0} bir necha marta kiritilgan
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +616,Already completed,To&#39;liq bajarildi
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock In Hand,Al-Qoida
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64,Import Successful!,Import muvaffaqiyatli!
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29,Payment Request already exists {0},To&#39;lov bo&#39;yicha so&#39;rov allaqachon {0}
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Chiqarilgan mahsulotlarning narxi
 DocType: Physician,Hospital,Kasalxona
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +362,Quantity must not be more than {0},Miqdori {0} dan ortiq bo&#39;lmasligi kerak
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +384,Quantity must not be more than {0},Miqdori {0} dan ortiq bo&#39;lmasligi kerak
 apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117,Previous Financial Year is not closed,Avvalgi moliyaviy yil yopiq emas
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46,Age (Days),Yosh (kunlar)
 DocType: Quotation Item,Quotation Item,Tavsif varag&#39;i
@@ -1797,14 +1931,15 @@
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198,Serial No {0} quantity {1} cannot be a fraction,Seriya No {0} miqdori {1} bir qism emas
 apps/erpnext/erpnext/config/buying.py +43,Supplier Type master.,Yetkazib beruvchi turi ustasi.
 DocType: Purchase Order Item,Supplier Part Number,Yetkazib beruvchi qismi raqami
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +105,Conversion rate cannot be 0 or 1,Ishlab chiqarish darajasi 0 yoki 1 bo&#39;lishi mumkin emas
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108,Conversion rate cannot be 0 or 1,Ishlab chiqarish darajasi 0 yoki 1 bo&#39;lishi mumkin emas
 DocType: Subscription,Reference Document,Malumot hujjati
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +208,{0} {1} is cancelled or stopped,{0} {1} bekor qilindi yoki to&#39;xtatildi
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +209,{0} {1} is cancelled or stopped,{0} {1} bekor qilindi yoki to&#39;xtatildi
 DocType: Accounts Settings,Credit Controller,Kredit nazoratchisi
+DocType: Grant Application,Applicant Type,Ariza beruvchi turi
 DocType: Delivery Note,Vehicle Dispatch Date,Avtomobilni jo&#39;natish sanasi
 DocType: Healthcare Settings,Default Medical Code Standard,Standart tibbiy standartlar standarti
 DocType: Purchase Invoice Item,HSN/SAC,HSN / SAC
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +234,Purchase Receipt {0} is not submitted,Xarid qilish shakli {0} yuborilmaydi
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237,Purchase Receipt {0} is not submitted,Xarid qilish shakli {0} yuborilmaydi
 DocType: Company,Default Payable Account,Foydalanuvchi to&#39;lanadigan hisob
 apps/erpnext/erpnext/config/website.py +17,"Settings for online shopping cart such as shipping rules, price list etc.","Yuk tashish qoidalari, narxlar ro&#39;yxati va h.k. kabi onlayn xarid qilish vositasi sozlamalari"
 apps/erpnext/erpnext/controllers/website_list_for_contact.py +113,{0}% Billed,{0}% to&#39;ldirildi
@@ -1813,40 +1948,44 @@
 DocType: Party Account,Party Account,Partiya hisoblari
 apps/erpnext/erpnext/config/setup.py +122,Human Resources,Kadrlar bo&#39;limi
 DocType: Lead,Upper Income,Yuqori daromad
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +41,Reject,Rad etish
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17,Reject,Rad etish
 DocType: Journal Entry Account,Debit in Company Currency,Kompaniya valyutasidagi debet
 DocType: BOM Item,BOM Item,BOM Item
 DocType: Appraisal,For Employee,Ishchi uchun
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49,Make Disbursement Entry,To&#39;lovni kiritish
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138,Row {0}: Advance against Supplier must be debit,Row {0}: Yetkazib beruvchiga qarshi oldindan qarzdor bo&#39;lishi kerak
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Supplier must be debit,Row {0}: Yetkazib beruvchiga qarshi oldindan qarzdor bo&#39;lishi kerak
 DocType: Company,Default Values,Standart qiymatlar
+DocType: Membership,INR,INR
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60,{frequency} Digest,{Frequency} Digest
 DocType: Expense Claim,Total Amount Reimbursed,To&#39;lov miqdori to&#39;langan
 apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5,This is based on logs against this Vehicle. See timeline below for details,"Bu, ushbu avtomobilga qarshi jurnallarga asoslangan. Tafsilotlar uchun quyidagi jadvalga qarang"
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +87,Against Supplier Invoice {0} dated {1},{1} {0} etkazib beruvchi hisob-fakturasiga qarshi
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90,Against Supplier Invoice {0} dated {1},{1} {0} etkazib beruvchi hisob-fakturasiga qarshi
 DocType: Customer,Default Price List,Standart narx ro&#39;yxati
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +244,Asset Movement record {0} created,Aktivlar harakati qaydlari {0} yaratildi
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +265,Asset Movement record {0} created,Aktivlar harakati qaydlari {0} yaratildi
 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,Moliyaviy yil {0} ni o&#39;chirib bo&#39;lmaydi. Moliyaviy yil {0} global sozlamalarda sukut o&#39;rnatilgan
 apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,A customer with the same name already exists,Xuddi shu nomga ega bo&#39;lgan mijoz allaqachon mavjud
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +183,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Bu ish haqi to`plarini taqdim etadi va hisobga olish jurnalini yaratadi. Davom etmoqchimisiz?
+DocType: Purchase Invoice,Total Net Weight,Jami aniq vazn
 DocType: Journal Entry,Entry Type,Kirish turi
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.py +44,No assessment plan linked with this assessment group,Ushbu baholash guruhi bilan bog&#39;liq bo&#39;lgan baholash rejasi yo&#39;q
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +44,No assessment plan linked with this assessment group,Ushbu baholash guruhi bilan bog&#39;liq bo&#39;lgan baholash rejasi yo&#39;q
 ,Customer Credit Balance,Xaridorlarning kredit balansi
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23,Net Change in Accounts Payable,To&#39;lanadigan qarzlarning sof o&#39;zgarishi
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',&quot;Customerwise-ning dasturi&quot;
-apps/erpnext/erpnext/config/accounts.py +148,Update bank payment dates with journals.,Bankdagi to&#39;lov kunlarini jurnallar bilan yangilang.
+apps/erpnext/erpnext/config/accounts.py +140,Update bank payment dates with journals.,Bankdagi to&#39;lov kunlarini jurnallar bilan yangilang.
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21,Pricing,Raqobatchilar
 DocType: Quotation,Term Details,Terim detallari
-DocType: Project,Total Sales Cost (via Sales Order),Jami sotish narxi (Sotuvdagi Buyurtma orqali)
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +30,Cannot enroll more than {0} students for this student group.,Ushbu talabalar guruhida {0} dan ortiq talabalarni ro&#39;yxatdan o&#39;tkazib bo&#39;lmaydi.
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30,Cannot enroll more than {0} students for this student group.,Ushbu talabalar guruhida {0} dan ortiq talabalarni ro&#39;yxatdan o&#39;tkazib bo&#39;lmaydi.
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Qo&#39;rg&#39;oshin soni
-apps/erpnext/erpnext/accounts/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} 0 dan katta bo&#39;lishi kerak
+apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} 0 dan katta bo&#39;lishi kerak
+apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +17,Stock Available,Mavjudotlar mavjud
 DocType: Manufacturing Settings,Capacity Planning For (Days),Imkoniyatlarni rejalashtirish (kunlar)
 apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10,Procurement,Xarid qilish
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +64,None of the items have any change in quantity or value.,Hech qaysi mahsulot miqdori yoki qiymati o&#39;zgarmas.
-apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +16,Mandatory field - Program,Majburiy maydon - Dastur
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +16,Mandatory field - Program,Majburiy maydon - Dastur
 DocType: Special Test Template,Result Component,Natija komponenti
 apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46,Warranty Claim,Kafolat talabi
 ,Lead Details,Qurilma detallari
+DocType: Volunteer,Availability and Skills,Mavjudligi va ko&#39;nikmalari
 DocType: Salary Slip,Loan repayment,Kreditni qaytarish
 DocType: Purchase Invoice,End date of current invoice's period,Joriy hisob-kitob davri tugash sanasi
 DocType: Pricing Rule,Applicable For,Qo&#39;llaniladigan
@@ -1857,11 +1996,11 @@
 DocType: Shipping Rule Country,Shipping Rule Country,Yuk tashish qoidalari mamlakat
 apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10,Leave and Attendance,Qoldiring va davom eting
 DocType: Maintenance Visit,Partially Completed,Qisman bajarildi
-apps/erpnext/erpnext/healthcare/setup.py +256,Moderate Sensitivity,O&#39;rtacha sezuvchanlik
+apps/erpnext/erpnext/healthcare/setup.py +257,Moderate Sensitivity,O&#39;rtacha sezuvchanlik
 DocType: Leave Type,Include holidays within leaves as leaves,Bayramlardagi bayramlarni barglar sifatida qo&#39;shish
 DocType: Sales Invoice,Packed Items,Paketlangan narsalar
 apps/erpnext/erpnext/config/support.py +27,Warranty Claim against Serial No.,Seriya raqami bo&#39;yicha kafolat talabi
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +65,'Total',&quot;Umumiy&quot;
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +71,'Total',&quot;Umumiy&quot;
 DocType: Shopping Cart Settings,Enable Shopping Cart,Savatga savatni faollashtirish
 DocType: Employee,Permanent Address,Doimiy yashash joyi
 DocType: Patient,Medication,Dori-darmon
@@ -1873,36 +2012,42 @@
 DocType: Purchase Invoice,Additional Discount,Qo&#39;shimcha chegirmalar
 DocType: Selling Settings,Selling Settings,Sotish sozlamalari
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +83,Confirm Action,Amalni tasdiqlang
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +39,Online Auctions,Onlayn auktsionlar
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39,Online Auctions,Onlayn auktsionlar
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +98,Please specify either Quantity or Valuation Rate or both,Miqdor yoki baholash bahosini yoki ikkalasini ham ko&#39;rsating
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18,Fulfillment,Tugatish
 apps/erpnext/erpnext/templates/generators/item.html +67,View in Cart,Savatda ko&#39;rish
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103,Marketing Expenses,Marketing xarajatlari
 ,Item Shortage Report,Mavzu kamchiliklari haqida hisobot
-apps/erpnext/erpnext/stock/doctype/item/item.js +279,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Og&#39;irligi ko&#39;rsatilgan, \ n &quot;Og&#39;irligi UOM&quot; ni ham eslang"
+apps/erpnext/erpnext/stock/doctype/item/item.js +275,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Og&#39;irligi ko&#39;rsatilgan, \ n &quot;Og&#39;irligi UOM&quot; ni ham eslang"
 DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Ushbu moddiy yordamni kiritish uchun foydalanilgan materiallar talabi
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Keyinchalik keyingi Amortizatsiya tarixi yangi aktiv uchun majburiydir
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Keyinchalik keyingi Amortizatsiya tarixi yangi aktiv uchun majburiydir
 DocType: Student Group Creation Tool,Separate course based Group for every Batch,Har bir guruh uchun alohida kurs bo&#39;yicha guruh
 apps/erpnext/erpnext/config/support.py +32,Single unit of an Item.,Ob&#39;ektning yagona birligi.
 DocType: Fee Category,Fee Category,Ish haqi toifasi
+DocType: Agriculture Task,Next Business Day,Keyingi ish kuni
+DocType: Customer,Primary Contact Detail,Asosiy aloqa ma&#39;lumoti
 DocType: Drug Prescription,Dosage by time interval,Vaqt oralig&#39;i bo&#39;yicha dozalash
 ,Student Fee Collection,Talabalar uchun yig&#39;im
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +23,Appointment Duration (mins),Uchrashuv davomiyligi (daqiqa)
 DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Har bir aktsiyadorlik harakati uchun buxgalteriya hisobini kiritish
 DocType: Leave Allocation,Total Leaves Allocated,Jami ajratmalar
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +160,Warehouse required at Row No {0},No {0} qatorida talab qilingan ombor
-apps/erpnext/erpnext/public/js/setup_wizard.js +139,Please enter valid Financial Year Start and End Dates,"Iltimos, joriy moliyaviy yilni boshlash va tugatish sanasini kiriting"
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163,Warehouse required at Row No {0},No {0} qatorida talab qilingan ombor
+apps/erpnext/erpnext/public/js/setup_wizard.js +142,Please enter valid Financial Year Start and End Dates,"Iltimos, joriy moliyaviy yilni boshlash va tugatish sanasini kiriting"
 DocType: Employee,Date Of Retirement,Pensiya tarixi
 DocType: Upload Attendance,Get Template,Andoza olish
 DocType: Material Request,Transferred,O&#39;tkazildi
 DocType: Vehicle,Doors,Eshiklar
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +196,ERPNext Setup Complete!,ERPNext O&#39;rnatish tugallandi!
+apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +117,ERPNext Setup Complete!,ERPNext O&#39;rnatish tugallandi!
 DocType: Healthcare Settings,Collect Fee for Patient Registration,Kasalni ro&#39;yxatdan o&#39;tkazish uchun yig&#39;im to&#39;lash
+apps/erpnext/erpnext/stock/doctype/item/item.py +650,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Birja bitimidan keyin Xususiyatlarni o&#39;zgartirib bo&#39;lmaydi. Yangi mahsulotni yarating va yangi mahsulotga aktsiyalaringizni topshiring
 DocType: Course Assessment Criteria,Weightage,Og&#39;irligi
 DocType: Purchase Invoice,Tax Breakup,Soliq to&#39;lash
 DocType: Packing Slip,PS-,PS-
+DocType: Member,Non Profit Member,Qor bo&#39;lmagan foyda
 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}: &quot;Qor va ziyon&quot; hisobiga {2} uchun xarajatlar markazi talab qilinadi. Iltimos, Kompaniya uchun standart narx markazini o&#39;rnating."
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +118,A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Xaridorlar guruhi shu nom bilan mavjud bo&#39;lib, xaridor nomini o&#39;zgartiring yoki xaridorlar guruhini o&#39;zgartiring"
+DocType: Payment Schedule,Payment Term,To&#39;lov muddati
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +146,A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Xaridorlar guruhi shu nom bilan mavjud bo&#39;lib, xaridor nomini o&#39;zgartiring yoki xaridorlar guruhini o&#39;zgartiring"
+DocType: Land Unit,Area,Hudud
 apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,Yangi kontakt
 DocType: Territory,Parent Territory,Ota-ona hududi
 DocType: Sales Invoice,Place of Supply,Yetkazib beriladigan joy
@@ -1912,39 +2057,40 @@
 DocType: Announcement,Instructor,O&#39;qituvchi
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +61,Select Item (optional),Ob&#39;ektni tanlash (ixtiyoriy)
 DocType: Fee Schedule Student Group,Fee Schedule Student Group,Ish haqi jadvali Studentlar guruhi
-DocType: Employee,AB+,AB +
+DocType: Student,AB+,AB +
 DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Agar ushbu mahsulot varianti bo&#39;lsa, u holda savdo buyurtmalarida va hokazolarni tanlash mumkin emas."
 DocType: Lead,Next Contact By,Keyingi aloqa
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +311,Quantity required for Item {0} in row {1},{1} qatoridagi {0} element uchun zarur miqdori
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +314,Quantity required for Item {0} in row {1},{1} qatoridagi {0} element uchun zarur miqdori
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +46,Warehouse {0} can not be deleted as quantity exists for Item {1},{1} elementi uchun {0} ombori miqdorini yo&#39;q qilib bo&#39;lmaydi
 DocType: Quotation,Order Type,Buyurtma turi
 ,Item-wise Sales Register,Buyurtmalar savdosi
 DocType: Asset,Gross Purchase Amount,Xarid qilishning umumiy miqdori
 apps/erpnext/erpnext/utilities/user_progress.py +36,Opening Balances,Ochilish balanslari
 DocType: Asset,Depreciation Method,Amortizatsiya usuli
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +67,Offline,Oflayn
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +64,Offline,Oflayn
 DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Ushbu soliq asosiy narxga kiritilganmi?
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Target,Umumiy maqsad
+DocType: Soil Texture,Sand Composition (%),Qum tarkibi (%)
 DocType: Job Applicant,Applicant for a Job,Ish uchun murojaat etuvchi
 DocType: Production Plan Material Request,Production Plan Material Request,Ishlab chiqarish rejasi Materiallar talabi
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231,No Production Orders created,Buyurtma ishlab chiqarilmadi
 DocType: Stock Reconciliation,Reconciliation JSON,Moslik JSON
 apps/erpnext/erpnext/accounts/report/financial_statements.html +3,Too many columns. Export the report and print it using a spreadsheet application.,Juda ko&#39;p ustunlar. Hisobotni eksport qiling va elektron jadval ilovasidan foydalaning.
 DocType: Purchase Invoice Item,Batch No,Partiya no
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +141,Request for Quotation: {0},Buyurtma uchun ariza: {0}
 DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Xaridorning Buyurtma buyrug&#39;iga qarshi bir nechta Sotish Buyurtmalariga ruxsat berish
 DocType: Student Group Instructor,Student Group Instructor,Talabalar guruhining o&#39;qituvchisi
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Guardian2 Mobil raqami
-apps/erpnext/erpnext/setup/doctype/company/company.py +197,Main,Asosiy
-apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant,Variant
+DocType: Grant Application,Assessment  Mark (Out of 10),Baholash belgisi (10)
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Guardian2 Mobil raqami
+apps/erpnext/erpnext/setup/doctype/company/company.py +194,Main,Asosiy
+apps/erpnext/erpnext/stock/doctype/item/item.js +72,Variant,Variant
 DocType: Naming Series,Set prefix for numbering series on your transactions,Sizning operatsiyalaringizda raqamlash seriyasi uchun prefiksni o&#39;rnating
 DocType: Employee Attendance Tool,Employees HTML,Xodimlar HTML
-apps/erpnext/erpnext/stock/doctype/item/item.py +428,Default BOM ({0}) must be active for this item or its template,Ushbu element yoki uning shabloni uchun standart BOM ({0}) faol bo&#39;lishi kerak
+apps/erpnext/erpnext/stock/doctype/item/item.py +444,Default BOM ({0}) must be active for this item or its template,Ushbu element yoki uning shabloni uchun standart BOM ({0}) faol bo&#39;lishi kerak
 DocType: Employee,Leave Encashed?,Encashed qoldiringmi?
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,Fursatdan dalolat majburiy
 DocType: Email Digest,Annual Expenses,Yillik xarajatlar
 DocType: Item,Variants,Variantlar
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1088,Make Purchase Order,Buyurtma buyurtma qiling
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1137,Make Purchase Order,Buyurtma buyurtma qiling
 DocType: SMS Center,Send To,Yuborish
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +152,There is not enough leave balance for Leave Type {0},{0} to`g`ri to`g`ri uchun muvozanat etarli emas
 DocType: Payment Reconciliation Payment,Allocated amount,Ajratilgan mablag&#39;
@@ -1952,35 +2098,37 @@
 DocType: Sales Invoice Item,Customer's Item Code,Xaridorning mahsulot kodi
 DocType: Stock Reconciliation,Stock Reconciliation,Qimmatli qog&#39;ozlar bilan kelishuv
 DocType: Territory,Territory Name,Hududning nomi
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +177,Work-in-Progress Warehouse is required before Submit,Yuborishdan oldin ishlaydigan ishlab chiqarish ombori talab qilinadi
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +197,Work-in-Progress Warehouse is required before Submit,Yuborishdan oldin ishlaydigan ishlab chiqarish ombori talab qilinadi
 apps/erpnext/erpnext/config/hr.py +40,Applicant for a Job.,Ish uchun murojaat etuvchi.
 DocType: Purchase Order Item,Warehouse and Reference,QXI va Yo&#39;naltiruvchi
 DocType: Supplier,Statutory info and other general information about your Supplier,Ta&#39;minlovchingiz haqidagi qonuniy ma&#39;lumotlar va boshqa umumiy ma&#39;lumotlar
 DocType: Item,Serial Nos and Batches,Seriya nos va paketlar
-apps/erpnext/erpnext/schools/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Talabalar guruhining kuchi
+apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Talabalar guruhining kuchi
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +250,Against Journal Entry {0} does not have any unmatched {1} entry,Jurnalga qarshi kiritilgan {0} yozuviga mos bo&#39;lmagan {1} yozuvi mavjud emas
-apps/erpnext/erpnext/config/hr.py +137,Appraisals,Baholash
+apps/erpnext/erpnext/config/hr.py +142,Appraisals,Baholash
 apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8,Training Events,O&#39;quv mashg&#39;ulotlari
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205,Duplicate Serial No entered for Item {0},Duplikat ketma-ket No {0} element uchun kiritilgan
 DocType: Shipping Rule Condition,A condition for a Shipping Rule,Yuk tashish qoidalari uchun shart
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +161,Please enter ,"Iltimos, kiring"
-apps/erpnext/erpnext/controllers/accounts_controller.py +423,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Buying Settings","{1} qatorda {2} dan ortiq {0} mahsulotiga ortiqcha to&#39;lov berilmaydi. To&#39;lovni ortiqcha berishga ruxsat berish uchun, iltimos, xarid parametrlarini belgilang"
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +212,Please set filter based on Item or Warehouse,"Iltimos, filtrni yoki odatiy ob&#39;ektni tanlang"
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +167,Please enter ,"Iltimos, kiring"
+apps/erpnext/erpnext/controllers/accounts_controller.py +467,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Buying Settings","{1} qatorda {2} dan ortiq {0} mahsulotiga ortiqcha to&#39;lov berilmaydi. To&#39;lovni ortiqcha berishga ruxsat berish uchun, iltimos, xarid parametrlarini belgilang"
+apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43,Maintenance Log,Xizmat yozuvi
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +234,Please set filter based on Item or Warehouse,"Iltimos, filtrni yoki odatiy ob&#39;ektni tanlang"
 DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Ushbu paketning sof og&#39;irligi. (mahsulotning sof og&#39;irligi yig&#39;indisi sifatida avtomatik ravishda hisoblanadi)
 DocType: Sales Order,To Deliver and Bill,Taqdim etish va Bill
 DocType: Student Group,Instructors,O&#39;qituvchilar
 DocType: GL Entry,Credit Amount in Account Currency,Hisob valyutasida kredit summasi
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +584,BOM {0} must be submitted,BOM {0} yuborilishi kerak
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +588,BOM {0} must be submitted,BOM {0} yuborilishi kerak
 DocType: Authorization Control,Authorization Control,Avtorizatsiya nazorati
-apps/erpnext/erpnext/controllers/buying_controller.py +308,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Roy # {0}: Rad etilgan QXI rad etilgan elementga qarshi majburiydir {1}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +782,Payment,To&#39;lov
+apps/erpnext/erpnext/controllers/buying_controller.py +309,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Roy # {0}: Rad etilgan QXI rad etilgan elementga qarshi majburiydir {1}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +808,Payment,To&#39;lov
 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}.","{0} ombori har qanday hisobga bog&#39;lanmagan bo&#39;lsa, iltimos, zaxiradagi yozuvni qayd qiling yoki kompaniya {1} da odatiy inventarizatsiya hisobini o&#39;rnating."
 apps/erpnext/erpnext/utilities/activation.py +81,Manage your orders,Buyurtmalarni boshqaring
 DocType: Production Order Operation,Actual Time and Cost,Haqiqiy vaqt va narx
+DocType: Crop,Crop Spacing,O&#39;simliklar oralig&#39;i
 DocType: Course,Course Abbreviation,Kurs qisqartmasi
 DocType: Student Leave Application,Student Leave Application,Talabalar uchun ariza
 DocType: Item,Will also apply for variants,"Shuningdek, variantlar uchun ham qo&#39;llaniladi"
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +160,"Asset cannot be cancelled, as it is already {0}","Aktivni bekor qilish mumkin emas, chunki allaqachon {0}"
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +160,"Asset cannot be cancelled, as it is already {0}","Aktivni bekor qilish mumkin emas, chunki allaqachon {0}"
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} on Half day on {1},Yarim kun {1} da xizmatdosh {0}
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42,Total working hours should not be greater than max working hours {0},Umumiy ish soatlari eng ko&#39;p ish vaqti {0} dan ortiq bo&#39;lmasligi kerak
 apps/erpnext/erpnext/templates/pages/task_info.html +90,On,Yoqilgan
@@ -1990,9 +2138,9 @@
 DocType: Quality Inspection Reading,Reading 10,O&#39;qish 10
 DocType: Hub Category,Hub Node,Uyadan tugun
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,"Siz ikki nusxadagi ma&#39;lumotlar kiritdingiz. Iltimos, tuzatish va qayta urinib ko&#39;ring."
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +125,Associate,Birgalikda
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129,Associate,Birgalikda
 DocType: Asset Movement,Asset Movement,Asset harakati
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2165,New Cart,Yangi savat
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2180,New Cart,Yangi savat
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Item {0} is not a serialized Item,{0} mahsuloti seriyali element emas
 DocType: SMS Center,Create Receiver List,Qabul qiluvchining ro&#39;yxatini yaratish
 DocType: Vehicle,Wheels,Jantlar
@@ -2003,18 +2151,21 @@
 DocType: Activity Cost,Activity Cost,Faoliyat bahosi
 DocType: Sales Invoice Timesheet,Timesheet Detail,Vaqt jadvalini batafsil
 DocType: Purchase Receipt Item Supplied,Consumed Qty,Iste&#39;mol qilingan Miqdor
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +52,Telecommunications,Telekommunikatsiyalar
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52,Telecommunications,Telekommunikatsiyalar
+apps/erpnext/erpnext/accounts/party.py +266,Billing currency must be equal to either default company's currency or party account currency,To&#39;lov valyutasi odatiy kompaniyaning valyutasiga yoki partiyaning hisobvaraqlariga teng bo&#39;lishi kerak
 DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),Paket ushbu etkazib berishning bir qismi ekanligini ko&#39;rsatadi (faqat loyiha)
+DocType: Soil Texture,Loam,Loam
+apps/erpnext/erpnext/controllers/accounts_controller.py +680,Row {0}: Due Date cannot be before posting date,Row {0}: sanasi sanasidan oldin sanasi bo&#39;lmaydi
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36,Make Payment Entry,To&#39;lovni kiritish
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129,Quantity for Item {0} must be less than {1},{0} uchun mahsulot miqdori {1} dan kam bo&#39;lishi kerak
 ,Sales Invoice Trends,Sotuvdagi taqdim etgan tendentsiyalari
 DocType: Leave Application,Apply / Approve Leaves,Yaproqlarni qo&#39;llash / tasdiqlash
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,For,Uchun
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +150,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Qatorni faqatgina &#39;On oldingi satr miqdori&#39; yoki &#39;oldingi qatorni jami&#39;
+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',Qatorni faqatgina &#39;On oldingi satr miqdori&#39; yoki &#39;oldingi qatorni jami&#39;
 DocType: Sales Order Item,Delivery Warehouse,Etkazib beriladigan ombor
-apps/erpnext/erpnext/config/accounts.py +249,Tree of financial Cost Centers.,Moliyaviy xarajatlar markazlarining daraxti.
+apps/erpnext/erpnext/config/accounts.py +241,Tree of financial Cost Centers.,Moliyaviy xarajatlar markazlarining daraxti.
 DocType: Serial No,Delivery Document No,Yetkazib berish hujjati №
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +191,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},{0} da kompaniyadagi aktivlarni yo&#39;qotish bo&#39;yicha &#39;Qimmatli /
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},{0} da kompaniyadagi aktivlarni yo&#39;qotish bo&#39;yicha &#39;Qimmatli /
 DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Buyurtma olimlaridan narsalarni oling
 DocType: Serial No,Creation Date,Yaratilish sanasi
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33,Item {0} appears multiple times in Price List {1},{0} mahsuloti {1}
@@ -2027,19 +2178,20 @@
 apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,Javobni yangilash
 apps/erpnext/erpnext/public/js/utils.js +226,You have already selected items from {0} {1},{0} {1} dan tanlangan elementlarni tanladingiz
 DocType: Monthly Distribution,Name of the Monthly Distribution,Oylik tarqatish nomi
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +25,Batch ID is mandatory,Partiya identifikatori majburiydir
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +26,Batch ID is mandatory,Partiya identifikatori majburiydir
 DocType: Sales Person,Parent Sales Person,Ota-savdogar
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +180,High to Low,Yuqoridan pastgacha
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.py +24,Select the program first,Avval dasturni tanlang
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24,Select the program first,Avval dasturni tanlang
 DocType: Patient Appointment,Patient Age,Bemor yoshi
 apps/erpnext/erpnext/config/learn.py +263,Managing Projects,Loyihalarni boshqarish
 DocType: Supplier,Supplier of Goods or Services.,Mahsulot yoki xizmatlarni yetkazib beruvchi.
 DocType: Budget,Fiscal Year,Moliyaviy yil
+DocType: Asset Maintenance Log,Planned,Rejalashtirilgan
 DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Consultation charges.,"Agar bemorda konsultatsiya uchun to&#39;lovlar belgilanmagan bo&#39;lsa, foydalaniladigan debitorlik hisoblari."
 DocType: Vehicle Log,Fuel Price,Yoqilg&#39;i narxi
 DocType: Budget,Budget,Byudjet
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +43,Set Open,Ochish-ni tanlang
-apps/erpnext/erpnext/stock/doctype/item/item.py +245,Fixed Asset Item must be a non-stock item.,Ruxsat etilgan aktiv elementi qimmatli qog&#39;oz emas.
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +51,Set Open,Ochish-ni tanlang
+apps/erpnext/erpnext/stock/doctype/item/item.py +247,Fixed Asset Item must be a non-stock item.,Ruxsat etilgan aktiv elementi qimmatli qog&#39;oz emas.
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Byudjet {0} ga nisbatan tayinlanishi mumkin emas, chunki u daromad yoki xarajatlar hisobidir"
 apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,Saqlandi
 DocType: Student Admission,Application Form Route,Ariza shakli
@@ -2053,12 +2205,13 @@
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69,Item {0} is not setup for Serial Nos. Check Item master,{0} mahsuloti ketma-ketlik uchun sozlanmagan
 DocType: Maintenance Visit,Maintenance Time,Xizmat muddati
 ,Amount to Deliver,Taqdim etiladigan summalar
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +321,Same item has been entered multiple times. {0},Xuddi shu element bir necha marta kiritilgan. {0}
-apps/erpnext/erpnext/schools/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.,"Davrning boshlanishi sana atamasi bilan bog&#39;liq bo&#39;lgan Akademik yilning Yil boshlanishi sanasidan oldin bo&#39;lishi mumkin emas (Akademik yil (})). Iltimos, sanalarni tahrirlang va qaytadan urinib ko&#39;ring."
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +324,Same item has been entered multiple times. {0},Xuddi shu element bir necha marta kiritilgan. {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.,"Davrning boshlanishi sana atamasi bilan bog&#39;liq bo&#39;lgan Akademik yilning Yil boshlanishi sanasidan oldin bo&#39;lishi mumkin emas (Akademik yil (})). Iltimos, sanalarni tahrirlang va qaytadan urinib ko&#39;ring."
+apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +192,There were errors.,Xatolar bor edi.
 DocType: Guardian,Guardian Interests,Guardian manfaatlari
 DocType: Naming Series,Current Value,Joriy qiymat
-apps/erpnext/erpnext/controllers/accounts_controller.py +240,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,"{0} sana uchun bir necha moliyaviy yillar mavjud. Iltimos, kompaniyani Moliyaviy yilga qo&#39;ying"
-DocType: School Settings,Instructor Records to be created by,O&#39;qituvchi tomonidan yaratiladigan yozuvlar
+apps/erpnext/erpnext/controllers/accounts_controller.py +263,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,"{0} sana uchun bir necha moliyaviy yillar mavjud. Iltimos, kompaniyani Moliyaviy yilga qo&#39;ying"
+DocType: Education Settings,Instructor Records to be created by,O&#39;qituvchi tomonidan yaratiladigan yozuvlar
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229,{0} created,{0} yaratildi
 DocType: Delivery Note Item,Against Sales Order,Savdo buyurtmasiga qarshi
 ,Serial No Status,Seriya No status
@@ -2069,19 +2222,20 @@
 						must be greater than or equal to {2}","Row {0}: davriylikni {1} o&#39;rnatish uchun, bu va hozirgi vaqt orasidagi farq {2} dan katta yoki teng bo&#39;lishi kerak"
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6,This is based on stock movement. See {0} for details,Bu fond aktsiyalariga asoslangan. Tafsilotlar uchun {0} ga qarang
 DocType: Pricing Rule,Selling,Sotish
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +378,Amount {0} {1} deducted against {2},{0} {1} miqdori {2} ga nisbatan tushdi
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +379,Amount {0} {1} deducted against {2},{0} {1} miqdori {2} ga nisbatan tushdi
 DocType: Employee,Salary Information,Ish haqi haqida ma&#39;lumot
 DocType: Sales Person,Name and Employee ID,Ismi va xizmatdoshi identifikatori
-apps/erpnext/erpnext/accounts/party.py +310,Due Date cannot be before Posting Date,Yetkazish sanasi o&#39;tilganlik sanasi sanasidan oldin bo&#39;la olmaydi
+apps/erpnext/erpnext/accounts/party.py +311,Due Date cannot be before Posting Date,Yetkazish sanasi o&#39;tilganlik sanasi sanasidan oldin bo&#39;la olmaydi
 DocType: Website Item Group,Website Item Group,Veb-sayt elementi guruhi
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150,Duties and Taxes,Vazifalar va soliq
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356,Please enter Reference date,"Iltimos, arizani kiriting"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354,Please enter Reference date,"Iltimos, arizani kiriting"
 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} to&#39;lov yozuvlari {1} tomonidan filtrlanmaydi
 DocType: Item Website Specification,Table for Item that will be shown in Web Site,Veb-saytda ko&#39;rsatiladigan element uchun jadval
 DocType: Purchase Order Item Supplied,Supplied Qty,Olingan son
 DocType: Purchase Order Item,Material Request Item,Material-buyurtma so&#39;rovi
 apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Mavzu guruhlari daraxti.
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +160,Cannot refer row number greater than or equal to current row number for this Charge type,Ushbu zaryad turi uchun joriy satr raqamidan kattaroq yoki kattaroq satrlarni topib bo&#39;lmaydi
+DocType: Payroll Entry,Get Employee Details,Xodimlarning ma&#39;lumotlarini olish
+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,Ushbu zaryad turi uchun joriy satr raqamidan kattaroq yoki kattaroq satrlarni topib bo&#39;lmaydi
 DocType: Asset,Sold,Sotildi
 ,Item-wise Purchase History,Ob&#39;ektga qarab sotib olish tarixi
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},{0} elementiga qo&#39;shilgan ketma-ketlik uchun &quot;Jadvalni yarat&quot; tugmasini bosing
@@ -2093,7 +2247,7 @@
 DocType: Sales Invoice,Accounting Details,Hisobot tafsilotlari
 apps/erpnext/erpnext/setup/doctype/company/company.js +84,Delete all the Transactions for this Company,Ushbu kompaniyaning barcha operatsiyalarini o&#39;chirish
 DocType: Patient,O Positive,U ijobiy
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +190,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,# {0} qatori: {1} mahsuloti ishlab chiqarish Buyurtma # {3} da tayyor mahsulotlarning {2} miqdorida bajarilmadi. Vaqt qaydnomalari orqali operatsiya holatini yangilang
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +195,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,# {0} qatori: {1} mahsuloti ishlab chiqarish Buyurtma # {3} da tayyor mahsulotlarning {2} miqdorida bajarilmadi. Vaqt qaydnomalari orqali operatsiya holatini yangilang
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,Investments,Investitsiyalar
 DocType: Issue,Resolution Details,Qaror ma&#39;lumotlari
 apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3,Allocations,Ajratishlar
@@ -2105,6 +2259,7 @@
 DocType: Employee Loan Application,Total Payable Amount,To&#39;lanadigan qarz miqdori
 DocType: Task,Expected Time (in hours),Kutilgan vaqt (soatda)
 DocType: Item Reorder,Check in (group),Kirish (guruh)
+DocType: Soil Texture,Silt,Silt
 ,Qty to Order,Buyurtma miqdori
 DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Mas&#39;uliyat yoki o&#39;z mablag&#39;lari bo&#39;yicha hisob-varag&#39;i boshlig&#39;i, unda Qor / ziyon yo&#39;qolishi mumkin"
 apps/erpnext/erpnext/config/projects.py +31,Gantt chart of all tasks.,Barcha vazifalar uchun Gantt jadvali.
@@ -2114,7 +2269,7 @@
 DocType: Course,Default Grading Scale,Standart Baholash o&#39;lchovi
 DocType: Appraisal,For Employee Name,Ishchi nomi uchun
 DocType: Holiday List,Clear Table,Jadvalni tozalang
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +98,Available slots,Mavjud bo&#39;shliqlar
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +106,Available slots,Mavjud bo&#39;shliqlar
 DocType: C-Form Invoice Detail,Invoice No,Faktura raqami №
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +350,Make Payment,To&#39;lovni amalga oshirish
 DocType: Room,Room Name,Xona nomi
@@ -2125,15 +2280,18 @@
 ,Campaign Efficiency,Kampaniya samaradorligi
 DocType: Discussion,Discussion,Munozara
 DocType: Payment Entry,Transaction ID,Jurnal identifikatori
+DocType: Volunteer,Anytime,Har doim
 DocType: Patient,Surgical History,Jarrohlik tarixi
 DocType: Employee,Resignation Letter Date,Ishdan bo&#39;shatish xati
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39,Pricing Rules are further filtered based on quantity.,Raqobatchilar qoidalari miqdori bo&#39;yicha qo&#39;shimcha ravishda filtrlanadi.
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335,Please set the Date Of Joining for employee {0},"Iltimos, xodimingizga {0}"
 DocType: Task,Total Billing Amount (via Time Sheet),Jami to&#39;lov miqdori (vaqt jadvalidan)
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Xaridor daromadini takrorlang
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +175,{0} ({1}) must have role 'Expense Approver',{0} ({1}) roli &quot;Expense Approver&quot;
-apps/erpnext/erpnext/utilities/user_progress.py +125,Pair,Juft
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +912,Select BOM and Qty for Production,Ishlab chiqarish uchun BOM va Qty ni tanlang
+DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
+DocType: Chapter,Chapter,Bo&#39;lim
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +200,{0} ({1}) must have role 'Expense Approver',{0} ({1}) roli &quot;Expense Approver&quot;
+apps/erpnext/erpnext/utilities/user_progress.py +143,Pair,Juft
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +959,Select BOM and Qty for Production,Ishlab chiqarish uchun BOM va Qty ni tanlang
 DocType: Asset,Depreciation Schedule,Amortizatsiya jadvali
 apps/erpnext/erpnext/config/selling.py +124,Sales Partner Addresses And Contacts,Savdo hamkorlari manzili va aloqalar
 DocType: Bank Reconciliation Detail,Against Account,Hisobga qarshi
@@ -2141,37 +2299,41 @@
 DocType: Maintenance Schedule Detail,Actual Date,Haqiqiy sana
 DocType: Item,Has Batch No,Partiya no
 apps/erpnext/erpnext/public/js/utils.js +100,Annual Billing: {0},Yillik to&#39;lov: {0}
-apps/erpnext/erpnext/config/accounts.py +208,Goods and Services Tax (GST India),Mol va xizmatlar solig&#39;i (GST Hindiston)
+apps/erpnext/erpnext/config/accounts.py +200,Goods and Services Tax (GST India),Mol va xizmatlar solig&#39;i (GST Hindiston)
 DocType: Delivery Note,Excise Page Number,Aktsiz to&#39;lanadigan sahifa raqami
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +157,"Company, From Date and To Date is mandatory","Kompaniya, Sana va Sana uchun majburiydir"
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +225,"Company, From Date and To Date is mandatory","Kompaniya, Sana va Sana uchun majburiydir"
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33,Get from Consultation,Maslahatlashuvdan oling
 DocType: Asset,Purchase Date,Sotib olish sanasi
-DocType: Employee,Personal Details,Shaxsiy ma&#39;lumotlar
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +193,Please set 'Asset Depreciation Cost Center' in Company {0},"Iltimos, {0} kompaniyasida &quot;Asset Amortizatsiya xarajatlari markazi&quot; ni belgilang"
+DocType: Volunteer,Volunteer Type,Ko&#39;ngilli turi
+DocType: Student,Personal Details,Shaxsiy ma&#39;lumotlar
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193,Please set 'Asset Depreciation Cost Center' in Company {0},"Iltimos, {0} kompaniyasida &quot;Asset Amortizatsiya xarajatlari markazi&quot; ni belgilang"
 ,Maintenance Schedules,Xizmat jadvali
 DocType: Task,Actual End Date (via Time Sheet),Haqiqiy tugash sanasi (vaqt jadvalidan orqali)
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +373,Amount {0} {1} against {2} {3},{0} {1} miqdori {2} {3} ga qarshi
+DocType: Soil Texture,Soil Type,Tuproq turi
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374,Amount {0} {1} against {2} {3},{0} {1} miqdori {2} {3} ga qarshi
 ,Quotation Trends,Iqtiboslar tendentsiyalari
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +159,Item Group not mentioned in item master for item {0},{0} element uchun maqola ustidagi ob&#39;ektlar guruhi
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +358,Debit To account must be a Receivable account,Debet Hisobni hisobvaraq deb hisoblash kerak
-DocType: Shipping Rule Condition,Shipping Amount,Yuk tashish miqdori
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +362,Debit To account must be a Receivable account,Debet Hisobni hisobvaraq deb hisoblash kerak
+DocType: Shipping Rule,Shipping Amount,Yuk tashish miqdori
 DocType: Supplier Scorecard Period,Period Score,Davr hisoboti
 apps/erpnext/erpnext/utilities/user_progress.py +63,Add Customers,Mijozlarni qo&#39;shish
 apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Pending Amount,Kutilayotgan miqdor
 DocType: Lab Test Template,Special,Maxsus
-DocType: Purchase Invoice Item,Conversion Factor,Ishlab chiqarish omili
+DocType: Purchase Order Item Supplied,Conversion Factor,Ishlab chiqarish omili
 DocType: Purchase Order,Delivered,Yetkazildi
 ,Vehicle Expenses,Avtomobil xarajatlari
 DocType: Serial No,Invoice Details,Faktura tafsilotlari
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +155,Expected value after useful life must be greater than or equal to {0},Foydali umrdan keyin kutilgan qiymat {0} dan katta yoki unga teng bo&#39;lishi kerak
-apps/erpnext/erpnext/schools/doctype/student_admission/templates/student_admission.html +29,Start on,Boshlang
+DocType: Grant Application,Show on Website,Saytda ko&#39;rsatish
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +155,Expected value after useful life must be greater than or equal to {0},Foydali umrdan keyin kutilgan qiymat {0} dan katta yoki unga teng bo&#39;lishi kerak
+apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29,Start on,Boshlang
 DocType: Hub Category,Hub Category,Hub-toifa
 DocType: Purchase Invoice,SEZ,SEZ
 DocType: Purchase Receipt,Vehicle Number,Avtomobil raqami
 DocType: Employee Loan,Loan Amount,Kredit miqdori
+apps/erpnext/erpnext/utilities/user_progress.py +88,Add Letterhead,Antetli qo&#39;shing
 DocType: Program Enrollment,Self-Driving Vehicle,O&#39;z-o&#39;zidan avtomashina vositasi
 DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Yetkazib beruvchi Koreya kartasi
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +419,Row {0}: Bill of Materials not found for the Item {1},Row {0}: Mahsulot {1} uchun topilmadi.
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +420,Row {0}: Bill of Materials not found for the Item {1},Row {0}: Mahsulot {1} uchun topilmadi.
 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,Berilgan jami {0} barglari davr uchun tasdiqlangan {1} barglaridan kam bo&#39;lishi mumkin emas
 DocType: Journal Entry,Accounts Receivable,Kutilgan tushim
 ,Supplier-Wise Sales Analytics,Yetkazib beruvchi-aqlli Sotuvdagi Tahliliy
@@ -2182,28 +2344,29 @@
 DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Ota-ona kursi (Bo&#39;sh qoldiring, agar bu Ota-ona kursining bir qismi bo&#39;lmasa)"
 DocType: Leave Control Panel,Leave blank if considered for all employee types,Barcha xodimlar uchun mo&#39;ljallangan bo&#39;lsa bo&#39;sh qoldiring
 DocType: Landed Cost Voucher,Distribute Charges Based On,To&#39;lov asosida to&#39;lovlarni taqsimlash
-apps/erpnext/erpnext/hooks.py +140,Timesheets,Vaqt jadvallari
+apps/erpnext/erpnext/hooks.py +144,Timesheets,Vaqt jadvallari
 DocType: HR Settings,HR Settings,HRni sozlash
 DocType: Salary Slip,net pay info,aniq to&#39;lov ma&#39;lumoti
 DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Ushbu qiymat Default Sales Price List&#39;da yangilanadi.
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +111,Expense Claim is pending approval. Only the Expense Approver can update status.,Xarajat talabi rozilikni kutmoqda. Faqat xarajatlarni tasdiqlovchi status yangilanishi mumkin.
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +122,Expense Claim is pending approval. Only the Expense Approver can update status.,Xarajat talabi rozilikni kutmoqda. Faqat xarajatlarni tasdiqlovchi status yangilanishi mumkin.
 DocType: Email Digest,New Expenses,Yangi xarajatlar
 DocType: Purchase Invoice,Additional Discount Amount,Qo&#39;shimcha chegirma miqdori
 DocType: Consultation,Patient Details,Bemor batafsil
 DocType: Patient,B Positive,B ijobiy
-apps/erpnext/erpnext/controllers/accounts_controller.py +531,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Row # {0}: element 1 element bo&#39;lishi shart. Iltimos, bir necha qty uchun alohida qatordan foydalaning."
+apps/erpnext/erpnext/controllers/accounts_controller.py +575,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Row # {0}: element 1 element bo&#39;lishi shart. Iltimos, bir necha qty uchun alohida qatordan foydalaning."
 DocType: Leave Block List Allow,Leave Block List Allow,Bloklashlar ro&#39;yxatini qoldiring
-apps/erpnext/erpnext/setup/doctype/company/company.py +291,Abbr can not be blank or space,Abbr bo&#39;sh yoki bo&#39;sh joy bo&#39;la olmaydi
+apps/erpnext/erpnext/setup/doctype/company/company.py +288,Abbr can not be blank or space,Abbr bo&#39;sh yoki bo&#39;sh joy bo&#39;la olmaydi
 DocType: Patient Medical Record,Patient Medical Record,Kasal Tibbiy Ro&#39;yxatdan
-apps/erpnext/erpnext/accounts/doctype/account/account.js +62,Group to Non-Group,Guruh bo&#39;lmaganlar guruhiga
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +50,Sports,Sport
+apps/erpnext/erpnext/accounts/doctype/account/account.js +68,Group to Non-Group,Guruh bo&#39;lmaganlar guruhiga
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50,Sports,Sport
 DocType: Loan Type,Loan Name,Kredit nomi
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Actual,Jami haqiqiy
 DocType: Lab Test UOM,Test UOM,UOMni sinab ko&#39;ring
 DocType: Student Siblings,Student Siblings,Talaba birodarlari
-apps/erpnext/erpnext/utilities/user_progress.py +125,Unit,Birlik
-apps/erpnext/erpnext/stock/get_item_details.py +141,Please specify Company,"Iltimos, kompaniyani ko&#39;rsating"
+apps/erpnext/erpnext/utilities/user_progress.py +143,Unit,Birlik
+apps/erpnext/erpnext/stock/get_item_details.py +136,Please specify Company,"Iltimos, kompaniyani ko&#39;rsating"
 ,Customer Acquisition and Loyalty,Mijozlarni xarid qilish va sodiqlik
+DocType: Asset Maintenance Task,Maintenance Task,Xizmat topshirish
 DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,Rad etilgan elementlar zaxirasini saqlayotgan ombor
 DocType: Production Order,Skip Material Transfer,Materiallarni o&#39;tkazib yuborish
 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,"{2} kalit sana uchun {0} dan {1} gacha bo&#39;lgan valyuta kursini topib bo&#39;lmadi. Iltimos, valyuta ayirboshlash yozuvini qo&#39;lda yarating"
@@ -2213,69 +2376,72 @@
 DocType: Issue,Support,Yordam
 ,BOM Search,BOM qidirish
 DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Ushbu omborda mavjud bo&#39;lgan kabinetga asosida &quot;In Stock&quot; yoki &quot;Stokta emas&quot; ni chop eting.
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +189,Closing (Opening + Totals),Yakunlovchi (ochilish + jami)
 DocType: Vehicle,Fuel Type,Yoqilg&#39;i turi
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27,Please specify currency in Company,"Iltimos, kompaniyadagi valyutani ko&#39;rsating"
 DocType: Workstation,Wages per hour,Bir soatlik ish haqi
 apps/erpnext/erpnext/templates/emails/reorder_item.html +1,Following Material Requests have been raised automatically based on Item's re-order level,"Materiallar so&#39;rovlaridan so&#39;ng, Materiallar buyurtma buyurtma darajasi bo&#39;yicha avtomatik ravishda to&#39;ldirildi"
 DocType: Email Digest,Pending Sales Orders,Kutilayotgan Sotuvdagi Buyurtma
-apps/erpnext/erpnext/controllers/accounts_controller.py +279,Account {0} is invalid. Account Currency must be {1},Hisob {0} yaroqsiz. Hisob valyutasi {1} bo&#39;lishi kerak
+apps/erpnext/erpnext/controllers/accounts_controller.py +302,Account {0} is invalid. Account Currency must be {1},Hisob {0} yaroqsiz. Hisob valyutasi {1} bo&#39;lishi kerak
 DocType: Healthcare Settings,Remind Before,Avval eslatish
 apps/erpnext/erpnext/buying/utils.py +34,UOM Conversion factor is required in row {0},{0} qatorida UOM o&#39;tkazish faktori talab qilinadi
 DocType: Production Plan Item,material_request_item,material_request_item
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1034,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","# {0} sath: Ariza Hujjat turi Sotuvdagi Buyurtma, Sotuvdagi Billing yoki Jurnal Yozuvi bo&#39;lishi kerak"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1060,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","# {0} sath: Ariza Hujjat turi Sotuvdagi Buyurtma, Sotuvdagi Billing yoki Jurnal Yozuvi bo&#39;lishi kerak"
 DocType: Salary Component,Deduction,O&#39;chirish
+DocType: Item,Retain Sample,Namunani saqlang
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,Row {0}: From Time and To Time is mandatory.,Row {0}: Vaqt va vaqtdan boshlab majburiydir.
 DocType: Stock Reconciliation Item,Amount Difference,Miqdori farqi
-apps/erpnext/erpnext/stock/get_item_details.py +306,Item Price added for {0} in Price List {1},{1} narxlar ro&#39;yxatida {0} uchun qo&#39;shilgan narx
+apps/erpnext/erpnext/stock/get_item_details.py +349,Item Price added for {0} in Price List {1},{1} narxlar ro&#39;yxatida {0} uchun qo&#39;shilgan narx
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8,Please enter Employee Id of this sales person,"Iltimos, ushbu savdo vakili xodimining identifikatorini kiriting"
 DocType: Territory,Classification of Customers by region,Mintaqalar bo&#39;yicha mijozlarni tasniflash
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +57,Difference Amount must be zero,Ajratish miqdori nol bo&#39;lishi kerak
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +71,In Production,Ishlab chiqarishda
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +59,Difference Amount must be zero,Ajratish miqdori nol bo&#39;lishi kerak
 DocType: Project,Gross Margin,Yalpi marj
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +61,Please enter Production Item first,Avval ishlab chiqarish elementini kiriting
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Calculated Bank Statement balance,Bank hisob-kitob balansi hisoblangan
 DocType: Normal Test Template,Normal Test Template,Oddiy viktorina namunasi
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,o&#39;chirilgan foydalanuvchi
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.js +764,Quotation,Tavsif
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +957,Cannot set a received RFQ to No Quote,Hechqisi taklif qilinmagan RFQni o&#39;rnatib bo&#39;lmaydi
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +913,Quotation,Tavsif
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +982,Cannot set a received RFQ to No Quote,Hechqisi taklif qilinmagan RFQni o&#39;rnatib bo&#39;lmaydi
 DocType: Quotation,QTN-,QTN-
 DocType: Salary Slip,Total Deduction,Jami cheklov
 ,Production Analytics,Ishlab chiqarish tahlillari
 apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6,This is based on transactions against this Patient. See timeline below for details,Bu bemorga qilingan operatsiyalarga asoslanadi. Tafsilotlar uchun quyidagi jadvalga qarang
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +201,Cost Updated,Qiymati yangilandi
-DocType: Employee,Date of Birth,Tug&#39;ilgan sana
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Mahsulot kodi&gt; Mahsulot guruhi&gt; Tovar
+DocType: Patient,Date of Birth,Tug&#39;ilgan sana
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +129,Item {0} has already been returned,{0} elementi allaqachon qaytarilgan
 DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Moliyaviy yil ** moliyaviy yilni anglatadi. Barcha buxgalteriya yozuvlari va boshqa muhim bitimlar ** moliyaviy yilga nisbatan ** kuzatiladi.
 DocType: Opportunity,Customer / Lead Address,Xaridor / qo&#39;rg&#39;oshin manzili
-DocType: Patient,DOB,DOB
 DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Yetkazib beruvchi Koreya kartasi
-apps/erpnext/erpnext/schools/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Baholash rejasining nomi
-apps/erpnext/erpnext/stock/doctype/item/item.py +220,Warning: Invalid SSL certificate on attachment {0},Ogohlantirish: {0} biriktirmasidagi SSL sertifikati noto&#39;g&#39;ri.
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Baholash rejasining nomi
+apps/erpnext/erpnext/stock/doctype/item/item.py +222,Warning: Invalid SSL certificate on attachment {0},Ogohlantirish: {0} biriktirmasidagi SSL sertifikati noto&#39;g&#39;ri.
 apps/erpnext/erpnext/utilities/activation.py +64,"Leads help you get business, add all your contacts and more as your leads","Rahbarlar sizning biznesingizga yordam beradi, sizning barcha kontaktlaringizni va boshqalaringizni yetakchilik qilishingiz mumkin"
 DocType: Production Order Operation,Actual Operation Time,Haqiqiy operatsiya vaqti
 DocType: Authorization Rule,Applicable To (User),Qo&#39;llaniladigan To (User)
 DocType: Purchase Taxes and Charges,Deduct,Deduct
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +226,Job Description,Ishning tavsifi
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +236,Job Description,Ishning tavsifi
 DocType: Student Applicant,Applied,Amalga oshirildi
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +834,Re-open,Qayta oching
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +859,Re-open,Qayta oching
 DocType: Sales Invoice Item,Qty as per Stock UOM,Qimmatli qog&#39;ozlar aktsiyadorlik jamiyati bo&#39;yicha
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Guardian2 Ismi
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Guardian2 Ismi
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +127,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Maxsus belgilar &quot;-&quot;, &quot;#&quot;, &quot;.&quot; va &quot;/&quot; seriyasining nomlanishiga ruxsat berilmaydi"
 DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Savdo kampaniyalarini kuzating. Qimmatli qog&#39;ozlar, takliflar, Sotuvdagi Buyurtma va boshqalar."
 DocType: Expense Claim,Approver,Tasdiqlash
 ,SO Qty,SO Miqdor
 DocType: Guardian,Work Address,Ish manzili
 DocType: Appraisal,Calculate Total Score,Umumiy ballni hisoblash
-DocType: Request for Quotation,Manufacturing Manager,Ishlab chiqarish menejeri
+DocType: Asset Repair,Manufacturing Manager,Ishlab chiqarish menejeri
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191,Serial No {0} is under warranty upto {1},Har qanday {0} gacha {1}
-apps/erpnext/erpnext/config/stock.py +163,Split Delivery Note into packages.,Bo&#39;linishni tarqatish Paketlarga eslatma.
-apps/erpnext/erpnext/hooks.py +107,Shipments,Yuklar
+DocType: Plant Analysis Criteria,Minimum Permissible Value,Minimal ruxsat qiymati
+apps/erpnext/erpnext/education/doctype/guardian/guardian.py +42,User {0} already exists,{0} foydalanuvchisi allaqachon mavjud
+apps/erpnext/erpnext/hooks.py +109,Shipments,Yuklar
 DocType: Payment Entry,Total Allocated Amount (Company Currency),Jami ajratilgan mablag&#39;lar (Kompaniya valyutasi)
 DocType: Purchase Order Item,To be delivered to customer,Xaridorga etkazib berish
 DocType: BOM,Scrap Material Cost,Hurda Materiallari narxi
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227,Serial No {0} does not belong to any Warehouse,No {0} seriyali har qanday omborga tegishli emas
+DocType: Grant Application,Email Notification Sent,E-pochta xabari yuborildi
 DocType: Purchase Invoice,In Words (Company Currency),So&#39;zlarda (Kompaniya valyutasi)
-DocType: Asset,Supplier,Yetkazib beruvchi
+DocType: Pricing Rule,Supplier,Yetkazib beruvchi
 DocType: Consultation,Consultation Time,Maslahatlash vaqti
 DocType: C-Form,Quarter,Chorak
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,Miscellaneous Expenses,Har xil xarajatlar
@@ -2288,112 +2454,120 @@
 DocType: Leave Application,Total Leave Days,Jami chiqish kunlari
 DocType: Email Digest,Note: Email will not be sent to disabled users,Eslatma: E-pochta nogironlar foydalanuvchilariga yuborilmaydi
 apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,O&#39;zaro munosabatlar soni
-apps/erpnext/erpnext/stock/doctype/item/item.js +102,Item Variant Settings,Variant sozlamalari
+apps/erpnext/erpnext/stock/doctype/item/item.js +105,Item Variant Settings,Variant sozlamalari
 apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +39,Select Company...,Kompaniyani tanlang ...
 DocType: Leave Control Panel,Leave blank if considered for all departments,Barcha bo&#39;limlarda ko&#39;rib chiqilsa bo&#39;sh qoldiring
-apps/erpnext/erpnext/config/hr.py +223,"Types of employment (permanent, contract, intern etc.).","Ish turlari (doimiy, shartnoma, stajyor va hk)."
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +424,{0} is mandatory for Item {1},{0} {1} mahsulot uchun majburiydir
-DocType: Process Payroll,Fortnightly,Ikki kun davomida
+apps/erpnext/erpnext/config/hr.py +228,"Types of employment (permanent, contract, intern etc.).","Ish turlari (doimiy, shartnoma, stajyor va hk)."
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +428,{0} is mandatory for Item {1},{0} {1} mahsulot uchun majburiydir
+DocType: Payroll Entry,Fortnightly,Ikki kun davomida
 DocType: Currency Exchange,From Currency,Valyutadan
 DocType: Vital Signs,Weight (In Kilogram),Og&#39;irligi (kilogrammda)
+DocType: Chapter,"chapters/chapter_name
+leave blank automatically set after saving chapter.",bo&#39;limlari / chapter_name qismni saqlashdan so&#39;ng avtomatik ravishda sozlansin.
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +170,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Iltimos, atigi bir qatorda ajratilgan miqdori, hisob-faktura turi va hisob-faktura raqami-ni tanlang"
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +125,Cost of New Purchase,Yangi xarid qiymati
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +128,Cost of New Purchase,Yangi xarid qiymati
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97,Sales Order required for Item {0},{0} band uchun zarur Sotuvdagi Buyurtma
+DocType: Grant Application,Grant Description,Grantlar tavsifi
 DocType: Purchase Invoice Item,Rate (Company Currency),Tarif (Kompaniya valyutasi)
 DocType: Student Guardian,Others,Boshqalar
 DocType: Payment Entry,Unallocated Amount,Dividendlar miqdori
 apps/erpnext/erpnext/templates/includes/product_page.js +71,Cannot find a matching Item. Please select some other value for {0}.,Mos keladigan elementni topib bo&#39;lmadi. {0} uchun boshqa qiymatni tanlang.
 DocType: POS Profile,Taxes and Charges,Soliqlar va yig&#39;imlar
 DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Xarid qilingan, sotiladigan yoki sotiladigan mahsulot yoki xizmat."
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +24,Please setup Employee Naming System in Human Resource &gt; HR Settings,Inson resurslari&gt; HR parametrlarini Xodimlar uchun nomlash tizimini sozlang
 apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44,No more updates,Boshqa yangilanishlar yo&#39;q
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +154,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,To&#39;lov turi &quot;Birinchi qatorda oldingi miqdorda&quot; yoki &quot;Birinchi qatorda oldingi qatorda&quot; tanlanmaydi
+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,To&#39;lov turi &quot;Birinchi qatorda oldingi miqdorda&quot; yoki &quot;Birinchi qatorda oldingi qatorda&quot; tanlanmaydi
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6,This covers all scorecards tied to this Setup,Ushbu sozlash bilan bog&#39;liq barcha ko&#39;rsatkichlar mavjud
 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,"Bola mahsuloti mahsulot to&#39;plami bo&#39;lmasligi kerak. Iltimos, `{0}` dan olib tashlang va saqlang"
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +12,Banking,Bank xizmatlari
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12,Banking,Bank xizmatlari
 apps/erpnext/erpnext/utilities/activation.py +108,Add Timesheets,Vaqt jadvallarini qo&#39;shish
 DocType: Vehicle Service,Service Item,Xizmat elementi
 DocType: Bank Guarantee,Bank Guarantee,Bank kafolati
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39,Please click on 'Generate Schedule' to get schedule,Jadvalni olish uchun &quot;Jadvalni yarat&quot; tugmasini bosing
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +56,There were errors while deleting following schedules:,Quyidagi jadvallarni o&#39;chirishda xatolar yuz berdi:
 DocType: Bin,Ordered Quantity,Buyurtma miqdori
-apps/erpnext/erpnext/public/js/setup_wizard.js +115,"e.g. ""Build tools for builders""","Masalan, &quot;Quruvchilar uchun asboblarni yaratish&quot;"
+apps/erpnext/erpnext/public/js/setup_wizard.js +118,"e.g. ""Build tools for builders""","Masalan, &quot;Quruvchilar uchun asboblarni yaratish&quot;"
 DocType: Grading Scale,Grading Scale Intervals,Baholash o&#39;lchov oralig&#39;i
 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} uchun: {2} uchun buxgalterlik yozuvi faqat valyutada amalga oshirilishi mumkin: {3}
-DocType: Production Order,In Process,Jarayonida
+DocType: Fee Schedule,In Process,Jarayonida
 DocType: Authorization Rule,Itemwise Discount,Imtiyozli miqdor
 apps/erpnext/erpnext/config/accounts.py +75,Tree of financial accounts.,Moliyaviy hisoblar daraxti.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364,{0} against Sales Order {1},{0} Sotuvdagi buyurtmalariga nisbatan {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +362,{0} against Sales Order {1},{0} Sotuvdagi buyurtmalariga nisbatan {1}
 DocType: Account,Fixed Asset,Ruxsat etilgan aktiv
 apps/erpnext/erpnext/config/stock.py +320,Serialized Inventory,Seriyali inventar
 DocType: Employee Loan,Account Info,Hisob ma&#39;lumotlari
 DocType: Activity Type,Default Billing Rate,Standart billing darajasi
 DocType: Fees,Include Payment,To&#39;lovni qo&#39;shing
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} Talabalar guruhlari yaratildi.
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} Talabalar guruhlari yaratildi.
 DocType: Sales Invoice,Total Billing Amount,To&#39;lov miqdori
 apps/erpnext/erpnext/hr/doctype/daily_work_summary_settings/daily_work_summary_settings.py +17,There must be a default incoming Email Account enabled for this to work. Please setup a default incoming Email Account (POP/IMAP) and try again.,Buning uchun ishlashga mos kelgan elektron pochta hisob qaydnomasi bo&#39;lishi kerak. Standart kirish elektron pochta qayd hisobini (POP / IMAP) sozlang va qaytadan urinib ko&#39;ring.
-DocType: Healthcare Settings,Receivable Account,Oladigan Hisob
-apps/erpnext/erpnext/controllers/accounts_controller.py +553,Row #{0}: Asset {1} is already {2},# {0} satri: Asset {1} allaqachon {2}
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50,Program in the Fee Structure and Student Group {0} are different.,Ish haqi tarkibi va talabalar guruhi {0} da dastur boshqacha.
+DocType: Fee Schedule,Receivable Account,Oladigan Hisob
+apps/erpnext/erpnext/controllers/accounts_controller.py +597,Row #{0}: Asset {1} is already {2},# {0} satri: Asset {1} allaqachon {2}
 DocType: Quotation Item,Stock Balance,Kabinetga balansi
 apps/erpnext/erpnext/config/selling.py +316,Sales Order to Payment,Sotish Buyurtma To&#39;lovi
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +119,CEO,Bosh ijrochi direktor
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123,CEO,Bosh ijrochi direktor
 DocType: Purchase Invoice,With Payment of Tax,Soliq to&#39;lash bilan
 DocType: Expense Claim Detail,Expense Claim Detail,Xarajatlar bo&#39;yicha da&#39;vo tafsiloti
 DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,Yetkazib beruvchiga TRIPLIKAT
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +868,Please select correct account,"Iltimos, to&#39;g&#39;ri hisobni tanlang"
-DocType: Item,Weight UOM,Og&#39;irligi UOM
+DocType: Land Unit,Is Container,Konteyner
+DocType: Crop Cycle,This will be day 1 of the crop cycle,Bu hosildorlikning 1-kunidir
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +869,Please select correct account,"Iltimos, to&#39;g&#39;ri hisobni tanlang"
+DocType: Purchase Invoice Item,Weight UOM,Og&#39;irligi UOM
 DocType: Salary Structure Employee,Salary Structure Employee,Ish haqi tuzilishi xodimi
-DocType: Patient,Blood Group,Qon guruhi
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45,Show Variant Attributes,Variant xususiyatlarini ko&#39;rsatish
+DocType: Student,Blood Group,Qon guruhi
 DocType: Course,Course Name,Kurs nomi
 DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,Muayyan xodimning ruxsatnomalarini tasdiqlashi mumkin bo&#39;lgan foydalanuvchilar
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52,Office Equipments,Ofis uskunalari
 DocType: Purchase Invoice Item,Qty,Miqdor
 DocType: Fiscal Year,Companies,Kompaniyalar
 DocType: Supplier Scorecard,Scoring Setup,Sozlamalarni baholash
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +24,Electronics,Elektronika
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24,Electronics,Elektronika
 DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Buyurtma qayta buyurtma darajasiga yetganida Materiallar so&#39;rovini ko&#39;taring
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +94,Full-time,To&#39;liq stavka
-DocType: Salary Structure,Employees,Xodimlar
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98,Full-time,To&#39;liq stavka
+DocType: Payroll Entry,Employees,Xodimlar
 DocType: Employee,Contact Details,Aloqa tafsilotlari
 DocType: C-Form,Received Date,Olingan sana
 DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Sotuvdagi soliqlar va to&#39;lovlar shablonida standart shablonni yaratgan bo&#39;lsangiz, ulardan birini tanlang va quyidagi tugmani bosing."
 DocType: BOM Scrap Item,Basic Amount (Company Currency),Asosiy miqdori (Kompaniya valyutasi)
 DocType: Student,Guardians,Himoyachilar
 DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,"Narxlar ro&#39;yxati o&#39;rnatilmagan bo&#39;lsa, narxlar ko&#39;rsatilmaydi"
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +28,Please specify a country for this Shipping Rule or check Worldwide Shipping,"Iltimos, ushbu yuk tashish qoida uchun mamlakatni ko&#39;rsating yoki butun dunyo bo&#39;ylab yuklarni tekshiring"
 DocType: Stock Entry,Total Incoming Value,Jami kirish qiymati
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +352,Debit To is required,Debet kerak
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +356,Debit To is required,Debet kerak
 apps/erpnext/erpnext/utilities/activation.py +109,"Timesheets help keep track of time, cost and billing for activites done by your team","Vaqt jadvallari sizning jamoangiz tomonidan amalga oshiriladigan tadbirlar uchun vaqtni, narxni va hisob-kitoblarni kuzatish imkonini beradi"
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,Sotib olish narxlari ro&#39;yxati
 apps/erpnext/erpnext/config/buying.py +155,Templates of supplier scorecard variables.,Yetkazib beruvchilar kartalari o&#39;zgaruvchilari shabloni.
 DocType: Offer Letter Term,Offer Term,Taklif muddati
-DocType: Quality Inspection,Quality Manager,Sifat menejeri
+DocType: Asset,Quality Manager,Sifat menejeri
 DocType: Job Applicant,Job Opening,Ishni ochish
 DocType: Payment Reconciliation,Payment Reconciliation,To&#39;lovni taqsimlash
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153,Please select Incharge Person's name,"Iltimos, Incharge Person nomini tanlang"
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +51,Technology,Texnologiya
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51,Technology,Texnologiya
 DocType: Hub Settings,Unregister from Hub,Uyadan ro&#39;yxatdan o&#39;tish
 apps/erpnext/erpnext/public/js/utils.js +102,Total Unpaid: {0},Jami to&#39;lanmagan: {0}
 DocType: BOM Website Operation,BOM Website Operation,BOM veb-sayt operatsiyasi
 apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,Offer Letter,Taklifnomani taqdim eting
 apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Production Orders.,Materiallar talablari (MRP) va ishlab chiqarish buyurtmalarini yaratish.
 DocType: Supplier Scorecard,Supplier Score,Yetkazib beruvchi reytingi
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +76,Total Invoiced Amt,Jami Faturali Amet
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +87,Total Invoiced Amt,Jami Faturali Amet
 DocType: Supplier,Warn RFQs,RFQlarni ogohlantir
 DocType: BOM,Conversion Rate,Ishlab chiqarish darajasi
 apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,Mahsulot qidirish
-DocType: Physician Schedule Time Slot,To Time,Vaqtgacha
+DocType: Assessment Plan,To Time,Vaqtgacha
 DocType: Authorization Rule,Approving Role (above authorized value),Rolni tasdiqlash (vakolatli qiymatdan yuqoriroq)
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115,Credit To account must be a Payable account,Kredit Hisob uchun to&#39;lanadigan hisob bo&#39;lishi kerak
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.py +43,Please select Student Admission which is mandatory for the paid student applicant,"Iltimos, to&#39;ldirilgan talaba nomzodiga majburiy bo&#39;lgan talabgor qabul qiling"
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +335,BOM recursion: {0} cannot be parent or child of {2},BOM recursion: {0} ota-ona yoki {2}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118,Credit To account must be a Payable account,Kredit Hisob uchun to&#39;lanadigan hisob bo&#39;lishi kerak
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43,Please select Student Admission which is mandatory for the paid student applicant,"Iltimos, to&#39;ldirilgan talaba nomzodiga majburiy bo&#39;lgan talabgor qabul qiling"
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +338,BOM recursion: {0} cannot be parent or child of {2},BOM recursion: {0} ota-ona yoki {2}
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +23,Please select a Price List to publish pricing,"Narxlarni nashr qilish uchun iltimos, narxlar ro&#39;yxatini tanlang"
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38,Budget List,Byudjet ro&#39;yxati
 DocType: Production Order Operation,Completed Qty,Tugallangan son
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148,"For {0}, only debit accounts can be linked against another credit entry",{0} uchun faqat bank hisoblari boshqa kredit yozuvlari bilan bog&#39;lanishi mumkin
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +146,"For {0}, only debit accounts can be linked against another credit entry",{0} uchun faqat bank hisoblari boshqa kredit yozuvlari bilan bog&#39;lanishi mumkin
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27,Price List {0} is disabled,Narxlar ro&#39;yxati {0} o&#39;chirildi
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127,Row {0}: Completed Qty cannot be more than {1} for operation {2},Row {0}: bajarilgan Qty {1} dan foydalanish uchun {2} dan ortiq bo&#39;lishi mumkin emas
 DocType: Manufacturing Settings,Allow Overtime,Vaqtdan ortiq ishlashga ruxsat berish
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +146,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Serialized Item {0} orqali kabinetga kelishuvi yordamida yangilanib bo&#39;lmaydigan, Iltimos, kabinetga kirishini kiriting"
 DocType: Training Event Employee,Training Event Employee,O&#39;quv xodimini tayyorlash
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +976,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Eng ko&#39;p namuna - {0} Batch {1} va Item {2} uchun saqlanishi mumkin.
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +6,Add Time Slots,Vaqt oraliqlarini qo&#39;shish
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} Seriya raqamlari {1} uchun kerak. Siz {2} berilgansiz.
 DocType: Stock Reconciliation Item,Current Valuation Rate,Joriy baholash darajasi
@@ -2410,10 +2584,13 @@
 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,"Qo&#39;shimcha xarajatlar markazlari Guruhlar bo&#39;yicha amalga oshirilishi mumkin, ammo guruhlar bo&#39;lmagan guruhlarga qarshi yozuvlarni kiritish mumkin"
 apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Foydalanuvchilar va ruxsatnomalar
 DocType: Vehicle Log,VLOG.,VLOG.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +945,Production Orders Created: {0},Ishlab chiqarilgan buyurtmalar: {0}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +994,Production Orders Created: {0},Ishlab chiqarilgan buyurtmalar: {0}
 DocType: Branch,Branch,Filial
+DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
+DocType: Delivery Trip,Fulfillment User,Fulfillment User
 apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Bosib chiqarish va brendlash
 DocType: Company,Total Monthly Sales,Jami oylik sotish
+DocType: Agriculture Analysis Criteria,Weather,Ob-havo
 DocType: Bin,Actual Quantity,Haqiqiy miqdori
 DocType: Shipping Rule,example: Next Day Shipping,Masalan: Keyingi Kunlik Yuk tashish
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187,Serial No {0} not found,Seriya no {0} topilmadi
@@ -2422,15 +2599,16 @@
 DocType: Fee Schedule Program,Student Batch,Talabalar guruhi
 apps/erpnext/erpnext/utilities/activation.py +119,Make Student,Talabani tayyorlang
 DocType: Supplier Scorecard Scoring Standing,Min Grade,Eng kam sinf
-apps/erpnext/erpnext/projects/doctype/project/project.py +203,You have been invited to collaborate on the project: {0},Siz loyihada hamkorlik qilish uchun taklif qilingan: {0}
+apps/erpnext/erpnext/projects/doctype/project/project.py +214,You have been invited to collaborate on the project: {0},Siz loyihada hamkorlik qilish uchun taklif qilingan: {0}
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +107,Physician not available on {0},{0} da shifokor mavjud emas
 DocType: Leave Block List Date,Block Date,Bloklash sanasi
+DocType: Crop,Crop,O&#39;simliklar
 DocType: Purchase Receipt,Supplier Delivery Note,Yetkazib beruvchi etkazib berish Eslatma
-apps/erpnext/erpnext/schools/doctype/student_admission/templates/student_admission.html +70,Apply Now,Endi murojaat qiling
+apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70,Apply Now,Endi murojaat qiling
 apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Haqiqiy miqdori {0} / kutayotgan Qty {1}
 DocType: Purchase Invoice,E-commerce GSTIN,E-tijorat GSTIN
 DocType: Sales Order,Not Delivered,Qabul qilinmadi
-apps/erpnext/erpnext/controllers/buying_controller.py +421,Expected Date cannot be before Transaction Date,Kutilgan sana Jurnal kunidan oldin bo&#39;lishi mumkin emas
+apps/erpnext/erpnext/controllers/buying_controller.py +422,Expected Date cannot be before Transaction Date,Kutilgan sana Jurnal kunidan oldin bo&#39;lishi mumkin emas
 ,Bank Clearance Summary,Bankni ochish xulosasi
 apps/erpnext/erpnext/config/setup.py +106,"Create and manage daily, weekly and monthly email digests.","Kundalik, haftalik va oylik elektron pochta digestlarini yarating va boshqaring."
 DocType: Appraisal Goal,Appraisal Goal,Baholash maqsadi
@@ -2439,21 +2617,23 @@
 DocType: Fee Schedule,Fee Structure,To&#39;lov tarkibi
 DocType: Timesheet Detail,Costing Amount,Xarajatlar miqdori
 DocType: Student Admission Program,Application Fee,Ariza narxi
-DocType: Process Payroll,Submit Salary Slip,Ish haqi slipini topshirish
-apps/erpnext/erpnext/controllers/selling_controller.py +165,Maxiumm discount for Item {0} is {1}%,{0} uchun Maxiumm chegirma {1}%
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +50,Submit Salary Slip,Ish haqi slipini topshirish
+apps/erpnext/erpnext/controllers/selling_controller.py +133,Maxiumm discount for Item {0} is {1}%,{0} uchun Maxiumm chegirma {1}%
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16,Import in Bulk,Katta hajmdagi import
 DocType: Sales Partner,Address & Contacts,Manzil va Kontaktlar
 DocType: SMS Log,Sender Name,Yuboruvchi nomi
+DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Qishloq xo&#39;jaligini tahlil qilish mezonlari
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +193,Sort by Criteria,Mezon bo&#39;yicha saralash
 DocType: POS Profile,[Select],[Tanlash]
 DocType: Vital Signs,Blood Pressure (diastolic),Qon bosimi (diastolik)
 DocType: SMS Log,Sent To,Yuborilgan
+DocType: Agriculture Task,Holiday Management,Dam olishni boshqarish
 DocType: Payment Request,Make Sales Invoice,Sotuvdagi hisob-fakturani tanlang
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61,Softwares,Dasturlar
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +50,Next Contact Date cannot be in the past,Keyingi kontakt tarixi o&#39;tmishda bo&#39;lishi mumkin emas
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +51,Next Contact Date cannot be in the past,Keyingi kontakt tarixi o&#39;tmishda bo&#39;lishi mumkin emas
 DocType: Company,For Reference Only.,Faqat ma&#39;lumot uchun.
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +91,Physician {0} not available on {1},{1} shifokori {1} da mavjud emas
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2519,Select Batch No,Partiya no. Ni tanlang
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +99,Physician {0} not available on {1},{1} shifokori {1} da mavjud emas
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2538,Select Batch No,Partiya no. Ni tanlang
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +52,Invalid {0}: {1},Noto&#39;g&#39;ri {0}: {1}
 DocType: Purchase Invoice,PINV-RET-,PINV-RET-
 DocType: Fee Validity,Reference Inv,Malumot
@@ -2465,12 +2645,12 @@
 DocType: Employee,Employment Details,Ish haqida ma&#39;lumot
 DocType: Employee,New Workplace,Yangi ish joyi
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Yopiq qilib belgilang
-apps/erpnext/erpnext/stock/get_item_details.py +131,No Item with Barcode {0},{0} shtrixli element yo&#39;q
+apps/erpnext/erpnext/stock/get_item_details.py +125,No Item with Barcode {0},{0} shtrixli element yo&#39;q
 DocType: Normal Test Items,Require Result Value,Natijada qiymat talab qiling
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,Case No. cannot be 0,Case no 0 bo&#39;lishi mumkin emas
 DocType: Item,Show a slideshow at the top of the page,Sahifaning yuqori qismidagi slayd-shouni ko&#39;rsatish
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +514,Boms,Boms
-apps/erpnext/erpnext/stock/doctype/item/item.py +149,Stores,Do&#39;konlar
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +517,Boms,Boms
+apps/erpnext/erpnext/stock/doctype/item/item.py +151,Stores,Do&#39;konlar
 DocType: Project Type,Projects Manager,Loyiha menejeri
 DocType: Serial No,Delivery Time,Yetkazish vaqti
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,Ageing Based On,Qarish asosli
@@ -2485,17 +2665,19 @@
 DocType: Rename Tool,Rename Tool,Vositachi nomini o&#39;zgartirish
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +72,Update Cost,Narxni yangilash
 DocType: Item Reorder,Item Reorder,Mahsulot qayta tartibga solish
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +446,Show Salary Slip,Ish haqi slipini ko&#39;rsatish
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +823,Transfer Material,Transfer materiallari
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463,Show Salary Slip,Ish haqi slipini ko&#39;rsatish
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +848,Transfer Material,Transfer materiallari
 DocType: Fees,Send Payment Request,To&#39;lov talabnomasini yuboring
 DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.","Operatsiyalarni, operatsion narxini belgilang va sizning operatsiyalaringizni bajarish uchun noyob Operatsiyani taqdim eting."
+DocType: Water Analysis,Origin,Kelib chiqishi
 apps/erpnext/erpnext/controllers/status_updater.py +201,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Ushbu hujjat {4} uchun {0} {1} tomonidan cheklangan. {2} ga qarshi yana bitta {3} qilyapsizmi?
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1006,Please set recurring after saving,Saqlaganingizdan keyin takroriy-ni tanlang
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +758,Select change amount account,O&#39;zgarish miqdorini tanlang
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1086,Please set recurring after saving,Saqlaganingizdan keyin takroriy-ni tanlang
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +763,Select change amount account,O&#39;zgarish miqdorini tanlang
 DocType: Purchase Invoice,Price List Currency,Narxlari valyutasi
 DocType: Naming Series,User must always select,Foydalanuvchiga har doim tanlangan bo&#39;lishi kerak
 DocType: Stock Settings,Allow Negative Stock,Salbiy aksiyaga ruxsat berish
 DocType: Installation Note,Installation Note,O&#39;rnatish eslatmasi
+DocType: Soil Texture,Clay,Clay
 DocType: Topic,Topic,Mavzu
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +40,Cash Flow from Financing,Moliyadan pul oqimi
 DocType: Budget Account,Budget Account,Byudjet hisobi
@@ -2504,33 +2686,37 @@
 DocType: Grading Scale Interval,Grade Description,Obyekt ta&#39;rifi
 DocType: Stock Entry,Purchase Receipt No,Xarid qilish no
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Earnest Money,Pul ishlang
-DocType: Process Payroll,Create Salary Slip,Ish haqi slipini yaratish
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,Izlanadiganlik
+DocType: Asset Maintenance Log,Actions performed,Amallar bajarildi
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137,Source of Funds (Liabilities),Jamg&#39;arma mablag&#39;lari (majburiyatlar)
 DocType: Supplier Scorecard Scoring Standing,Employee,Xodim
+DocType: Asset Repair,Failure Date,Xato tarixi
 DocType: Sample Collection,Collected Time,To&#39;plangan vaqt
 DocType: Company,Sales Monthly History,Savdo oylik tarixi
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +204,Select Batch,Batch-ni tanlang
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244,{0} {1} is fully billed,{0} {1} to&#39;liq taqdim etiladi
+DocType: Asset Maintenance Task,Next Due Date,Keyingi to&#39;lov sanasi
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214,Select Batch,Batch-ni tanlang
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +242,{0} {1} is fully billed,{0} {1} to&#39;liq taqdim etiladi
 apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +48,Vital Signs,Vital belgilari
 DocType: Training Event,End Time,Tugash vaqti
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,Active Salary Structure {0} found for employee {1} for the given dates,Berilgan sana uchun {1} ishlaydigan xodim uchun {0} faol ish haqi tuzilishi
 DocType: Payment Entry,Payment Deductions or Loss,To&#39;lovni kamaytirish yoki yo&#39;qotish
+DocType: Soil Analysis,Soil Analysis Criterias,Tuproq tahlil qilish mezonlari
 apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Sotuv yoki sotib olish uchun standart shartnoma shartlari.
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +100,Group by Voucher,Voucher tomonidan guruh
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +186,Are you sure you want to cancel this appointment?,Siz ushbu uchrashuvni bekor qilmoqchimisiz?
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +195,Are you sure you want to cancel this appointment?,Siz ushbu uchrashuvni bekor qilmoqchimisiz?
 apps/erpnext/erpnext/config/crm.py +6,Sales Pipeline,Savdo Quvuri
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +216,Please set default account in Salary Component {0},"Iltimos, ish haqi komponentida {0}"
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201,Please set default account in Salary Component {0},"Iltimos, ish haqi komponentida {0}"
 apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Majburiy On
 DocType: Rename Tool,File to Rename,Qayta nomlash uchun fayl
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200,Please select BOM for Item in Row {0},"Iltimos, Row {0} qatori uchun BOM-ni tanlang"
 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},Hisob {0} Hisob holatida Kompaniya {1} bilan mos emas: {2}
-apps/erpnext/erpnext/controllers/buying_controller.py +270,Specified BOM {0} does not exist for Item {1},{1} mahsulot uchun belgilangan BOM {0} mavjud emas
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +221,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,"Ushbu Sotuvdagi Buyurtmani bekor qilishdan avval, {0} Xizmat jadvali bekor qilinishi kerak"
+apps/erpnext/erpnext/controllers/buying_controller.py +271,Specified BOM {0} does not exist for Item {1},{1} mahsulot uchun belgilangan BOM {0} mavjud emas
+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,"Ushbu Sotuvdagi Buyurtmani bekor qilishdan avval, {0} Xizmat jadvali bekor qilinishi kerak"
 DocType: POS Profile,Applicable for Users,Foydalanuvchilar uchun amal qiladi
 DocType: Notification Control,Expense Claim Approved,Xarajat talabi ma&#39;qullangan
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +321,Salary Slip of employee {0} already created for this period,Ish staji Bu davr uchun allaqachon yaratilgan {0} xodim
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +151,Pharmaceutical,Dori-darmon
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155,Pharmaceutical,Dori-darmon
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,Xarid qilingan buyumlarning narxi
 DocType: Selling Settings,Sales Order Required,Savdo buyurtmasi kerak
 DocType: Purchase Invoice,Credit To,Kredit berish
@@ -2540,75 +2726,75 @@
 DocType: Supplier Scorecard,Warn for new Purchase Orders,Yangi Buyurtma Buyurtmalarini ogohlantiring
 DocType: Quality Inspection Reading,Reading 9,O&#39;qish 9
 DocType: Supplier,Is Frozen,Muzlatilgan
-apps/erpnext/erpnext/stock/utils.py +217,Group node warehouse is not allowed to select for transactions,Guruh tugunli omborga bitimlarni tanlashga ruxsat berilmaydi
+apps/erpnext/erpnext/stock/utils.py +222,Group node warehouse is not allowed to select for transactions,Guruh tugunli omborga bitimlarni tanlashga ruxsat berilmaydi
 DocType: Buying Settings,Buying Settings,Sozlamalarni xarid qilish
 DocType: Stock Entry Detail,BOM No. for a Finished Good Item,Yaxshi natija uchun BOM No
 DocType: Upload Attendance,Attendance To Date,Ishtirok etish tarixi
 DocType: Request for Quotation Supplier,No Quote,Hech qanday taklif yo&#39;q
 DocType: Warranty Claim,Raised By,Ko&#39;tarilgan
 DocType: Payment Gateway Account,Payment Account,To&#39;lov qaydnomasi
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +880,Please specify Company to proceed,Davom etish uchun kompaniyani ko&#39;rsating
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +906,Please specify Company to proceed,Davom etish uchun kompaniyani ko&#39;rsating
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +22,Net Change in Accounts Receivable,Xarid oluvchilarning aniq o&#39;zgarishi
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +84,Compensatory Off,Compensatory Off
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88,Compensatory Off,Compensatory Off
 DocType: Offer Letter,Accepted,Qabul qilingan
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +25,Organization,Tashkilot
+DocType: Grant Application,Organization,Tashkilot
 DocType: BOM Update Tool,BOM Update Tool,BOMni yangilash vositasi
-apps/erpnext/erpnext/accounts/party.py +204,"Party account not specified, please setup default party account in company","Partiya hisobi aniqlanmagan bo&#39;lsa, iltimos, kompaniyada sukut bo&#39;yicha partiya hisobini sozlang"
 DocType: SG Creation Tool Course,Student Group Name,Isoning shogirdi guruhi nomi
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Narxlarni yaratish
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Narxlarni yaratish
 apps/erpnext/erpnext/setup/doctype/company/company.js +62,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.,"Iltimos, ushbu kompaniya uchun barcha operatsiyalarni o&#39;chirib tashlamoqchimisiz. Sizning asosiy ma&#39;lumotlaringiz qoladi. Ushbu amalni bekor qilish mumkin emas."
 DocType: Room,Room Number,Xona raqami
 apps/erpnext/erpnext/utilities/transaction_base.py +96,Invalid reference {0} {1},Noto&#39;g&#39;ri reference {0} {1}
 DocType: Shipping Rule,Shipping Rule Label,Yuk tashish qoidalari yorlig&#39;i
+DocType: Journal Entry Account,Payroll Entry,Ish haqi miqdori
 apps/erpnext/erpnext/public/js/conf.js +28,User Forum,Foydalanuvchining forumi
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +305,Raw Materials cannot be blank.,Xom ashyoni bo&#39;sh bo&#39;lishi mumkin emas.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +488,"Could not update stock, invoice contains drop shipping item.","Qimmatli qog&#39;ozlar yangilanib bo&#39;lmadi, hisob-faktura tomchi qoplama mahsulotini o&#39;z ichiga oladi."
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +308,Raw Materials cannot be blank.,Xom ashyoni bo&#39;sh bo&#39;lishi mumkin emas.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +492,"Could not update stock, invoice contains drop shipping item.","Qimmatli qog&#39;ozlar yangilanib bo&#39;lmadi, hisob-faktura tomchi qoplama mahsulotini o&#39;z ichiga oladi."
 DocType: Lab Test Sample,Lab Test Sample,Laborotoriya namunasi
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +484,Quick Journal Entry,Tez jurnalni kiritish
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +492,Quick Journal Entry,Tez jurnalni kiritish
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200,You can not change rate if BOM mentioned agianst any item,"Agar BOM biron-bir elementni eslatmasa, tarifni o&#39;zgartira olmaysiz"
 DocType: Restaurant,Invoice Series Prefix,Billing-uz prefiksi
 DocType: Employee,Previous Work Experience,Oldingi ish tajribasi
 DocType: Stock Entry,For Quantity,Miqdor uchun
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205,Please enter Planned Qty for Item {0} at row {1},{1} qatorida {0} uchun rejalashtirilgan sonni kiriting
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241,{0} {1} is not submitted,{0} {1} yuborilmadi
-apps/erpnext/erpnext/config/stock.py +27,Requests for items.,Ma&#39;lumotlar uchun talablar.
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +102,Google Maps integration is not enabled,Google Xaritalar integratsiyasi yoqilmagan
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +239,{0} {1} is not submitted,{0} {1} yuborilmadi
 DocType: Production Planning Tool,Separate production order will be created for each finished good item.,Har bir tayyor mahsulot uchun alohida ishlab chiqarish tartibi yaratiladi.
+DocType: Member,Membership Expiry Date,Registratsiya sanasi
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +127,{0} must be negative in return document,{0} qaytariladigan hujjatda salbiy bo&#39;lishi kerak
 ,Minutes to First Response for Issues,Muammolar uchun birinchi javob uchun daqiqalar
 DocType: Purchase Invoice,Terms and Conditions1,Shartlar va shartlar1
-apps/erpnext/erpnext/public/js/setup_wizard.js +106,The name of the institute for which you are setting up this system.,Ushbu tizimni tashkil qilayotgan institut nomi.
+apps/erpnext/erpnext/public/js/setup_wizard.js +109,The name of the institute for which you are setting up this system.,Ushbu tizimni tashkil qilayotgan institut nomi.
 DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Bu sanaga qadar muzlatilgan yozuv donduruldu, hech kim quyida ko&#39;rsatilgan vazifalar tashqari kirishni o&#39;zgartirishi / o&#39;zgartirishi mumkin emas."
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116,Please save the document before generating maintenance schedule,Xizmat rejasini tuzishdan oldin hujjatni saqlab qo&#39;ying
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30,Latest price updated in all BOMs,Eng so&#39;nggi narx barcha BOMlarda yangilandi
-DocType: Fee Schedule,Successful,Muvaffaqiyatli
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,Loyiha holati
 DocType: UOM,Check this to disallow fractions. (for Nos),Fraktsiyalarni taqiqlash uchun buni tanlang. (Nos uchun)
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +423,The following Production Orders were created:,Quyidagi ishlab chiqarish buyurtmalari yaratildi:
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +424,The following Production Orders were created:,Quyidagi ishlab chiqarish buyurtmalari yaratildi:
 DocType: Student Admission Program,Naming Series (for Student Applicant),Nom turkumi (talabalar uchun)
 DocType: Delivery Note,Transporter Name,Transporter nomi
 DocType: Authorization Rule,Authorized Value,Tayinlangan qiymat
 DocType: BOM,Show Operations,Operatsiyalarni ko&#39;rsatish
 ,Minutes to First Response for Opportunity,Imkoniyatlar uchun birinchi javob daqiqalari
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Absent,Hammasi yo&#39;q
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +794,Item or Warehouse for row {0} does not match Material Request,{0} satriga yoki odatdagi materialga Material talabiga mos kelmaydi
-apps/erpnext/erpnext/config/stock.py +194,Unit of Measure,O&#39;lchov birligi
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +823,Item or Warehouse for row {0} does not match Material Request,{0} satriga yoki odatdagi materialga Material talabiga mos kelmaydi
+apps/erpnext/erpnext/config/stock.py +187,Unit of Measure,O&#39;lchov birligi
 DocType: Fiscal Year,Year End Date,Yil tugash sanasi
 DocType: Task Depends On,Task Depends On,Vazifa bog&#39;liq
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +999,Opportunity,Imkoniyat
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1024,Opportunity,Imkoniyat
 ,Completed Production Orders,Tugallangan buyurtmalar
 DocType: Operation,Default Workstation,Standart ish stantsiyani
 DocType: Notification Control,Expense Claim Approved Message,Xarajat da&#39;vo tasdiqlangan xabar
 DocType: Payment Entry,Deductions or Loss,O&#39;chirish yoki yo&#39;qotish
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +247,{0} {1} is closed,{0} {1} yopildi
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +245,{0} {1} is closed,{0} {1} yopildi
 DocType: Email Digest,How frequently?,Qancha tez-tez?
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.js +57,Total Collected: {0},Hammasi jamlangan: {0}
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +58,Total Collected: {0},Hammasi jamlangan: {0}
 DocType: Purchase Receipt,Get Current Stock,Joriy aktsiyani oling
 apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,Materiallar hisoboti daraxti
 DocType: Student,Joining Date,Birlashtirilgan sana
 ,Employees working on a holiday,Bayramda ishlaydigan xodimlar
 apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,Markni hozir aytib bering
 DocType: Project,% Complete Method,% Komple usul
-apps/erpnext/erpnext/healthcare/setup.py +180,Drug,Dori
+apps/erpnext/erpnext/healthcare/setup.py +181,Drug,Dori
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200,Maintenance start date can not be before delivery date for Serial No {0},Xizmatni boshlash sanasi Serial No {0} uchun etkazib berish sanasidan oldin bo&#39;lishi mumkin emas.
 DocType: Production Order,Actual End Date,Haqiqiy tugash sanasi
 DocType: BOM,Operating Cost (Company Currency),Faoliyat xarajati (Kompaniya valyutasi)
@@ -2616,12 +2802,12 @@
 DocType: Authorization Rule,Applicable To (Role),Qo&#39;llanishi mumkin (rol)
 DocType: BOM Update Tool,Replace BOM,BOMni almashtiring
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110,Code {0} already exist,{0} kodi allaqachon mavjud
-DocType: Stock Entry,Purpose,Maqsad
+DocType: Employee Advance,Purpose,Maqsad
 DocType: Company,Fixed Asset Depreciation Settings,Ruxsat etilgan aktivlar amortizatsiyasi sozlamalari
 DocType: Item,Will also apply for variants unless overrridden,"Variantlar uchun ham qo&#39;llanilmaydi, agar bekor qilinsa"
 DocType: Purchase Invoice,Advances,Avanslar
 DocType: Production Order,Manufacture against Material Request,Materiallar talabiga qarshi ishlab chiqarish
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +10,Assessment Group: ,Baholash guruhi:
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +10,Assessment Group: ,Baholash guruhi:
 DocType: Item Reorder,Request for,Talabnoma
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,Foydalanuvchini tasdiqlash qoida sifatida qo&#39;llanilishi mumkin bo&#39;lgan foydalanuvchi sifatida bir xil bo&#39;lishi mumkin emas
 DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Asosiy stavkasi (Har bir O&#39;quv markazi uchun)
@@ -2629,23 +2815,26 @@
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +245,Leave Without Pay does not match with approved Leave Application records,"Pulsiz qoldirish, tasdiqlangan Taqdimnoma arizalari bilan mos emas"
 DocType: Campaign,Campaign-.####,Kampaniya - ####
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Keyingi qadamlar
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +769,Please supply the specified items at the best possible rates,"Iltimos, ko&#39;rsatilgan narsalarni eng yaxshi narxlarda bering"
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +794,Please supply the specified items at the best possible rates,"Iltimos, ko&#39;rsatilgan narsalarni eng yaxshi narxlarda bering"
+DocType: Membership,USD,USD
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Make Invoice,Billing-ni tanlang
 DocType: Selling Settings,Auto close Opportunity after 15 days,Avtomatik yopish 15 kundan keyin Imkoniyat
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +75,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,{1} belgisi tufayli buyurtma berish buyurtmalariga {0} uchun ruxsat berilmaydi.
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +76,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,{1} belgisi tufayli buyurtma berish buyurtmalariga {0} uchun ruxsat berilmaydi.
 apps/erpnext/erpnext/public/js/financial_statements.js +83,End Year,End Year
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Qisqacha / qo&#39;rg&#39;oshin%
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +119,Contract End Date must be greater than Date of Joining,Shartnoma tugash sanasi qo&#39;shilish sanasidan katta bo&#39;lishi kerak
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +124,Contract End Date must be greater than Date of Joining,Shartnoma tugash sanasi qo&#39;shilish sanasidan katta bo&#39;lishi kerak
+DocType: Driver,Driver,Drayv
 DocType: Vital Signs,Nutrition Values,Oziqlanish qiymati
 DocType: Lab Test Template,Is billable,To&#39;lanishi mumkin
 DocType: Delivery Note,DN-,DN-
 apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +44,"Both ""Physician Schedule"" and Time Per Appointment"" must be set for Dr {0}",Doktor {0} uchun &quot;Shifokorlar rejasi&quot; va &quot;Tayinlangan vaqt&quot;
 DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,Kompaniyalar mahsulotlarini komissiyaga sotadigan uchinchi tomon distributor / diler / komissiya agenti / affillangan / sotuvchisi.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +376,{0} against Purchase Order {1},{0} Xarid qilish buyrug&#39;iga qarshi {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +374,{0} against Purchase Order {1},{0} Xarid qilish buyrug&#39;iga qarshi {1}
 DocType: Patient,Patient Demographics,Kasal demografiyasi
 DocType: Task,Actual Start Date (via Time Sheet),Haqiqiy boshlash sanasi (vaqt jadvalidan orqali)
 apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15,This is an example website auto-generated from ERPNext,Bu ERPNext-dan avtomatik tarzda yaratilgan veb-sayt
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +37,Ageing Range 1,Qarish oralig&#39;i 1
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +226,Total advance amount cannot be greater than total claimed amount,Umumiy avans miqdori jami talab qilingan miqdordan ko&#39;p bo&#39;lishi mumkin emas
 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
@@ -2669,21 +2858,25 @@
 10. Add or Deduct: Whether you want to add or deduct the tax.","Barcha sotib olish operatsiyalarida qo&#39;llanilishi mumkin bo&#39;lgan standart soliq shabloni. Ushbu shablon soliq boshliqlarining ro&#39;yxatini va shuningdek, &quot;Yuk tashish&quot;, &quot;Sug&#39;urta&quot;, &quot;Xizmat&quot; va hokazolar kabi boshqa xarajatlarning boshlarini o&#39;z ichiga olishi mumkin. #### Eslatma Bu erda belgilagan soliq stavkasi barcha uchun standart soliq stavkasi bo&#39;ladi. *. Turli xil stavkalari bor ** Shartnomalar ** mavjud bo&#39;lsa, ular ** Ustun ** magistrining ** Item Tax ** jadvaliga qo&#39;shilishi kerak. #### Ustunlarning tavsifi 1. Hisoblash turi: - Bu ** bo&#39;lishi mumkin ** Total Total (ya&#39;ni asosiy miqdor summasi). - ** Oldingi qatorda Umumiy / Miqdori ** (jami soliq yoki yig&#39;im uchun). Agar siz bu optsiyani tanlasangiz, soliq soliq jadvalidagi avvalgi qatordagi foizga yoki jami miqdorda qo&#39;llaniladi. - ** Haqiqiy ** (yuqorida aytib o&#39;tilganidek). 2. Hisob boshlig&#39;i: ushbu soliq hisobga olinadigan Hisob naqsh kitobchisi. 3. Qiymat markazi: Agar soliq / majburiy to&#39;lov (daromad kabi) yoki xarajat bo&#39;lsa, u Xarajat markaziga zahiraga olinishi kerak. 4. Belgilar: Soliq tavsifi (fakturalar / tirnoqlarda chop etiladi). 5. Rate: Soliq stavkasi. 6. Miqdor: Soliq summasi. 7. Jami: bu nuqtaga jami jami. 8. Qatorni kiriting: Agar &quot;Older Row Total&quot; ga asoslangan holda ushbu hisob-kitob uchun asos sifatida olinadigan satr raqamini tanlash mumkin (asl qiymati oldingi satr). 9. Quyidagilar uchun soliq yoki majburiy to&#39;lovni ko&#39;rib chiqing: Ushbu bo&#39;limda soliq / yig&#39;im faqat baholash uchun (jami qismi emas) yoki faqat jami (mahsulotga qiymat qo&#39;shmaydi) yoki har ikkala uchun belgilanishi mumkin. 10. Qo&#39;shish yoki cheklash: Siz soliqni qo&#39;shish yoki kamaytirishni xohlaysizmi."
 DocType: Homepage,Homepage,Bosh sahifa
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +71,Select Physician...,Shifokorlar tanlang ...
+DocType: Grant Application,Grant Application Details ,Dastur haqida batafsil ma&#39;lumot
 DocType: Purchase Receipt Item,Recd Quantity,Raqamlar soni
-apps/erpnext/erpnext/schools/doctype/program_enrollment/program_enrollment.py +57,Fee Records Created - {0},Yaratilgan yozuvlar - {0}
+apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +59,Fee Records Created - {0},Yaratilgan yozuvlar - {0}
 DocType: Asset Category Account,Asset Category Account,Aktiv turkumidagi hisob
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +539,Stock Entry {0} is not submitted,Stock Entry {0} yuborilmadi
+apps/erpnext/erpnext/stock/doctype/item/item.js +360,Select Attribute Values,Nitelik qiymatlarini tanlang
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +537,Stock Entry {0} is not submitted,Stock Entry {0} yuborilmadi
 DocType: Payment Reconciliation,Bank / Cash Account,Bank / pul hisob
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +44,Next Contact By cannot be same as the Lead Email Address,Keyingi kontaktni Kontakt Email manzili bilan bir xil bo&#39;lmaydi
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +45,Next Contact By cannot be same as the Lead Email Address,Keyingi kontaktni Kontakt Email manzili bilan bir xil bo&#39;lmaydi
 DocType: Tax Rule,Billing City,Billing Siti
 DocType: Asset,Manual,Qo&#39;llanma
 DocType: Salary Component Account,Salary Component Account,Ish haqi komponentining hisob raqami
 DocType: Global Defaults,Hide Currency Symbol,Valyuta belgisini yashirish
-apps/erpnext/erpnext/config/accounts.py +338,"e.g. Bank, Cash, Credit Card","masalan, bank, naqd pul, kredit kartasi"
+apps/erpnext/erpnext/config/non_profit.py +58,Donor information.,Donor ma&#39;lumoti.
+apps/erpnext/erpnext/config/accounts.py +330,"e.g. Bank, Cash, Credit Card","masalan, bank, naqd pul, kredit kartasi"
 DocType: Lead Source,Source Name,Manba nomi
 DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Katta yoshdagi normal qon bosimi taxminan 120 mmHg sistolik va 80 mmHg diastolik, qisqartirilgan &quot;120/80 mmHg&quot;"
 DocType: Journal Entry,Credit Note,Kredit eslatma
 DocType: Warranty Claim,Service Address,Xizmat manzili
+DocType: Asset Maintenance Task,Calibration,Kalibrlash
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49,Furnitures and Fixtures,Mebel va anjomlar
 DocType: Item,Manufacture,Ishlab chiqarish
 apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Company,Kompaniya o&#39;rnatish
@@ -2695,8 +2888,9 @@
 DocType: Opportunity,Customer / Lead Name,Xaridor / qo&#39;rg&#39;oshin nomi
 apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +99,Clearance Date not mentioned,Bo&#39;shatish tarixi eslatma topilmadi
 apps/erpnext/erpnext/config/manufacturing.py +7,Production,Ishlab chiqarish
-DocType: Patient,Occupation,Kasbingiz
+DocType: Guardian,Occupation,Kasbingiz
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74,Row {0}:Start Date must be before End Date,Row {0}: Boshlanish sanasi tugash sanasidan oldin bo&#39;lishi kerak
+DocType: Crop,Planting Area,O&#39;sish maydoni
 apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),Hammasi bo&#39;lib (Miqdor)
 DocType: Installation Note Item,Installed Qty,O&#39;rnatilgan Miqdor
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4,This could be because of some invalid Email Addresses in the,"Buning sababi, ba&#39;zi bir bekor E-pochta manzili"
@@ -2706,25 +2900,25 @@
 DocType: Purchase Invoice,Is Paid,Pul to&#39;lanadi
 DocType: Salary Structure,Total Earning,Jami daromad
 DocType: Purchase Receipt,Time at which materials were received,Materiallar olingan vaqt
+DocType: Products Settings,Products per Page,Har bir sahifa uchun mahsulotlar
 DocType: Stock Ledger Entry,Outgoing Rate,Chiqish darajasi
-apps/erpnext/erpnext/config/hr.py +228,Organization branch master.,Tashkilot filialining ustasi.
-apps/erpnext/erpnext/controllers/accounts_controller.py +280, or ,yoki
+apps/erpnext/erpnext/config/hr.py +233,Organization branch master.,Tashkilot filialining ustasi.
+apps/erpnext/erpnext/controllers/accounts_controller.py +303, or ,yoki
 DocType: Sales Order,Billing Status,Billing holati
 apps/erpnext/erpnext/public/js/conf.js +32,Report an Issue,Muammo haqida xabar bering
-apps/erpnext/erpnext/public/js/setup_wizard.js +28,Education (beta),Ta&#39;lim (beta)
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,Utility Expenses,Kommunal xizmat xarajatlari
 apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64,90-Above,90-yuqorida
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +241,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,{{0} qatori: {1} yozuvi {2} hisobiga ega emas yoki boshqa kafelga qarama-qarshi
 DocType: Supplier Scorecard Criteria,Criteria Weight,Kriterlar Og&#39;irligi
 DocType: Buying Settings,Default Buying Price List,Standart xarid narxlari
-DocType: Process Payroll,Salary Slip Based on Timesheet,Vaqt jadvaliga asosan ish haqi miqdori
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +113,No employee for the above selected criteria OR salary slip already created,Yuqoridagi tanlangan mezonlarga YoKI ish haqi slipi yaratilmagan
+DocType: Payroll Entry,Salary Slip Based on Timesheet,Vaqt jadvaliga asosan ish haqi miqdori
+apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +19,Buying Rate,Xarid qilish darajasi
 DocType: Notification Control,Sales Order Message,Savdo buyurtma xabarlari
 apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Kompaniya, valyuta, joriy moliyaviy yil, va hokazo kabi standart qiymatlarni o&#39;rnating."
 DocType: Payment Entry,Payment Type,To&#39;lov turi
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +131,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,{0} uchun mahsulotni tanlang. Ushbu talabni bajaradigan yagona guruh topilmadi
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +140,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,{0} uchun mahsulotni tanlang. Ushbu talabni bajaradigan yagona guruh topilmadi
 DocType: Hub Category,Parent Category,Ota-toifa
-DocType: Process Payroll,Select Employees,Xodimlarni tanlang
+DocType: Payroll Entry,Select Employees,Xodimlarni tanlang
 DocType: Opportunity,Potential Sales Deal,Potentsial savdo bitimi
 DocType: Complaint,Complaints,Shikoyat
 DocType: Payment Entry,Cheque/Reference Date,Tekshirish / Ariza sanasi
@@ -2733,7 +2927,7 @@
 DocType: Bank Reconciliation Detail,Payment Entry,To&#39;lov kiritish
 DocType: Item,Quality Parameters,Sifat parametrlari
 ,sales-browser,sotuv-brauzer
-apps/erpnext/erpnext/accounts/doctype/account/account.js +73,Ledger,Ledger
+apps/erpnext/erpnext/accounts/doctype/account/account.js +79,Ledger,Ledger
 DocType: Patient Medical Record,PMR-,PMR-
 DocType: Drug Prescription,Drug Code,Dori kodi
 DocType: Target Detail,Target  Amount,Nishon miqdori
@@ -2741,11 +2935,12 @@
 DocType: Shopping Cart Settings,Shopping Cart Settings,Xarid savatni sozlamalari
 DocType: Journal Entry,Accounting Entries,Buxgalteriya yozuvlari
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},"Ikki nusxadagi yozuv. Iltimos, tasdiqlash qoidasini {0}"
+DocType: Journal Entry Account,Reference Due Date,Malumot sanasi
 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,Qabul hujjati topshirilishi kerak
 DocType: Purchase Invoice Item,Received Qty,Qabul qilingan Miqdor
 DocType: Stock Entry Detail,Serial No / Batch,Seriya No / Klaster
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +320,Not Paid and Not Delivered,To&#39;langan emas va taslim qilinmagan
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340,Not Paid and Not Delivered,To&#39;langan emas va taslim qilinmagan
 DocType: Product Bundle,Parent Item,Ota-ona
 DocType: Account,Account Type,Hisob turi
 DocType: Delivery Note,DN-RET-,DN-RET-
@@ -2754,32 +2949,35 @@
 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',Xizmat jadvali barcha elementlar uchun yaratilmaydi. &quot;Jadvalni yarat&quot; tugmasini bosing
 ,To Produce,Ishlab chiqarish
 apps/erpnext/erpnext/config/hr.py +93,Payroll,Ish haqi
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +179,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included",{1} da {0} qator uchun. Mavzu kursiga {2} ni qo&#39;shish uchun {3} qatorlari ham qo&#39;shilishi kerak
+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",{1} da {0} qator uchun. Mavzu kursiga {2} ni qo&#39;shish uchun {3} qatorlari ham qo&#39;shilishi kerak
 apps/erpnext/erpnext/utilities/activation.py +101,Make User,Foydalanuvchi qilish
 DocType: Packing Slip,Identification of the package for the delivery (for print),Yetkazib berish paketini aniqlash (chop etish uchun)
 DocType: Bin,Reserved Quantity,Rezervlangan miqdori
 apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,"Iltimos, to&#39;g&#39;ri elektron pochta manzilini kiriting"
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +654,Please select an item in the cart,Savatdagi elementni tanlang
+DocType: Volunteer Skill,Volunteer Skill,Ko&#39;ngilli ko&#39;nikma
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +713,Please select an item in the cart,Savatdagi elementni tanlang
 DocType: Landed Cost Voucher,Purchase Receipt Items,Qabulnoma buyurtmalarini sotib olish
 apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,Formalarni xususiylashtirish
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +70,Arrear,Arrear
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +155,Depreciation Amount during the period,Amortisman muddati davomida
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +74,Arrear,Arrear
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158,Depreciation Amount during the period,Amortisman muddati davomida
 apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +38,Disabled template must not be default template,Nogironlar shabloni asl shabloni bo&#39;lmasligi kerak
 DocType: Account,Income Account,Daromad hisobvarag&#39;i
 DocType: Payment Request,Amount in customer's currency,Mijozning valyutadagi miqdori
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +776,Delivery,Yetkazib berish
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +823,Delivery,Yetkazib berish
+DocType: Volunteer,Weekdays,Hafta kunlari
 DocType: Stock Reconciliation Item,Current Qty,Joriy Miqdor
 DocType: Restaurant Menu,Restaurant Menu,Restoran menyusi
 apps/erpnext/erpnext/templates/generators/item_group.html +36,Prev,Oldindan
 DocType: Appraisal Goal,Key Responsibility Area,Asosiy mas&#39;uliyat maydoni
 apps/erpnext/erpnext/utilities/activation.py +127,"Student Batches help you track attendance, assessments and fees for students","Talaba to&#39;dalari talabalar uchun tashrif buyurish, baholash va to&#39;lovlarni kuzatishda sizga yordam beradi"
 DocType: Payment Entry,Total Allocated Amount,Jami ajratilgan mablag&#39;lar
-apps/erpnext/erpnext/setup/doctype/company/company.py +143,Set default inventory account for perpetual inventory,Doimiy ro&#39;yxatga olish uchun odatiy inventarizatsiyadan foydalaning
+apps/erpnext/erpnext/setup/doctype/company/company.py +140,Set default inventory account for perpetual inventory,Doimiy ro&#39;yxatga olish uchun odatiy inventarizatsiyadan foydalaning
 DocType: Item Reorder,Material Request Type,Materiallar talabi turi
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +268,Accural Journal Entry for salaries from {0} to {1},Accural Journal {0} dan {1} ga qadar ish haqi uchun kirish
-apps/erpnext/erpnext/accounts/page/pos/pos.js +824,"LocalStorage is full, did not save","LocalStorage to&#39;liq, saqlanmadi"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +85,Row {0}: UOM Conversion Factor is mandatory,Row {0}: UOM Conversion Factor majburiydir
-apps/erpnext/erpnext/utilities/user_progress.py +214,Room Capacity,Xona hajmi
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252,Accural Journal Entry for salaries from {0} to {1},Accural Journal {0} dan {1} ga qadar ish haqi uchun kirish
+apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17,Send Grant Review Email,Grantlar bo&#39;yicha ko&#39;rib chiqish elektron pochta manzilini yuboring
+apps/erpnext/erpnext/accounts/page/pos/pos.js +839,"LocalStorage is full, did not save","LocalStorage to&#39;liq, saqlanmadi"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +90,Row {0}: UOM Conversion Factor is mandatory,Row {0}: UOM Conversion Factor majburiydir
+apps/erpnext/erpnext/utilities/user_progress.py +232,Room Capacity,Xona hajmi
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +14,Ref,Ref
 DocType: Lab Test,LP-,LP-
 DocType: Healthcare Settings,Registration Fee,Ro&#39;yxatdan o&#39;tish badallari
@@ -2793,16 +2991,17 @@
 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.",Raqobatchilar qoidasi narx-navo varag&#39;ining ustiga yozish uchun belgilanadi / ba&#39;zi mezonlarga asoslanib chegirma foizini belgilaydi.
 DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Omborxonani faqat aktsiyalarni qabul qilish / etkazib berish eslatmasi / sotib olish haqidagi ma&#39;lumotnoma orqali o&#39;zgartirish mumkin
 DocType: Employee Education,Class / Percentage,Sinf / foiz
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +130,Head of Marketing and Sales,Marketing va sotish boshqarmasi boshlig&#39;i
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +68,Income Tax,Daromad solig&#39;i
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134,Head of Marketing and Sales,Marketing va sotish boshqarmasi boshlig&#39;i
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72,Income Tax,Daromad solig&#39;i
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17,"If selected Pricing Rule is made for 'Price', it will overwrite Price List. Pricing Rule price is the final price, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Agar tanlangan narxlash qoidasi &quot;Price&quot; uchun tuzilgan bo&#39;lsa, u narxlarni ro&#39;yxatini yozadi. Raqobatchilarning narx qoidasi - bu oxirgi narx, shuning uchun hech qanday chegirmalar qo&#39;llanilmaydi. Shuning uchun, Sotuvdagi Buyurtma, Xarid qilish Buyurtma va shunga o&#39;xshash operatsiyalarda, u &quot;Narxlar ro&#39;yxati darajasi&quot; o&#39;rniga &quot;Ovoz&quot; maydoniga keltiriladi."
 apps/erpnext/erpnext/config/selling.py +174,Track Leads by Industry Type.,Sanoat turiga qarab kuzatish.
+apps/erpnext/erpnext/utilities/user_progress.py +98,Go to Letterheads,Antetli qog&#39;ozlarga o&#39;ting
 DocType: Item Supplier,Item Supplier,Mahsulot etkazib beruvchisi
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1107,Please enter Item Code to get batch no,"Iltimos, mahsulot kodini kiriting"
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +827,Please select a value for {0} quotation_to {1},"Iltimos, {0} uchun kotirovka qiymatini tanlang {1}"
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1187,Please enter Item Code to get batch no,"Iltimos, mahsulot kodini kiriting"
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +874,Please select a value for {0} quotation_to {1},"Iltimos, {0} uchun kotirovka qiymatini tanlang {1}"
 apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Barcha manzillar.
 DocType: Company,Stock Settings,Kabinetga sozlamalari
-apps/erpnext/erpnext/accounts/doctype/account/account.py +199,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Birlashma faqatgina ikkita yozuvda bir xil xususiyatlar mavjud bo&#39;lganda mumkin. Guruh, Ildiz turi, Kompaniya"
+apps/erpnext/erpnext/accounts/doctype/account/account.py +185,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Birlashma faqatgina ikkita yozuvda bir xil xususiyatlar mavjud bo&#39;lganda mumkin. Guruh, Ildiz turi, Kompaniya"
 DocType: Vehicle,Electric,Elektr
 DocType: Task,% Progress,% Progress
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123,Gain/Loss on Asset Disposal,Aktivlarni yo&#39;qotish bo&#39;yicha daromad / yo&#39;qotish
@@ -2815,10 +3014,11 @@
 DocType: Leave Control Panel,Leave Control Panel,Boshqarish panelidan chiqing
 DocType: Project,Task Completion,Vazifa yakuni
 apps/erpnext/erpnext/templates/includes/product_page.js +21,Not in Stock,Stoktaki emas
+DocType: Volunteer,Volunteer Skills,Ko&#39;ngilli ko&#39;nikmalar
 DocType: Appraisal,HR User,HR foydalanuvchisi
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +53,POS?,POS?
+apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36,POS?,POS?
 DocType: Purchase Invoice,Taxes and Charges Deducted,Soliqlar va yig&#39;imlar kamaytirildi
-apps/erpnext/erpnext/hooks.py +138,Issues,Muammolar
+apps/erpnext/erpnext/hooks.py +142,Issues,Muammolar
 apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Vaziyat {0} dan biri bo&#39;lishi kerak
 DocType: Sales Invoice,Debit To,Debet To
 DocType: Restaurant Menu Item,Restaurant Menu Item,Restoran menyusi
@@ -2826,58 +3026,60 @@
 DocType: Stock Ledger Entry,Actual Qty After Transaction,Jurnal so&#39;ng haqiqiy miqdori
 apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +79,No salary slip found between {0} and {1},{0} va {1} o&#39;rtasida hech qanday maosh yo&#39;q
 ,Pending SO Items For Purchase Request,Buyurtma so&#39;rovini bajarish uchun buyurtmalarni bekor qilish
-apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +35,Student Admissions,Talabalarni qabul qilish
-apps/erpnext/erpnext/accounts/party.py +364,{0} {1} is disabled,{0} {1} o&#39;chirib qo&#39;yilgan
+apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35,Student Admissions,Talabalarni qabul qilish
+apps/erpnext/erpnext/accounts/party.py +376,{0} {1} is disabled,{0} {1} o&#39;chirib qo&#39;yilgan
 DocType: Supplier,Billing Currency,To&#39;lov valyutasi
 DocType: Sales Invoice,SINV-RET-,SINV-RET-
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +196,Extra Large,Juda katta
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200,Extra Large,Juda katta
+DocType: Crop,Scientific Name,Ilmiy ism
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Leaves,Jami barglar
 DocType: Consultation,In print,Chop etildi
 ,Profit and Loss Statement,Qor va ziyon bayonnomasi
 DocType: Bank Reconciliation Detail,Cheque Number,Raqamni tekshiring
 ,Sales Browser,Sotuvlar brauzeri
 DocType: Journal Entry,Total Credit,Jami kredit
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542,Warning: Another {0} # {1} exists against stock entry {2},Ogohlantirish: {0} # {1} boshqa {0}
-apps/erpnext/erpnext/utilities/user_progress_utils.py +51,Local,Mahalliy
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +540,Warning: Another {0} # {1} exists against stock entry {2},Ogohlantirish: {0} # {1} boshqa {0}
+apps/erpnext/erpnext/utilities/user_progress_utils.py +66,Local,Mahalliy
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),Kreditlar va avanslar (aktivlar)
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,Qarzdorlar
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +195,Large,Katta
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199,Large,Katta
 DocType: Homepage Featured Product,Homepage Featured Product,Bosh sahifa Featured Mahsulot
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +236,All Assessment Groups,Barcha baholash guruhlari
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +246,All Assessment Groups,Barcha baholash guruhlari
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,Yangi ombor nomi
 apps/erpnext/erpnext/accounts/report/financial_statements.py +233,Total {0} ({1}),Jami {0} ({1})
 DocType: C-Form Invoice Detail,Territory,Hudud
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151,Please mention no of visits required,"Iltimos, kerakli tashriflardan hech qanday foydalanmang"
 DocType: Stock Settings,Default Valuation Method,Standart baholash usuli
-apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +26,Fee,Narxlar
-apps/erpnext/erpnext/setup/doctype/company/company.js +124,Update in progress. It might take a while.,Yangilanish davom etmoqda. Biroz vaqt talab etiladi.
+apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26,Fee,Narxlar
+apps/erpnext/erpnext/setup/doctype/company/company.js +125,Update in progress. It might take a while.,Yangilanish davom etmoqda. Biroz vaqt talab etiladi.
 DocType: Vehicle Log,Fuel Qty,Yoqilg&#39;i miqdori
 DocType: Production Order Operation,Planned Start Time,Rejalashtirilgan boshlash vaqti
 DocType: Course,Assessment,Baholash
 DocType: Payment Entry Reference,Allocated,Ajratilgan
-apps/erpnext/erpnext/config/accounts.py +275,Close Balance Sheet and book Profit or Loss.,Balansni yopish va daromadni yo&#39;qotish.
+apps/erpnext/erpnext/config/accounts.py +267,Close Balance Sheet and book Profit or Loss.,Balansni yopish va daromadni yo&#39;qotish.
 DocType: Student Applicant,Application Status,Dastur holati
 DocType: Sensitivity Test Items,Sensitivity Test Items,Sezuvchanlik sinovlari buyumlari
 DocType: Fees,Fees,Narxlar
 DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Bir valyutani boshqasiga aylantirish uchun ayirboshlash kursini tanlang
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +158,Quotation {0} is cancelled,Quotatsiya {0} bekor qilindi
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159,Quotation {0} is cancelled,Quotatsiya {0} bekor qilindi
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Total Outstanding Amount,Umumiy natija miqdori
 DocType: Sales Partner,Targets,Maqsadlar
 DocType: Price List,Price List Master,Narxlar ro&#39;yxati ustasi
 DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Barcha Sotuvdagi Jurnallarni bir nechta ** Sotuvdagi Shaxslarga ** joylashtirishingiz mumkin, shunday qilib maqsadlarni belgilashingiz va monitoring qilishingiz mumkin."
 ,S.O. No.,Yo&#39;q.
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +199,Please create Customer from Lead {0},"Iltimos, {0} qo&#39;rg&#39;oshidan mijozni yarating"
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241,Please create Customer from Lead {0},"Iltimos, {0} qo&#39;rg&#39;oshidan mijozni yarating"
 apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3,Select Patient,Kasalni tanlang
 DocType: Price List,Applicable for Countries,Davlatlar uchun amal qiladi
 DocType: Supplier Scorecard Scoring Variable,Parameter Name,Parametrning nomi
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Faqat &quot;Tasdiqlangan&quot; va &quot;Rad etilgan&quot; ilovalarni qoldiring
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +52,Student Group Name is mandatory in row {0},Isoning shogirdi guruhi nomi {0} qatorida majburiydir.
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52,Student Group Name is mandatory in row {0},Isoning shogirdi guruhi nomi {0} qatorida majburiydir.
 DocType: Homepage,Products to be shown on website homepage,Veb-saytning asosiy sahifasida ko&#39;rsatiladigan mahsulotlar
 apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13,This is a root customer group and cannot be edited.,Bu ildiz mijozlar guruhidir va tahrirlanmaydi.
-DocType: Employee,AB-,AB-
+DocType: Student,AB-,AB-
 DocType: POS Profile,Ignore Pricing Rule,Raqobatchilar qoidasiga e&#39;tibor bermang
 DocType: Employee Education,Graduate,Bitirmoq
 DocType: Leave Block List,Block Days,Bloklarni kunlar
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83,"Shipping Address does not have country, which is required for this Shipping Rule",Yetkazib berish manzili ushbu Shartnoma uchun zarur bo&#39;lgan mamlakatga ega emas
 DocType: Journal Entry,Excise Entry,Aktsiz to&#39;lash
 DocType: Terms and Conditions,"Standard Terms and Conditions that can be added to Sales and Purchases.
 
@@ -2892,54 +3094,56 @@
 1. Terms of shipping, if applicable.
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","Savdo va xaridlarga qo&#39;shilishi mumkin bo&#39;lgan standart shartlar. Misollar: 1. Taklifning amal qilish muddati. 1. To&#39;lov shartlari (Advance, Credit, part advance va boshqalar). 1. Qanday qo&#39;shimcha (yoki Xaridor tomonidan to&#39;lanishi kerak). 1. Xavfsizlik / foydalanish bo&#39;yicha ogohlantirish. 1. Agar mavjud bo&#39;lsa, kafolat. 1. Siyosatni qaytaradi. 1. Taqdim etish shartlari, agar mavjud bo&#39;lsa. 1. Nizolarni hal etish usullari, tovon, javobgarlik va boshqalar. 1. Sizning kompaniyangiz manzili va aloqasi."
+DocType: Issue,Issue Type,Muammo turi
 DocType: Attendance,Leave Type,Turini qoldiring
 DocType: Purchase Invoice,Supplier Invoice Details,Yetkazib beruvchi hisob-faktura ma&#39;lumotlari
+DocType: Agriculture Task,Ignore holidays,Bayramlarni e&#39;tiborsiz qoldiring
 apps/erpnext/erpnext/controllers/stock_controller.py +233,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Xarajatlar / farq statistikasi ({0}) &quot;Qor yoki ziyon&quot; hisobiga bo&#39;lishi kerak
 DocType: Project,Copied From,Ko&#39;chirildi
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96,Name error: {0},Ism xato: {0}
 apps/erpnext/erpnext/stock/doctype/item/item_list.js +12,Shortage,Kamchilik
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,{0} {1} does not associated with {2} {3},{0} {1} {2} {3} bilan bog&#39;lanmagan
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,Attendance for employee {0} is already marked,Xodimga ({0} davomi allaqachon belgilangan
 DocType: Packing Slip,If more than one package of the same type (for print),Agar bir xil turdagi bir nechta paketi (chop etish uchun)
 apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27,Please set default customer in Restaurant Settings,Restoran sozlamalarida standart mijozni tanlang
 ,Salary Register,Ish haqi registrati
 DocType: Warehouse,Parent Warehouse,Ota-onalar
 DocType: C-Form Invoice Detail,Net Total,Net Jami
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +498,Default BOM not found for Item {0} and Project {1},{0} va Project {1} uchun standart BOM topilmadi
-apps/erpnext/erpnext/config/hr.py +163,Define various loan types,Turli xil kredit turlarini aniqlang
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +526,Default BOM not found for Item {0} and Project {1},{0} va Project {1} uchun standart BOM topilmadi
+apps/erpnext/erpnext/config/hr.py +168,Define various loan types,Turli xil kredit turlarini aniqlang
 DocType: Bin,FCFS Rate,FCFS bahosi
-DocType: Payment Reconciliation Invoice,Outstanding Amount,Ustun miqdori
+DocType: Opening Invoice Creation Tool Item,Outstanding Amount,Ustun miqdori
 apps/erpnext/erpnext/templates/generators/bom.html +71,Time(in mins),Soat (daqiqa)
 DocType: Project Task,Working,Ishlash
 DocType: Stock Ledger Entry,Stock Queue (FIFO),Qimmatli qog&#39;ozlardagi navbat (FIFO)
-apps/erpnext/erpnext/public/js/setup_wizard.js +124,Financial Year,Moliyaviy yil
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +41,{0} does not belong to Company {1},{0} Kompaniya {1} ga tegishli emas
+apps/erpnext/erpnext/public/js/setup_wizard.js +127,Financial Year,Moliyaviy yil
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46,{0} does not belong to Company {1},{0} Kompaniya {1} ga tegishli emas
 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.,{0} uchun kriteriya funksiyasini o&#39;chirib bo&#39;lmadi. Formulaning haqiqiyligiga ishonch hosil qiling.
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +119,Cost as on,Narh-navo
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122,Cost as on,Narh-navo
 DocType: Healthcare Settings,Out Patient Settings,Kasalni sozlash
 DocType: Account,Round Off,Dumaloq yopiq
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +231,Quantity must be positive,Miqdor ijobiy bo&#39;lishi kerak
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +252,Quantity must be positive,Miqdor ijobiy bo&#39;lishi kerak
 ,Requested Qty,Kerakli son
 DocType: Tax Rule,Use for Shopping Cart,Savatga savatni uchun foydalaning
 apps/erpnext/erpnext/controllers/item_variant.py +96,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},{1} atributi uchun {0} {2} {Item uchun joriy element identifikatorlari qiymatlari ro&#39;yxatida mavjud emas
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +78,Select Serial Numbers,Seriya raqamlarini tanlang
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79,Select Serial Numbers,Seriya raqamlarini tanlang
 DocType: BOM Item,Scrap %,Hurda%
 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",Narxlar Sizning tanlovingiz bo&#39;yicha mahsulot miqdori yoki miqdori bo&#39;yicha mutanosib ravishda taqsimlanadi
 DocType: Maintenance Visit,Purposes,Maqsadlar
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +111,Atleast one item should be entered with negative quantity in return document,Eng kamida bitta element qaytarib berilgan hujjatda salbiy miqdor bilan kiritilishi kerak
 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",{0} ish stantsiyasida ishlaydigan har qanday ish soatlaridan ko&#39;proq {0} operatsiya operatsiyani bir nechta operatsiyalarga ajratish
+DocType: Membership,Membership Status,Registratsiya holati
 ,Requested,Talab qilingan
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90,No Remarks,Izohlar yo&#39;q
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93,No Remarks,Izohlar yo&#39;q
+DocType: Asset,In Maintenance,Xizmatda
 DocType: Purchase Invoice,Overdue,Vadesi o&#39;tgan
 DocType: Account,Stock Received But Not Billed,"Qabul qilingan, lekin olinmagan aktsiyalar"
-apps/erpnext/erpnext/accounts/doctype/account/account.py +87,Root Account must be a group,Ildiz hisobi guruh bo&#39;lishi kerak
+apps/erpnext/erpnext/accounts/doctype/account/account.py +86,Root Account must be a group,Ildiz hisobi guruh bo&#39;lishi kerak
 DocType: Consultation,Drug Prescription,Dori retsepti
 DocType: Fees,FEE.,Fee.
 DocType: Employee Loan,Repaid/Closed,Qaytarilgan / yopiq
 DocType: Item,Total Projected Qty,Jami loyiha miqdori
 DocType: Monthly Distribution,Distribution Name,Tarqatish nomi
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Yetkazib beruvchi&gt; Yetkazib beruvchi turi
-apps/erpnext/erpnext/stock/stock_ledger.py +464,"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","{1} {2} uchun buxgalter yozuvlarini kiritish uchun talab qilinadigan {0} elementi uchun baholanish darajasi topilmadi. Agar element {1} da nol qiymatni baholash darajasi elementi sifatida ishlayotgan bo&#39;lsa, iltimos, {1} Mavzu jadvalidagi buni eslatib o&#39;ting. Aks holda, mahsulot ro&#39;yxatiga kiritilgan qimmatli qog&#39;ozlar bilan bog&#39;liq bitim tuzing yoki qiymat qaydini qaydlang va keyin ushbu yozuvni taqdim etishni / bekor qilib ko&#39;ring."
+apps/erpnext/erpnext/stock/stock_ledger.py +471,"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","{1} {2} uchun buxgalter yozuvlarini kiritish uchun talab qilinadigan {0} elementi uchun baholanish darajasi topilmadi. Agar element {1} da nol qiymatni baholash darajasi elementi sifatida ishlayotgan bo&#39;lsa, iltimos, {1} Mavzu jadvalidagi buni eslatib o&#39;ting. Aks holda, mahsulot ro&#39;yxatiga kiritilgan qimmatli qog&#39;ozlar bilan bog&#39;liq bitim tuzing yoki qiymat qaydini qaydlang va keyin ushbu yozuvni taqdim etishni / bekor qilib ko&#39;ring."
 DocType: Course,Course Code,Kurs kodi
 apps/erpnext/erpnext/controllers/stock_controller.py +331,Quality Inspection required for Item {0},{0} mahsulot uchun sifat nazorati zarur
 DocType: POS Settings,Use POS in Offline Mode,Oflayn rejimida QO&#39;yi ishlatish
@@ -2950,20 +3154,20 @@
 apps/erpnext/erpnext/config/selling.py +105,Manage Territory Tree.,Mintaqa daraxtini boshqarish.
 DocType: Journal Entry Account,Sales Invoice,Savdo billing
 DocType: Journal Entry Account,Party Balance,Partiya balansi
-apps/erpnext/erpnext/accounts/page/pos/pos.js +484,Please select Apply Discount On,"Iltimos, &quot;Ilovani yoqish&quot; ni tanlang"
+apps/erpnext/erpnext/accounts/page/pos/pos.js +497,Please select Apply Discount On,"Iltimos, &quot;Ilovani yoqish&quot; ni tanlang"
+DocType: Stock Settings,Sample Retention Warehouse,Namuna tutish ombori
 DocType: Company,Default Receivable Account,Oladigan schyot hisob
-DocType: Process Payroll,Create Bank Entry for the total salary paid for the above selected criteria,Yuqorida ko&#39;rsatilgan tanlangan mezonlarga to&#39;lanadigan umumiy ish haqi uchun bankdagi yozuvni yarating
 DocType: Physician,Physician Schedule,Shifokor dasturi
 DocType: Purchase Invoice,Deemed Export,Qabul qilingan eksport
 DocType: Stock Entry,Material Transfer for Manufacture,Ishlab chiqarish uchun material etkazib berish
 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.,Chegirma foizlar yoki Narxlar ro&#39;yxatiga yoki barcha Narxlar ro&#39;yxatiga nisbatan qo&#39;llanilishi mumkin.
 DocType: Subscription,Half-yearly,Yarim yillik
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +402,Accounting Entry for Stock,Qimmatli qog&#39;ozlar uchun hisob yozuvi
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +406,Accounting Entry for Stock,Qimmatli qog&#39;ozlar uchun hisob yozuvi
 DocType: Lab Test,LabTest Approver,LabTest Approval
-apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.py +49,You have already assessed for the assessment criteria {}.,Siz allaqachon baholash mezonlari uchun baholagansiz {}.
+apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +49,You have already assessed for the assessment criteria {}.,Siz allaqachon baholash mezonlari uchun baholagansiz {}.
 DocType: Vehicle Service,Engine Oil,Motor moyi
 DocType: Sales Invoice,Sales Team1,Savdo guruhi1
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +39,Item {0} does not exist,{0} elementi mavjud emas
+apps/erpnext/erpnext/stock/doctype/item/item.py +521,Item {0} does not exist,{0} elementi mavjud emas
 DocType: Sales Invoice,Customer Address,Mijozlar manzili
 DocType: Employee Loan,Loan Details,Kredit tafsilotlari
 DocType: Company,Default Inventory Account,Inventarizatsiyadan hisob qaydnomasi
@@ -2971,6 +3175,7 @@
 DocType: Antibiotic,Antibiotic Name,Antibiotik nomi
 DocType: Purchase Invoice,Apply Additional Discount On,Qo&#39;shimcha imtiyozni yoqish
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +69,Select Type...,Turini tanlang ...
+DocType: Crop Cycle,A link to all the Land Units in which the Crop is growing,O&#39;simliklar o&#39;sadigan barcha yer uchastkalari bilan bog&#39;lanish
 DocType: Account,Root Type,Ildiz turi
 DocType: Item,FIFO,FIFO
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +132,Row # {0}: Cannot return more than {1} for Item {2},{0} qatori: {1} dan ortiq {2}
@@ -2978,21 +3183,23 @@
 DocType: Item Group,Show this slideshow at the top of the page,Ushbu slayd-shouni sahifaning yuqori qismida ko&#39;rsatish
 DocType: BOM,Item UOM,UOM mahsuloti
 DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Chegirma miqdori bo&#39;yicha soliq summasi (Kompaniya valyutasi)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +150,Target warehouse is mandatory for row {0},Nishon ombor {0} satr uchun majburiydir.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +155,Target warehouse is mandatory for row {0},Nishon ombor {0} satr uchun majburiydir.
 DocType: Cheque Print Template,Primary Settings,Asosiy sozlamalar
 DocType: Purchase Invoice,Select Supplier Address,Ta&#39;minlovchining manzilini tanlang
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +380,Add Employees,Ishchilarni qo&#39;shish
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397,Add Employees,Ishchilarni qo&#39;shish
 DocType: Purchase Invoice Item,Quality Inspection,Sifatni tekshirish
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +192,Extra Small,Qo&#39;shimcha kichik
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196,Extra Small,Qo&#39;shimcha kichik
 DocType: Company,Standard Template,Standart shablon
 DocType: Training Event,Theory,Nazariya
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +780,Warning: Material Requested Qty is less than Minimum Order Qty,Ogohlantirish: Kerakli ma&#39;lumot Minimum Buyurtma miqdori ostida
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +805,Warning: Material Requested Qty is less than Minimum Order Qty,Ogohlantirish: Kerakli ma&#39;lumot Minimum Buyurtma miqdori ostida
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211,Account {0} is frozen,{0} hisobi muzlatilgan
 DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Yuridik shaxs / Tashkilotga qarashli alohida hisob-kitob rejasi bo&#39;lgan filial.
 DocType: Payment Request,Mute Email,E-pochtani o&#39;chirish
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +29,"Food, Beverage & Tobacco","Oziq-ovqat, ichgani va tamaki"
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +689,Can only make payment against unbilled {0},Faqat to&#39;ldirilmagan {0} ga to&#39;lovni amalga oshirishi mumkin
-apps/erpnext/erpnext/controllers/selling_controller.py +130,Commission rate cannot be greater than 100,Komissiya stavkasi 100 dan ortiq bo&#39;lishi mumkin emas
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29,"Food, Beverage & Tobacco","Oziq-ovqat, ichgani va tamaki"
+DocType: Account,Account Number,Hisob raqami
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +714,Can only make payment against unbilled {0},Faqat to&#39;ldirilmagan {0} ga to&#39;lovni amalga oshirishi mumkin
+apps/erpnext/erpnext/controllers/selling_controller.py +98,Commission rate cannot be greater than 100,Komissiya stavkasi 100 dan ortiq bo&#39;lishi mumkin emas
+DocType: Volunteer,Volunteer,Ko&#39;ngilli
 DocType: Stock Entry,Subcontract,Subpudrat
 apps/erpnext/erpnext/public/js/utils/party.js +165,Please enter {0} first,Avval {0} kiriting
 apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +87,No replies from,Javoblar yo&#39;q
@@ -3001,60 +3208,68 @@
 DocType: Item,Manufacturer Part Number,Ishlab chiqaruvchi raqami
 DocType: Production Order Operation,Estimated Time and Cost,Bashoratli vaqt va narx
 DocType: Bin,Bin,Bin
+DocType: Crop,Crop Name,O&#39;simlik nomi
 DocType: SMS Log,No of Sent SMS,Yuborilgan SMS yo&#39;q
 DocType: Antibiotic,Healthcare Administrator,Sog&#39;liqni saqlash boshqaruvchisi
 apps/erpnext/erpnext/utilities/user_progress.py +44,Set a Target,Nishonni o&#39;rnating
 DocType: Dosage Strength,Dosage Strength,Dozalash kuchi
 DocType: Account,Expense Account,Xisob-kitobi
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +49,Software,Dasturiy ta&#39;minot
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +199,Colour,Rang
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49,Software,Dasturiy ta&#39;minot
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203,Colour,Rang
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Baholashni baholash mezonlari
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Buyurtma buyurtmalaridan saqlanish
-apps/erpnext/erpnext/healthcare/setup.py +257,Susceptible,E&#39;tiborli
+apps/erpnext/erpnext/healthcare/setup.py +258,Susceptible,E&#39;tiborli
 DocType: Patient Appointment,Scheduled,Rejalashtirilgan
 apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Taklif so&#39;rovi.
 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",&quot;Stoktaki Mahsulot&quot; - &quot;Yo&#39;q&quot; va &quot;Sotuvdagi Maqsad&quot; - &quot;Ha&quot; deb nomlangan Mavzu-ni tanlang va boshqa Mahsulot Bundlei yo&#39;q
 apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148,Select Customer,Xaridorni tanlang
 DocType: Student Log,Academic,Ilmiy
 DocType: Patient,Personal and Social History,Shaxsiy va ijtimoiy tarix
+apps/erpnext/erpnext/education/doctype/guardian/guardian.py +52,User {0} created,Foydalanuvchi {0} yaratildi
 DocType: Fee Schedule,Fee Breakup for each student,Har bir talaba uchun to&#39;lovni taqsimlash
-apps/erpnext/erpnext/controllers/accounts_controller.py +476,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Buyurtma {1} ga nisbatan umumiy oldindan ({0}) Grand Total ({2})
+apps/erpnext/erpnext/controllers/accounts_controller.py +520,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Buyurtma {1} ga nisbatan umumiy oldindan ({0}) Grand Total ({2})
 DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,Oylar bo&#39;ylab maqsadlarni teng darajada taqsimlash uchun oylik tarqatish-ni tanlang.
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78,Change Code,Kodni o&#39;zgartirish
 DocType: Purchase Invoice Item,Valuation Rate,Baholash darajasi
 DocType: Stock Reconciliation,SR/,SR /
 DocType: Vehicle,Diesel,Diesel
-apps/erpnext/erpnext/stock/get_item_details.py +338,Price List Currency not selected,Narxlar ro&#39;yxati Valyutasi tanlanmagan
+apps/erpnext/erpnext/stock/get_item_details.py +381,Price List Currency not selected,Narxlar ro&#39;yxati Valyutasi tanlanmagan
 apps/erpnext/erpnext/config/healthcare.py +46,Results,Natijalar
 ,Student Monthly Attendance Sheet,Talabalar oylik davomiyligi varaqasi
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96,Shipping rule only applicable for Selling,Yuk tashish qoidasi faqat Sotish uchun amal qiladi
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +185,Employee {0} has already applied for {1} between {2} and {3},{0} xizmatdoshi allaqachon {1} uchun {2} va {3}
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Loyiha boshlanish sanasi
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +5,Until,To
 DocType: Rename Tool,Rename Log,Jurnalni qayta nomlash
-apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Talabalar guruhi yoki kurslar jadvali majburiydir
+apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Talabalar guruhi yoki kurslar jadvali majburiydir
 DocType: HR Settings,Maintain Billing Hours and Working Hours Same on Timesheet,Billing vaqtlarini va ish soatlarini vaqt jadvalini bilan bir xil saqlang
 DocType: Maintenance Visit Purpose,Against Document No,Hujjatlarga qarshi
 DocType: BOM,Scrap,Hurda
-apps/erpnext/erpnext/utilities/user_progress.py +196,Go to Instructors,O&#39;qituvchilarga o&#39;ting
+apps/erpnext/erpnext/utilities/user_progress.py +214,Go to Instructors,O&#39;qituvchilarga o&#39;ting
 apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,Savdo hamkorlarini boshqarish.
 DocType: Quality Inspection,Inspection Type,Tekshirish turi
 DocType: Fee Validity,Visited yet,Hoziroq tashrif buyurdi
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +135,Warehouses with existing transaction can not be converted to group.,Mavjud bitimlarga ega bo&#39;lgan omborlar guruhga o&#39;tkazilmaydi.
 DocType: Assessment Result Tool,Result HTML,Natijada HTML
+apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6,Memeber Activity,Memeber faoliyati
 apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35,Expires On,Muddati tugaydi
 apps/erpnext/erpnext/utilities/activation.py +117,Add Students,Talabalarni qo&#39;shish
+apps/erpnext/erpnext/public/js/utils.js +264,Please select {0},"Iltimos, {0}"
 DocType: C-Form,C-Form No,S-formasi №
 DocType: BOM,Exploded_items,Exploded_items
-apps/erpnext/erpnext/utilities/user_progress.py +118,List your products or services that you buy or sell.,Siz sotib olgan yoki sotgan mahsulot va xizmatlarni ro&#39;yxatlang.
+apps/erpnext/erpnext/utilities/user_progress.py +136,List your products or services that you buy or sell.,Siz sotib olgan yoki sotgan mahsulot va xizmatlarni ro&#39;yxatlang.
+DocType: Water Analysis,Storage Temperature,Saqlash harorati
 DocType: Employee Attendance Tool,Unmarked Attendance,Belgilangan tomoshabin
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +133,Researcher,Tadqiqotchi
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137,Researcher,Tadqiqotchi
 DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Dasturni ro&#39;yxatga olish vositasi
+apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16,Start date should be less than end date for task {0},Boshlanish sanasi {0} vazifasi uchun tugatish sanasidan past bo&#39;lishi kerak
 apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Ism yoki elektron pochta manzili majburiydir
-apps/erpnext/erpnext/config/stock.py +168,Incoming quality inspection.,Kiruvchi sifat nazorati.
 DocType: Purchase Order Item,Returned Qty,Miqdori qaytarildi
-DocType: Employee,Exit,Chiqish
-apps/erpnext/erpnext/accounts/doctype/account/account.py +159,Root Type is mandatory,Ildiz turi majburiydir
+DocType: Student,Exit,Chiqish
+apps/erpnext/erpnext/accounts/doctype/account/account.py +158,Root Type is mandatory,Ildiz turi majburiydir
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29,Failed to install presets,Avvalgi sozlamalarni o&#39;rnatib bo&#39;lmadi
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +42,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.",{0} hozirda {1} Yetkazib beruvchi hisoblagichi mavjud va bu yetkazib beruvchiga RFQ ehtiyotkorlik bilan berilishi kerak.
+DocType: Chapter,Non Profit Manager,Qor bo&#39;lmagan menedjer
 DocType: BOM,Total Cost(Company Currency),Jami xarajat (Kompaniya valyutasi)
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315,Serial No {0} created,Seriya no {0} yaratildi
 DocType: Homepage,Company Description for website homepage,Veb-saytning ota-sahifasi uchun Kompaniya tavsifi
@@ -3065,39 +3280,40 @@
 DocType: Employee,You can enter any date manually,Har qanday sanani qo&#39;lda kiritishingiz mumkin
 DocType: Healthcare Settings,Result Printed,Chop etilgan natija
 DocType: Asset Category Account,Depreciation Expense Account,Amortizatsiya ketadi hisob
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +221,Probationary Period,Sinov muddati
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +231,Probationary Period,Sinov muddati
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32,View {0},{0} ko&#39;rinishi
 DocType: Customer Group,Only leaf nodes are allowed in transaction,Jurnal paytida faqat bargli tugunlarga ruxsat beriladi
-DocType: Expense Claim,Expense Approver,Xarajatlarni taqsimlash
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Customer must be credit,Row {0}: mijozga qarshi avans kredit bo&#39;lishi kerak
-apps/erpnext/erpnext/accounts/doctype/account/account.js +83,Non-Group to Group,Guruh bo&#39;lmagan guruhga
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},{0} qatorida paketli bo&#39;lish kerak
+DocType: Project,Total Costing Amount (via Timesheets),Jami xarajat summasi (vaqt jadvallari orqali)
+DocType: Employee Advance,Expense Approver,Xarajatlarni taqsimlash
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +134,Row {0}: Advance against Customer must be credit,Row {0}: mijozga qarshi avans kredit bo&#39;lishi kerak
+apps/erpnext/erpnext/accounts/doctype/account/account.js +89,Non-Group to Group,Guruh bo&#39;lmagan guruhga
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},{0} qatorida paketli bo&#39;lish kerak
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Qabul qilish uchun ma&#39;lumot elementi yetkazib berildi
 DocType: Payment Entry,Pay,To&#39;lash
 apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,Datetime-ga
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +54,Course Schedules deleted:,Kurs jadvali o&#39;chirildi:
 apps/erpnext/erpnext/config/selling.py +297,Logs for maintaining sms delivery status,Sms yetkazib berish holatini saqlab qolish uchun qaydlar
 DocType: Accounts Settings,Make Payment via Journal Entry,Jurnalga kirish orqali to&#39;lovni amalga oshiring
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +86,Printed On,Chop etilgan
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +97,Printed On,Chop etilgan
 DocType: Item,Inspection Required before Delivery,Etkazib berishdan oldin tekshirish kerak
 DocType: Item,Inspection Required before Purchase,Sotib olishdan oldin tekshirish kerak
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93,Pending Activities,Kutilayotgan amallar
 DocType: Patient Appointment,Reminded,Eslatildi
 DocType: Patient,PID-,PID-
-apps/erpnext/erpnext/public/js/setup_wizard.js +103,Your Organization,Tashkilotingiz
+DocType: Chapter Member,Chapter Member,Bo&#39;lim a&#39;zosi
+apps/erpnext/erpnext/public/js/setup_wizard.js +106,Your Organization,Tashkilotingiz
 DocType: Fee Component,Fees Category,Narxlar toifasi
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +129,Please enter relieving date.,"Iltimos, bo&#39;sh vaqtni kiriting."
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +134,Please enter relieving date.,"Iltimos, bo&#39;sh vaqtni kiriting."
 apps/erpnext/erpnext/controllers/trends.py +149,Amt,Amt
 DocType: Supplier Scorecard,Notify Employee,Xodimlarni xabardor qiling
 DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,"So&#39;rovnomaning manbasi kampaniya bo&#39;lsa, kampaniyaning nomini kiriting"
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +38,Newspaper Publishers,Gazeta nashriyoti
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38,Newspaper Publishers,Gazeta nashriyoti
 apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30,Select Fiscal Year,Moliyaviy yilni tanlang
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +114,Expected Delivery Date should be after Sales Order Date,Kutilayotgan etkazib berish sanasi Sotuvdagi Buyurtma tarixidan keyin bo&#39;lishi kerak
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115,Expected Delivery Date should be after Sales Order Date,Kutilayotgan etkazib berish sanasi Sotuvdagi Buyurtma tarixidan keyin bo&#39;lishi kerak
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Tartibni qayta tartibga solish
 DocType: Company,Chart Of Accounts Template,Hisob jadvalining jadvali
 DocType: Attendance,Attendance Date,Ishtirok etish sanasi
 DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Daromadni kamaytirish va tushirishga asosan ish haqi taqsimoti.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +131,Account with child nodes cannot be converted to ledger,Bola tugunlari bilan hisob qaydnomasiga o&#39;tkazilmaydi
+apps/erpnext/erpnext/accounts/doctype/account/account.py +130,Account with child nodes cannot be converted to ledger,Bola tugunlari bilan hisob qaydnomasiga o&#39;tkazilmaydi
 DocType: Purchase Invoice Item,Accepted Warehouse,Qabul qilingan omborxona
 DocType: Bank Reconciliation Detail,Posting Date,O&#39;tilganlik sanasi
 DocType: Item,Valuation Method,Baholash usuli
@@ -3106,14 +3322,14 @@
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +85,Duplicate entry,Ikki nusxadagi kirish
 DocType: Program Enrollment Tool,Get Students,Talabalarni oling
 DocType: Serial No,Under Warranty,Kafolat ostida
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +491,[Error],[Xato]
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +515,[Error],[Xato]
 DocType: Sales Order,In Words will be visible once you save the Sales Order.,Savdo buyurtmasini saqlaganingizdan so&#39;ng So&#39;zlarda paydo bo&#39;ladi.
 ,Employee Birthday,Xodimlarning tug&#39;ilgan kuni
+apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14,Please select Completion Date for Completed Repair,Tugallangan ta&#39;mirlash uchun tugagan sanani tanlang
 DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Talabalar to&#39;plamini tomosha qilish vositasi
 apps/erpnext/erpnext/controllers/status_updater.py +210,Limit Crossed,Cheklangan chiziqli
-apps/erpnext/erpnext/schools/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Rejalashtirilgan Upto
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +55,Venture Capital,Venture Capital
-apps/erpnext/erpnext/stock/doctype/item/item.py +474,"As there are existing transactions against item {0}, you can not change the value of {1}",{0} elementiga nisbatan mavjud bitimlar mavjud bo&#39;lgani uchun {1} qiymatini o&#39;zgartira olmaysiz
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Rejalashtirilgan Upto
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55,Venture Capital,Venture Capital
 DocType: UOM,Must be Whole Number,Barcha raqamlar bo&#39;lishi kerak
 DocType: Leave Control Panel,New Leaves Allocated (In Days),Yangi barglar ajratilgan (kunlar)
 DocType: Purchase Invoice,Invoice Copy,Faktura nusxasi
@@ -3123,7 +3339,7 @@
 DocType: Payment Reconciliation Invoice,Invoice Number,Billing raqami
 DocType: Shopping Cart Settings,Orders,Buyurtma
 DocType: Employee Leave Approver,Leave Approver,Approvatni qoldiring
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +272,Please select a batch,"Iltimos, partiyani tanlang"
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +285,Please select a batch,"Iltimos, partiyani tanlang"
 DocType: Assessment Group,Assessment Group Name,Baholash guruhining nomi
 DocType: Manufacturing Settings,Material Transferred for Manufacture,Ishlab chiqarish uchun mo&#39;ljallangan material
 DocType: Expense Claim,"A user with ""Expense Approver"" role",&quot;Expense Approver&quot; roli bilan foydalanuvchi
@@ -3132,21 +3348,23 @@
 ,Issued Items Against Production Order,Ishlab chiqarish tartibiga qarshi chiqarilgan buyumlar
 DocType: Antibiotic,Healthcare,Sog&#39;liqni saqlash
 DocType: Target Detail,Target Detail,Maqsad tafsilotlari
+apps/erpnext/erpnext/stock/doctype/item/item.js +65,Single Variant,Bitta variant
 apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24,All Jobs,Barcha ishlar
 DocType: Sales Order,% of materials billed against this Sales Order,Ushbu Buyurtma Buyurtma uchun taqdim etilgan materiallarning%
 DocType: Program Enrollment,Mode of Transportation,Tashish tartibi
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49,Period Closing Entry,Davrni yopish
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +75,Select Department...,Bo&#39;limni tanlang ...
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38,Cost Center with existing transactions can not be converted to group,Amalga oshirilgan operatsiyalar bilan Narx Markaziga guruhga o&#39;tish mumkin emas
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +360,Amount {0} {1} {2} {3},Miqdor {0} {1} {2} {3}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +361,Amount {0} {1} {2} {3},Miqdor {0} {1} {2} {3}
 DocType: Account,Depreciation,Amortizatsiya
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,Supplier(s),Yetkazib beruvchilar (lar)
 DocType: Employee Attendance Tool,Employee Attendance Tool,Xodimlarga qatnashish vositasi
 DocType: Guardian Student,Guardian Student,Guardian talaba
 DocType: Supplier,Credit Limit,Kredit cheklovi
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Selling Price List Rate,Ort Sotish narxi narxlari darajasi
 DocType: Production Plan Sales Order,Salse Order Date,Buyurtma tarixi
 DocType: Salary Component,Salary Component,Ish haqi komponenti
-apps/erpnext/erpnext/accounts/utils.py +490,Payment Entries {0} are un-linked,To&#39;lov yozuvlari {0} un-bog&#39;lanmagan
+apps/erpnext/erpnext/accounts/utils.py +492,Payment Entries {0} are un-linked,To&#39;lov yozuvlari {0} un-bog&#39;lanmagan
 DocType: GL Entry,Voucher No,Voucher No.
 ,Lead Owner Efficiency,Qurilish egasining samaradorligi
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +195,Most Popular,Eng mashhurlari
@@ -3159,12 +3377,12 @@
 apps/erpnext/erpnext/config/selling.py +164,Template of terms or contract.,Atamalar yoki shartnoma namunalari.
 DocType: Purchase Invoice,Address and Contact,Manzil va aloqa
 DocType: Cheque Print Template,Is Account Payable,Hisobni to&#39;lash mumkinmi?
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +273,Stock cannot be updated against Purchase Receipt {0},Qimmatli qog&#39;ozlar oldi-sotdisi qabul qilinmasa {0}
-DocType: Supplier,Last Day of the Next Month,Keyingi oyning oxirgi kuni
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276,Stock cannot be updated against Purchase Receipt {0},Qimmatli qog&#39;ozlar oldi-sotdisi qabul qilinmasa {0}
+DocType: Company,Last Day of the Next Month,Keyingi oyning oxirgi kuni
 DocType: Support Settings,Auto close Issue after 7 days,7 kundan so&#39;ng avtomatik yopilish
 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}","{0} dan oldin qoldirib bo&#39;linmaydi, chunki kelajakda bo&#39;sh joy ajratish yozuvida {1}"
-apps/erpnext/erpnext/accounts/party.py +319,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),"Eslatma: Muddati o&#39;tgan / mos yozuvlar sanasi, mijozlar kredit kunlarini {0} kun (lar)"
-apps/erpnext/erpnext/schools/doctype/program/program.js +8,Student Applicant,Talabalar uchun nomzod
+apps/erpnext/erpnext/accounts/party.py +320,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),"Eslatma: Muddati o&#39;tgan / mos yozuvlar sanasi, mijozlar kredit kunlarini {0} kun (lar)"
+apps/erpnext/erpnext/education/doctype/program/program.js +8,Student Applicant,Talabalar uchun nomzod
 DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,ORIGINAL FOR RECIPIENT
 DocType: Asset Category Account,Accumulated Depreciation Account,Yig&#39;ilgan Amortisman hisobi
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11,This email is autogenerated,Ushbu e-pochta autentifikatsiyalangan
@@ -3175,37 +3393,40 @@
 DocType: Activity Cost,Billing Rate,Billing darajasi
 ,Qty to Deliver,Miqdorni etkazish
 ,Stock Analytics,Stock Analytics
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +505,Operations cannot be left blank,Operatsiyalarni bo&#39;sh qoldirib bo&#39;lmaydi
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +508,Operations cannot be left blank,Operatsiyalarni bo&#39;sh qoldirib bo&#39;lmaydi
 DocType: Maintenance Visit Purpose,Against Document Detail No,Hujjat bo&#39;yicha batafsil ma&#39;lumot yo&#39;q
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +98,Party Type is mandatory,Partiya turi majburiydir
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +99,Party Type is mandatory,Partiya turi majburiydir
 DocType: Quality Inspection,Outgoing,Chiqish
 DocType: Material Request,Requested For,Talab qilingan
 DocType: Quotation Item,Against Doctype,Doctypega qarshi
-apps/erpnext/erpnext/controllers/buying_controller.py +395,{0} {1} is cancelled or closed,{0} {1} bekor qilindi yoki yopildi
+apps/erpnext/erpnext/controllers/buying_controller.py +396,{0} {1} is cancelled or closed,{0} {1} bekor qilindi yoki yopildi
+DocType: Asset,Calculate Depreciation,Amortizatsiyani hisoblang
 DocType: Delivery Note,Track this Delivery Note against any Project,Ushbu etkazib berishni kuzatib boring
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +30,Net Cash from Investing,Investitsiyalardan tushgan aniq pul
 DocType: Production Order,Work-in-Progress Warehouse,Harakatlanuvchi ishchi stantsiyasi
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +111,Asset {0} must be submitted,Asset {0} yuborilishi kerak
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111,Asset {0} must be submitted,Asset {0} yuborilishi kerak
 DocType: Fee Schedule Program,Total Students,Jami talabalar
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354,Reference #{0} dated {1},{{1}} {{0}
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +161,Depreciation Eliminated due to disposal of assets,Amortizatsiya Aktivlarni yo&#39;qotish oqibatida yo&#39;qotilgan
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +352,Reference #{0} dated {1},{{1}} {{0}
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164,Depreciation Eliminated due to disposal of assets,Amortizatsiya Aktivlarni yo&#39;qotish oqibatida yo&#39;qotilgan
+DocType: Member,Member,Ro&#39;yxatdan
 apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Manzillarni boshqarish
-DocType: Asset,Item Code,Mahsulot kodi
+DocType: Pricing Rule,Item Code,Mahsulot kodi
 DocType: Production Planning Tool,Create Production Orders,Buyurtma yaratish
 DocType: Serial No,Warranty / AMC Details,Kafolat / AMC tafsilotlari
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Faoliyatga asoslangan guruh uchun talabalarni qo&#39;lda tanlang
+apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Faoliyatga asoslangan guruh uchun talabalarni qo&#39;lda tanlang
 DocType: Journal Entry,User Remark,Foydalanuvchi eslatmasi
 DocType: Lead,Market Segment,Bozor segmenti
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +924,Paid Amount cannot be greater than total negative outstanding amount {0},To&#39;langan pul miqdori jami salbiy ortiqcha {0}
+DocType: Crop,Agriculture Manager,Qishloq xo&#39;jalik boshqaruvchisi
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +950,Paid Amount cannot be greater than total negative outstanding amount {0},To&#39;langan pul miqdori jami salbiy ortiqcha {0}
 DocType: Supplier Scorecard Period,Variables,Argumentlar
 DocType: Employee Internal Work History,Employee Internal Work History,Xodimning ichki ish tarixi
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +239,Closing (Dr),Yakunlovchi (doktor)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +246,Closing (Dr),Yakunlovchi (doktor)
 DocType: Cheque Print Template,Cheque Size,Hajmi tekshirilsin
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232,Serial No {0} not in stock,Serial No {0} aksiyada mavjud emas
 apps/erpnext/erpnext/config/selling.py +169,Tax template for selling transactions.,Jurnallarni sotish uchun soliq shablonni.
 DocType: Sales Invoice,Write Off Outstanding Amount,Katta miqdorda yozing
 apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27,Account {0} does not match with Company {1},Hisob {0} Kompaniya bilan {1}
-DocType: School Settings,Current Academic Year,Joriy o&#39;quv yili
+DocType: Education Settings,Current Academic Year,Joriy o&#39;quv yili
 DocType: Stock Settings,Default Stock UOM,Foydalanuvchi kabinetga UOM
 DocType: Asset,Number of Depreciations Booked,Ilova qilingan amortizatsiya miqdori
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32,Against Employee Loan: {0},Xodimlarga qarzga qarshi: {0}
@@ -3213,80 +3434,86 @@
 DocType: Production Planning Tool,Create Material Requests,Materiallar so&#39;rovlarini yaratish
 DocType: Employee Education,School/University,Maktab / Universitet
 DocType: Payment Request,Reference Details,Ma&#39;lumotnoma ma&#39;lumotlari
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +59,Expected Value After Useful Life must be less than Gross Purchase Amount,Foydali umrdan keyin kutilgan qiymat Brüt Xarid qilish miqdoridan kam bo&#39;lishi kerak
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +59,Expected Value After Useful Life must be less than Gross Purchase Amount,Foydali umrdan keyin kutilgan qiymat Brüt Xarid qilish miqdoridan kam bo&#39;lishi kerak
 DocType: Sales Invoice Item,Available Qty at Warehouse,Mavjud QXI da
 apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Billed Amount,To&#39;lov miqdori
 DocType: Asset,Double Declining Balance,Ikki marta tushgan muvozanat
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +179,Closed order cannot be cancelled. Unclose to cancel.,Yopiq buyurtmani bekor qilish mumkin emas. Bekor qilish uchun yoping.
-DocType: Patient Relation,Father,Ota
-apps/erpnext/erpnext/controllers/accounts_controller.py +562,'Update Stock' cannot be checked for fixed asset sale,&#39;Qimmatli qog&#39;ozlar yangilanishi&#39; moddiy aktivlarni sotish uchun tekshirib bo&#39;lmaydi
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180,Closed order cannot be cancelled. Unclose to cancel.,Yopiq buyurtmani bekor qilish mumkin emas. Bekor qilish uchun yoping.
+DocType: Student Guardian,Father,Ota
+apps/erpnext/erpnext/controllers/accounts_controller.py +606,'Update Stock' cannot be checked for fixed asset sale,&#39;Qimmatli qog&#39;ozlar yangilanishi&#39; moddiy aktivlarni sotish uchun tekshirib bo&#39;lmaydi
 DocType: Bank Reconciliation,Bank Reconciliation,Bank bilan kelishuv
 DocType: Attendance,On Leave,Chiqishda
 apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Get Updates,Yangilanishlarni oling
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Hisob {2} Kompaniyaga tegishli emas {3}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +147,Material Request {0} is cancelled or stopped,Materialda so&#39;rov {0} bekor qilindi yoki to&#39;xtatildi
-apps/erpnext/erpnext/config/hr.py +305,Leave Management,Boshqarishni qoldiring
+apps/erpnext/erpnext/stock/doctype/item/item.js +366,Select at least one value from each of the attributes.,Har bir atributdan kamida bitta qiymatni tanlang.
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +156,Material Request {0} is cancelled or stopped,Materialda so&#39;rov {0} bekor qilindi yoki to&#39;xtatildi
+apps/erpnext/erpnext/config/hr.py +310,Leave Management,Boshqarishni qoldiring
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +106,Group by Account,Hisobga ko&#39;ra guruh
 DocType: Sales Order,Fully Delivered,To&#39;liq topshirildi
 DocType: Lead,Lower Income,Kam daromad
 DocType: Restaurant Order Entry,Current Order,Joriy Buyurtma
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +169,Source and target warehouse cannot be same for row {0},Resurs va maqsadli omborlar {0} qatori uchun bir xil bo&#39;lishi mumkin emas
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +174,Source and target warehouse cannot be same for row {0},Resurs va maqsadli omborlar {0} qatori uchun bir xil bo&#39;lishi mumkin emas
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +241,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Farq Hisobi Hisob-kitobi bo&#39;lishi kerak, chunki bu fondning kelishuvi ochilish yozuvi"
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107,Disbursed Amount cannot be greater than Loan Amount {0},Ish haqi miqdori Kredit summasidan katta bo&#39;lishi mumkin emas {0}
-apps/erpnext/erpnext/utilities/user_progress.py +155,Go to Programs,Dasturlarga o&#39;ting
+apps/erpnext/erpnext/utilities/user_progress.py +173,Go to Programs,Dasturlarga o&#39;ting
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +219,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Row {0} # Ajratilgan miqdor {1} da&#39;vo qilinmagan miqdordan ortiq bo&#39;lmasligi mumkin {2}
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89,Purchase Order number required for Item {0},{0} band uchun xaridni tartib raqami talab qilinadi
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +896,Production Order not created,Ishlab chiqarish tartibi yaratilmadi
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +943,Production Order not created,Ishlab chiqarish tartibi yaratilmadi
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date',&quot;Sana&quot; kunidan keyin &quot;To Date&quot;
 DocType: Asset,Fully Depreciated,To&#39;liq Amortizatsiyalangan
 ,Stock Projected Qty,Qimmatli qog&#39;ozlar miqdori
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434,Customer {0} does not belong to project {1},Xaridor {0} loyihaga {1} tegishli emas
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +438,Customer {0} does not belong to project {1},Xaridor {0} loyihaga {1} tegishli emas
 DocType: Employee Attendance Tool,Marked Attendance HTML,Belgilangan tomoshabin HTML
 apps/erpnext/erpnext/utilities/activation.py +73,"Quotations are proposals, bids you have sent to your customers","Qabullar sizning mijozlaringizga yuborilgan takliflar, takliflar"
 DocType: Sales Order,Customer's Purchase Order,Xaridor buyurtma buyurtmasi
 DocType: Consultation,Patient,Kasal
-apps/erpnext/erpnext/config/stock.py +117,Serial No and Batch,Seriya raqami va to&#39;plami
+apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47,Bypass credit check at Sales Order ,Savdo buyurtmasidan kredit chekini chetlab o&#39;ting
+DocType: Land Unit,Check if it is a hydroponic unit,Hidroponik birlikmi tekshiring
+apps/erpnext/erpnext/config/stock.py +109,Serial No and Batch,Seriya raqami va to&#39;plami
 DocType: Warranty Claim,From Company,Kompaniyadan
-apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.py +40,Sum of Scores of Assessment Criteria needs to be {0}.,Ko&#39;rib chiqishlar kriterlarining yig&#39;indisi {0} bo&#39;lishi kerak.
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +77,Please set Number of Depreciations Booked,"Iltimos, ko&#39;rsatilgan Amortizatsiya miqdorini belgilang"
+apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +40,Sum of Scores of Assessment Criteria needs to be {0}.,Ko&#39;rib chiqishlar kriterlarining yig&#39;indisi {0} bo&#39;lishi kerak.
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +77,Please set Number of Depreciations Booked,"Iltimos, ko&#39;rsatilgan Amortizatsiya miqdorini belgilang"
 DocType: Supplier Scorecard Period,Calculations,Hisoblashlar
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +89,Value or Qty,Qiymati yoki kattaligi
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +425,Productions Orders cannot be raised for:,Mahsulotlar buyurtmalarini quyidagi sabablarga ko&#39;ra olish mumkin:
-apps/erpnext/erpnext/utilities/user_progress.py +126,Minute,Minut
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +201,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,"Iltimos, {0} uchun nomlash seriyasini Sozlamalar&gt; Sozlamalar&gt; Naming Series orqali sozlang"
+DocType: Payment Terms Template,Payment Terms,To&#39;lov shartlari
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +426,Productions Orders cannot be raised for:,Mahsulotlar buyurtmalarini quyidagi sabablarga ko&#39;ra olish mumkin:
+apps/erpnext/erpnext/utilities/user_progress.py +144,Minute,Minut
 DocType: Purchase Invoice,Purchase Taxes and Charges,Soliqlar va yig&#39;imlar xarid qilish
-apps/erpnext/erpnext/utilities/user_progress.py +100,Go to Suppliers,Ta&#39;minlovchilarga boring
+DocType: Chapter,Meetup Embed HTML,Meetup Embed HTML
+apps/erpnext/erpnext/utilities/user_progress.py +118,Go to Suppliers,Ta&#39;minlovchilarga boring
 ,Qty to Receive,Qabul qiladigan Miqdor
 DocType: Leave Block List,Leave Block List Allowed,Bloklash ro&#39;yxatini qoldiring
 DocType: Grading Scale Interval,Grading Scale Interval,Baholash o&#39;lchov oralig&#39;i
 DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Narh-navo bilan narx-navo bahosi bo&#39;yicha chegirma (%)
 apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,Barcha saqlash
 DocType: Sales Partner,Retailer,Chakana savdo
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +112,Credit To account must be a Balance Sheet account,Hisobga olish uchun Hisob balansi yozuvi bo&#39;lishi kerak
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115,Credit To account must be a Balance Sheet account,Hisobga olish uchun Hisob balansi yozuvi bo&#39;lishi kerak
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +122,All Supplier Types,Barcha yetkazib beruvchi turlari
+DocType: Donor,Donor,Donor
 DocType: Global Defaults,Disable In Words,So&#39;zlarda o&#39;chirib qo&#39;yish
-apps/erpnext/erpnext/stock/doctype/item/item.py +51,Item Code is mandatory because Item is not automatically numbered,"Mahsulot kodi majburiydir, chunki ob&#39;ekt avtomatik ravishda raqamlangan emas"
+apps/erpnext/erpnext/stock/doctype/item/item.py +49,Item Code is mandatory because Item is not automatically numbered,"Mahsulot kodi majburiydir, chunki ob&#39;ekt avtomatik ravishda raqamlangan emas"
 DocType: Maintenance Schedule Item,Maintenance Schedule Item,Xizmat jadvali
 DocType: Sales Order,%  Delivered,% Taslim bo&#39;ldi
-apps/erpnext/erpnext/schools/doctype/fees/fees.js +105,Please set the Email ID for the Student to send the Payment Request,"Iltimos, to&#39;lov talabnomasini yuborish uchun Talabaga Email ID-ni belgilang"
+apps/erpnext/erpnext/education/doctype/fees/fees.js +105,Please set the Email ID for the Student to send the Payment Request,"Iltimos, to&#39;lov talabnomasini yuborish uchun Talabaga Email ID-ni belgilang"
 DocType: Production Order,PRO-,PRO-
 DocType: Patient,Medical History,Tibbiyot tarixi
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157,Bank Overdraft Account,Bankning omonat hisoboti
 DocType: Patient,Patient ID,Kasal kimligi
 DocType: Physician Schedule,Schedule Name,Jadval nomi
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48,Make Salary Slip,Ish haqini kamaytirish
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +813,Add All Suppliers,Barcha etkazib beruvchilarni qo&#39;shish
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +81,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Row # {0}: Ajratilgan miqdori uncha katta bo&#39;lmagan miqdordan ortiq bo&#39;lishi mumkin emas.
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +838,Add All Suppliers,Barcha etkazib beruvchilarni qo&#39;shish
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +83,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Row # {0}: Ajratilgan miqdori uncha katta bo&#39;lmagan miqdordan ortiq bo&#39;lishi mumkin emas.
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75,Browse BOM,BOM-ga ko&#39;z tashlang
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155,Secured Loans,Kafolatlangan kreditlar
 DocType: Purchase Invoice,Edit Posting Date and Time,Kundalik sana va vaqtni tahrirlash
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +101,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Amalga oshirilgan hisob-kitoblarni {0} obyekti yoki Kompaniya {1}
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +101,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Amalga oshirilgan hisob-kitoblarni {0} obyekti yoki Kompaniya {1}
 DocType: Lab Test Groups,Normal Range,Oddiy intervalli
 DocType: Academic Term,Academic Year,O&#39;quv yili
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Available Selling,Sotuvga tayyor
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169,Opening Balance Equity,Balansni muomalaga kiritish
 DocType: Lead,CRM,CRM
 DocType: Purchase Invoice,N,N
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +24,Reconciliation,Muvofiqlik
-apps/erpnext/erpnext/schools/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,Qoldik
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,Qoldik
 DocType: Appraisal,Appraisal,Baholash
 DocType: Purchase Invoice,GST Details,GST tafsilotlari
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +154,Email sent to supplier {0},{0} yetkazib beruvchiga yuborilgan elektron xat
@@ -3295,22 +3522,23 @@
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19,Date is repeated,Sana takrorlanadi
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27,Authorized Signatory,Vakolatli vakil
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +215,Leave approver must be one of {0},Ilovani bekor qilish {0} dan biri bo&#39;lishi kerak
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.js +66,Create Fees,Narxlarni yarating
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +67,Create Fees,Narxlarni yarating
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Jami xarid qiymati (Xarid qilish byudjeti orqali)
 DocType: Training Event,Start Time,Boshlanish vaqti
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +377,Select Quantity,Miqdorni tanlang
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +399,Select Quantity,Miqdorni tanlang
 DocType: Customs Tariff Number,Customs Tariff Number,Bojxona tariflari raqami
 DocType: Patient Appointment,Patient Appointment,Bemorni tayinlash
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,Ishtirokni tasdiqlash qoida sifatida qo&#39;llanilishi mumkin bo&#39;lgan rolga o&#39;xshamaydi
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +64,Unsubscribe from this Email Digest,Ushbu e-pochta xujjatidan obunani bekor qilish
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +803,Get Suppliers By,Ta&#39;minlovchilarni qabul qiling
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +828,Get Suppliers By,Ta&#39;minlovchilarni qabul qiling
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +170,{0} not found for Item {1},{1} elementi uchun {0} topilmadi
-apps/erpnext/erpnext/utilities/user_progress.py +176,Go to Courses,Kurslarga o&#39;ting
+apps/erpnext/erpnext/utilities/user_progress.py +194,Go to Courses,Kurslarga o&#39;ting
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,Xabar yuborildi
-apps/erpnext/erpnext/accounts/doctype/account/account.py +101,Account with child nodes cannot be set as ledger,"Bola düğümleri bo&#39;lgan hisob, kitoblar sifatida ayarlanamaz"
+apps/erpnext/erpnext/accounts/doctype/account/account.py +100,Account with child nodes cannot be set as ledger,"Bola düğümleri bo&#39;lgan hisob, kitoblar sifatida ayarlanamaz"
 DocType: C-Form,II,II
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Narxlar ro&#39;yxati valyutasi mijozning asosiy valyutasiga aylantirildi
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Sof miqdori (Kompaniya valyutasi)
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +229,Total advance amount cannot be greater than total sanctioned amount,Umumiy avans miqdori jami ruxsat etilgan miqdordan ortiq bo&#39;lishi mumkin emas
 DocType: Salary Slip,Hour Rate,Soat darajasi
 DocType: Stock Settings,Item Naming By,Nomlanishi nomga ega
 apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46,Another Period Closing Entry {0} has been made after {1},Boshqa bir davrni yopish {0} {1}
@@ -3326,12 +3554,14 @@
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +155,Source and target warehouse must be different,Resurslar va maqsadli omborlar boshqacha bo&#39;lishi kerak
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101,Not allowed to update stock transactions older than {0},{0} dan katta aktsiyalarini yangilash uchun ruxsat berilmadi
 DocType: Purchase Invoice Item,PR Detail,PR batafsil
+DocType: Driving License Category,Class,Sinf
 DocType: Sales Order,Fully Billed,To&#39;liq to&#39;ldirilgan
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101,Shipping rule only applicable for Buying,Yuk tashish qoidani faqat xarid uchun qo&#39;llash mumkin
 DocType: Vital Signs,BMI,BMI
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,Qo&#39;ldagi pul
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +136,Delivery warehouse required for stock item {0},{0} aksessuarlari uchun yetkazib berish ombori
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137,Delivery warehouse required for stock item {0},{0} aksessuarlari uchun yetkazib berish ombori
 DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Paketning umumiy og&#39;irligi. Odatda aniq og&#39;irlik + qadoqlash materialining og&#39;irligi. (chop etish uchun)
-apps/erpnext/erpnext/schools/doctype/course/course.js +3,Program,Dastur
+apps/erpnext/erpnext/education/doctype/course/course.js +3,Program,Dastur
 DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Ushbu rolga ega foydalanuvchilar muzlatilgan hisoblarni o&#39;rnatish va muzlatilgan hisoblarga qarshi buxgalter yozuvlarini yaratish / o&#39;zgartirishga ruxsat beriladi
 DocType: Serial No,Is Cancelled,Bekor qilinadi
 DocType: Student Group,Group Based On,Guruh asoslangan
@@ -3339,15 +3569,15 @@
 DocType: Healthcare Settings,Laboratory SMS Alerts,Laboratoriya SMS-ogohlantirishlari
 apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20,"Service Item,Type,frequency and expense amount are required","Sizga xizmat ko&#39;rsatuvchi ob&#39;ekt, toifa, chastotalar va xarajatlar miqdori talab qilinadi"
 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:","Yuqori ustuvorlikka ega bo&#39;lgan bir nechta narx qoidalari mavjud bo&#39;lsa ham, ichki ustuvorliklar quyidagilarga amal qiladi:"
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +128,Do you really want to Submit all Salary Slip from {0} to {1},"Darhaqiqat, barcha ish haqini Slaydni {0} dan {1} gacha topshirmoqchimisiz?"
+DocType: Plant Analysis Criteria,Plant Analysis Criteria,O&#39;simliklarni tahlil qilish mezonlari
 DocType: Cheque Print Template,Cheque Height,Balandligini tekshiring
 DocType: Supplier,Supplier Details,Yetkazib beruvchi ma&#39;lumotlari
 DocType: Setup Progress,Setup Progress,O&#39;rnatish jarayoni
 DocType: Expense Claim,Approval Status,Tasdiqlash maqomi
 DocType: Hub Settings,Publish Items to Hub,Uyalarga nashr qilish
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +43,From value must be less than to value in row {0},Qiymatdan {0} qatorda qiymatdan kam bo&#39;lishi kerak
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +178,Wire Transfer,Telegraf ko&#39;chirmasi
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +132,Check all,Barchasini tekshiring
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35,From value must be less than to value in row {0},Qiymatdan {0} qatorda qiymatdan kam bo&#39;lishi kerak
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182,Wire Transfer,Telegraf ko&#39;chirmasi
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92,Check all,Barchasini tekshiring
 DocType: Vehicle Log,Invoice Ref,Faktura
 DocType: Company,Default Income Account,Standart daromad hisoblari
 apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32,Customer Group / Customer,Mijozlar guruhi / xaridorlar
@@ -3356,19 +3586,18 @@
 DocType: Lab Test Template,Change In Item,Ob&#39;ektni o&#39;zgartirish
 DocType: Payment Gateway Account,Default Payment Request Message,Standart to&#39;lov so&#39;rovnomasi
 DocType: Item Group,Check this if you want to show in website,"Veb-saytda ko&#39;rishni xohlasangiz, buni tekshirib ko&#39;ring"
-apps/erpnext/erpnext/config/accounts.py +142,Banking and Payments,Bank va to&#39;lovlar
+apps/erpnext/erpnext/config/accounts.py +134,Banking and Payments,Bank va to&#39;lovlar
 ,Welcome to ERPNext,ERPNext-ga xush kelibsiz
 apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,So&#39;zga chiqing
 DocType: Patient,A Negative,Salbiy
 apps/erpnext/erpnext/templates/includes/product_list.js +45,Nothing more to show.,Ko&#39;rsatish uchun boshqa hech narsa yo&#39;q.
 DocType: Lead,From Customer,Xaridordan
 apps/erpnext/erpnext/demo/setup/setup_data.py +327,Calls,Qo&#39;ng&#39;iroqlar
-apps/erpnext/erpnext/utilities/user_progress.py +122,A Product,Mahsulot
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +197,Batches,Kassalar
-DocType: Project,Total Costing Amount (via Time Logs),Jami xarajat summasi (vaqt jadvallari orqali)
-apps/erpnext/erpnext/schools/doctype/fee_structure/fee_structure.js +34,Make Fee Schedule,Ish haqi jadvalini tuzing
+apps/erpnext/erpnext/utilities/user_progress.py +140,A Product,Mahsulot
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +207,Batches,Kassalar
+apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34,Make Fee Schedule,Ish haqi jadvalini tuzing
 DocType: Purchase Order Item Supplied,Stock UOM,Qimmatli qog&#39;ozlar UOM
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +230,Purchase Order {0} is not submitted,Buyurtma {0} topshirilmadi
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233,Purchase Order {0} is not submitted,Buyurtma {0} topshirilmadi
 DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Kattalar uchun oddiy mos yozuvlar diapazoni 16-20 nafar / daqiqa (RCP 2012)
 DocType: Customs Tariff Number,Tariff Number,Tarif raqami
 DocType: Production Order Item,Available Qty at WIP Warehouse,WIP omborxonasida mavjud Miqdor
@@ -3378,69 +3607,76 @@
 DocType: Notification Control,Quotation Message,Iqtibos Xabar
 DocType: Employee Loan,Employee Loan Application,Xodimlarning qarz olish
 DocType: Issue,Opening Date,Ochilish tarixi
-apps/erpnext/erpnext/schools/api.py +80,Attendance has been marked successfully.,Ishtirok etish muvaffaqiyatli o&#39;tdi.
+apps/erpnext/erpnext/education/api.py +80,Attendance has been marked successfully.,Ishtirok etish muvaffaqiyatli o&#39;tdi.
 DocType: Program Enrollment,Public Transport,Jamoat transporti
+DocType: Soil Texture,Silt Composition (%),Shiling tarkibi (%)
 DocType: Journal Entry,Remark,Izoh
 DocType: Healthcare Settings,Avoid Confirmation,Tasdiqdan saqlaning
 DocType: Purchase Receipt Item,Rate and Amount,Bahosi va miqdori
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +165,Account Type for {0} must be {1},{0} uchun hisob turi {1} bo&#39;lishi kerak
 DocType: Healthcare Settings,Default income accounts to be used if not set in Physician to book Consultation charges.,Vaqtinchalik daromad hisoblari shifokorda Konsultatsiya to&#39;lovlari kitobida belgilanmagan bo&#39;lsa qo&#39;llaniladi.
 apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Barg va dam olish
-DocType: School Settings,Current Academic Term,Joriy Akademik atamalar
+DocType: Education Settings,Current Academic Term,Joriy Akademik atamalar
 DocType: Sales Order,Not Billed,To&#39;lov olinmaydi
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +77,Both Warehouse must belong to same Company,Har ikkisi ham bir xil kompaniyaga tegishli bo&#39;lishi kerak
 apps/erpnext/erpnext/public/js/templates/contact_list.html +34,No contacts added yet.,Hech qanday kontakt qo&#39;shilmagan.
 DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Belgilangan xarajatlarning dastlabki miqdori
 apps/erpnext/erpnext/config/accounts.py +17,Bills raised by Suppliers.,Yetkazuvchilar tomonidan ko&#39;tarilgan qonun loyihalari.
 DocType: POS Profile,Write Off Account,Hisobni yozing
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +78,Debit Note Amt,Debet-Not Amt
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +89,Debit Note Amt,Debet-Not Amt
 apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5,Discount Amount,Chegirma miqdori
 DocType: Purchase Invoice,Return Against Purchase Invoice,Xarajatlarni sotib olishdan voz kechish
 DocType: Item,Warranty Period (in days),Kafolat muddati (kunlar)
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Guardian1 bilan aloqalar
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61,Failed to set defaults,Varsayliklarni belgilash muvaffaqiyatsiz tugadi
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Guardian1 bilan aloqalar
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +797,Please select BOM against item {0},"Iltimos, {0} elementiga qarshi BOM ni tanlang"
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18,Make Invoices,Xarajatlarni tuzish
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +18,Net Cash from Operations,Operatsiyalar bo&#39;yicha aniq pul
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26,Item 4,4-band
 DocType: Student Admission,Admission End Date,Qabul tugash sanasi
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30,Sub-contracting,Sub-shartnoma
 DocType: Journal Entry Account,Journal Entry Account,Kundalik hisob yozuvi
-apps/erpnext/erpnext/schools/doctype/academic_year/academic_year.js +3,Student Group,Talabalar guruhi
+apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3,Student Group,Talabalar guruhi
 DocType: Shopping Cart Settings,Quotation Series,Quotation Series
 apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +56,"An item exists with same name ({0}), please change the item group name or rename the item","Biror narsa ({0}) bir xil nom bilan mavjud bo&#39;lsa, iltimos, element guruh nomini o&#39;zgartiring yoki ob&#39;ektni qayta nomlang"
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2005,Please select customer,"Iltimos, mijozni tanlang"
+DocType: Soil Analysis Criteria,Soil Analysis Criteria,Tuproq tahlil mezonlari
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2020,Please select customer,"Iltimos, mijozni tanlang"
 DocType: C-Form,I,Men
 DocType: Company,Asset Depreciation Cost Center,Aktivlar Amortizatsiya Narxlari Markazi
 DocType: Sales Order Item,Sales Order Date,Savdo Buyurtma sanasi
 DocType: Sales Invoice Item,Delivered Qty,Miqdori topshirilgan
 DocType: Production Planning Tool,"If checked, all the children of each production item will be included in the Material Requests.","Belgilangan bo&#39;lsa, har bir ishlab chiqarilgan mahsulotning barcha bolalari Materiallar Talablariga kiritiladi."
 DocType: Assessment Plan,Assessment Plan,Baholash rejasi
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +90,Customer {0} is created.,Xaridor {0} yaratildi.
+apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +93,Customer {0} is created.,Xaridor {0} yaratildi.
 DocType: Stock Settings,Limit Percent,Limit ulushi
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82, Currently no stock available in any warehouse,Hozirda biron-bir omborda stok yo&#39;q
 ,Payment Period Based On Invoice Date,Hisob-faktura sanasi asosida to&#39;lov davri
 DocType: Sample Collection,No. of print,Chop etish soni
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58,Missing Currency Exchange Rates for {0},{0} uchun yo&#39;qolgan valyuta kurslari
 DocType: Assessment Plan,Examiner,Ekspert
-DocType: Patient Relation,Siblings,Birodarlar
+DocType: Student,Siblings,Birodarlar
 DocType: Journal Entry,Stock Entry,Stock Entry
 DocType: Payment Entry,Payment References,To&#39;lov zikr qilish
 DocType: C-Form,C-FORM-,C-FORM-
 DocType: Vehicle,Insurance Details,Sug&#39;urta detallari
 DocType: Account,Payable,To&#39;lanishi kerak
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113,Please enter Repayment Periods,To&#39;lov muddatlarini kiriting
-apps/erpnext/erpnext/shopping_cart/cart.py +365,Debtors ({0}),Qarzdorlar ({0})
+apps/erpnext/erpnext/shopping_cart/cart.py +376,Debtors ({0}),Qarzdorlar ({0})
 DocType: Pricing Rule,Margin,Marjin
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Yangi mijozlar
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +75,Gross Profit %,Yalpi foyda %
 DocType: Appraisal Goal,Weightage (%),Og&#39;irligi (%)
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +489,Change POS Profile,POS profilini o&#39;zgartirish
 DocType: Bank Reconciliation Detail,Clearance Date,Bo&#39;shatish sanasi
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Baholash bo&#39;yicha hisobot
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +62,Gross Purchase Amount is mandatory,Umumiy xarid miqdori majburiydir
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Baholash bo&#39;yicha hisobot
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +62,Gross Purchase Amount is mandatory,Umumiy xarid miqdori majburiydir
 DocType: Lead,Address Desc,Manzil raq
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +101,Party is mandatory,Partiya majburiydir
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +102,Party is mandatory,Partiya majburiydir
 DocType: Journal Entry,JV-,JV-
+apps/erpnext/erpnext/controllers/accounts_controller.py +687,Rows with duplicate due dates in other rows were found: {list},Boshqa qatorlardagi takroriy sanalarni ko&#39;rsatadigan qatorlar topildi: {list}
 DocType: Topic,Topic Name,Mavzu nomi
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +36,Atleast one of the Selling or Buying must be selected,Eng ko&#39;p sotilgan yoki sotilgan mahsulotlardan biri tanlangan bo&#39;lishi kerak
-apps/erpnext/erpnext/public/js/setup_wizard.js +33,Select the nature of your business.,Biznesingizning xususiyatini tanlang.
+apps/erpnext/erpnext/public/js/setup_wizard.js +36,Select the nature of your business.,Biznesingizning xususiyatini tanlang.
 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
@@ -3450,19 +3686,21 @@
 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.","Natijalarga faqatgina bitta kirishni, UOM natijasini va oddiy qiymatni talab qiladigan yagona <br> Tegishli hodisalar nomlari bilan bir nechta kirish maydonlarini talab qiladigan natijalar uchun birikma, UOM va odatdagi qiymatlar natijalari <br> Bir nechta natija tarkibiy qismlari va tegishli natija kirish joylari bo'lgan testlar uchun tavsiflovchi. <br> Boshqa test shablonlari guruhi bo'lgan test andozalari uchun guruhlangan. <br> Natija bermagan testlar uchun natija yo'q. Bundan tashqari, hech qanday laboratoriya tekshiruvi yaratilmaydi. Misol uchun. Guruhlangan natijalar uchun kichik sinovlar."
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +73,Row #{0}: Duplicate entry in References {1} {2},{0} qatori: {1} {2} da zikr etilgan dublikat
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +75,Row #{0}: Duplicate entry in References {1} {2},{0} qatori: {1} {2} da zikr etilgan dublikat
 apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,Ishlab chiqarish operatsiyalari olib borilayotgan joylarda.
 DocType: Asset Movement,Source Warehouse,Resurs ombori
 DocType: Installation Note,Installation Date,O&#39;rnatish sanasi
-apps/erpnext/erpnext/controllers/accounts_controller.py +541,Row #{0}: Asset {1} does not belong to company {2},{0} qator: Asset {1} kompaniyaga tegishli emas {2}
+apps/erpnext/erpnext/controllers/accounts_controller.py +585,Row #{0}: Asset {1} does not belong to company {2},{0} qator: Asset {1} kompaniyaga tegishli emas {2}
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206,Sales Invoice {0} created,Savdo shaxsi {0} yaratildi
 DocType: Employee,Confirmation Date,Tasdiqlash sanasi
 DocType: C-Form,Total Invoiced Amount,Umumiy hisobdagi mablag &#39;
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +49,Min Qty can not be greater than Max Qty,Min Kty Maksimum kattaridan kattaroq bo&#39;la olmaydi
+DocType: Soil Texture,Silty Clay,Silty Clay
 DocType: Account,Accumulated Depreciation,Yig&#39;ilgan Amortizatsiya
 DocType: Supplier Scorecard Scoring Standing,Standing Name,Doimiy ism
 DocType: Stock Entry,Customer or Supplier Details,Xaridor yoki yetkazib beruvchi ma&#39;lumotlari
 DocType: Employee Loan Application,Required by Date,Sana bo&#39;yicha talab qilinadi
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +222,Closing Balance (Dr - Cr),Yakunlovchi balans (doktor - Cr)
 DocType: Lead,Lead Owner,Qurilish egasi
 DocType: Bin,Requested Quantity,Kerakli miqdor
 DocType: Patient,Marital Status,Oilaviy holat
@@ -3472,33 +3710,36 @@
 DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Brüt to&#39;lash - Jami cheklov - Kreditni qaytarish
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +26,Current BOM and New BOM can not be same,Joriy BOM va yangi BOM bir xil bo&#39;lishi mumkin emas
 apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +45,Salary Slip ID,Ish haqi miqdori
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +113,Date Of Retirement must be greater than Date of Joining,Pensiya tarixi sanasi qo&#39;shilish sanasidan katta bo&#39;lishi kerak
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +52,There were errors while scheduling course on :,Kursni rejalashtirish vaqtida xatolar bor edi:
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +118,Date Of Retirement must be greater than Date of Joining,Pensiya tarixi sanasi qo&#39;shilish sanasidan katta bo&#39;lishi kerak
+apps/erpnext/erpnext/stock/doctype/item/item.js +68,Multiple Variants,Bir nechta varianti
 DocType: Sales Invoice,Against Income Account,Daromad hisobiga qarshi
 apps/erpnext/erpnext/controllers/website_list_for_contact.py +117,{0}% Delivered,{0}% taslim etildi
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +95,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,{0} elementi: Buyurtma berilgan qty {1} minimal buyurtma miqdordan kam {2} dan kam bo&#39;lmasligi kerak.
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +96,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,{0} elementi: Buyurtma berilgan qty {1} minimal buyurtma miqdordan kam {2} dan kam bo&#39;lmasligi kerak.
 DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Oylik tarqatish foizi
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +90,Please login as another user.,Iltimos boshqa foydalanuvchi sifatida kiring.
 DocType: Territory,Territory Targets,Mintaqaviy maqsadlar
+DocType: Soil Analysis,Ca/Mg,Ca / Mg
 DocType: Delivery Note,Transporter Info,Transporter ma&#39;lumoti
-apps/erpnext/erpnext/accounts/utils.py +497,Please set default {0} in Company {1},{1} kompaniyasida standart {0} ni belgilang
+apps/erpnext/erpnext/accounts/utils.py +499,Please set default {0} in Company {1},{1} kompaniyasida standart {0} ni belgilang
 DocType: Cheque Print Template,Starting position from top edge,Yuqori burchakdan boshlash holati
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +31,Same supplier has been entered multiple times,Xuddi shunday yetkazib beruvchi bir necha marta kiritilgan
 apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Brüt Qor / Zarari
 DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Buyurtma buyurtmasi berilgan
-apps/erpnext/erpnext/public/js/setup_wizard.js +90,Company Name cannot be Company,Kompaniyaning nomi Kompaniya bo&#39;lishi mumkin emas
+apps/erpnext/erpnext/public/js/setup_wizard.js +94,Company Name cannot be Company,Kompaniyaning nomi Kompaniya bo&#39;lishi mumkin emas
 apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,Chop etish uchun andozalar.
 apps/erpnext/erpnext/config/setup.py +32,Titles for print templates e.g. Proforma Invoice.,"Bosma andozalar namunalari, masalan Proforma Billing."
 DocType: Program Enrollment,Walking,Yurish
 DocType: Student Guardian,Student Guardian,Talaba himoyachisi
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +201,Valuation type charges can not marked as Inclusive,Baholashning turi to&#39;lovlari inklyuziv sifatida belgilanishi mumkin emas
+DocType: Member,Member Name,Ro&#39;yxatdan nomi
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218,Valuation type charges can not marked as Inclusive,Baholashning turi to&#39;lovlari inklyuziv sifatida belgilanishi mumkin emas
 DocType: POS Profile,Update Stock,Stokni yangilang
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,in the subscription,obunada
 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.,Ma&#39;lumotlar uchun turli UOM noto&#39;g&#39;ri (Total) Net Og&#39;irligi qiymatiga olib keladi. Har bir elementning aniq vazniga bir xil UOM ichida ekanligiga ishonch hosil qiling.
+DocType: Membership,Payment Details,To&#39;lov ma&#39;lumoti
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,BOM darajasi
 DocType: Asset,Journal Entry for Scrap,Hurda uchun jurnalni kiritish
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83,Please pull items from Delivery Note,"Iltimos, mahsulotni etkazib berish Eslatma"
-apps/erpnext/erpnext/accounts/utils.py +467,Journal Entries {0} are un-linked,Journal yozuvlari {0} un-bog&#39;lanmagan
+apps/erpnext/erpnext/accounts/utils.py +469,Journal Entries {0} are un-linked,Journal yozuvlari {0} un-bog&#39;lanmagan
 apps/erpnext/erpnext/config/crm.py +92,"Record of all communications of type email, phone, chat, visit, etc.","E-pochta, telefon, suhbat, tashrif va hk."
 DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Yetkazib beruvchi Koreya kartochkalari reytingi
 DocType: Manufacturer,Manufacturers used in Items,Ishlab chiqaruvchilar mahsulotda ishlatiladi
@@ -3508,9 +3749,10 @@
 DocType: Buying Settings,Purchase Order Required,Sotib olish tartibi majburiy
 ,Item-wise Sales History,Sotish tarixi
 DocType: Expense Claim,Total Sanctioned Amount,Jami sanksiya miqdori
+DocType: Land Unit,Land Unit,Er uchastkasi
 ,Purchase Analytics,Analytics xarid qiling
 DocType: Sales Invoice Item,Delivery Note Item,Yetkazib berish eslatmasi elementi
-DocType: Expense Claim,Task,Vazifa
+DocType: Asset Maintenance Log,Task,Vazifa
 DocType: Purchase Taxes and Charges,Reference Row #,Yo&#39;naltirilgan satr #
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76,Batch number is mandatory for Item {0},Partiya raqami {0} element uchun majburiydir.
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13,This is a root sales person and cannot be edited.,Bu ildiz sotuvchisidir va tahrirlanmaydi.
@@ -3519,8 +3761,8 @@
 apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},Baholash: {0}
 DocType: Company,Exchange Gain / Loss Account,Birgalikdagi daromad / yo&#39;qotish hisobi
 apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Xodimlar va qatnashish
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +78,Purpose must be one of {0},Maqsad {0} dan biri bo&#39;lishi kerak
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +105,Fill the form and save it,Shaklni to&#39;ldiring va uni saqlang
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +83,Purpose must be one of {0},Maqsad {0} dan biri bo&#39;lishi kerak
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +116,Fill the form and save it,Shaklni to&#39;ldiring va uni saqlang
 DocType: Production Planning Tool,Download a report containing all raw materials with their latest inventory status,Barcha xom ashyolarni o&#39;z ichiga olgan hisobotni oxirgi inventarizatsiya holati bilan yuklab oling
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Jamoa forumi
 apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Actual qty in stock,Aksiyada haqiqiy miqdor
@@ -3533,7 +3775,7 @@
 DocType: Purchase Order,Get Items from Open Material Requests,Ochiq materiallar so&#39;rovlaridan ma&#39;lumotlar oling
 DocType: Lab Test Template,Standard Selling Rate,Standart sotish bahosi
 DocType: Account,Rate at which this tax is applied,Ushbu soliq qo&#39;llaniladigan stavka
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +65,Reorder Qty,Miqdorni qayta tartiblashtirish
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +75,Reorder Qty,Miqdorni qayta tartiblashtirish
 apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28,Current Job Openings,Joriy ish o&#39;rinlari
 DocType: Company,Stock Adjustment Account,Qimmatli qog&#39;ozlarni tartibga solish hisobi
 apps/erpnext/erpnext/public/js/payment/pos_payment.html +17,Write Off,Hisobdan o&#39;chirish
@@ -3544,36 +3786,41 @@
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +49,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Barcha materiallar materiallarida eng so&#39;nggi narxni yangilash uchun navbatda turdi. Bir necha daqiqa o&#39;tishi mumkin.
 apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,"Yangi hisob nomi. Eslatma: Iltimos, mijozlar va etkazib beruvchilar uchun hisoblar yarating"
 apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Country wise wise manzili Shablonlar
+DocType: Water Analysis,Appearance,Tashqi ko&#39;rinishi
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Buying Price List Rate,Ort Sotib olish narxlarining ro&#39;yxati
 DocType: Sales Order Item,Supplier delivers to Customer,Yetkazib beruvchi xaridorga yetkazib beradi
+apps/erpnext/erpnext/config/non_profit.py +23,Member information.,Ro&#39;yxatdan ma&#39;lumotlari.
 apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Shakl / element / {0}) aksiyalar mavjud emas
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +58,Asset Maintenance,Aktivlarga texnik xizmat ko&#39;rsatish
 ,Sales Payment Summary,Sotuvni to&#39;lash xulosasi
 DocType: Restaurant,Restaurant,Restoran
-apps/erpnext/erpnext/accounts/party.py +322,Due / Reference Date cannot be after {0},Vaqt / ariza sanasi {0}
+apps/erpnext/erpnext/accounts/party.py +323,Due / Reference Date cannot be after {0},Vaqt / ariza sanasi {0}
 apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Ma&#39;lumotlarni import qilish va eksport qilish
 DocType: Patient,Account Details,Hisob ma&#39;lumotlari
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +76,No students Found,Hech kim topilmadi
+DocType: Crop,Materials Required,Materiallar kerak
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76,No students Found,Hech kim topilmadi
 DocType: Medical Department,Medical Department,Tibbiy bo&#39;lim
 DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Yetkazib beruvchi Scorecard reyting mezonlari
 apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55,Invoice Posting Date,Faktura yuborish sanasi
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,Sotish
-DocType: Sales Invoice,Rounded Total,Rounded Total
+DocType: Purchase Invoice,Rounded Total,Rounded Total
 DocType: Product Bundle,List items that form the package.,Paketni tashkil etadigan elementlarni ro&#39;yxatlang.
 apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Foizlarni taqsimlash 100%
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +567,Please select Posting Date before selecting Party,Tomonni tanlashdan oldin sanasi sanasini tanlang
+DocType: Crop Cycle,Linked Land Unit,Bog&#39;langan er uchastkasi
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584,Please select Posting Date before selecting Party,Tomonni tanlashdan oldin sanasi sanasini tanlang
 DocType: Program Enrollment,School House,Maktab uyi
 DocType: Serial No,Out of AMC,AMCdan tashqarida
-apps/erpnext/erpnext/public/js/utils.js +263,Please select Quotations,Iltimos takliflarni tanlang
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +82,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Qayd qilingan amortizatsiya miqdori jami Amortizatsiya miqdoridan ko&#39;p bo&#39;lishi mumkin emas
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +82,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Qayd qilingan amortizatsiya miqdori jami Amortizatsiya miqdoridan ko&#39;p bo&#39;lishi mumkin emas
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Xizmatga tashrif buyurish
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +170,Please contact to the user who have Sales Master Manager {0} role,Sotish bo&#39;yicha Magistr Direktori {0} roli mavjud foydalanuvchi bilan bog&#39;laning
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +198,Please contact to the user who have Sales Master Manager {0} role,Sotish bo&#39;yicha Magistr Direktori {0} roli mavjud foydalanuvchi bilan bog&#39;laning
 DocType: Company,Default Cash Account,Naqd pul hisobvarag&#39;i
 apps/erpnext/erpnext/config/accounts.py +62,Company (not Customer or Supplier) master.,Kompaniya (mijoz yoki yetkazib beruvchi emas) ustasi.
-apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,Bu talaba ushbu talabaga asoslanadi
-apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +178,No Students in,Kirish yo&#39;q
+apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,Bu talaba ushbu talabaga asoslanadi
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +178,No Students in,Kirish yo&#39;q
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +171,Add more items or open full form,Boshqa narsalarni qo&#39;shish yoki to&#39;liq shaklni oching
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +206,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Ushbu Sotuvdagi Buyurtmani bekor qilishdan oldin etkazib berish xatnomalarini {0} bekor qilish kerak
-apps/erpnext/erpnext/utilities/user_progress.py +238,Go to Users,Foydalanuvchilarga o&#39;ting
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +82,Paid amount + Write Off Amount can not be greater than Grand Total,To&#39;langan pul miqdori + Write Off To&#39;lov miqdori Grand Totaldan katta bo&#39;lishi mumkin emas
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Ushbu Sotuvdagi Buyurtmani bekor qilishdan oldin etkazib berish xatnomalarini {0} bekor qilish kerak
+apps/erpnext/erpnext/utilities/user_progress.py +256,Go to Users,Foydalanuvchilarga o&#39;ting
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85,Paid amount + Write Off Amount can not be greater than Grand Total,To&#39;langan pul miqdori + Write Off To&#39;lov miqdori Grand Totaldan katta bo&#39;lishi mumkin emas
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78,{0} is not a valid Batch Number for Item {1},{0} {1} element uchun haqiqiy partiya raqami emas
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +149,Note: There is not enough leave balance for Leave Type {0},Izoh: Tovar {0} uchun qoldirilgan muvozanat etarli emas.
 apps/erpnext/erpnext/regional/india/utils.py +15,Invalid GSTIN or Enter NA for Unregistered,GSTIN noto&#39;g&#39;ri yoki ro&#39;yxatdan o&#39;tish uchun NA kiriting
@@ -3591,31 +3838,35 @@
 DocType: Hub Settings,Publish Availability,Mavjudligi e&#39;lon qiling
 DocType: Company,Create Chart Of Accounts Based On,Hisoblar jadvalini tuzish
 apps/erpnext/erpnext/projects/doctype/task/task.js +91,Cannot convert it to non-group. Child Tasks exist.,Guruhni guruhga o&#39;tkazib bo&#39;lmadi. Bola vazifalari mavjud.
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +107,Date of Birth cannot be greater than today.,Tug&#39;ilgan sanasi bugungi kunda katta bo&#39;lmasligi mumkin.
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +112,Date of Birth cannot be greater than today.,Tug&#39;ilgan sanasi bugungi kunda katta bo&#39;lmasligi mumkin.
 ,Stock Ageing,Qarshi qarish
-apps/erpnext/erpnext/schools/doctype/student/student.py +38,Student {0} exist against student applicant {1},Isoning shogirdi {0} talaba arizachiga nisbatan {1}
+apps/erpnext/erpnext/education/doctype/student/student.py +38,Student {0} exist against student applicant {1},Isoning shogirdi {0} talaba arizachiga nisbatan {1}
 DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Dumaloq tuzatish (Kompaniya valyutasi)
 apps/erpnext/erpnext/projects/doctype/task/task.js +39,Timesheet,Vaqt jadvallari
-apps/erpnext/erpnext/controllers/accounts_controller.py +233,{0} '{1}' is disabled,{0} &#39;{1}&#39; o&#39;chirib qo&#39;yilgan
+DocType: Volunteer,Afternoon,Kunduzi
+apps/erpnext/erpnext/controllers/accounts_controller.py +256,{0} '{1}' is disabled,{0} &#39;{1}&#39; o&#39;chirib qo&#39;yilgan
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Ochiq qilib belgilang
 DocType: Cheque Print Template,Scanned Cheque,Skaner qilingan tekshiruv
 DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Jurnallarni yuborish haqida Kontaktlar ga avtomatik elektron pochta xabarlarini yuboring.
 DocType: Timesheet,Total Billable Amount,Jami hisoblash summasi
+DocType: Customer,Credit Limit and Payment Terms,Kredit cheklovi va to&#39;lov shartlari
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,3-modda
 apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6,Order Entry,Buyurtma yozuvi
 DocType: Purchase Order,Customer Contact Email,Mijozlar bilan aloqa elektron pochta
 DocType: Warranty Claim,Item and Warranty Details,Mahsulot va Kafolat haqida ma&#39;lumot
+DocType: Chapter,Chapter Members,Bo&#39;lim a&#39;zolari
 DocType: Sales Team,Contribution (%),Miqdori (%)
-apps/erpnext/erpnext/controllers/accounts_controller.py +75,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Eslatma: &quot;Naqd yoki Bank hisobi&quot; ko&#39;rsatilmagani uchun to&#39;lov kiritish yaratilmaydi
-apps/erpnext/erpnext/projects/doctype/project/project.py +65,Project {0} already exists,{0} loyihasi allaqachon mavjud
+apps/erpnext/erpnext/controllers/accounts_controller.py +100,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Eslatma: &quot;Naqd yoki Bank hisobi&quot; ko&#39;rsatilmagani uchun to&#39;lov kiritish yaratilmaydi
+apps/erpnext/erpnext/projects/doctype/project/project.py +67,Project {0} already exists,{0} loyihasi allaqachon mavjud
 DocType: Medical Department,Nursing User,Hemşirelik Foydalanuvchi bilan
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +227,Responsibilities,Mas&#39;uliyat
+DocType: Plant Analysis,Plant Analysis Criterias,O&#39;simliklarni tahlil qilish mezonlari
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +237,Responsibilities,Mas&#39;uliyat
 apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125,Validity period of this quotation has ended.,Ushbu tirnoqning amal qilish muddati tugadi.
 DocType: Expense Claim Account,Expense Claim Account,Xarajat shikoyati qaydnomasi
 DocType: Accounts Settings,Allow Stale Exchange Rates,Sovuq valyuta kurslariga ruxsat berish
 DocType: Sales Person,Sales Person Name,Sotuvchining ismi
 apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,"Iltimos, stolda atleast 1-fakturani kiriting"
-apps/erpnext/erpnext/utilities/user_progress.py +226,Add Users,Foydalanuvchilarni qo&#39;shish
+apps/erpnext/erpnext/utilities/user_progress.py +244,Add Users,Foydalanuvchilarni qo&#39;shish
 DocType: POS Item Group,Item Group,Mavzu guruhi
 DocType: Item,Safety Stock,Xavfsizlik kabinetga
 DocType: Healthcare Settings,Healthcare Settings,Sog&#39;liqni saqlash sozlamalari
@@ -3623,74 +3874,78 @@
 DocType: Stock Reconciliation Item,Before reconciliation,Yig&#39;ilishdan oldin
 apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12,To {0},{0} uchun
 DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Soliqlar va yig&#39;imlar qo&#39;shildi (Kompaniya valyutasi)
-apps/erpnext/erpnext/stock/doctype/item/item.py +445,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Mahsulot Soliq Royi {0} turidagi Soliq yoki daromad yoki xarajatlar yoki Ulanish uchun hisobga ega bo&#39;lishi kerak
+apps/erpnext/erpnext/stock/doctype/item/item.py +461,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Mahsulot Soliq Royi {0} turidagi Soliq yoki daromad yoki xarajatlar yoki Ulanish uchun hisobga ega bo&#39;lishi kerak
 DocType: Sales Order,Partly Billed,Qisman taqsimlangan
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,{0} elementi Ruxsat etilgan aktiv obyekti bo&#39;lishi kerak
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,{0} elementi Ruxsat etilgan aktiv obyekti bo&#39;lishi kerak
+apps/erpnext/erpnext/stock/doctype/item/item.js +341,Make Variants,Variantlarni tanlang
 DocType: Item,Default BOM,Standart BOM
+DocType: Project,Total Billed Amount (via Sales Invoices),Jami to&#39;lov miqdori (Savdo shkaflari orqali)
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Debit Note Amount,Debet qaydnomasi miqdori
 apps/erpnext/erpnext/setup/doctype/company/company.js +60,Please re-type company name to confirm,"Iltimos, tasdiqlash uchun kompaniya nomini qayta kiriting"
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +79,Total Outstanding Amt,Umumiy qarzdor
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +90,Total Outstanding Amt,Umumiy qarzdor
 DocType: Journal Entry,Printing Settings,Chop etish sozlamalari
+DocType: Employee Advance,Advance Account,Advance hisob
 DocType: Sales Invoice,Include Payment (POS),To&#39;lovni qo&#39;shish (POS)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292,Total Debit must be equal to Total Credit. The difference is {0},Jami debet umumiy kredit bilan teng bo&#39;lishi kerak. Farqi {0}
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +11,Automotive,Avto
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +290,Total Debit must be equal to Total Credit. The difference is {0},Jami debet umumiy kredit bilan teng bo&#39;lishi kerak. Farqi {0}
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11,Automotive,Avto
 DocType: Vehicle,Insurance Company,Sug&#39;urta kompaniyasi
 DocType: Asset Category Account,Fixed Asset Account,Ruxsat etilgan aktivlar hisobi
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397,Variable,Argumentlar
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +414,Variable,Argumentlar
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,From Delivery Note,Etkazib berish eslatmasidan
+DocType: Chapter,Members,A&#39;zolar
 DocType: Student,Student Email Address,Isoning shogirdi elektron pochta manzili
 DocType: Item,Hub Warehouse,Hub ombori
-DocType: Physician Schedule Time Slot,From Time,Vaqtdan
+DocType: Assessment Plan,From Time,Vaqtdan
 apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock: ,Omborda mavjud; sotuvda mavjud:
 DocType: Notification Control,Custom Message,Maxsus xabar
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +33,Investment Banking,Investitsiya banklari
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +78,Cash or Bank Account is mandatory for making payment entry,To&#39;lovni kiritish uchun naqd pul yoki bank hisobi majburiydir
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Isoning shogirdi manzili
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33,Investment Banking,Investitsiya banklari
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79,Cash or Bank Account is mandatory for making payment entry,To&#39;lovni kiritish uchun naqd pul yoki bank hisobi majburiydir
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Isoning shogirdi manzili
 DocType: Purchase Invoice,Price List Exchange Rate,Narxlar ro&#39;yxati almashuv kursi
+apps/erpnext/erpnext/accounts/doctype/account/account.py +253,Account Number {0} already used in account {1},Hisob raqami {0} allaqachon {1} hisobida ishlatilgan
 DocType: POS Profile,POS Profile Name,Qalin profil nomi
 DocType: Purchase Invoice Item,Rate,Baholash
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +100,Intern,Stajyer
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1569,Address Name,Manzil nomi
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104,Intern,Stajyer
+DocType: Delivery Stop,Address Name,Manzil nomi
 DocType: Stock Entry,From BOM,BOM&#39;dan
 DocType: Assessment Code,Assessment Code,Baholash kodi
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +69,Basic,Asosiy
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73,Basic,Asosiy
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,{0} dan oldin birja bitimlari muzlatilgan
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219,Please click on 'Generate Schedule',&quot;Jadvalni yarat&quot; tugmasini bosing
-apps/erpnext/erpnext/config/stock.py +195,"e.g. Kg, Unit, Nos, m","Masalan, Kg, birlik, Nos, m"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122,Reference No is mandatory if you entered Reference Date,"Malumot sanasi kiritilgan bo&#39;lsa, Yo&#39;naltiruvchi raqami majburiy emas"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +120,Reference No is mandatory if you entered Reference Date,"Malumot sanasi kiritilgan bo&#39;lsa, Yo&#39;naltiruvchi raqami majburiy emas"
 DocType: Bank Reconciliation Detail,Payment Document,To&#39;lov hujjati
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37,Error evaluating the criteria formula,Me&#39;riy formulani baholashda xato
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +110,Date of Joining must be greater than Date of Birth,Kiritilgan sana Tug&#39;ilgan kundan katta bo&#39;lishi kerak
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +115,Date of Joining must be greater than Date of Birth,Kiritilgan sana Tug&#39;ilgan kundan katta bo&#39;lishi kerak
 DocType: Salary Slip,Salary Structure,Ish haqi tuzilishi
 DocType: Account,Bank,Bank
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +9,Airline,Aviakompaniya
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +827,Issue Material,Muammo materiallari
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9,Airline,Aviakompaniya
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +852,Issue Material,Muammo materiallari
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,An error occured while creating recurring,Ikki nusxadagi yaratish paytida xatolik yuz berdi
 DocType: Material Request Item,For Warehouse,QXI uchun
 DocType: Employee,Offer Date,Taklif sanasi
 apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Quotations,Qo&#39;shtirnoq
-apps/erpnext/erpnext/accounts/page/pos/pos.js +711,You are in offline mode. You will not be able to reload until you have network.,Siz oflayn rejasiz. Tarmoqqa ega bo&#39;lguncha qayta yuklay olmaysiz.
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,Hech qanday talabalar guruhi yaratilmagan.
+apps/erpnext/erpnext/accounts/page/pos/pos.js +726,You are in offline mode. You will not be able to reload until you have network.,Siz oflayn rejasiz. Tarmoqqa ega bo&#39;lguncha qayta yuklay olmaysiz.
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,Hech qanday talabalar guruhi yaratilmagan.
 DocType: Purchase Invoice Item,Serial No,Serial №
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119,Monthly Repayment Amount cannot be greater than Loan Amount,Oylik qaytarib beriladigan pul miqdori Kredit miqdoridan kattaroq bo&#39;lishi mumkin emas
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143,Please enter Maintaince Details first,"Iltimos, birinchi navbatda Tafsilotlarni kiriting"
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +55,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Row # {0}: Kutilayotgan etkazib berish sanasi Buyurtma tarixidan oldin bo&#39;lishi mumkin emas
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Row # {0}: Kutilayotgan etkazib berish sanasi Buyurtma tarixidan oldin bo&#39;lishi mumkin emas
 DocType: Purchase Invoice,Print Language,Chop etish tili
 DocType: Salary Slip,Total Working Hours,Umumiy ish vaqti
 DocType: Subscription,Next Schedule Date,Keyingi Jadval tarixi
 DocType: Stock Entry,Including items for sub assemblies,Sub assemblies uchun elementlarni o&#39;z ichiga oladi
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1928,Enter value must be positive,Qiymatni kiritish ijobiy bo&#39;lishi kerak
+DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Vaqtinchalik ochilish hisobi
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1943,Enter value must be positive,Qiymatni kiritish ijobiy bo&#39;lishi kerak
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +392,All Territories,Barcha hududlar
 DocType: Purchase Invoice,Items,Mahsulotlar
-apps/erpnext/erpnext/schools/doctype/program_enrollment/program_enrollment.py +26,Student is already enrolled.,Talabalar allaqachon ro&#39;yxatdan o&#39;tgan.
+apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +28,Student is already enrolled.,Talabalar allaqachon ro&#39;yxatdan o&#39;tgan.
 DocType: Fiscal Year,Year Name,Yil nomi
-DocType: Process Payroll,Process Payroll,Jarayonni to&#39;lash
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +240,There are more holidays than working days this month.,Bu oyda ish kunlaridan ko&#39;ra ko&#39;proq bayramlar bor.
 DocType: Product Bundle Item,Product Bundle Item,Mahsulot paketi elementi
 DocType: Sales Partner,Sales Partner Name,Savdo hamkorining nomi
-apps/erpnext/erpnext/hooks.py +132,Request for Quotations,Takliflar uchun so&#39;rov
+apps/erpnext/erpnext/hooks.py +136,Request for Quotations,Takliflar uchun so&#39;rov
 DocType: Payment Reconciliation,Maximum Invoice Amount,Maksimal Billing miqdori
-apps/erpnext/erpnext/healthcare/setup.py +209,Haematology,Gematologiya
+apps/erpnext/erpnext/healthcare/setup.py +210,Haematology,Gematologiya
 DocType: Normal Test Items,Normal Test Items,Oddiy test buyumlari
 DocType: Student Language,Student Language,Isoning shogirdi tili
 apps/erpnext/erpnext/config/selling.py +23,Customers,Iste&#39;molchilar
@@ -3700,11 +3955,12 @@
 DocType: Asset,Partially Depreciated,Qisman Amortizatsiyalangan
 DocType: Issue,Opening Time,Vaqtni ochish
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +92,From and To dates required,Kerakli kunlardan boshlab
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +46,Securities & Commodity Exchanges,Qimmatli qog&#39;ozlar va BUyuMLAR birjalari
-apps/erpnext/erpnext/stock/doctype/item/item.py +675,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',&#39;{0}&#39; variantining standart o&#39;lchov birligi &#39;{1}&#39; shablonidagi kabi bo&#39;lishi kerak
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46,Securities & Commodity Exchanges,Qimmatli qog&#39;ozlar va BUyuMLAR birjalari
+apps/erpnext/erpnext/stock/doctype/item/item.py +661,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',&#39;{0}&#39; variantining standart o&#39;lchov birligi &#39;{1}&#39; shablonidagi kabi bo&#39;lishi kerak
 DocType: Shipping Rule,Calculate Based On,Oddiy qiymatni hisoblash
 DocType: Delivery Note Item,From Warehouse,QXIdan
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +897,No Items with Bill of Materials to Manufacture,Ishlab chiqarish uchun materiallar varaqasi yo&#39;q
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59,No employees for the mentioned criteria,Ko&#39;rsatilgan mezonlarga xodimlar yo&#39;q
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +944,No Items with Bill of Materials to Manufacture,Ishlab chiqarish uchun materiallar varaqasi yo&#39;q
 DocType: Restaurant,Default Customer,Standart mijoz
 DocType: Assessment Plan,Supervisor Name,Boshqaruvchi nomi
 DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,Xuddi shu kuni Uchrashuvni tashkil etganligini tasdiqlamang
@@ -3714,40 +3970,41 @@
 DocType: Tax Rule,Shipping City,Yuk tashish shahri
 DocType: Notification Control,Customize the Notification,Xabarnomani moslashtiring
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +19,Cash Flow from Operations,Operatsiyalardan pul oqimi
-DocType: Sales Invoice,Shipping Rule,Yuk tashish qoidalari
+DocType: Purchase Invoice,Shipping Rule,Yuk tashish qoidalari
 DocType: Patient Relation,Spouse,Turmush o&#39;rtog&#39;im
 DocType: Lab Test Groups,Add Test,Testni qo&#39;shish
 DocType: Manufacturer,Limited to 12 characters,12 ta belgi bilan cheklangan
 DocType: Journal Entry,Print Heading,Bosib sarlavhasi
+apps/erpnext/erpnext/config/stock.py +146,Delivery Trip service tours to customers.,Xaridorlarga ekskursiya safarlari.
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57,Total cannot be zero,Jami nol bo&#39;lmasligi mumkin
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16,'Days Since Last Order' must be greater than or equal to zero,&quot;Oxirgi buyurtma beri o&#39;tgan kunlar&quot; noldan kattaroq yoki teng bo&#39;lishi kerak
-DocType: Process Payroll,Payroll Frequency,Bordro chastotasi
+DocType: Plant Analysis Criteria,Maximum Permissible Value,Ruxsat etilgan maksimal qiymat
+DocType: Journal Entry Account,Employee Advance,Ishchi Advance
+DocType: Payroll Entry,Payroll Frequency,Bordro chastotasi
 DocType: Lab Test Template,Sensitivity,Ta&#39;sirchanlik
-DocType: Asset,Amended From,O&#39;zgartirishlar
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +58,Raw Material,Xom ashyo
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +62,Raw Material,Xom ashyo
 DocType: Leave Application,Follow via Email,Elektron pochta orqali qiling
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55,Plants and Machineries,O&#39;simliklar va mashinalari
 DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Chegirma summasi bo&#39;yicha soliq summasi
 DocType: Daily Work Summary Settings,Daily Work Summary Settings,Kundalik ish sarlavhalari sozlamalari
 DocType: Payment Entry,Internal Transfer,Ichki pul o&#39;tkazish
-apps/erpnext/erpnext/accounts/doctype/account/account.py +179,Child account exists for this account. You can not delete this account.,Ushbu hisob uchun bolaning hisob raqami mavjud. Ushbu hisobni o&#39;chirib bo&#39;lmaydi.
+DocType: Asset Maintenance,Maintenance Tasks,Xizmat vazifalari
 apps/erpnext/erpnext/setup/doctype/territory/territory.py +19,Either target qty or target amount is mandatory,Nishon miqdor yoki maqsad miqdori majburiydir
-apps/erpnext/erpnext/stock/get_item_details.py +536,No default BOM exists for Item {0},{0} element uchun odatiy BOM mavjud emas
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +359,Please select Posting Date first,"Marhamat, birinchi marta o&#39;tilganlik sanasi tanlang"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +367,Please select Posting Date first,"Marhamat, birinchi marta o&#39;tilganlik sanasi tanlang"
 apps/erpnext/erpnext/public/js/account_tree_grid.js +210,Opening Date should be before Closing Date,Ochilish sanasi tugash sanasidan oldin bo&#39;lishi kerak
 DocType: Leave Control Panel,Carry Forward,Oldinga boring
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cost Center with existing transactions can not be converted to ledger,Amalga oshirilgan operatsiyalarni bajarish uchun xarajatlar markaziy hisob kitobiga o&#39;tkazilmaydi
 DocType: Department,Days for which Holidays are blocked for this department.,Bayramlar ushbu bo&#39;lim uchun bloklangan kunlar.
+DocType: Crop Cycle,Detected Disease,Yuqumli kasalliklar
 ,Produced,Ishlab chiqarilgan
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +118,Created Salary Slips,Ish haqi sliplari yaratildi
 DocType: Item,Item Code for Suppliers,Ta&#39;minlovchilar uchun mahsulot kodi
 DocType: Issue,Raised By (Email),Qabul qilingan (Email)
 DocType: Training Event,Trainer Name,Trainer nomi
 DocType: Mode of Payment,General,Umumiy
 apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,Oxirgi muloqot
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +355,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',&quot;Baholash&quot; yoki &quot;Baholash va jami&quot;
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +372,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',&quot;Baholash&quot; yoki &quot;Baholash va jami&quot;
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +234,Serial Nos Required for Serialized Item {0},Serileştirilmiş Mahsulot uchun Serial Nos kerak {0}
-apps/erpnext/erpnext/config/accounts.py +152,Match Payments with Invoices,Xarajatlarni hisob-kitob qilish
+apps/erpnext/erpnext/config/accounts.py +144,Match Payments with Invoices,Xarajatlarni hisob-kitob qilish
 DocType: Journal Entry,Bank Entry,Bank kartasi
 DocType: Authorization Rule,Applicable To (Designation),Qo&#39;llanishi mumkin (belgilash)
 ,Profitability Analysis,Sotish tahlili
@@ -3757,17 +4014,19 @@
 apps/erpnext/erpnext/templates/generators/item.html +62,Add to Cart,savatchaga qo&#39;shish
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,Guruh tomonidan
 DocType: Guardian,Interests,Qiziqishlar
-apps/erpnext/erpnext/config/accounts.py +306,Enable / disable currencies.,Pullarni yoqish / o&#39;chirish.
+apps/erpnext/erpnext/config/accounts.py +298,Enable / disable currencies.,Pullarni yoqish / o&#39;chirish.
 DocType: Production Planning Tool,Get Material Request,Moddiy talablarni oling
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Postal Expenses,Pochta xarajatlari
 apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Jami (Amt)
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +26,Entertainment & Leisure,O&#39;yin-kulgi va hordiq
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26,Entertainment & Leisure,O&#39;yin-kulgi va hordiq
+,Item Variant Details,Mavzu variantlari tafsilotlari
 DocType: Quality Inspection,Item Serial No,Mahsulot Seriya raqami
 apps/erpnext/erpnext/utilities/activation.py +135,Create Employee Records,Xodimlarning yozuvlarini yaratish
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Present,Jami mavjud
-apps/erpnext/erpnext/config/accounts.py +113,Accounting Statements,Buxgalteriya hisobi
+apps/erpnext/erpnext/config/accounts.py +105,Accounting Statements,Buxgalteriya hisobi
 DocType: Drug Prescription,Hour,Soat
 DocType: Restaurant Order Entry,Last Sales Invoice,Oxirgi Sotuvdagi Billing
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +799,Please select Qty against item {0},"Iltimos, {0} elementiga qarshi Qty ni tanlang"
 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,"Yangi seriyali yo&#39;q, QXK bo&#39;lishi mumkin emas. QXI kabinetga kirish yoki Xarid qilish Qabulnomasi bilan o&#39;rnatilishi kerak"
 DocType: Lead,Lead Type,Qo&#39;rg&#39;oshin turi
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133,You are not authorized to approve leaves on Block Dates,Siz bloklangan sana bo&#39;yicha barglarni tasdiqlash uchun vakolatga ega emassiz
@@ -3779,6 +4038,7 @@
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13,Unknown,Noma&#39;lum
 DocType: Shipping Rule,Shipping Rule Conditions,Yuk tashish qoida shartlari
 DocType: Purchase Invoice,Export Type,Eksport turi
+DocType: Salary Slip Loan,Salary Slip Loan,Ish haqi pul mablag&#39;lari
 DocType: BOM Update Tool,The new BOM after replacement,O&#39;zgartirish o&#39;rniga yangi BOM
 ,Point of Sale,Sotuv nuqtasi
 DocType: Payment Entry,Received Amount,Qabul qilingan summalar
@@ -3786,44 +4046,49 @@
 DocType: GST Settings,GSTIN Email Sent On,GSTIN elektron pochta manzili yuborildi
 DocType: Program Enrollment,Pick/Drop by Guardian,Guardian tomonidan olib tashlang / qoldiring
 DocType: Production Planning Tool,"Create for full quantity, ignoring quantity already on order","To&#39;liq miqdor uchun yarating, buyurtma miqdorini e&#39;tiborsiz qoldiring"
+DocType: Crop,Planting UOM,UOM ni ekish
 DocType: Account,Tax,Soliq
-apps/erpnext/erpnext/schools/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,Belgilangan emas
+apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,Belgilangan emas
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1,Opening Invoices Summary,Xarajatlarni qisqacha tavsifi
+DocType: Education Settings,Education Manager,Ta&#39;lim menejeri
 DocType: Production Planning Tool,Production Planning Tool,Ishlab chiqarishni rejalashtirish vositasi
+DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Tegishli o&#39;sish uchun har bir o&#39;simlikning minimal uzunligi
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +150,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","Kiyinilgan {0} mahsulotini kabinetga kelishuvidan foydalanib yangilash mumkin emas, buning o&#39;rniga kabinetga kirishini ishlatish"
 DocType: Quality Inspection,Report Date,Hisobot sanasi
 DocType: Student,Middle Name,Otasini ismi
 DocType: C-Form,Invoices,Xarajatlar
+DocType: Water Analysis,Type of Sample,Namunaning turi
 DocType: Batch,Source Document Name,Manba hujjat nomi
 DocType: Job Opening,Job Title,Lavozim
 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} {1} tirnoq taqdim etmasligini bildiradi, lekin barcha elementlar \ kote qilingan. RFQ Buyurtma holatini yangilash."
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +971,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Eng ko&#39;p namuna - {0} ommaviy {1} va {2} elementlari uchun ommaviy {3} da allaqachon saqlangan.
 DocType: Manufacturing Settings,Update BOM Cost Automatically,BOM narxini avtomatik ravishda yangilang
 DocType: Lab Test,Test Name,Sinov nomi
 apps/erpnext/erpnext/utilities/activation.py +99,Create Users,Foydalanuvchilarni yaratish
-apps/erpnext/erpnext/utilities/user_progress.py +126,Gram,Gram
+apps/erpnext/erpnext/utilities/user_progress.py +144,Gram,Gram
 DocType: Supplier Scorecard,Per Month,Oyiga
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +394,Quantity to Manufacture must be greater than 0.,Ishlab chiqarish miqdori 0dan katta bo&#39;lishi kerak.
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +414,Quantity to Manufacture must be greater than 0.,Ishlab chiqarish miqdori 0dan katta bo&#39;lishi kerak.
 apps/erpnext/erpnext/config/maintenance.py +17,Visit report for maintenance call.,Xizmatga qo&#39;ng&#39;iroq qilish uchun hisobotga tashrif buyuring.
 DocType: Stock Entry,Update Rate and Availability,Yangilash darajasi va mavjudligi
 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.,"Buyurtma berilgan miqdorga nisbatan ko&#39;proq miqdorda qabul qilishingiz yoki topshirishingiz mumkin bo&#39;lgan foiz. Misol uchun: Agar siz 100 ta buyurtma bergan bo&#39;lsangiz. va sizning Rag&#39;batingiz 10% bo&#39;lsa, sizda 110 ta bo&#39;linmaga ega bo&#39;lishingiz mumkin."
 DocType: POS Customer Group,Customer Group,Mijozlar guruhi
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +113,New Batch ID (Optional),Yangi partiya identifikatori (majburiy emas)
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +198,Expense account is mandatory for item {0},Xarajat hisobi {0} elementi uchun majburiydir.
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +120,New Batch ID (Optional),Yangi partiya identifikatori (majburiy emas)
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201,Expense account is mandatory for item {0},Xarajat hisobi {0} elementi uchun majburiydir.
 DocType: BOM,Website Description,Veb-sayt ta&#39;rifi
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +42,Net Change in Equity,Özkaynakta aniq o&#39;zgarishlar
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +196,Newest,Yangilar
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +163,Please cancel Purchase Invoice {0} first,Avval xaridlar fakturasini {0} bekor qiling
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +163,Please cancel Purchase Invoice {0} first,Avval xaridlar fakturasini {0} bekor qiling
 apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43,"Email Address must be unique, already exists for {0}","E-pochta manzili noyob bo&#39;lishi kerak, {0} uchun allaqachon mavjud"
 DocType: Serial No,AMC Expiry Date,AMC tugash sanasi
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +840,Receipt,Qabul qilish
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +865,Receipt,Qabul qilish
 ,Sales Register,Savdo registri
 DocType: Daily Work Summary Settings Company,Send Emails At,Elektron pochta xabarlarini yuborish
 DocType: Quotation,Quotation Lost Reason,Iqtibos yo&#39;qolgan sabab
-apps/erpnext/erpnext/public/js/setup_wizard.js +19,Select your Domain,Domeningizni tanlang
 apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Tahrir qilish uchun hech narsa yo&#39;q.
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +419,Form View,Formasi ko&#39;rinishi
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +476,Form View,Formasi ko&#39;rinishi
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116,Summary for this month and pending activities,Bu oy uchun xulosa va kutilayotgan tadbirlar
-apps/erpnext/erpnext/utilities/user_progress.py +227,"Add users to your organization, other than yourself.",Foydalanuvchilarni o&#39;zingizning tashkilotingizdan tashqari tashkilotga qo&#39;shing.
+apps/erpnext/erpnext/utilities/user_progress.py +245,"Add users to your organization, other than yourself.",Foydalanuvchilarni o&#39;zingizning tashkilotingizdan tashqari tashkilotga qo&#39;shing.
 DocType: Customer Group,Customer Group Name,Mijozlar guruhi nomi
 apps/erpnext/erpnext/public/js/pos/pos.html +98,No Customers yet!,Hozir mijozlar yo&#39;q!
 apps/erpnext/erpnext/public/js/financial_statements.js +56,Cash Flow Statement,Naqd pul oqimlari bayonoti
@@ -3835,26 +4100,30 @@
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +50,Time slots added,Vaqt oraliqlari qo&#39;shildi
 DocType: Item,Attributes,Xususiyatlar
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31,Enable Template,Shabloni yoqish
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +223,Please enter Write Off Account,"Iltimos, hisob raqamini kiriting"
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226,Please enter Write Off Account,"Iltimos, hisob raqamini kiriting"
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,Oxirgi Buyurtma sanasi
 DocType: Patient,B Negative,B salbiy
+apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25,Maintenance Status has to be Cancelled or Completed to Submit,Xizmat holatini bekor qilish yoki topshirish uchun bajarilishi lozim
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47,Account {0} does not belongs to company {1},Hisob {0} kompaniya {1} ga tegishli emas
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +873,Serial Numbers in row {0} does not match with Delivery Note,{0} qatoridagi ketma-ket raqamlar etkazib berish eslatmasiga mos kelmaydi
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +878,Serial Numbers in row {0} does not match with Delivery Note,{0} qatoridagi ketma-ket raqamlar etkazib berish eslatmasiga mos kelmaydi
 DocType: Student,Guardian Details,Guardian tafsilotlari
 DocType: C-Form,C-Form,C-shakl
 apps/erpnext/erpnext/config/hr.py +18,Mark Attendance for multiple employees,Bir nechta xodimlar uchun Markni tomosha qiling
+DocType: Agriculture Task,Start Day,Boshlanish kuni
 DocType: Vehicle,Chassis No,Yo&#39;lak No
 DocType: Payment Request,Initiated,Boshlandi
 DocType: Production Order,Planned Start Date,Rejalashtirilgan boshlanish sanasi
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +592,Please select a BOM,"Iltimos, BOM-ni tanlang"
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +596,Please select a BOM,"Iltimos, BOM-ni tanlang"
 DocType: Serial No,Creation Document Type,Hujjatning tuzilishi
+DocType: Project Task,View Timesheet,Vaqt jadvalini ko&#39;rish
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54,End date must be greater than start date,Tugash sanasi boshlanish sanasidan katta bo&#39;lishi kerak
 DocType: Leave Type,Is Encash,Encashmi?
 DocType: Leave Allocation,New Leaves Allocated,Yangi barglar ajratildi
 apps/erpnext/erpnext/controllers/trends.py +269,Project-wise data is not available for Quotation,Loyiha bo&#39;yicha ma&#39;lumot quyish uchun mavjud emas
-apps/erpnext/erpnext/schools/doctype/student_admission/templates/student_admission.html +30,End on,Tugatish
+apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30,End on,Tugatish
 DocType: Project,Expected End Date,Kutilayotgan tugash sanasi
 DocType: Budget Account,Budget Amount,Byudjet summasi
+DocType: Donor,Donor Name,Donor nomi
 DocType: Appraisal Template,Appraisal Template Title,Baholash shablonlari nomi
 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},Employee {1} uchun Sana {0} dan xodimning ishtirok etishidan oldin bo&#39;la olmaydi Sana {2}
 apps/erpnext/erpnext/utilities/user_progress_utils.py +29,Commercial,Savdo
@@ -3866,32 +4135,34 @@
 DocType: Expense Claim,More Details,Batafsil ma&#39;lumot
 DocType: Supplier Quotation,Supplier Address,Yetkazib beruvchi manzili
 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} {1} {2} {3} ga qarshi hisob qaydnomasi {4}. {5} dan oshib ketadi
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +685,Row {0}# Account must be of type 'Fixed Asset',Row {0} # Hisob turi &quot;Ruxsat etilgan obyekt&quot; turi bo&#39;lishi kerak
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +689,Row {0}# Account must be of type 'Fixed Asset',Row {0} # Hisob turi &quot;Ruxsat etilgan obyekt&quot; turi bo&#39;lishi kerak
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,Miqdori
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,and unchcked Disabled in the,va unchcked o&#39;chirilgan
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +46,Series is mandatory,Seriya majburiy
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +28,Financial Services,Moliyaviy xizmatlar
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28,Financial Services,Moliyaviy xizmatlar
 DocType: Student Sibling,Student ID,Isoning shogirdi kimligi
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +457,Supplier Email,Yetkazib beruvchi elektron pochta
 apps/erpnext/erpnext/config/projects.py +46,Types of activities for Time Logs,Vaqt qaydlari uchun faoliyat turlari
-DocType: Tax Rule,Sales,Savdo
+DocType: Opening Invoice Creation Tool,Sales,Savdo
 DocType: Stock Entry Detail,Basic Amount,Asosiy miqdori
 DocType: Training Event,Exam,Test
 DocType: Complaint,Complaint,Shikoyat
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +452,Warehouse required for stock Item {0},{0} uchun kabinetga ombori kerak
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +456,Warehouse required for stock Item {0},{0} uchun kabinetga ombori kerak
 DocType: Leave Allocation,Unused leaves,Foydalanilmagan barglar
 DocType: Patient,Alcohol Past Use,Spirtli ichimliklarni o&#39;tmishda ishlatish
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +179,Cr,Cr
+DocType: Fertilizer Content,Fertilizer Content,Go&#39;ng tarkibi
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +188,Cr,Cr
 DocType: Tax Rule,Billing State,Billing davlati
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +276,Transfer,Transfer
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +891,Fetch exploded BOM (including sub-assemblies),"Fetch portlash qilingan BOM (sub-assemblies, shu jumladan)"
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +296,Transfer,Transfer
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +916,Fetch exploded BOM (including sub-assemblies),"Fetch portlash qilingan BOM (sub-assemblies, shu jumladan)"
 DocType: Authorization Rule,Applicable To (Employee),Qo&#39;llanilishi mumkin (xodim)
-apps/erpnext/erpnext/controllers/accounts_controller.py +113,Due Date is mandatory,To&#39;lov sanasi majburiydir
+apps/erpnext/erpnext/controllers/accounts_controller.py +135,Due Date is mandatory,To&#39;lov sanasi majburiydir
 apps/erpnext/erpnext/controllers/item_variant.py +80,Increment for Attribute {0} cannot be 0,{0} xususiyati uchun ortish 0 bo&#39;lishi mumkin emas
 DocType: Journal Entry,Pay To / Recd From,Qabul qiling / Qabul qiling
 DocType: Naming Series,Setup Series,O&#39;rnatish seriyasi
 DocType: Payment Reconciliation,To Invoice Date,Faktura tarixiga
 DocType: Supplier,Contact HTML,HTML bilan bog&#39;laning
+DocType: Disease,Treatment Period,Davolash davri
 ,Inactive Customers,Faol bo&#39;lmagan mijozlar
 DocType: Student Admission Program,Maximum Age,Maksimal yosh
 DocType: Landed Cost Voucher,LCV,LCV
@@ -3900,13 +4171,13 @@
 DocType: Stock Entry,Delivery Note No,Etkazib berish Eslatma No
 DocType: Production Planning Tool,"If checked, only Purchase material requests for final raw materials will be included in the Material Requests. Otherwise, Material Requests for parent items will be created","Tekshirilgandan so&#39;ng, xom ashyoning oxirgi materiallari uchun sotib olish materiallari talablari Materiallar talablariga kiritiladi. Aks holda, yuqori elementlar uchun Materiallar so&#39;rovlari yaratiladi"
 DocType: Cheque Print Template,Message to show,Ko&#39;rsatiladigan xabar
-DocType: Company,Retail,Chakana savdo
-DocType: Attendance,Absent,Yo&#39;q
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +566,Product Bundle,Mahsulot to&#39;plami
+apps/erpnext/erpnext/public/js/setup_wizard.js +28,Retail,Chakana savdo
+DocType: Student Attendance,Absent,Yo&#39;q
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591,Product Bundle,Mahsulot to&#39;plami
 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,{0} da boshlangan balni topib bo&#39;lmadi. Siz 0 dan 100 gacha bo&#39;lgan sog&#39;lom balllarga ega bo&#39;lishingiz kerak
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +212,Row {0}: Invalid reference {1},Row {0}: yaroqsiz ma&#39;lumot {1}
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +206,No submitted Delivery Notes found,Taqdim etilgan etkazib berish qaydlari topilmadi
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +210,Row {0}: Invalid reference {1},Row {0}: yaroqsiz ma&#39;lumot {1}
 DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Xarajatlar va to&#39;lovlar shablonini sotib oling
-DocType: Upload Attendance,Download Template,Andoza yuklab oling
 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}: {2} uchun, debet yoki kredit summasi talab qilinadi"
 DocType: GL Entry,Remarks,Izohlar
@@ -3917,29 +4188,33 @@
 apps/erpnext/erpnext/utilities/activation.py +65,Make Lead,Qo&#39;rg&#39;oshin bo&#39;ling
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112,Print and Stationery,Chop etish va ish yuritish
 DocType: Stock Settings,Show Barcode Field,Barcode maydonini ko&#39;rsatish
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +782,Send Supplier Emails,Yetkazib beruvchi elektron pochta xabarlarini yuborish
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +807,Send Supplier Emails,Yetkazib beruvchi elektron pochta xabarlarini yuborish
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +115,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","{0} va {1} oralig&#39;idagi davrda allaqachon ishlov berilgan ish haqi, ushbu muddat oralig&#39;ida ariza berish muddati qoldirilmasligi kerak."
-apps/erpnext/erpnext/config/stock.py +132,Installation record for a Serial No.,Seriya raqami uchun o&#39;rnatish yozuvi
 DocType: Guardian Interest,Guardian Interest,Guardian qiziqishi
-apps/erpnext/erpnext/config/accounts.py +327,Setup default values for POS Invoices,POS hisob-fakturalarida standart qiymatlarni sozlash
-apps/erpnext/erpnext/config/hr.py +177,Training,Trening
+DocType: Volunteer,Availability,Mavjudligi
+apps/erpnext/erpnext/config/accounts.py +319,Setup default values for POS Invoices,POS hisob-fakturalarida standart qiymatlarni sozlash
+apps/erpnext/erpnext/config/hr.py +182,Training,Trening
 DocType: Timesheet,Employee Detail,Xodimlar haqida batafsil
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1 Email identifikatori
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1 Email identifikatori
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68,Next Date's day and Repeat on Day of Month must be equal,Keyingi kunning kuni va oyning takroriy kuni teng bo&#39;lishi kerak
 DocType: Lab Prescription,Test Code,Sinov kodi
 apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Veb-sayt bosh sahifasining sozlamalari
+DocType: Delivery Stop,Select/Unselect Delivery Notes,Buyurtma eslatmalarini tanlang
 DocType: Offer Letter,Awaiting Response,Javobni kutish
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60,Above,Yuqorida
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1298,Total Amount {0},Jami miqdori {0}
-apps/erpnext/erpnext/controllers/item_variant.py +232,Invalid attribute {0} {1},{0} {1} atributi noto&#39;g&#39;ri
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1375,Total Amount {0},Jami miqdori {0}
+apps/erpnext/erpnext/controllers/item_variant.py +301,Invalid attribute {0} {1},{0} {1} atributi noto&#39;g&#39;ri
 DocType: Supplier,Mention if non-standard payable account,Nodavlat to&#39;lanadigan hisob qaydnomasini qayd etish
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.py +18,Please select the assessment group other than 'All Assessment Groups',"Iltimos, barcha baholash guruhlaridan boshqa baholash guruhini tanlang."
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +18,Please select the assessment group other than 'All Assessment Groups',"Iltimos, barcha baholash guruhlaridan boshqa baholash guruhini tanlang."
 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}: xarajat markazi {1}
 DocType: Training Event Employee,Optional,Majburiy emas
 DocType: Salary Slip,Earning & Deduction,Mablag&#39;larni kamaytirish
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +36,Optional. This setting will be used to filter in various transactions.,Majburiy emas. Ushbu parametr turli operatsiyalarda filtrlash uchun ishlatiladi.
+DocType: Agriculture Analysis Criteria,Water Analysis,Suvni tahlil qilish
+DocType: Chapter,Region,Mintaqa
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38,Optional. This setting will be used to filter in various transactions.,Majburiy emas. Ushbu parametr turli operatsiyalarda filtrlash uchun ishlatiladi.
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +108,Negative Valuation Rate is not allowed,Salbiy baholash darajasi ruxsat etilmaydi
 DocType: Holiday List,Weekly Off,Haftalik yopiq
+apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7,Reload Linked Analysis,Bog&#39;langan tahlilni qayta tiklash
 DocType: Fiscal Year,"For e.g. 2012, 2012-13","Masalan, 2012, 2012-13 yy"
 apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96,Provisional Profit / Loss (Credit),Vaqtinchalik foyda / zarar (kredit)
 DocType: Sales Invoice,Return Against Sales Invoice,Sotuvdagi hisob-fakturaga qarshi chiqish
@@ -3951,11 +4226,10 @@
 ,Monthly Attendance Sheet,Oylik qatnashish varaqasi
 DocType: Production Order Item,Production Order Item,Buyurtma buyurtmasi
 apps/erpnext/erpnext/healthcare/report/lab_test_report/lab_test_report.py +15,No record found,Hech qanday yozuv topilmadi
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +137,Cost of Scrapped Asset,Chiqib ketgan aktivlarning qiymati
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140,Cost of Scrapped Asset,Chiqib ketgan aktivlarning qiymati
 apps/erpnext/erpnext/controllers/stock_controller.py +236,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: narxlari markazi {2}
 DocType: Vehicle,Policy No,Siyosat No
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +659,Get Items from Product Bundle,Mahsulot paketidagi narsalarni oling
-apps/erpnext/erpnext/stock/doctype/item/item.py +663,"As stock exists against an item {0}, you can not enable has variants property",{0} elementiga qarshi aktsiyalar mavjud bo&#39;lgani uchun sizda varianti xususiyatini yoqib bo&#39;lmaydi
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +684,Get Items from Product Bundle,Mahsulot paketidagi narsalarni oling
 DocType: Asset,Straight Line,To&#39;g&#39;ri chiziq
 DocType: Project User,Project User,Loyiha foydalanuvchisi
 apps/erpnext/erpnext/stock/doctype/batch/batch.js +64,Split,Split
@@ -3966,6 +4240,8 @@
 apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Oxirgi aloqa davri
 DocType: Sales Team,Contact No.,Aloqa raqami.
 DocType: Bank Reconciliation,Payment Entries,To&#39;lov yozuvlari
+DocType: Land Unit,Land Unit Details,Er uchastkasining tafsilotlari
+DocType: Land Unit,Latitude,Enlem
 DocType: Production Order,Scrap Warehouse,Hurda ombori
 DocType: Production Order,Check if material transfer entry is not required,Moddiy uzatishni talab qilmasligini tekshiring
 DocType: Program Enrollment Tool,Get Students From,Shogirdlarni o&#39;zingizdan oling
@@ -3978,77 +4254,83 @@
 DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Savdo soliqlar va to&#39;lovlar shabloni
 apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68,Total (Credit),Jami (kredit)
 DocType: Repayment Schedule,Payment Date,To&#39;lov sanasi
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +107,New Batch Qty,Yangi Batch son
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +10,Apparel & Accessories,Tashqi va o&#39;smirlar
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +114,New Batch Qty,Yangi Batch son
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10,Apparel & Accessories,Tashqi va o&#39;smirlar
 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.,Og&#39;irlikdagi ball vazifasini hal qila olmadi. Formulaning haqiqiyligiga ishonch hosil qiling.
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67,Number of Order,Buyurtma soni
 DocType: Item Group,HTML / Banner that will show on the top of product list.,Mahsulot ro&#39;yxatining yuqori qismida ko&#39;rsatiladigan HTML / Banner.
 DocType: Shipping Rule,Specify conditions to calculate shipping amount,Yuk tashish miqdorini hisoblash uchun shartlarni belgilang
+DocType: Program Enrollment,Institute's Bus,Institut avtobusi
 DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Muzlatilgan hisoblarni sozlash va muzlatilgan yozuvlarni tahrir qilish uchun roli mumkin
 DocType: Supplier Scorecard Scoring Variable,Path,Yo&#39;l
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28,Cannot convert Cost Center to ledger as it has child nodes,"Xarajatli markazni kitob nusxa ko&#39;chirish qurilmasiga aylantira olmaysiz, chunki u tugmachalarga ega"
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +56,Opening Value,Ochilish qiymati
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +66,Opening Value,Ochilish qiymati
 DocType: Salary Detail,Formula,Formulalar
 apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47,Serial #,Seriya #
 DocType: Lab Test Template,Lab Test Template,Laboratoriya viktorina namunasi
+DocType: Purchase Invoice Item,Total Weight,Jami Og&#39;irligi
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94,Commission on Sales,Savdo bo&#39;yicha komissiya
 DocType: Offer Letter Term,Value / Description,Qiymati / ta&#39;rifi
-apps/erpnext/erpnext/controllers/accounts_controller.py +565,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","# {0} qatori: Asset {1} yuborib bo&#39;lolmaydi, allaqachon {2}"
+apps/erpnext/erpnext/controllers/accounts_controller.py +609,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","# {0} qatori: Asset {1} yuborib bo&#39;lolmaydi, allaqachon {2}"
 DocType: Tax Rule,Billing Country,Billing davlati
 DocType: Purchase Order Item,Expected Delivery Date,Kutilayotgan etkazib berish sanasi
 DocType: Restaurant Order Entry,Restaurant Order Entry,Restoran Buyurtma yozuvi
 apps/erpnext/erpnext/accounts/general_ledger.py +132,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debet va kredit {0} # {1} uchun teng emas. Farqi {2} dir.
+DocType: Asset Maintenance Task,Assign To Name,Ismni belgilash
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98,Entertainment Expenses,O&#39;yin xarajatlari
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +48,Make Material Request,Materiallar talabini bajarish
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +63,Make Material Request,Materiallar talabini bajarish
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20,Open Item {0},{0} bandini ochish
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +214,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Sotuvdagi Buyurtmani bekor qilishdan oldin {0} Sotuvdagi Billing bekor qilinishi kerak
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Sotuvdagi Buyurtmani bekor qilishdan oldin {0} Sotuvdagi Billing bekor qilinishi kerak
 DocType: Consultation,Age,Yoshi
 DocType: Sales Invoice Timesheet,Billing Amount,To&#39;lov miqdori
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,Invalid quantity specified for item {0}. Quantity should be greater than 0.,{0} elementi uchun belgilangan miqdor noto&#39;g&#39;ri. Miqdori 0 dan katta bo&#39;lishi kerak.
+DocType: Company,Default Employee Advance Account,Standart ishchi Advance qaydnomasi
 apps/erpnext/erpnext/config/hr.py +60,Applications for leave.,Dam olish uchun arizalar.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +177,Account with existing transaction can not be deleted,Mavjud amal bilan hisob o&#39;chirilmaydi
+apps/erpnext/erpnext/accounts/doctype/account/account.py +166,Account with existing transaction can not be deleted,Mavjud amal bilan hisob o&#39;chirilmaydi
 DocType: Vehicle,Last Carbon Check,Oxirgi Karbon nazorati
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102,Legal Expenses,Huquqiy xarajatlar
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +130,Please select quantity on row ,"Iltimos, qatordagi miqdorni tanlang"
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140,Please select quantity on row ,"Iltimos, qatordagi miqdorni tanlang"
+apps/erpnext/erpnext/config/accounts.py +277,Make Opening Sales and Purchase Invoices,Savdo va Xaridlar Xarajatlarni ochish
 DocType: Purchase Invoice,Posting Time,Vaqtni yuborish vaqti
 DocType: Timesheet,% Amount Billed,% To&#39;lov miqdori
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +102,"""Time Per Appointment"" hasn""t been set for Dr {0}. Add it in Physician master.","&quot;Vaqtni belgilash vaqti&quot; doktor {0} uchun o&#39;rnatilmagan, uni shifokor ustasiga qo&#39;shing."
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118,Telephone Expenses,Telefon xarajatlari
 DocType: Sales Partner,Logo,Asosiy
 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.,"Foydalanuvchini saqlashdan oldin bir qatorni tanlashga majburlashni xohlasangiz, buni tekshiring. Buni tekshirsangiz, hech qanday ko&#39;rsatuv bo&#39;lmaydi."
-apps/erpnext/erpnext/stock/get_item_details.py +135,No Item with Serial No {0},Hech narsa Serialli yo&#39;q {0}
+apps/erpnext/erpnext/stock/get_item_details.py +129,No Item with Serial No {0},Hech narsa Serialli yo&#39;q {0}
 DocType: Email Digest,Open Notifications,Bildirishnomalarni oching
 DocType: Payment Entry,Difference Amount (Company Currency),Ajratilgan mablag&#39;lar (Kompaniya valyutasi)
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79,Direct Expenses,To&#39;g&#39;ridan-to&#39;g&#39;ri xarajatlar
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in Education &gt; Education Settings,"Marhamat, Ta&#39;lim bo&#39;yicha o&#39;qituvchilarni nomlash tizimini sozlash&gt; Ta&#39;lim sozlamalari"
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Yangi xaridorlar daromadi
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119,Travel Expenses,Sayohat xarajatlari
 DocType: Maintenance Visit,Breakdown,Buzilmoq
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50,Add custom field Subscription in the doctype {0},{0} doctype dagi maxsus maydon obunani qo&#39;shish
-apps/erpnext/erpnext/controllers/accounts_controller.py +677,Account: {0} with currency: {1} can not be selected,Hisob: {0} valyutaga: {1} tanlanmaydi
+apps/erpnext/erpnext/controllers/accounts_controller.py +789,Account: {0} with currency: {1} can not be selected,Hisob: {0} valyutaga: {1} tanlanmaydi
+DocType: Purchase Receipt Item,Sample Quantity,Namuna miqdori
 DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.",Tez-tez yangilanadigan narxlarni / narx ro&#39;yxatining nisbati / xom ashyoning so&#39;nggi sotib olish nisbati asosida Scheduler orqali BOM narxini avtomatik ravishda yangilang.
 DocType: Bank Reconciliation Detail,Cheque Date,Tekshirish sanasi
-apps/erpnext/erpnext/accounts/doctype/account/account.py +54,Account {0}: Parent account {1} does not belong to company: {2},Hisob {0}: Ota-hisob {1} kompaniyaga tegishli emas: {2}
+apps/erpnext/erpnext/accounts/doctype/account/account.py +50,Account {0}: Parent account {1} does not belong to company: {2},Hisob {0}: Ota-hisob {1} kompaniyaga tegishli emas: {2}
 DocType: Program Enrollment Tool,Student Applicants,Talaba nomzodlari
 apps/erpnext/erpnext/setup/doctype/company/company.js +77,Successfully deleted all transactions related to this company!,Ushbu kompaniya bilan bog&#39;liq barcha operatsiyalar muvaffaqiyatli o&#39;chirildi!
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +21,As on Date,Sana Sana bo&#39;yicha
 DocType: Appraisal,HR,HR
 DocType: Program Enrollment,Enrollment Date,Ro&#39;yxatga olish sanasi
 DocType: Healthcare Settings,Out Patient SMS Alerts,Kasal SMS-ogohlantirishlari
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +96,Probation,Sinov
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100,Probation,Sinov
 apps/erpnext/erpnext/config/hr.py +115,Salary Components,Ish haqi komponentlari
 DocType: Program Enrollment Tool,New Academic Year,Yangi o&#39;quv yili
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +762,Return / Credit Note,Qaytaring / Kredit eslatma
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +809,Return / Credit Note,Qaytaring / Kredit eslatma
 DocType: Stock Settings,Auto insert Price List rate if missing,Avtotexnika uchun narxlash ro&#39;yxati mavjud emas
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +23,Total Paid Amount,To&#39;langan pul miqdori
 DocType: Production Order Item,Transferred Qty,Miqdor o&#39;tkazildi
 apps/erpnext/erpnext/config/learn.py +11,Navigating,Navigatsiya
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +184,Planning,Rejalashtirish
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188,Planning,Rejalashtirish
 DocType: Material Request,Issued,Berilgan sana
-apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +14,Student Activity,Talabalar faoliyati
-DocType: Project,Total Billing Amount (via Time Logs),Jami to&#39;lov miqdori (vaqtli jurnallar orqali)
+apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14,Student Activity,Talabalar faoliyati
 apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80,Supplier Id,Yetkazib beruvchi identifikatori
 DocType: Payment Request,Payment Gateway Details,Payment Gateway Details
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +264,Quantity should be greater than 0,Miqdori 0 dan katta bo&#39;lishi kerak
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +267,Quantity should be greater than 0,Miqdori 0 dan katta bo&#39;lishi kerak
 DocType: Journal Entry,Cash Entry,Naqd kiritish
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17,Child nodes can be only created under 'Group' type nodes,Bolalar tugunlari faqat &quot;Guruh&quot; tipidagi tugunlar ostida yaratilishi mumkin
 DocType: Leave Application,Half Day Date,Yarim kunlik sana
@@ -4057,22 +4339,25 @@
 apps/erpnext/erpnext/config/hr.py +65,"Type of leaves like casual, sick etc.","Oddiy, kasal va hokazo. Barglar turi."
 DocType: Email Digest,Send regular summary reports via Email.,Elektron pochta orqali muntazam abstrakt hisobotlar yuboring.
 DocType: Payment Entry,PE-,PE-
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +254,Please set default account in Expense Claim Type {0},"Iltimos, xarajat shikoyati toifasiga kiritilgan standart hisobni tanlang {0}"
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +305,Please set default account in Expense Claim Type {0},"Iltimos, xarajat shikoyati toifasiga kiritilgan standart hisobni tanlang {0}"
 DocType: Assessment Result,Student Name,Isoning shogirdi nomi
 DocType: Brand,Item Manager,Mavzu menejeri
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Payroll Payable,To&#39;lanadigan qarzlar
 DocType: Buying Settings,Default Supplier Type,Standart etkazib beruvchi turi
+DocType: Plant Analysis,Collection Datetime,Datetime yig&#39;ish
 DocType: Production Order,Total Operating Cost,Jami Operatsion XARAJATLAR
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171,Note: Item {0} entered multiple times,Eslatma: {0} elementi bir necha marta kiritilgan
 apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Barcha kontaktlar.
-apps/erpnext/erpnext/public/js/setup_wizard.js +67,Company Abbreviation,Kompaniya qisqartmasi
+apps/erpnext/erpnext/public/js/setup_wizard.js +71,Company Abbreviation,Kompaniya qisqartmasi
 apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +57,User {0} does not exist,{0} foydalanuvchisi mavjud emas
+DocType: Payment Term,Day(s) after invoice date,Billing sanasi so&#39;ng kun (lar)
+DocType: Payment Schedule,Payment Schedule,To&#39;lov jadvali
 DocType: Subscription,SUB-,SUB-
 DocType: Item Attribute Value,Abbreviation,Qisqartirish
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +182,Payment Entry already exists,To&#39;lov usuli allaqachon mavjud
 apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,{0} dan boshlab authroized emas
 apps/erpnext/erpnext/config/hr.py +110,Salary template master.,Ish haqi shabloni ustasi.
-apps/erpnext/erpnext/healthcare/setup.py +240,Pathology,Patologiya
+apps/erpnext/erpnext/healthcare/setup.py +241,Pathology,Patologiya
 DocType: Restaurant Order Entry,Restaurant Table,Restoran jadvalidan
 DocType: Leave Type,Max Days Leave Allowed,Maksimal kunlar ruxsat berilsin
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63,Set Tax Rule for shopping cart,Xarid qilish vositasi uchun Soliq qoidasini o&#39;rnating
@@ -4085,67 +4370,71 @@
 apps/erpnext/erpnext/config/selling.py +13,Quotes to Leads or Customers.,Qabul qiluvchi yoki mijozlarga takliflar.
 DocType: Stock Settings,Role Allowed to edit frozen stock,Muzlatilgan zahiralarni tartibga solishga rolik
 ,Territory Target Variance Item Group-Wise,Hududning maqsadli o&#39;zgarishi Mavzu guruh - dono
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +139,All Customer Groups,Barcha xaridorlar guruhlari
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143,All Customer Groups,Barcha xaridorlar guruhlari
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114,Accumulated Monthly,Yil olingan oy
-apps/erpnext/erpnext/controllers/accounts_controller.py +638,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,"{0} majburiydir. Ehtimol, valyuta ayirboshlash yozuvi {1} - {2} uchun yaratilmagan."
+apps/erpnext/erpnext/controllers/accounts_controller.py +750,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,"{0} majburiydir. Ehtimol, valyuta ayirboshlash yozuvi {1} - {2} uchun yaratilmagan."
 apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +41,Tax Template is mandatory.,Soliq namunasi majburiydir.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +48,Account {0}: Parent account {1} does not exist,Hisob {0}: Ota-hisob {1} mavjud emas
+apps/erpnext/erpnext/accounts/doctype/account/account.py +44,Account {0}: Parent account {1} does not exist,Hisob {0}: Ota-hisob {1} mavjud emas
 DocType: Purchase Invoice Item,Price List Rate (Company Currency),Narhlar kursi (Kompaniya valyutasi)
 DocType: Products Settings,Products Settings,Mahsulotlar Sozlamalari
+,Item Price Stock,Mavzu narxi kabinetga
 DocType: Lab Prescription,Test Created,Test yaratildi
 DocType: Healthcare Settings,Custom Signature in Print,Bosma uchun maxsus imzo
 DocType: Account,Temporary,Vaqtinchalik
 DocType: Program,Courses,Kurslar
 DocType: Monthly Distribution Percentage,Percentage Allocation,Foizlarni ajratish
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +124,Secretary,Kotib
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128,Secretary,Kotib
 DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Agar o&#39;chirib qo&#39;yilsa, &quot;So&#39;zlar&quot; maydonida hech qanday operatsiyani ko&#39;rish mumkin bo&#39;lmaydi"
 DocType: Serial No,Distinct unit of an Item,Ob&#39;ektning aniq birligi
 DocType: Supplier Scorecard Criteria,Criteria Name,Kriterlar nomi
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1213,Please set Company,"Iltimos, kompaniyani tanlang"
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1289,Please set Company,"Iltimos, kompaniyani tanlang"
 DocType: Pricing Rule,Buying,Sotib olish
+apps/erpnext/erpnext/config/agriculture.py +24,Diseases & Fertilizers,Kasallik va go&#39;ng
 DocType: HR Settings,Employee Records to be created by,Tomonidan yaratiladigan xodimlar yozuvlari
 DocType: Patient,AB Negative,Evropa Ittifoqi salbiy
 DocType: Sample Collection,SMPL-,SMPL-
 DocType: POS Profile,Apply Discount On,Dasturni yoqish
+DocType: Member,Membership Type,Registratsiya turi
 ,Reqd By Date,Sana bo&#39;yicha sana
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140,Creditors,Kreditorlar
 DocType: Assessment Plan,Assessment Name,Baholashning nomi
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +96,Row # {0}: Serial No is mandatory,# {0} qatori: seriya raqami majburiy emas
 DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Maqola Wise Soliq Batafsil
-apps/erpnext/erpnext/public/js/setup_wizard.js +67,Institute Abbreviation,Institut qisqartmasi
+apps/erpnext/erpnext/public/js/setup_wizard.js +71,Institute Abbreviation,Institut qisqartmasi
 ,Item-wise Price List Rate,Narh-navolar narxi ro&#39;yxati
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +941,Supplier Quotation,Yetkazib beruvchi kotirovkasi
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +966,Supplier Quotation,Yetkazib beruvchi kotirovkasi
 DocType: Quotation,In Words will be visible once you save the Quotation.,So&#39;zlarni saqlaganingizdan so&#39;ng so&#39;zlar ko&#39;rinadi.
 apps/erpnext/erpnext/utilities/transaction_base.py +153,Quantity ({0}) cannot be a fraction in row {1},Miqdor ({0}) qatorda {1}
 DocType: Consultation,C-,C-
 DocType: Attendance,ATT-,ATT-
-apps/erpnext/erpnext/stock/doctype/item/item.py +457,Barcode {0} already used in Item {1},{1} {{1} shtrix kodi
+apps/erpnext/erpnext/stock/doctype/item/item.py +473,Barcode {0} already used in Item {1},{1} {{1} shtrix kodi
 apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,Yuk tashish xarajatlarini qo&#39;shish qoidalari.
 DocType: Item,Opening Stock,Ochilish hisobi
 apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Xaridor talab qilinadi
 DocType: Lab Test,Result Date,Natija sanasi
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20,{0} is mandatory for Return,{0} qaytishi uchun majburiydir
 DocType: Purchase Order,To Receive,Qabul qilmoq
-apps/erpnext/erpnext/utilities/user_progress.py +231,user@example.com,user@example.com
+apps/erpnext/erpnext/utilities/user_progress.py +249,user@example.com,user@example.com
+DocType: Asset,Asset Owner,Shaxs egasi
 DocType: Employee,Personal Email,Shaxsiy Email
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57,Total Variance,Jami o&#39;zgarish
 DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Agar yoqilgan bo&#39;lsa, tizim avtomatik ravishda inventarizatsiyadan o&#39;tkazish uchun buxgalteriya yozuvlarini yuboradi."
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +15,Brokerage,Brokerlik
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15,Brokerage,Brokerlik
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +232,Attendance for employee {0} is already marked for this day,Xodimga {0} davomi bu kun uchun belgilandi
 DocType: Production Order Operation,"in Minutes
 Updated via 'Time Log'",daqiqada &quot;Time log&quot; orqali yangilangan.
 DocType: Customer,From Lead,Qo&#39;rg&#39;oshin
 apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,Ishlab chiqarish uchun chiqarilgan buyurtmalar.
 apps/erpnext/erpnext/public/js/account_tree_grid.js +66,Select Fiscal Year...,Moliyaviy yilni tanlang ...
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +557,POS Profile required to make POS Entry,Qalin kirishni amalga oshirish uchun qalin profil talab qilinadi
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +561,POS Profile required to make POS Entry,Qalin kirishni amalga oshirish uchun qalin profil talab qilinadi
 DocType: Program Enrollment Tool,Enroll Students,O&#39;quvchilarni ro&#39;yxatga olish
 DocType: Lab Test,Approved Date,Tasdiqlangan sana
 apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Standart sotish
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +138,Atleast one warehouse is mandatory,Eng kamida bir omborxona majburiydir
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +143,Atleast one warehouse is mandatory,Eng kamida bir omborxona majburiydir
 DocType: Serial No,Out of Warranty,Kafolatli emas
 DocType: BOM Update Tool,Replace,O&#39;zgartiring
 apps/erpnext/erpnext/templates/includes/product_list.js +42,No products found.,Hech qanday mahsulot topilmadi.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360,{0} against Sales Invoice {1},{0} Sotuvdagi taqdimotga qarshi {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +358,{0} against Sales Invoice {1},{0} Sotuvdagi taqdimotga qarshi {1}
 DocType: Antibiotic,Laboratory User,Laboratoriya foydalanuvchisi
 DocType: Sales Invoice,SINV-,SINV-
 DocType: Request for Quotation Item,Project Name,Loyiha nomi
@@ -4155,43 +4444,47 @@
 DocType: Stock Ledger Entry,Stock Value Difference,Hissa qiymatining o&#39;zgarishi
 apps/erpnext/erpnext/config/learn.py +234,Human Resource,Inson resursi
 DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,To&#39;lovni tasdiqlash to&#39;lovi
+DocType: Disease,Treatment Task,Davolash vazifasi
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38,Tax Assets,Soliq aktivlari
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +626,Production Order has been {0},Ishlab chiqarish tartibi {0}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +630,Production Order has been {0},Ishlab chiqarish tartibi {0}
 DocType: BOM Item,BOM No,BOM No
 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,Kundalik yozuv {0} da {1} hisobiga ega emas yoki boshqa to&#39;lovlarga qarshi allaqachon mos kelgan
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +158,Journal Entry {0} does not have account {1} or already matched against other voucher,Kundalik yozuv {0} da {1} hisobiga ega emas yoki boshqa to&#39;lovlarga qarshi allaqachon mos kelgan
 DocType: Item,Moving Average,O&#39;rtacha harakatlanuvchi
 DocType: BOM Update Tool,The BOM which will be replaced,O&#39;zgartiriladigan BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46,Electronic Equipments,Elektron uskunalar
+DocType: Asset,Maintenance Required,Xizmat talab qilinadi
 DocType: Account,Debit,Debet
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49,Leaves must be allocated in multiples of 0.5,"Barglari 0,5 foizga bo&#39;linadi"
 DocType: Production Order,Operation Cost,Operatsion qiymati
 apps/erpnext/erpnext/config/hr.py +29,Upload attendance from a .csv file,.csv faylidan tashrif buyurish
-apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +39,Outstanding Amt,Amaldor Amt
+apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45,Outstanding Amt,Amaldor Amt
 DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Ushbu Sotuvdagi Shaxs uchun Maqsadlar guruhini aniqlang.
 DocType: Stock Settings,Freeze Stocks Older Than [Days],Qimmatbaho qog&#39;ozlarni qisqartirish [Days]
-apps/erpnext/erpnext/controllers/accounts_controller.py +535,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Row # {0}: Asset asosiy vositalarni sotib olish va sotish uchun majburiydir
+apps/erpnext/erpnext/controllers/accounts_controller.py +579,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Row # {0}: Asset asosiy vositalarni sotib olish va sotish uchun majburiydir
+DocType: Asset Maintenance Team,Maintenance Team Name,Ta&#39;minot jamoasi nomi
 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.","Yuqoridagi shartlarga asosan ikki yoki undan ko&#39;proq narx belgilash qoidalari mavjud bo&#39;lsa, birinchi o&#39;ringa qo&#39;llaniladi. Prioritet 0 dan 20 gacha bo&#39;lgan sonni ko&#39;rsatib, standart qiymat nol (bo&#39;sh). Agar yuqorida ko&#39;rsatilgan shartlarga ega bo&#39;lgan bir nechta narxlash qoidalari mavjud bo&#39;lsa, yuqoriroq raqam birinchi o&#39;ringa ega bo&#39;lishni anglatadi."
 apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,Moliyaviy yil: {0} mavjud emas
 DocType: Currency Exchange,To Currency,Valyuta uchun
 DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Quyidagi foydalanuvchilarga bloklangan kunlar uchun Ilovalarni jo&#39;nating.
-apps/erpnext/erpnext/config/hr.py +132,Types of Expense Claim.,Xarajatlar shikoyati turlari.
-apps/erpnext/erpnext/controllers/selling_controller.py +176,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},{0} elementi uchun sotish darajasi {1} dan past. Sotish narxi atleast {2}
+apps/erpnext/erpnext/config/hr.py +137,Types of Expense Claim.,Xarajatlar shikoyati turlari.
+apps/erpnext/erpnext/controllers/selling_controller.py +144,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},{0} elementi uchun sotish darajasi {1} dan past. Sotish narxi atleast {2}
 DocType: Item,Taxes,Soliqlar
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +324,Paid and Not Delivered,To&#39;langan va etkazib berilmagan
+DocType: Purchase Invoice Item,Weight Per Unit,Birlikning og&#39;irligi
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344,Paid and Not Delivered,To&#39;langan va etkazib berilmagan
 DocType: Project,Default Cost Center,Standart xarajatlar markazi
 DocType: Bank Guarantee,End Date,Tugash sanasi
 apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,Stock Transactions
 DocType: Budget,Budget Accounts,Byudjet hisobi
 DocType: Employee,Internal Work History,Ichki ishlash tarixi
 DocType: Depreciation Schedule,Accumulated Depreciation Amount,Yig&#39;ilgan Amortizatsiya summasi
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +42,Private Equity,Xususiy kapital
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42,Private Equity,Xususiy kapital
 DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Yetkazib beruvchi Scorecard o&#39;zgaruvchan
 DocType: Employee Loan,Fully Disbursed,To&#39;liq to&#39;langan
 DocType: Maintenance Visit,Customer Feedback,Xaridorlarning fikri
 DocType: Account,Expense,Xarajatlar
-apps/erpnext/erpnext/schools/doctype/assessment_result/assessment_result.js +36,Score cannot be greater than Maximum Score,Skor maksimal balldan ortiq bo&#39;lishi mumkin emas
-apps/erpnext/erpnext/utilities/user_progress.py +108,Customers and Suppliers,Mijozlar va etkazib beruvchilar
+apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +36,Score cannot be greater than Maximum Score,Skor maksimal balldan ortiq bo&#39;lishi mumkin emas
+apps/erpnext/erpnext/utilities/user_progress.py +126,Customers and Suppliers,Mijozlar va etkazib beruvchilar
 DocType: Item Attribute,From Range,Oralig&#39;idan
 DocType: BOM,Set rate of sub-assembly item based on BOM,BOM-ga asoslangan pastki yig&#39;iladigan elementni o&#39;rnatish tezligi
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98,Syntax error in formula or condition: {0},Formulada yoki vaziyatda sintaksik xato: {0}
@@ -4200,6 +4493,7 @@
 DocType: Appraisal,APRSL,APRSL
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +109,Submit this Production Order for further processing.,Keyinchalik ishlash uchun ushbu ishlab chiqarish tartibini yuboring.
 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.",Raqobatchilar qoidasini muayyan operatsiyalarda qo&#39;llamaslik uchun barcha amaldagi narx qoidalari bekor qilinishi kerak.
+DocType: Payment Term,Day(s) after the end of the invoice month,Vaqtinchalik hisob-varag&#39;i tugagandan so&#39;ng kun (lar)
 DocType: Assessment Group,Parent Assessment Group,Ota-ona baholash guruhi
 apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27,Jobs,Ishlar
 ,Sales Order Trends,Savdo buyurtma yo&#39;nalishlari
@@ -4208,21 +4502,23 @@
 ,Employee Information,Xodimlar haqida ma&#39;lumot
 DocType: Stock Entry Detail,Additional Cost,Qo&#39;shimcha xarajatlar
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +39,"Can not filter based on Voucher No, if grouped by Voucher","Voucher tomonidan guruhlangan bo&#39;lsa, Voucher No ga asoslangan holda filtrlay olmaydi"
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +891,Make Supplier Quotation,Yetkazib beruvchini taklif eting
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +916,Make Supplier Quotation,Yetkazib beruvchini taklif eting
 DocType: Quality Inspection,Incoming,Kiruvchi
-apps/erpnext/erpnext/schools/doctype/assessment_result/assessment_result.py +47,Assessment Result record {0} already exists.,Baholash natijasi {0} allaqachon mavjud.
+apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +47,Assessment Result record {0} already exists.,Baholash natijasi {0} allaqachon mavjud.
 DocType: BOM,Materials Required (Exploded),Zarur bo&#39;lgan materiallar (portlatilgan)
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60,Please set Company filter blank if Group By is 'Company',"Guruh tomonidan &quot;Kompaniya&quot; bo&#39;lsa, Kompaniya filtrini bo&#39;sh qoldiring."
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66,Posting Date cannot be future date,Kiritilgan sana kelajakdagi sana bo&#39;la olmaydi
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +101,Row # {0}: Serial No {1} does not match with {2} {3},# {0} qatori: ketma-ket No {1} {2} {3}
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,for generating the recurring,takroriy yaratish uchun
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +82,Casual Leave,Oddiy chiqish
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86,Casual Leave,Oddiy chiqish
 apps/erpnext/erpnext/config/healthcare.py +138,Lab Test UOM.,Laborator tekshiruvi UOM.
+DocType: Agriculture Task,End Day,Oxiri kuni
 DocType: Batch,Batch ID,Ommaviy ID raqami
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380,Note: {0},Eslatma: {0}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +378,Note: {0},Eslatma: {0}
 ,Delivery Note Trends,Yetkazib berish bo&#39;yicha eslatma trend
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112,This Week's Summary,Ushbu xaftaning qisqacha bayoni
 apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +20,In Stock Qty,Qimmatli qog&#39;ozlar sonida
+DocType: Delivery Trip,Calculate Estimated Arrival Times,Bashoratli keladigan vaqtni hisoblash
 apps/erpnext/erpnext/accounts/general_ledger.py +111,Account: {0} can only be updated via Stock Transactions,Hisob: {0} faqatgina kabinetga operatsiyalari orqali yangilanishi mumkin
 DocType: Student Group Creation Tool,Get Courses,Kurslar oling
 DocType: GL Entry,Party,Partiya
@@ -4231,59 +4527,68 @@
 DocType: Sales Order,Delivery Date,Yetkazib berish sanasi
 DocType: Opportunity,Opportunity Date,Imkoniyat tarixi
 DocType: Purchase Receipt,Return Against Purchase Receipt,Xarid qilish olingani qaytaring
+DocType: Water Analysis,Person Responsible,Shaxs javobgar
 DocType: Request for Quotation Item,Request for Quotation Item,Buyurtma varag&#39;i uchun so&#39;rov
 DocType: Purchase Order,To Bill,Billga
 DocType: Material Request,% Ordered,% Buyurtma qilingan
-DocType: School Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",Kurs asosidagi talabalar guruhi uchun Kursni ro&#39;yxatdan o&#39;tishda ro&#39;yxatdan o&#39;tgan kurslardan har bir talaba uchun tasdiqlanadi.
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +99,Piecework,Perework
+DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",Kurs asosidagi talabalar guruhi uchun Kursni ro&#39;yxatdan o&#39;tishda ro&#39;yxatdan o&#39;tgan kurslardan har bir talaba uchun tasdiqlanadi.
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103,Piecework,Perework
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71,Avg. Buying Rate,Ort Xarid qilish darajasi
 DocType: Task,Actual Time (in Hours),Haqiqiy vaqt (soati)
 DocType: Employee,History In Company,Kompaniya tarixida
 apps/erpnext/erpnext/config/learn.py +107,Newsletters,Axborotnomalar
 DocType: Drug Prescription,Description/Strength,Tavsif / kuch
 DocType: Stock Ledger Entry,Stock Ledger Entry,Qimmatli qog&#39;ozlar bazasini kiritish
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +82,Same item has been entered multiple times,Xuddi shu element bir necha marta kiritilgan
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83,Same item has been entered multiple times,Xuddi shu element bir necha marta kiritilgan
 DocType: Department,Leave Block List,Bloklar ro&#39;yxatini qoldiring
-DocType: Sales Invoice,Tax ID,Soliq identifikatori
+DocType: Purchase Invoice,Tax ID,Soliq identifikatori
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192,Item {0} is not setup for Serial Nos. Column must be blank,{0} elementi ketma-ketlik uchun sozlanmagan. Ustun bo&#39;sh bo&#39;lishi kerak
 DocType: Accounts Settings,Accounts Settings,Hisob sozlamalari
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +38,Approve,Tasdiqlang
-apps/erpnext/erpnext/schools/doctype/assessment_result_tool/assessment_result_tool.js +149,No Result to submit,Yuborish uchun natija yo&#39;q
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11,Approve,Tasdiqlang
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +51,"Malformatted address for {0}, please fix to continue.","{0} uchun noto&#39;g&#39;ri manzil, davom etish uchun tuzatishni iltimos qiling."
+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","Yangi hisob raqami, u old nomdagi hisob nomiga kiritiladi"
+DocType: Maintenance Team Member,Team Member,Jamoa a&#39;zosi
+apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151,No Result to submit,Yuborish uchun natija yo&#39;q
 DocType: Customer,Sales Partner and Commission,Savdo hamkori va komissiyasi
 DocType: Employee Loan,Rate of Interest (%) / Year,Foiz stavkasi (%) / yil
 ,Project Quantity,Loyiha miqdori
 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'","Barcha elementlar uchun {0} nolga teng bo&#39;lsa, siz &quot;Distribute Charges Based On&quot;"
 DocType: Opportunity,To Discuss,Muhokama qilish
-apps/erpnext/erpnext/stock/stock_ledger.py +368,{0} units of {1} needed in {2} to complete this transaction.,Ushbu amalni bajarish uchun {2} da {1} {1} kerak.
+apps/erpnext/erpnext/stock/stock_ledger.py +375,{0} units of {1} needed in {2} to complete this transaction.,Ushbu amalni bajarish uchun {2} da {1} {1} kerak.
 DocType: Loan Type,Rate of Interest (%) Yearly,Foiz stavkasi (%) Yillik
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71,Temporary Accounts,Vaqtinchalik hisob qaydnomalari
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +203,Black,Qora
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207,Black,Qora
 DocType: BOM Explosion Item,BOM Explosion Item,BOM portlash elementi
 DocType: Account,Auditor,Auditor
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +132,{0} items produced,{0} mahsulot ishlab chiqarildi
 apps/erpnext/erpnext/utilities/user_progress.py +55,Learn More,Ko&#39;proq ma&#39;lumot olish
 DocType: Cheque Print Template,Distance from top edge,Yuqori tomondan masofa
-apps/erpnext/erpnext/stock/get_item_details.py +317,Price List {0} is disabled or does not exist,Narxlar ro&#39;yxati {0} o&#39;chirib qo&#39;yilgan yoki mavjud emas
+apps/erpnext/erpnext/stock/get_item_details.py +360,Price List {0} is disabled or does not exist,Narxlar ro&#39;yxati {0} o&#39;chirib qo&#39;yilgan yoki mavjud emas
 DocType: Purchase Invoice,Return,Qaytish
 DocType: Production Order Operation,Production Order Operation,Buyurtmaning ishlab chiqarilishi
 DocType: Pricing Rule,Disable,O&#39;chirish
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +161,Mode of payment is required to make a payment,To&#39;lovni amalga oshirish uchun to&#39;lov shakli talab qilinadi
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +186,Mode of payment is required to make a payment,To&#39;lovni amalga oshirish uchun to&#39;lov shakli talab qilinadi
 DocType: Project Task,Pending Review,Ko&#39;rib chiqishni kutish
+apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14,"Edit in full page for more options like assets, serial nos, batches etc.","Aktivlar, ketma-ket noslar, partiyalar va h.k. kabi qo&#39;shimcha variantlar uchun to&#39;liq sahifada tahrir qiling."
 apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10,Appointments and Consultations,Uchrashuvlar va maslahatlar
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +41,{0} - {1} is not enrolled in the Batch {2},{0} - {1} Batch {2} ga kiritilmagan
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +113,"Asset {0} cannot be scrapped, as it is already {1}",{0} obyekti allaqachon {1}
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41,{0} - {1} is not enrolled in the Batch {2},{0} - {1} Batch {2} ga kiritilmagan
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113,"Asset {0} cannot be scrapped, as it is already {1}",{0} obyekti allaqachon {1}
 DocType: Task,Total Expense Claim (via Expense Claim),Jami xarajatlar bo&#39;yicha da&#39;vo (mablag &#39;to&#39;lovi bo&#39;yicha)
 apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177,Mark Absent,Mark Luqo Absent
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40,Failed to setup company,Kompaniya o&#39;rnatilmadi
+DocType: Asset Repair,Asset Repair,Aktivlarni ta&#39;mirlash
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +140,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Row {0}: BOM # {1} valyutasi tanlangan valyutaga teng bo&#39;lishi kerak {2}
 DocType: Journal Entry Account,Exchange Rate,Valyuta kursi
 DocType: Patient,Additional information regarding the patient,Bemor haqida qo&#39;shimcha ma&#39;lumot
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +575,Sales Order {0} is not submitted,Savdo Buyurtma {0} yuborilmadi
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +579,Sales Order {0} is not submitted,Savdo Buyurtma {0} yuborilmadi
 DocType: Homepage,Tag Line,Tag qatori
 DocType: Fee Component,Fee Component,Narxlar komponenti
-apps/erpnext/erpnext/config/hr.py +199,Fleet Management,Filo boshqarish
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +939,Add items from,Narsalarni qo&#39;shish
+apps/erpnext/erpnext/config/hr.py +204,Fleet Management,Filo boshqarish
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +964,Add items from,Narsalarni qo&#39;shish
+apps/erpnext/erpnext/config/agriculture.py +7,Crops & Lands,O&#39;simliklar va erlar
 DocType: Cheque Print Template,Regular,Muntazam
-apps/erpnext/erpnext/schools/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Barcha baholash mezonlarining umumiy vazni 100%
+DocType: Fertilizer,Density (if liquid),Zichlik (suyuqlik bo&#39;lsa)
+apps/erpnext/erpnext/education/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Barcha baholash mezonlarining umumiy vazni 100%
 DocType: Purchase Order Item,Last Purchase Rate,Oxirgi xarid qiymati
 DocType: Account,Asset,Asset
 DocType: Project Task,Task ID,Vazifa identifikatori
@@ -4293,29 +4598,33 @@
 DocType: Training Event,Contact Number,Aloqa raqami
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0} does not exist,{0} ombori mavjud emas
 DocType: Monthly Distribution,Monthly Distribution Percentages,Oylik tarqatish foizi
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +37,The selected item cannot have Batch,Tanlangan elementda partiyalar mavjud emas
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +38,The selected item cannot have Batch,Tanlangan elementda partiyalar mavjud emas
 DocType: Delivery Note,% of materials delivered against this Delivery Note,Ushbu etkazib berish eslatmasiga etkazilgan materiallarning%
-DocType: Training Event,Has Certificate,Sertifikatga ega
+DocType: Asset Maintenance Log,Has Certificate,Sertifikatga ega
 DocType: Project,Customer Details,Xaridorlar uchun ma&#39;lumot
+DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,Assotsiatsiya profilaktik xizmat yoki kalibrlashni talab qiladimi-yo&#39;qligini tekshiring
 DocType: Employee,Reports to,Hisobotlar
 ,Unpaid Expense Claim,To&#39;lanmagan to&#39;lov xarajatlari
 DocType: Payment Entry,Paid Amount,To&#39;langan pul miqdori
-apps/erpnext/erpnext/utilities/user_progress.py +137,Explore Sales Cycle,Sotish tsiklini o&#39;rganing
+apps/erpnext/erpnext/utilities/user_progress.py +155,Explore Sales Cycle,Sotish tsiklini o&#39;rganing
 DocType: Assessment Plan,Supervisor,Boshqaruvchi
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +73,Online,Onlaynda
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +70,Online,Onlaynda
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +867,Retention Stock Entry,Saqlash fondini kiritish
 ,Available Stock for Packing Items,Paket buyumlari mavjud
 DocType: Item Variant,Item Variant,Variant variantlari
 DocType: Assessment Result Tool,Assessment Result Tool,Ko&#39;rib natijasi vositasi
 DocType: BOM Scrap Item,BOM Scrap Item,BOM Hurdası mahsulotlari
-apps/erpnext/erpnext/accounts/page/pos/pos.js +871,Submitted orders can not be deleted,Berilgan buyurtmalarni o&#39;chirib bo&#39;lmaydi
-apps/erpnext/erpnext/accounts/doctype/account/account.py +117,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Debet-da hisob balansi mavjud bo&#39;lsa, sizda &quot;Balance Must Be&quot; (&quot;Balans Must Be&quot;) &quot;Credit&quot;"
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +114,Quality Management,Sifat menejmenti
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +41,Item {0} has been disabled,{0} mahsuloti o&#39;chirib qo&#39;yildi
+apps/erpnext/erpnext/accounts/page/pos/pos.js +886,Submitted orders can not be deleted,Berilgan buyurtmalarni o&#39;chirib bo&#39;lmaydi
+apps/erpnext/erpnext/accounts/doctype/account/account.py +116,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Debet-da hisob balansi mavjud bo&#39;lsa, sizda &quot;Balance Must Be&quot; (&quot;Balans Must Be&quot;) &quot;Credit&quot;"
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118,Quality Management,Sifat menejmenti
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +41,Item {0} has been disabled,{0} mahsuloti o&#39;chirib qo&#39;yildi
+DocType: Project,Total Billable Amount (via Timesheets),Jami to&#39;lov miqdori (vaqt jadvallari orqali)
+DocType: Agriculture Task,Previous Business Day,Avvalgi ish kuni
 DocType: Employee Loan,Repay Fixed Amount per Period,Davr uchun belgilangan miqdorni to&#39;lash
 apps/erpnext/erpnext/buying/utils.py +47,Please enter quantity for Item {0},"Iltimos, {0} mahsulot uchun miqdorni kiriting"
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +78,Credit Note Amt,Kredit eslatma
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +89,Credit Note Amt,Kredit eslatma
 DocType: Employee External Work History,Employee External Work History,Xodimning tashqi ish tarixi
-DocType: Tax Rule,Purchase,Sotib olish
+DocType: Opening Invoice Creation Tool,Purchase,Sotib olish
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,Balans miqdori
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20,Goals cannot be empty,Maqsadlar bo&#39;sh bo&#39;lishi mumkin emas
 DocType: Item Group,Parent Item Group,Ota-ona guruhi
@@ -4323,23 +4632,25 @@
 apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{1} uchun {0}
 DocType: Healthcare Settings,Valid number of days,To&#39;g&#39;ri kunlar soni
 apps/erpnext/erpnext/setup/doctype/company/company.js +35,Cost Centers,Xarajat markazlari
+DocType: Land Unit,Linked Plant Analysis,Bog&#39;langan o&#39;simlik tahlili
 DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,Ta&#39;minlovchining valyutasi qaysi kompaniyaning asosiy valyutasiga aylantiriladigan darajasi
 apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},# {0} satr: vaqt {1} qatori bilan zid
 DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Nolinchi baholash darajasiga ruxsat berish
 DocType: Training Event Employee,Invited,Taklif etilgan
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +177,Multiple active Salary Structures found for employee {0} for the given dates,Berilgan sana uchun xodim {0} uchun bir nechta faol ish haqi tuzilmasi topildi
-apps/erpnext/erpnext/config/accounts.py +316,Setup Gateway accounts.,Gateway hisoblarini sozlash.
+apps/erpnext/erpnext/config/accounts.py +308,Setup Gateway accounts.,Gateway hisoblarini sozlash.
 DocType: Employee,Employment Type,Bandlik turi
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42,Fixed Assets,Asosiy vositalar
 DocType: Payment Entry,Set Exchange Gain / Loss,Exchange Gain / Lossni o&#39;rnatish
 ,GST Purchase Register,GST Xarid qilish Register
 ,Cash Flow,Pul muomalasi
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +92,Application period cannot be across two alocation records,Ilova davri ikki daftar yozuvi bo&#39;yicha bo&#39;lishi mumkin emas
+apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25,Combined invoice portion must equal 100%,Qo&#39;shma hisob-faktura qismi 100%
 DocType: Item Group,Default Expense Account,Standart xarajat hisob
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,Isoning shogirdi Email identifikatori
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,Isoning shogirdi Email identifikatori
 DocType: Employee,Notice (days),Izoh (kun)
 DocType: Tax Rule,Sales Tax Template,Savdo bo&#39;yicha soliq jadvalini
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2448,Select items to save the invoice,Billingni saqlash uchun elementlarni tanlang
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2467,Select items to save the invoice,Billingni saqlash uchun elementlarni tanlang
 DocType: Employee,Encashment Date,Inkassatsiya sanasi
 DocType: Training Event,Internet,Internet
 DocType: Special Test Template,Special Test Template,Maxsus test shablonni
@@ -4349,6 +4660,7 @@
 DocType: Academic Term,Term Start Date,Yil boshlanish sanasi
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Opp Count
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +242,Please find attached {0} #{1},"Iltimos, iltimos, {0} # {1}"
+apps/erpnext/erpnext/controllers/accounts_controller.py +701,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,To&#39;lov tarifidagi umumiy to&#39;lov miqdori Grand / Rounded Totalga teng bo&#39;lishi kerak
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,Bank Bosh balansidagi balans balansi
 DocType: Job Applicant,Applicant Name,Ariza beruvchi nomi
 DocType: Authorization Rule,Customer / Item Name,Xaridor / Mahsulot nomi
@@ -4362,6 +4674,7 @@
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42,Serial No is mandatory for Item {0},Serial No {0} uchun majburiy emas
 DocType: Item Variant Attribute,Attribute,Xususiyat
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43,Please specify from/to range,"Marhamat, tanlang"
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28,Opening {0} Invoice created,{0} ochilgan hisob-faktura
 DocType: Serial No,Under AMC,AMC ostida
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55,Item valuation rate is recalculated considering landed cost voucher amount,Tovarlarni baholash darajasi tushirilgan narx-kvot miqdorini inobatga olgan holda qayta hisoblab chiqiladi
 apps/erpnext/erpnext/config/selling.py +153,Default settings for selling transactions.,Jurnallarni sotish uchun standart sozlamalar.
@@ -4373,53 +4686,57 @@
 apps/erpnext/erpnext/config/support.py +22,Warranty,Kafolat
 DocType: Purchase Invoice,Debit Note Issued,Debet notasi chiqarildi
 DocType: Production Order,Warehouses,Omborlar
-apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} aktivni o&#39;tkazish mumkin emas
-apps/erpnext/erpnext/stock/doctype/item/item.js +66,This Item is a Variant of {0} (Template).,Ushbu element {0} ning bir variantidir (Andoza).
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} aktivni o&#39;tkazish mumkin emas
+apps/erpnext/erpnext/stock/doctype/item/item.js +80,This Item is a Variant of {0} (Template).,Ushbu element {0} ning bir variantidir (Andoza).
 DocType: Workstation,per hour,soatiga
 apps/erpnext/erpnext/config/buying.py +7,Purchasing,Xarid qilish
 DocType: Announcement,Announcement,E&#39;lon
-DocType: School Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",Partiyalarga asoslangan talabalar guruhi uchun Talabalar partiyasi dasturni ro&#39;yxatga olishdan har bir talaba uchun tasdiqlanadi.
+DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",Partiyalarga asoslangan talabalar guruhi uchun Talabalar partiyasi dasturni ro&#39;yxatga olishdan har bir talaba uchun tasdiqlanadi.
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +51,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Ushbu ombor uchun kabinetga hisob yozuvi mavjud bo&#39;lib, omborni o&#39;chirib bo&#39;lmaydi."
-DocType: Company,Distribution,Tarqatish
+apps/erpnext/erpnext/public/js/setup_wizard.js +25,Distribution,Tarqatish
+DocType: Expense Claim Advance,Expense Claim Advance,Xarajatlar bo&#39;yicha da&#39;vo Advance
 DocType: Lab Test,Report Preference,Hisobot afzalligi
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +129,Project Manager,Proyekt menejeri
+apps/erpnext/erpnext/config/non_profit.py +43,Volunteer information.,Ixtiyoriy ma&#39;lumot.
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133,Project Manager,Proyekt menejeri
 ,Quoted Item Comparison,Qisqartirilgan ob&#39;ektni solishtirish
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34,Overlap in scoring between {0} and {1},{0} va {1} orasida
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +110,Dispatch,Dispetcher
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114,Dispatch,Dispetcher
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +73,Max discount allowed for item: {0} is {1}%,Element uchun ruxsat etilgan maksimal chegirma: {0} {1}%
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +173,Net Asset value as on,Net aktiv qiymati
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176,Net Asset value as on,Net aktiv qiymati
+DocType: Crop,Produce,Mahsulot
 DocType: Account,Receivable,Oladigan
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +288,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,"Row # {0}: Yetkazib beruvchini Xarid qilish tartibi sifatida o&#39;zgartirishga ruxsat yo&#39;q, allaqachon mavjud"
+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}: Yetkazib beruvchini Xarid qilish tartibi sifatida o&#39;zgartirishga ruxsat yo&#39;q, allaqachon mavjud"
 DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,Kredit limitlarini oshib ketadigan bitimlar taqdim etishga ruxsat berilgan rol.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +929,Select Items to Manufacture,Mahsulotni tayyorlash buyrug&#39;ini tanlang
-apps/erpnext/erpnext/accounts/page/pos/pos.js +939,"Master data syncing, it might take some time","Magistr ma&#39;lumotlarini sinxronlash, biroz vaqt talab qilishi mumkin"
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +978,Select Items to Manufacture,Mahsulotni tayyorlash buyrug&#39;ini tanlang
+DocType: Delivery Stop,Delivery Stop,Yetkazib berish to&#39;xtashi
+apps/erpnext/erpnext/accounts/page/pos/pos.js +954,"Master data syncing, it might take some time","Magistr ma&#39;lumotlarini sinxronlash, biroz vaqt talab qilishi mumkin"
 DocType: Item,Material Issue,Moddiy muammolar
 DocType: Employee Education,Qualification,Malakali
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +40,View Salary Slips,Ish haqi tovushlarini ko&#39;rish
 DocType: Item Price,Item Price,Mahsulot narxi
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +48,Soap & Detergent,Sovun va detarjen
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48,Soap & Detergent,Sovun va detarjen
 DocType: BOM,Show Items,Ma&#39;lumotlar ko&#39;rsatish
-apps/erpnext/erpnext/schools/doctype/course_schedule/course_schedule.py +30,From Time cannot be greater than To Time.,Vaqtdan Vaqtga qaraganda Kattaroq bo&#39;la olmaydi.
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +36,Motion Picture & Video,Motion Picture &amp; Video
+apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30,From Time cannot be greater than To Time.,Vaqtdan Vaqtga qaraganda Kattaroq bo&#39;la olmaydi.
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +74,Do you want to notify all the customers by email?,Barcha mijozlarni elektron pochta orqali xabardor qilishni xohlaysizmi?
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36,Motion Picture & Video,Motion Picture &amp; Video
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Buyurtma qilingan
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51,Resume,Rezyume; qayta boshlash
-DocType: Item Variant Settings,If enabled then system will not update the fields of variants from the template but will copy the data of below mentioned fields while making new variant,"Agar yoqilgan bo&#39;lsa, tizim shablondan varianti maydonlarini yangilamaydi, ammo yangi variantni yaratishda quyidagi maydonlardan ma&#39;lumotlarni ko&#39;chirib oladi"
 DocType: Salary Detail,Component,Komponent
 DocType: Assessment Criteria,Assessment Criteria Group,Baholash mezonlari guruhi
 DocType: Healthcare Settings,Patient Name By,Bemor nomi
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +72,Opening Accumulated Depreciation must be less than equal to {0},Yig&#39;ilgan Amortizatsiyani ochish {0} ga teng bo&#39;lishi kerak.
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +72,Opening Accumulated Depreciation must be less than equal to {0},Yig&#39;ilgan Amortizatsiyani ochish {0} ga teng bo&#39;lishi kerak.
 DocType: Warehouse,Warehouse Name,Ombor nomi
 DocType: Naming Series,Select Transaction,Jurnalni tanlang
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,"Iltimos, rozni rozilikni kiriting yoki foydalanuvchini tasdiqlang"
 DocType: Journal Entry,Write Off Entry,Yozuvni yozing
 DocType: BOM,Rate Of Materials Based On,Materiallar asoslari
-DocType: Item Variant Settings,Do not Update Variants,Varyantlarni yangilang
 apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Analytics-ni qo&#39;llab-quvvatlash
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +142,Uncheck all,Barchasini olib tashlang
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102,Uncheck all,Barchasini olib tashlang
 DocType: POS Profile,Terms and Conditions,Foydalanish shartlari
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49,To Date should be within the Fiscal Year. Assuming To Date = {0},Sana uchun moliyaviy yil ichida bo&#39;lishi kerak. Halihazırda = {0}
 DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Bu erda siz balandlik, og&#39;irlik, allergiya, tibbiy xavotir va h.k.larni saqlashingiz mumkin"
 DocType: Leave Block List,Applies to Company,Kompaniya uchun amal qiladi
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +202,Cannot cancel because submitted Stock Entry {0} exists,"Bekor qilolmaysiz, chunki taqdim etilgan Stock Entry {0} mavjud"
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +222,Cannot cancel because submitted Stock Entry {0} exists,"Bekor qilolmaysiz, chunki taqdim etilgan Stock Entry {0} mavjud"
 DocType: Employee Loan,Disbursement Date,To&#39;lov sanasi
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80,'Recipients' not specified,&#39;Qabul qiluvchilar&#39; ko&#39;rsatilmagan
 DocType: BOM Update Tool,Update latest price in all BOMs,Barcha BOMlarda oxirgi narxni yangilang
@@ -4428,43 +4745,52 @@
 DocType: Purchase Invoice,In Words,So&#39;zlarda
 apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15,{0} must be submitted,{0} yuborilishi kerak
 DocType: POS Profile,Item Groups,Mavzu guruhlari
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +217,Today is {0}'s birthday!,Bugun {0} tug&#39;ilgan kun!
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +221,Today is {0}'s birthday!,Bugun {0} tug&#39;ilgan kun!
 DocType: Production Planning Tool,Material Request For Warehouse,Ombor uchun materiallar talabi
 DocType: Sales Order Item,For Production,Ishlab chiqarish uchun
 DocType: Payment Request,payment_url,to&#39;lov_url
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +163,Please add a Temporary Opening account in Chart of Accounts,"Iltimos, Hisoblar jadvalida vaqtinchalik ochilish hisobini qo&#39;shing"
+DocType: Customer,Customer Primary Contact,Birlamchi mijoz bilan aloqa
 DocType: Project Task,View Task,Vazifani ko&#39;ring
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Opp / Lead%
 DocType: Material Request,MREQ-,MREQ-
+DocType: Payment Schedule,Invoice Portion,Billing qismi
 ,Asset Depreciations and Balances,Assotsiatsiyalangan amortizatsiya va balans
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +356,Amount {0} {1} transferred from {2} to {3},{0} {1} miqdori {2} dan {3}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +357,Amount {0} {1} transferred from {2} to {3},{0} {1} miqdori {2} dan {3}
 DocType: Sales Invoice,Get Advances Received,Qabul qilingan avanslar oling
 DocType: Email Digest,Add/Remove Recipients,Qabul qiluvchilarni qo&#39;shish / o&#39;chirish
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +461,Transaction not allowed against stopped Production Order {0},Jarayon to&#39;xtatilgan ishlab chiqarish buyurtmasi bo&#39;yicha ruxsat etilmagan {0}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +486,Transaction not allowed against stopped Production Order {0},Jarayon to&#39;xtatilgan ishlab chiqarish buyurtmasi bo&#39;yicha ruxsat etilmagan {0}
 apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'",Ushbu moliyaviy yilni &quot;Standart&quot; deb belgilash uchun &quot;Default as default&quot; -ni bosing
-apps/erpnext/erpnext/projects/doctype/project/project.py +205,Join,Ishtirok etish
+apps/erpnext/erpnext/projects/doctype/project/project.py +216,Join,Ishtirok etish
 apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +20,Shortage Qty,Miqdori miqdori
-apps/erpnext/erpnext/stock/doctype/item/item.py +699,Item variant {0} exists with same attributes,{0} mahsulot varianti bir xil xususiyatlarga ega
+apps/erpnext/erpnext/stock/doctype/item/item.py +645,Cannot change Variant properties after stock transction. You will have to make a new Item to do this.,Birja transkripsiyasidan keyin Variant xususiyatlarini o&#39;zgartirib bo&#39;lmaydi. Buning uchun yangi mahsulotni yaratish kerak bo&#39;ladi.
+apps/erpnext/erpnext/stock/doctype/item/item.py +685,Item variant {0} exists with same attributes,{0} mahsulot varianti bir xil xususiyatlarga ega
 DocType: Employee Loan,Repay from Salary,Ish haqidan to&#39;lash
 DocType: Leave Application,LAP/,LAP /
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +347,Requesting payment against {0} {1} for amount {2},{0} {1} dan {2}
 DocType: Salary Slip,Salary Slip,Ish haqi miqdori
 DocType: Lead,Lost Quotation,Yo&#39;qotilgan taklif
-apps/erpnext/erpnext/utilities/user_progress.py +200,Student Batches,Talaba to&#39;rlari
+apps/erpnext/erpnext/utilities/user_progress.py +218,Student Batches,Talaba to&#39;rlari
 DocType: Pricing Rule,Margin Rate or Amount,Margin darajasi yoki miqdori
 apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48,'To Date' is required,&quot;Sana uchun&quot; so&#39;raladi
 DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Etkazib beriladigan paketlar uchun paketli sliplarni yarating. Paket raqamini, paketini va uning og&#39;irligini xabar qilish uchun ishlatiladi."
 DocType: Sales Invoice Item,Sales Order Item,Savdo Buyurtma Buyurtma
 DocType: Salary Slip,Payment Days,To&#39;lov kunlari
+DocType: Stock Settings,Convert Item Description to Clean HTML,HTMLni tozalash uchun Mavzu tavsifini o&#39;zgartiring
 DocType: Patient,Dormant,Kutilmaganda
+DocType: Salary Slip,Total Interest Amount,Foiz miqdori
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +125,Warehouses with child nodes cannot be converted to ledger,Bolalar noduslari joylashgan omborlar kitobga o&#39;tkazilmaydi
 DocType: BOM,Manage cost of operations,Amaliyot xarajatlarini boshqaring
 DocType: Accounts Settings,Stale Days,Eski kunlar
 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.","Belgilangan tranzaktsiyalardan biri &quot;yuborilgan&quot; bo&#39;lsa, tranzaksiya bilan qo&#39;shimcha qilib, ushbu operatsiyada tegishli &quot;Kontakt&quot; ga elektron pochta yuborish uchun elektron pochta pop-up avtomatik ravishda ochiladi. Foydalanuvchi e-pochtani yuborishi yoki olmasligi mumkin."
 apps/erpnext/erpnext/config/setup.py +14,Global Settings,Global sozlamalar
+DocType: Crop,Row Spacing UOM,Qator oralig&#39;i UOM
 DocType: Assessment Result Detail,Assessment Result Detail,Ko&#39;rib natijasi batafsil
 DocType: Employee Education,Employee Education,Xodimlarni o&#39;qitish
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +48,Duplicate item group found in the item group table,Elementlar guruhi jadvalida topilgan nusxalash elementlari guruhi
-apps/erpnext/erpnext/public/js/controllers/transaction.js +965,It is needed to fetch Item Details.,Ma&#39;lumotlar ma&#39;lumotlarini olish kerak.
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53,Duplicate item group found in the item group table,Elementlar guruhi jadvalida topilgan nusxalash elementlari guruhi
+DocType: Land Unit,Parent Land Unit,Ota-ona uchastkasi
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1045,It is needed to fetch Item Details.,Ma&#39;lumotlar ma&#39;lumotlarini olish kerak.
+DocType: Fertilizer,Fertilizer Name,Go&#39;ng nomi
 DocType: Salary Slip,Net Pay,Net to&#39;lov
 DocType: Account,Account,Hisob
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217,Serial No {0} has already been received,No {0} seriyali allaqachon qabul qilingan
@@ -4472,49 +4798,54 @@
 DocType: Expense Claim,Vehicle Log,Avtomobil logi
 DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),Isitmaning mavjudligi (temp&gt; 38.5 ° C / 101.3 ° F yoki doimiy temp&gt; 38 ° C / 100.4 ° F)
 DocType: Customer,Sales Team Details,Savdo jamoasining tafsilotlari
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1326,Delete permanently?,Doimiy o&#39;chirilsinmi?
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1341,Delete permanently?,Doimiy o&#39;chirilsinmi?
 DocType: Expense Claim,Total Claimed Amount,Jami da&#39;vo miqdori
 apps/erpnext/erpnext/config/crm.py +17,Potential opportunities for selling.,Sotish uchun potentsial imkoniyatlar.
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +228,Invalid {0},Noto&#39;g&#39;ri {0}
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +86,Sick Leave,Yuqumli kasalliklar
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90,Sick Leave,Yuqumli kasalliklar
 DocType: Email Digest,Email Digest,E-pochtaning elektron ko&#39;rinishi
 DocType: Delivery Note,Billing Address Name,To&#39;lov manzili nomi
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +22,Department Stores,Savdo do&#39;konlari
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22,Department Stores,Savdo do&#39;konlari
 ,Item Delivery Date,Mahsulotni etkazib berish sanasi
 DocType: Warehouse,PIN,PIN-kod
-apps/erpnext/erpnext/setup/setup_wizard/sample_data.py +110,Setup your School in ERPNext,Maktabingizni ERP-matnida sozlang
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +125,Error '{0}' occured. Arguments {1}.,&#39;{0}&#39; xatosi yuz berdi. Argumentlar {1}.
 DocType: Sales Invoice,Base Change Amount (Company Currency),Boz almashtirish miqdori (Kompaniya valyutasi)
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304,No accounting entries for the following warehouses,Quyidagi omborlar uchun buxgalteriya yozuvlari mavjud emas
 apps/erpnext/erpnext/projects/doctype/project/project.js +111,Save the document first.,Avval hujjatni yozib oling.
+apps/erpnext/erpnext/shopping_cart/cart.py +71,Only {0} in stock for item {1},{1} element uchun faqat {0}
 DocType: Account,Chargeable,To&#39;lanishi mumkin
 DocType: Company,Change Abbreviation,Qisqartishni o&#39;zgartiring
 DocType: Expense Claim Detail,Expense Date,Xarajat sanasi
 DocType: Item,Max Discount (%),Maksimal chegirma (%)
+apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30,Credit Days cannot be a negative number,Kredit kuni salbiy raqam bo&#39;lishi mumkin emas
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Oxirgi Buyurtma miqdori
+apps/erpnext/erpnext/stock/doctype/item/item.py +264," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Saqlash saqlab qoling, omborga asoslangan"
 DocType: Task,Is Milestone,Milestone
-DocType: Daily Work Summary,Email Sent To,E - mail yuborildi
+DocType: Delivery Stop,Email Sent To,E - mail yuborildi
 DocType: Budget,Warn,Ogoh bo&#39;ling
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +81,Are you sure you want to unregister?,Siz ro&#39;yxatdan o&#39;tkazishni xohlaysizmi?
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Boshqa yozuvlar, yozuvlardagi diqqat-e&#39;tiborli harakatlar."
-DocType: BOM,Manufacturing User,Ishlab chiqarish foydalanuvchisi
+DocType: Asset Maintenance,Manufacturing User,Ishlab chiqarish foydalanuvchisi
 DocType: Purchase Invoice,Raw Materials Supplied,Xom-ashyo etkazib berildi
 DocType: C-Form,Series,Series
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +270,Currency of the price list {0} must be {1} or {2},Narxlar ro&#39;yxatining {0} valyutasi {1} yoki {2}
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +273,Currency of the price list {0} must be {1} or {2},Narxlar ro&#39;yxatining {0} valyutasi {1} yoki {2}
 DocType: Appraisal,Appraisal Template,Baholash shabloni
+DocType: Soil Texture,Ternary Plot,Ternary uchastkasi
 DocType: Item Group,Item Classification,Mavzu tasnifi
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +127,Business Development Manager,Ish oshirish menejeri
+DocType: Driver,License Number,Litsenziya raqami
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131,Business Development Manager,Ish oshirish menejeri
 DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Xizmat tashrif maqsadi
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19,Invoice Patient Registration,Billingni ro&#39;yxatdan o&#39;tkazish
-DocType: Drug Prescription,Period,Davr
+DocType: Crop,Period,Davr
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +18,General Ledger,Umumiy Buxgalteriya
 apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Ko&#39;rsatmalarini ko&#39;rish
 DocType: Program Enrollment Tool,New Program,Yangi dastur
 DocType: Item Attribute Value,Attribute Value,Xususiyat bahosi
 ,Itemwise Recommended Reorder Level,Tavsiya etilgan buyurtmaning darajasi
 DocType: Salary Detail,Salary Detail,Ish haqi bo&#39;yicha batafsil
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1017,Please select {0} first,Avval {0} ni tanlang
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1043,Please select {0} first,Avval {0} ni tanlang
 DocType: Appointment Type,Physician,Shifokor
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +804,Batch {0} of Item {1} has expired.,{1} banddagi {0} guruhining amal qilish muddati tugadi.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +833,Batch {0} of Item {1} has expired.,{1} banddagi {0} guruhining amal qilish muddati tugadi.
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11,Consultations,Maslahatlar
 DocType: Sales Invoice,Commission,Komissiya
 apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Ishlab chiqarish uchun vaqt jadvalini.
@@ -4525,7 +4856,7 @@
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +93,Warehouse not found in the system,Tizimda mavjud bo&#39;lmagan ombor
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115,This Month's Summary,Ushbu oyning qisqacha bayoni
 DocType: Quality Inspection Reading,Quality Inspection Reading,Sifatni tekshirishni o&#39;qish
-apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +24,`Freeze Stocks Older Than` should be smaller than %d days.,&quot;Freeze Stocks Older&quot; dan kamida% d kun bo&#39;lishi kerak.
+apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25,`Freeze Stocks Older Than` should be smaller than %d days.,&quot;Freeze Stocks Older&quot; dan kamida% d kun bo&#39;lishi kerak.
 DocType: Tax Rule,Purchase Tax Template,Xarid qilish shablonini sotib oling
 apps/erpnext/erpnext/utilities/user_progress.py +45,Set a sales goal you'd like to achieve for your company.,Sizning kompaniya uchun erishmoqchi bo&#39;lgan savdo maqsadini belgilang.
 ,Project wise Stock Tracking,Loyihani oqilona kuzatish
@@ -4533,42 +4864,50 @@
 apps/erpnext/erpnext/config/healthcare.py +40,Laboratory,Laboratoriya
 DocType: Stock Entry Detail,Actual Qty (at source/target),Haqiqiy Miqdor (manba / maqsadda)
 DocType: Item Customer Detail,Ref Code,Qayta kod
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +66,Customer Group is Required in POS Profile,Qalin profilda mijozlar guruhi talab qilinadi
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +71,Customer Group is Required in POS Profile,Qalin profilda mijozlar guruhi talab qilinadi
 apps/erpnext/erpnext/config/hr.py +12,Employee records.,Xodimlarning yozuvlari.
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +92,Please set Next Depreciation Date,"Iltimos, keyingi Amortizatsiya sanasini belgilang"
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +92,Please set Next Depreciation Date,"Iltimos, keyingi Amortizatsiya sanasini belgilang"
 DocType: HR Settings,Payroll Settings,Bordro Sozlamalari
-apps/erpnext/erpnext/config/accounts.py +154,Match non-linked Invoices and Payments.,Bog&#39;langan bo&#39;lmagan Xarajatlar va To&#39;lovlar bilan bog&#39;lang.
+apps/erpnext/erpnext/config/accounts.py +146,Match non-linked Invoices and Payments.,Bog&#39;langan bo&#39;lmagan Xarajatlar va To&#39;lovlar bilan bog&#39;lang.
 DocType: POS Settings,POS Settings,Qalin sozlamalari
 apps/erpnext/erpnext/templates/pages/cart.html +16,Place Order,Buyurtmani joylashtiring
 DocType: Email Digest,New Purchase Orders,Yangi sotib olish buyurtmalari
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24,Root cannot have a parent cost center,Ildiz ota-ona xarajatlari markaziga ega bo&#39;lmaydi
 apps/erpnext/erpnext/public/js/stock_analytics.js +57,Select Brand...,Tovar belgisini tanlang ...
+apps/erpnext/erpnext/public/js/setup_wizard.js +32,Non Profit (beta),Non-foyda (beta)
 apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18,Training Events/Results,O&#39;quv mashg&#39;ulotlari / natijalari
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +149,Accumulated Depreciation as on,Yig&#39;ilgan Amortismanlar
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152,Accumulated Depreciation as on,Yig&#39;ilgan Amortismanlar
 DocType: Sales Invoice,C-Form Applicable,C-formasi amal qiladi
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +399,Operation Time must be greater than 0 for Operation {0},Operatsion vaqti {0} dan foydalanish uchun 0 dan katta bo&#39;lishi kerak
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +419,Operation Time must be greater than 0 for Operation {0},Operatsion vaqti {0} dan foydalanish uchun 0 dan katta bo&#39;lishi kerak
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +106,Warehouse is mandatory,QXI majburiydir
 DocType: Supplier,Address and Contacts,Manzil va Kontaktlar
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67,Failed to create website,Veb-sayt yaratilmadi
+DocType: Soil Analysis,Mg/K,Mg / K
 DocType: UOM Conversion Detail,UOM Conversion Detail,UOM ishlab chiqarish ma&#39;lumoti
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +922,Retention Stock Entry already created or Sample Quantity not provided,Ta&#39;minlangan aktsiyadorlik jamg&#39;armasi yaratilgan yoki taqlid miqdori berilmagan
 DocType: Program,Program Abbreviation,Dastur qisqartmasi
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +387,Production Order cannot be raised against a Item Template,Mahsulot shablonini ishlab chiqarish tartibi ko&#39;tarilmaydi
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +407,Production Order cannot be raised against a Item Template,Mahsulot shablonini ishlab chiqarish tartibi ko&#39;tarilmaydi
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52,Charges are updated in Purchase Receipt against each item,To&#39;lovlar har bir elementga nisbatan Buyurtmachnomada yangilanadi
 DocType: Warranty Claim,Resolved By,Qaror bilan
 DocType: Bank Guarantee,Start Date,Boshlanish vaqti
 apps/erpnext/erpnext/config/hr.py +75,Allocate leaves for a period.,Bir vaqtlar barglarini ajratib turing.
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Cheques and Deposits incorrectly cleared,Chexlar va depozitlar noto&#39;g&#39;ri tozalanadi
-apps/erpnext/erpnext/accounts/doctype/account/account.py +50,Account {0}: You can not assign itself as parent account,Hisob {0}: Siz uni yuqori hisob sifatida belgilashingiz mumkin emas
+apps/erpnext/erpnext/accounts/doctype/account/account.py +46,Account {0}: You can not assign itself as parent account,Hisob {0}: Siz uni yuqori hisob sifatida belgilashingiz mumkin emas
 DocType: Purchase Invoice Item,Price List Rate,Narxlar ro&#39;yxati darajasi
 apps/erpnext/erpnext/utilities/activation.py +72,Create customer quotes,Xaridor taklifini yarating
 DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",Ushbu omborda mavjud bo&#39;lgan &quot;Stoktaki&quot; yoki &quot;Stokta emas&quot; aksiyalarini ko&#39;rsatish.
 apps/erpnext/erpnext/config/manufacturing.py +38,Bill of Materials (BOM),Materiallar to&#39;plami (BOM)
 DocType: Item,Average time taken by the supplier to deliver,Yetkazib beruvchi etkazib beradigan o&#39;rtacha vaqt
 DocType: Sample Collection,Collected By,Yig&#39;ilganlar
-apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.js +22,Assessment Result,Baholash natijasi
+apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +22,Assessment Result,Baholash natijasi
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,Soatlar
 DocType: Project,Expected Start Date,Kutilayotgan boshlanish sanasi
+apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant Details Report,Variant tafsilotlari haqida hisobot
 DocType: Setup Progress Action,Setup Progress Action,O&#39;rnatish progress progress
+apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +18,Buying Price List,Narxlar ro&#39;yxatini sotib olish
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49,Remove item if charges is not applicable to that item,"Ushbu elementga to&#39;lovlar tegishli bo&#39;lmasa, elementni olib tashlang"
+apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21,Please select Maintenance Status as Completed or remove Completion Date,Marhamat qilib Xizmat Statusini Tugallangan yoki tugatish sanasini tanlang
+DocType: Supplier,Default Payment Terms Template,Standart to&#39;lov shartlari shabloni
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34,Transaction currency must be same as Payment Gateway currency,Jurnal valyutasi to&#39;lov shluzi valyutasi bilan bir xil bo&#39;lishi kerak
 DocType: Payment Entry,Receive,Oling
 apps/erpnext/erpnext/templates/pages/rfq.html +75,Quotations: ,Qo&#39;shtirnoq:
@@ -4578,20 +4917,20 @@
 DocType: Workstation,Operating Costs,Operatsion xarajatlar
 DocType: Budget,Action if Accumulated Monthly Budget Exceeded,Yig&#39;ilgan oylik byudjetdan oshiq bo&#39;lgan harakatlar
 DocType: Subscription,Submit on creation,Yaratishni topshirish
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +469,Currency for {0} must be {1},{0} uchun valyuta {1} bo&#39;lishi kerak
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +470,Currency for {0} must be {1},{0} uchun valyuta {1} bo&#39;lishi kerak
 DocType: Asset,Disposal Date,Chiqarish sanasi
 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.","Agar dam olishlari bo&#39;lmasa, elektron pochta xabarlari kompaniyaning barcha faol xodimlariga berilgan vaqtda yuboriladi. Javoblarning qisqacha bayoni yarim tunda yuboriladi."
 DocType: Employee Leave Approver,Employee Leave Approver,Xodimga taxminan yo&#39;l qo&#39;ying
-apps/erpnext/erpnext/stock/doctype/item/item.py +508,Row {0}: An Reorder entry already exists for this warehouse {1},Row {0}: Qayta buyurtmaning arizasi allaqachon {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +485,Row {0}: An Reorder entry already exists for this warehouse {1},Row {0}: Qayta buyurtmaning arizasi allaqachon {1}
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99,"Cannot declare as lost, because Quotation has been made.","Yo&#39;qotilgan deb e&#39;lon qilinmaydi, chunki takliflar qilingan."
 apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16,Training Feedback,Ta&#39;lim bo&#39;yicha fikr-mulohazalar
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +458,Production Order {0} must be submitted,Ishlab chiqarish Buyurtma {0} topshirilishi kerak
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +483,Production Order {0} must be submitted,Ishlab chiqarish Buyurtma {0} topshirilishi kerak
 DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Yetkazib beruvchi Kuzatuv Kriteri
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149,Please select Start Date and End Date for Item {0},"Iltimos, {0} uchun mahsulotning boshlanish sanasi va tugash sanasini tanlang"
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +55,Course is mandatory in row {0},Kurs {0} qatorida majburiydir.
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55,Course is mandatory in row {0},Kurs {0} qatorida majburiydir.
 apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16,To date cannot be before from date,Bugungi kunga qadar tarixdan oldin bo&#39;la olmaydi
 DocType: Supplier Quotation Item,Prevdoc DocType,Prevdoc DocType
-apps/erpnext/erpnext/stock/doctype/item/item.js +272,Add / Edit Prices,Narxlarni qo&#39;shish / tahrirlash
+apps/erpnext/erpnext/stock/doctype/item/item.js +268,Add / Edit Prices,Narxlarni qo&#39;shish / tahrirlash
 DocType: Batch,Parent Batch,Ota-ona partiyasi
 DocType: Cheque Print Template,Cheque Print Template,Chop shablonini tekshiring
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36,Chart of Cost Centers,Xarajat markazlari jadvali
@@ -4600,7 +4939,6 @@
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +655,My Orders,Mening buyurtmalarim
 DocType: Price List,Price List Name,Narhlar ro&#39;yxati nomi
 apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +32,Daily Work Summary for {0},{0} uchun kundalik ish xulosasi
-DocType: Employee Loan,Totals,Jami
 DocType: BOM,Manufacturing,Ishlab chiqarish
 ,Ordered Items To Be Delivered,Buyurtma qilingan narsalar taslim qilinadi
 DocType: Account,Income,Daromad
@@ -4610,127 +4948,140 @@
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +266,Sales Invoice {0} has already been submitted,Savdo shaxsi {0} allaqachon yuborilgan
 DocType: Supplier Scorecard Scoring Criteria,Score,Hisob
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,Moliyaviy yil {0} mavjud emas
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Completion Date,Tugatish sanasi
+DocType: Asset Maintenance Log,Completion Date,Tugatish sanasi
 DocType: Purchase Invoice Item,Amount (Company Currency),Miqdor (Kompaniya valyutasi)
+DocType: Crop,Agriculture User,Qishloq xo&#39;jaligi foydalanuvchisi
 apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38,Valid till date cannot be before transaction date,O&#39;tgan sanaga qadar amal qilish muddati tranzaksiya sanasidan oldin bo&#39;lishi mumkin emas
-apps/erpnext/erpnext/stock/stock_ledger.py +372,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,Ushbu bitimni bajarish uchun {1} {0} {2} da {3} {4} da {5} uchun kerak.
+apps/erpnext/erpnext/stock/stock_ledger.py +379,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,Ushbu bitimni bajarish uchun {1} {0} {2} da {3} {4} da {5} uchun kerak.
 DocType: Fee Schedule,Student Category,Talaba toifasi
 DocType: Announcement,Student,Talaba
-apps/erpnext/erpnext/config/hr.py +233,Organization unit (department) master.,Tashkiliy bo&#39;linma (bo&#39;lim) magistr.
-apps/erpnext/erpnext/utilities/user_progress.py +218,Go to Rooms,Xonalarga boring
+apps/erpnext/erpnext/config/hr.py +238,Organization unit (department) master.,Tashkiliy bo&#39;linma (bo&#39;lim) magistr.
+DocType: Shipping Rule,Shipping Rule Type,Yuk tashish qoidalari turi
+apps/erpnext/erpnext/utilities/user_progress.py +236,Go to Rooms,Xonalarga boring
 apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,Yuborishdan oldin xabarni kiriting
 DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,TAShQI TAQDIM ETILGAN
 DocType: Email Digest,Pending Quotations,Kutayotgan takliflar
-apps/erpnext/erpnext/config/accounts.py +326,Point-of-Sale Profile,Sotuv nuqtasi profili
+apps/erpnext/erpnext/config/accounts.py +318,Point-of-Sale Profile,Sotuv nuqtasi profili
 apps/erpnext/erpnext/config/healthcare.py +153,Lab Test Configurations.,Laboratoriya test konfiguratsiyasi.
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156,Unsecured Loans,Ta&#39;minlanmagan kreditlar
 DocType: Cost Center,Cost Center Name,Xarajat markazi nomi
-DocType: Employee,B+,B +
+DocType: Student,B+,B +
 DocType: HR Settings,Max working hours against Timesheet,Vaqt jadvaliga qarshi maksimal ish vaqti
 DocType: Maintenance Schedule Detail,Scheduled Date,Rejalashtirilgan sana
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +77,Total Paid Amt,Hammasi bo&#39;lib to&#39;lanadi
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +88,Total Paid Amt,Hammasi bo&#39;lib to&#39;lanadi
 DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,160 belgidan kattaroq xabarlar bir nechta xabarlarga bo&#39;linadi
 DocType: Purchase Receipt Item,Received and Accepted,Qabul qilingan va qabul qilingan
 DocType: Hub Settings,Company and Seller Profile,Kompaniya va sotuvchi profil
 ,GST Itemised Sales Register,GST Itemized Sales Register
+DocType: Soil Texture,Silt Loam,Silt Loam
 ,Serial No Service Contract Expiry,Seriya Yo&#39;q Xizmat shartnoma muddati tugamadi
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299,You cannot credit and debit same account at the same time,Siz bir vaqtning o&#39;zida bir xil hisobni to&#39;ldirishingiz va hisobni to&#39;lashingiz mumkin emas
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +297,You cannot credit and debit same account at the same time,Siz bir vaqtning o&#39;zida bir xil hisobni to&#39;ldirishingiz va hisobni to&#39;lashingiz mumkin emas
 DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Kattalar uchun pulsning tezligi har daqiqada 50 dan 80 gacha bo&#39;lgan joylarda bo&#39;ladi.
 DocType: Naming Series,Help HTML,HTMLga yordam bering
 DocType: Student Group Creation Tool,Student Group Creation Tool,Isoning shogirdi guruhini yaratish vositasi
 DocType: Item,Variant Based On,Variant asosida
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53,Total weightage assigned should be 100%. It is {0},Belgilangan jami vaznda 100% bo&#39;lishi kerak. Bu {0}
-apps/erpnext/erpnext/utilities/user_progress.py +88,Your Suppliers,Sizning etkazib beruvchilaringiz
+apps/erpnext/erpnext/utilities/user_progress.py +106,Your Suppliers,Sizning etkazib beruvchilaringiz
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,Please correct the,"Iltimos, to&#39;g&#39;rilang"
 apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80,Cannot set as Lost as Sales Order is made.,Savdo buyurtmasi sifatida yo&#39;qolgan deb belgilanmaydi.
 DocType: Request for Quotation Item,Supplier Part No,Yetkazib beruvchi qism No
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +365,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Qaysi kategoriya uchun &quot;Baholash&quot; yoki &quot;Vaulusiya va jami&quot;
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +363,Received From,Qabul qilingan
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +382,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Qaysi kategoriya uchun &quot;Baholash&quot; yoki &quot;Vaulusiya va jami&quot;
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +364,Received From,Qabul qilingan
 DocType: Lead,Converted,O&#39;tkazilgan
 DocType: Item,Has Serial No,Seriya raqami yo&#39;q
 DocType: Employee,Date of Issue,Berilgan sana
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +24,{0}: From {0} for {1},{0}: {1} uchun {0} dan
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +219,"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}","Xarid qilish sozlamalari kerak bo&#39;lsa == &quot;YES&quot; ni xarid qilsangiz, u holda Xarid-fakturani yaratish uchun foydalanuvchi oldin {0}"
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +166,Row #{0}: Set Supplier for item {1},{0} qator: Ta&#39;minlovchini {1} elementiga sozlang
+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}","Xarid qilish sozlamalari kerak bo&#39;lsa == &quot;YES&quot; ni xarid qilsangiz, u holda Xarid-fakturani yaratish uchun foydalanuvchi oldin {0}"
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167,Row #{0}: Set Supplier for item {1},{0} qator: Ta&#39;minlovchini {1} elementiga sozlang
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121,Row {0}: Hours value must be greater than zero.,Row {0}: soat qiymati noldan katta bo&#39;lishi kerak.
-apps/erpnext/erpnext/stock/doctype/item/item.py +183,Website Image {0} attached to Item {1} cannot be found,Veb-sayt {1} mahsulotiga biriktirilgan {0} rasm topilmadi
+apps/erpnext/erpnext/stock/doctype/item/item.py +185,Website Image {0} attached to Item {1} cannot be found,Veb-sayt {1} mahsulotiga biriktirilgan {0} rasm topilmadi
 DocType: Issue,Content Type,Kontent turi
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +17,Computer,Kompyuter
+DocType: Asset,Assets,Aktivlar
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17,Computer,Kompyuter
 DocType: Item,List this Item in multiple groups on the website.,Ushbu elementni veb-saytdagi bir nechta guruhda ko&#39;rsating.
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +82,Please set default customer group and territory in Selling Settings,Savdo sozlamalarida standart mijozlar guruhini va hududni tanlang
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323,Please check Multi Currency option to allow accounts with other currency,Boshqa valyutadagi hisoblarga ruxsat berish uchun ko&#39;p valyuta opsiyasini tanlang
+DocType: Payment Term,Due Date Based On,O&#39;tkazilgan sana asosida
+apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +85,Please set default customer group and territory in Selling Settings,Savdo sozlamalarida standart mijozlar guruhini va hududni tanlang
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +203,{0} {1} does not exist,{0} {1} mavjud emas
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +321,Please check Multi Currency option to allow accounts with other currency,Boshqa valyutadagi hisoblarga ruxsat berish uchun ko&#39;p valyuta opsiyasini tanlang
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +85,Item: {0} does not exist in the system,Mavzu: {0} tizimda mavjud emas
-apps/erpnext/erpnext/accounts/doctype/account/account.py +109,You are not authorized to set Frozen value,Siz muzlatilgan qiymatni belgilash huquqiga ega emassiz
+apps/erpnext/erpnext/accounts/doctype/account/account.py +108,You are not authorized to set Frozen value,Siz muzlatilgan qiymatni belgilash huquqiga ega emassiz
 DocType: Payment Reconciliation,Get Unreconciled Entries,Bog&#39;liq bo&#39;lmagan yozuvlarni qabul qiling
 DocType: Payment Reconciliation,From Invoice Date,Faktura sanasidan boshlab
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.py +28,You don't have permission to submit,Sizga ruxsat berishga ruxsat yo&#39;q
-apps/erpnext/erpnext/accounts/party.py +268,Billing currency must be equal to either default comapany's currency or party account currency,To&#39;lov valyutasi odatdagidan hisoblangan valyuta yoki partiyaning hisob valyutasiga teng bo&#39;lishi kerak
 DocType: Healthcare Settings,Laboratory Settings,Laboratoriya sozlamalari
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +71,Leave Encashment,Inkassatsiya qilishni qoldiring
-apps/erpnext/erpnext/public/js/setup_wizard.js +111,What does it do?,U nima qiladi?
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +75,To Warehouse,QXIga
-apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +26,All Student Admissions,Barcha talabalar qabul qilish
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75,Leave Encashment,Inkassatsiya qilishni qoldiring
+apps/erpnext/erpnext/public/js/setup_wizard.js +114,What does it do?,U nima qiladi?
+DocType: Crop,Byproducts,Yupqa buyumlar
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +76,To Warehouse,QXIga
+apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26,All Student Admissions,Barcha talabalar qabul qilish
 ,Average Commission Rate,O&#39;rtacha komissiya kursi
-apps/erpnext/erpnext/stock/doctype/item/item.py +418,'Has Serial No' can not be 'Yes' for non-stock item,&quot;Seriya Yo&#39;q&quot; yo&#39;q stokli mahsulot uchun &quot;Ha&quot; bo&#39;lishi mumkin emas
+apps/erpnext/erpnext/stock/doctype/item/item.py +434,'Has Serial No' can not be 'Yes' for non-stock item,&quot;Seriya Yo&#39;q&quot; yo&#39;q stokli mahsulot uchun &quot;Ha&quot; bo&#39;lishi mumkin emas
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +62,Select Status,Status-ni tanlang
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41,Attendance can not be marked for future dates,Kelgusi sanalar uchun tomosha qilish mumkin emas
 DocType: Pricing Rule,Pricing Rule Help,Raqobat qoidalari yordami
 DocType: School House,House Name,Uyning nomi
 DocType: Fee Schedule,Total Amount per Student,Talaba boshiga jami miqdor
 DocType: Purchase Taxes and Charges,Account Head,Hisob boshlig&#39;i
-apps/erpnext/erpnext/config/stock.py +173,Update additional costs to calculate landed cost of items,Buyurtma xarajatlarini hisoblash uchun qo&#39;shimcha xarajatlarni yangilash
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +149,Electrical,Elektr
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153,Electrical,Elektr
 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,"Tashkilotingiz qolgan qismini foydalanuvchilar sifatida qo&#39;shing. Siz shuningdek mijozlaringizni Kontaktlar ro&#39;yxatidan qo&#39;shib, portalga taklif qilishingiz mumkin"
 DocType: Stock Entry,Total Value Difference (Out - In),Jami qiymat farqi (Out - In)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348,Row {0}: Exchange Rate is mandatory,Row {0}: Valyuta kursi majburiydir
+DocType: Grant Application,Requested Amount,Kerakli miqdor
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +346,Row {0}: Exchange Rate is mandatory,Row {0}: Valyuta kursi majburiydir
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27,User ID not set for Employee {0},Foydalanuvchining identifikatori {0} xizmatdoshiga o&#39;rnatilmagan
 DocType: Vehicle,Vehicle Value,Avtomobil qiymati
+DocType: Crop Cycle,Detected Diseases,Aniqlangan kasalliklar
 DocType: Stock Entry,Default Source Warehouse,Standart manbalar ombori
 DocType: Item,Customer Code,Xaridor kodi
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +216,Birthday Reminder for {0},{0} uchun tug&#39;ilgan kun eslatmasi
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +220,Birthday Reminder for {0},{0} uchun tug&#39;ilgan kun eslatmasi
+DocType: Asset Maintenance Task,Last Completion Date,Oxirgi tugash sanasi
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72,Days Since Last Order,Oxirgi Buyurtma berib o&#39;tgan kunlar
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +355,Debit To account must be a Balance Sheet account,Debet Hisobni balans hisoboti bo&#39;lishi kerak
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +359,Debit To account must be a Balance Sheet account,Debet Hisobni balans hisoboti bo&#39;lishi kerak
 DocType: Buying Settings,Naming Series,Namunaviy qator
 DocType: Leave Block List,Leave Block List Name,Blok ro&#39;yxati nomini qoldiring
 apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14,Insurance Start date should be less than Insurance End date,Sug&#39;urtaning boshlanish sanasi sug&#39;urta tugagan sanadan kam bo&#39;lishi kerak
-apps/erpnext/erpnext/schools/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in School &gt; School Settings,"Iltimos, maktabdagi o&#39;qituvchilar nomini tizimini sozlang"
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,Fond aktivlari
 DocType: Timesheet,Production Detail,Ishlab chiqarish detali
 DocType: Restaurant,Active Menu,Faol menyu
 DocType: Target Detail,Target Qty,Nishon Miqdor
 DocType: Shopping Cart Settings,Checkout Settings,To&#39;lov sozlamalari
-DocType: Attendance,Present,Mavjud
+DocType: Student Attendance,Present,Mavjud
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37,Delivery Note {0} must not be submitted,Yetkazib berish eslatmasi {0} yuborilmasligi kerak
 DocType: Notification Control,Sales Invoice Message,Sotuvdagi hisob-faktura xabari
 apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,Closing Account {0} must be of type Liability / Equity,Hisobni yopish {0} javobgarlik / tenglik turi bo&#39;lishi kerak
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +325,Salary Slip of employee {0} already created for time sheet {1},Ish staji {1} vaqt jadvalini uchun yaratilgan ({0})
 DocType: Vehicle Log,Odometer,Odometer
 DocType: Sales Order Item,Ordered Qty,Buyurtma miqdori
-apps/erpnext/erpnext/stock/doctype/item/item.py +727,Item {0} is disabled,{0} element o&#39;chirib qo&#39;yilgan
+apps/erpnext/erpnext/stock/doctype/item/item.py +713,Item {0} is disabled,{0} element o&#39;chirib qo&#39;yilgan
 DocType: Stock Settings,Stock Frozen Upto,Stock Frozen Upto
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +904,BOM does not contain any stock item,BOMda biron-bir mahsulot elementi yo&#39;q
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +929,BOM does not contain any stock item,BOMda biron-bir mahsulot elementi yo&#39;q
+DocType: Chapter,Chapter Head,Bo&#39;lim boshlig&#39;i
+DocType: Payment Term,Month(s) after the end of the invoice month,Hisob-fakturaning oyi tugagandan so&#39;ng oy (lar)
 apps/erpnext/erpnext/config/projects.py +19,Project activity / task.,Loyiha faoliyati / vazifasi.
 DocType: Vehicle Log,Refuelling Details,Yoqilg&#39;i tafsilotlari
 apps/erpnext/erpnext/config/hr.py +104,Generate Salary Slips,Ish haqi slipslarini yaratish
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +44,"Buying must be checked, if Applicable For is selected as {0}","{0} sifatida tanlangan bo&#39;lsa, xarid qilishni tekshirish kerak"
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,Diskont 100 dan kam bo&#39;lishi kerak
+DocType: Shipping Rule,Restrict to Countries,Davlatlarni cheklash
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +171,Select Delivery Notes,Buyurtma eslatmalarini tanlang
 DocType: Purchase Invoice,Write Off Amount (Company Currency),Miqdorni yozing (Kompaniya valyutasi)
 DocType: Sales Invoice Timesheet,Billing Hours,To&#39;lov vaqti
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +500,Default BOM for {0} not found,{0} uchun odatiy BOM topilmadi
-apps/erpnext/erpnext/stock/doctype/item/item.py +498,Row #{0}: Please set reorder quantity,"# {0} qatori: Iltimos, buyurtmaning miqdorini belgilang"
+DocType: Project,Total Sales Amount (via Sales Order),Jami Sotuvdagi miqdori (Sotuvdagi Buyurtma orqali)
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +528,Default BOM for {0} not found,{0} uchun odatiy BOM topilmadi
+apps/erpnext/erpnext/stock/doctype/item/item.py +489,Row #{0}: Please set reorder quantity,"# {0} qatori: Iltimos, buyurtmaning miqdorini belgilang"
 apps/erpnext/erpnext/public/js/pos/pos.html +20,Tap items to add them here,Bu yerga qo&#39;shish uchun narsalarni teging
 DocType: Fees,Program Enrollment,Dasturlarni ro&#39;yxatga olish
 DocType: Landed Cost Voucher,Landed Cost Voucher,Belgilangan xarajatlar varaqasi
 apps/erpnext/erpnext/public/js/queries.js +39,Please set {0},"Iltimos, {0}"
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} faol emas
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} faol emas
 DocType: Employee,Health Details,Sog&#39;liqni saqlash haqida ma&#39;lumot
 DocType: Offer Letter,Offer Letter Terms,Kelishuv shartlarini taklif qilish
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,To create a Payment Request reference document is required,To&#39;lov talabnomasini yaratish uchun ma&#39;lumotnoma talab qilinadi
+DocType: Soil Texture,Sandy Clay,Sandy Clay
+DocType: Grant Application,Assessment  Manager,Baholash menejeri
 DocType: Payment Entry,Allocate Payment Amount,To&#39;lov miqdorini ajratish
 DocType: Employee External Work History,Salary,Ish haqi
 DocType: Serial No,Delivery Document Type,Hujjatning turi
-DocType: Process Payroll,Submit all salary slips for the above selected criteria,Yuqorida ko&#39;rsatilgan tanlangan mezonlarga barcha ish haqi slipslarini yuboring
 DocType: Sales Order,Partly Delivered,Qisman etkazib berildi
+DocType: Item Variant Settings,Do not update variants on save,Saqlash bo&#39;yicha variantlarni yangilang
 DocType: Email Digest,Receivables,Oladiganlar
 DocType: Lead Source,Lead Source,Qo&#39;rg&#39;oshin manbai
 DocType: Customer,Additional information regarding the customer.,Xaridor haqida qo&#39;shimcha ma&#39;lumot.
@@ -4741,23 +5092,26 @@
 DocType: Maintenance Visit,Maintenance Date,Xizmat sanasi
 DocType: Purchase Invoice Item,Rejected Serial No,Rad etilgan seriya raqami
 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,Yil boshlanish sanasi yoki tugash sanasi {0} bilan örtüşüyor. Buning oldini olish uchun kompaniyani tanlang
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +94,Please mention the Lead Name in Lead {0},"Iltimos, qo&#39;rg&#39;oshin nomi {0}"
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +108,Please mention the Lead Name in Lead {0},"Iltimos, qo&#39;rg&#39;oshin nomi {0}"
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156,Start date should be less than end date for Item {0},Boshlanish sanasi {0} element uchun tugash sanasidan past bo&#39;lishi kerak
 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.","Misol: ABCD. ##### Agar ketma-ketlik belgilanadigan bo&#39;lsa va tranzaktsiyalarda ketma-ket No ko&#39;rsatilmasa, u holda ushbu ketma-ketlik asosida avtomatik seriya raqami yaratiladi. Agar siz doimo bu element uchun ketma-ketlikdagi Seriya Nosani eslatmoqchi bo&#39;lsangiz. bu bo&#39;sh qoldiring."
 DocType: Upload Attendance,Upload Attendance,Yuklashni davom ettirish
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +319,BOM and Manufacturing Quantity are required,BOM va ishlab chiqarish miqdori talab qilinadi
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +535,BOM and Manufacturing Quantity are required,BOM va ishlab chiqarish miqdori talab qilinadi
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,Qarish oralig&#39;i 2
 DocType: SG Creation Tool Course,Max Strength,Maks kuch
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +28,Installing presets,Oldindan o&#39;rnatish
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +67,No Delivery Note selected for Customer {},Buyurtmachilar uchun {}
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +22,BOM replaced,BOM almashtirildi
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +992,Select Items based on Delivery Date,Etkazib berish sanasi asosida narsalarni tanlang
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1041,Select Items based on Delivery Date,Etkazib berish sanasi asosida narsalarni tanlang
+DocType: Grant Application,Has any past Grant Record,O&#39;tgan Grantlar rekordi mavjud
 ,Sales Analytics,Savdo tahlillari
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +119,Available {0},{0} mavjud
 ,Prospects Engaged But Not Converted,"Kutilayotgan imkoniyatlar, lekin o&#39;zgartirilmadi"
 DocType: Manufacturing Settings,Manufacturing Settings,Ishlab chiqarish sozlamalari
 apps/erpnext/erpnext/config/setup.py +56,Setting up Email,E-pochtani sozlash
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,Guardian1 Mobil raqami
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +103,Please enter default currency in Company Master,"Iltimos, kompaniyaning ustalidagi valyutani kiriting"
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,Guardian1 Mobil raqami
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106,Please enter default currency in Company Master,"Iltimos, kompaniyaning ustalidagi valyutani kiriting"
 DocType: Stock Entry Detail,Stock Entry Detail,Stock Entry Detail
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +109,Daily Reminders,Kundalik eslatmalar
 DocType: Products Settings,Home Page is Products,Bosh sahifa - Mahsulotlar
@@ -4766,17 +5120,17 @@
 apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25,New Account Name,Yangi hisob nomi
 DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Xom ashyo materiallari bilan ta&#39;minlangan
 DocType: Selling Settings,Settings for Selling Module,Sotuvdagi modulni sozlash
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +111,Customer Service,Mijozlarga hizmat
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115,Customer Service,Mijozlarga hizmat
 DocType: BOM,Thumbnail,Kichik rasm
 DocType: Item Customer Detail,Item Customer Detail,Xaridorlar uchun batafsil ma&#39;lumot
 apps/erpnext/erpnext/config/hr.py +50,Offer candidate a Job.,Nomzodga Job taklif qiling.
 DocType: Notification Control,Prompt for Email on Submission of,E-pochtani topshirish haqida so&#39;rov
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88,Total allocated leaves are more than days in the period,Jami ajratilgan barglar davr ichida kundan ortiq
+DocType: Land Unit,Linked Soil Analysis,Bog&#39;langan tuproq tahlillari
 DocType: Pricing Rule,Percentage,Foiz
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70,Item {0} must be a stock Item,{0} elementi birja elementi bo&#39;lishi kerak
 DocType: Manufacturing Settings,Default Work In Progress Warehouse,Standart ishni bajarishda ombor
-apps/erpnext/erpnext/config/accounts.py +296,Default settings for accounting transactions.,Buxgalteriya operatsiyalari uchun standart sozlamalar.
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +23,Please setup Employee Naming System in Human Resource &gt; HR Settings,Inson resurslari&gt; HR parametrlarini Xodimlar uchun nomlash tizimini sozlang
+apps/erpnext/erpnext/config/accounts.py +288,Default settings for accounting transactions.,Buxgalteriya operatsiyalari uchun standart sozlamalar.
 DocType: Maintenance Visit,MV,MV
 DocType: Restaurant,Default Tax Template,Standart soliq kodi
 DocType: Fees,Student Details,Talaba tafsilotlari
@@ -4789,11 +5143,11 @@
 DocType: Sales Order,Printing Details,Chop etish uchun ma&#39;lumot
 DocType: Task,Closing Date,Yakunlovchi sana
 DocType: Sales Order Item,Produced Quantity,Ishlab chiqarilgan miqdor
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +122,Engineer,Muhandis
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126,Engineer,Muhandis
 DocType: Journal Entry,Total Amount Currency,Jami valyuta miqdori
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Qidiruv Sub Assemblies
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +168,Item Code required at Row No {0},Yo&#39;q qatorida zarur bo&#39;lgan mahsulot kodi yo&#39;q {0}
-apps/erpnext/erpnext/utilities/user_progress.py +133,Go to Items,Ma&#39;lumotlar bo&#39;limiga o&#39;ting
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171,Item Code required at Row No {0},Yo&#39;q qatorida zarur bo&#39;lgan mahsulot kodi yo&#39;q {0}
+apps/erpnext/erpnext/utilities/user_progress.py +151,Go to Items,Ma&#39;lumotlar bo&#39;limiga o&#39;ting
 DocType: Sales Partner,Partner Type,Hamkor turi
 DocType: Purchase Taxes and Charges,Actual,Haqiqiy
 DocType: Restaurant Menu,Restaurant Manager,Restoran menejeri
@@ -4810,35 +5164,37 @@
 DocType: Item Reorder,Re-Order Level,Buyurtma darajasini qayta yuklash
 DocType: Production Planning Tool,Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,Ishlab chiqarish buyurtmalarini oshirish yoki tahlil qilish uchun xom ashyolarni yuklab olishni istagan narsalarni va rejalashtirilgan miqdorni kiriting.
 apps/erpnext/erpnext/projects/doctype/project/project.js +64,Gantt Chart,Gantt grafikasi
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +95,Part-time,To&#39;liqsiz ish kuni
+DocType: Crop Cycle,Cycle Type,Ko&#39;chadan turi
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99,Part-time,To&#39;liqsiz ish kuni
 DocType: Employee,Applicable Holiday List,Amaldagi bayramlar ro&#39;yxati
 DocType: Employee,Cheque,Tekshiring
 DocType: Training Event,Employee Emails,Xodimlarning elektron pochta manzili
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +59,Series Updated,Series yangilandi
-apps/erpnext/erpnext/accounts/doctype/account/account.py +162,Report Type is mandatory,Hisobot turi majburiydir
+apps/erpnext/erpnext/accounts/doctype/account/account.py +161,Report Type is mandatory,Hisobot turi majburiydir
 DocType: Item,Serial Number Series,Seriya raqami
 apps/erpnext/erpnext/buying/utils.py +68,Warehouse is mandatory for stock Item {0} in row {1},{1} qatoridagi kabinetga {0} uchun ombor kerak
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +45,Retail & Wholesale,Chakana va ulgurji savdo
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45,Retail & Wholesale,Chakana va ulgurji savdo
 DocType: Issue,First Responded On,Birinchi javob
 DocType: Website Item Group,Cross Listing of Item in multiple groups,Bir nechta guruhda elementlarning o&#39;zaro roziligi
 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},Moliyaviy yil boshlash sanasi va moliya yili tugash sanasi Moliyaviy yil {0}
 apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,Clearance Date updated,Bo&#39;shatish sanasi yangilandi
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +131,Split Batch,Split partiyasi
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +138,Split Batch,Split partiyasi
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +131,Successfully Reconciled,Muvaffaqiyatli o&#39;zaro kelishilgan
 DocType: Request for Quotation Supplier,Download PDF,PDF-ni yuklab olish
 DocType: Production Order,Planned End Date,Rejalashtirilgan tugash sanasi
-apps/erpnext/erpnext/controllers/buying_controller.py +423,Please enter Schedule Date,Jadvaldagi sanani kiriting
-apps/erpnext/erpnext/config/stock.py +189,Where items are stored.,Qaerda narsalar saqlanadi.
+apps/erpnext/erpnext/controllers/buying_controller.py +424,Please enter Schedule Date,Jadvaldagi sanani kiriting
+apps/erpnext/erpnext/config/non_profit.py +63,Donor Type information.,Donor turi haqida ma&#39;lumot.
 DocType: Request for Quotation,Supplier Detail,Yetkazib beruvchi ma&#39;lumotlarni
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100,Error in formula or condition: {0},Formulada yoki vaziyatda xato: {0}
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +16,Invoiced Amount,Xarajatlar miqdori
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47,Criteria weights must add up to 100%,Mezonning og&#39;irliklari 100%
-DocType: Attendance,Attendance,Ishtirok etish
+apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7,Attendance,Ishtirok etish
 apps/erpnext/erpnext/public/js/pos/pos.html +104,Stock Items,Qimmatli qog&#39;ozlar
 DocType: BOM,Materials,Materiallar
 DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Belgilangan bo&#39;lmasa, ro&#39;yxat qo&#39;llanilishi kerak bo&#39;lgan har bir Bo&#39;limga qo&#39;shilishi kerak."
-apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Resurs va maqsadli omborlar bir xil bo&#39;lishi mumkin emas
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +535,Posting date and posting time is mandatory,Yozish sanasi va joylashtirish vaqti majburiydir
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +103,Creating {0},{0} yaratish
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Resurs va maqsadli omborlar bir xil bo&#39;lishi mumkin emas
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +561,Posting date and posting time is mandatory,Yozish sanasi va joylashtirish vaqti majburiydir
 apps/erpnext/erpnext/config/buying.py +76,Tax template for buying transactions.,Jurnallarni sotib olish uchun soliq shablonni.
 ,Item Prices,Mahsulot bahosi
 DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,Buyurtma buyurtmasini saqlaganingizdan so&#39;ng So&#39;zlar paydo bo&#39;ladi.
@@ -4848,39 +5204,42 @@
 apps/erpnext/erpnext/config/selling.py +67,Price List master.,Narxlar ro&#39;yxati ustasi.
 DocType: Task,Review Date,Ko&#39;rib chiqish sanasi
 DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Assotsiatsiya uchun amortizatsiya qilish uchun jurnal (jurnalga yozilish)
+DocType: Membership,Member Since,Ro&#39;yxatdan bo&#39;lgan
 DocType: Purchase Invoice,Advance Payments,Advance to&#39;lovlar
 DocType: Purchase Taxes and Charges,On Net Total,Jami aniq
 apps/erpnext/erpnext/controllers/item_variant.py +90,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},{0} atributi uchun {4} belgisi uchun {1} - {2} oralig&#39;ida {3}
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +161,Target warehouse in row {0} must be same as Production Order,{0} qatoridagi maqsadli ombor ishlab chiqarish tartibi bilan bir xil bo&#39;lishi kerak
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +166,Target warehouse in row {0} must be same as Production Order,{0} qatoridagi maqsadli ombor ishlab chiqarish tartibi bilan bir xil bo&#39;lishi kerak
 DocType: Restaurant Reservation,Waitlisted,Kutib turildi
-apps/erpnext/erpnext/accounts/doctype/account/account.py +127,Currency can not be changed after making entries using some other currency,Valyutani boshqa valyutani qo&#39;llagan holda kiritish o&#39;zgartirilmaydi
+apps/erpnext/erpnext/accounts/doctype/account/account.py +126,Currency can not be changed after making entries using some other currency,Valyutani boshqa valyutani qo&#39;llagan holda kiritish o&#39;zgartirilmaydi
+DocType: Shipping Rule,Fixed,Ruxsat etilgan
 DocType: Vehicle Service,Clutch Plate,Debriyaj plitasi
 DocType: Company,Round Off Account,Dumaloq hisob qaydnomasi
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93,Administrative Expenses,Ma&#39;muriy xarajatlar
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +18,Consulting,Konsalting
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18,Consulting,Konsalting
 DocType: Customer Group,Parent Customer Group,Ota-xaridorlar guruhi
 DocType: Journal Entry,Subscription,Obuna
 DocType: Purchase Invoice,Contact Email,E-pochtaga murojaat qiling
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Ish haqi yaratilishi kutilmoqda
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Ish haqi yaratilishi kutilmoqda
 DocType: Appraisal Goal,Score Earned,Quloqqa erishildi
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +229,Notice Period,Bildirishnoma muddati
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239,Notice Period,Bildirishnoma muddati
 DocType: Asset Category,Asset Category Name,Asset kategoriyasi nomi
 apps/erpnext/erpnext/setup/doctype/territory/territory.js +13,This is a root territory and cannot be edited.,Bu ildiz hududidir va tahrirlanmaydi.
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5,New Sales Person Name,Yangi Sotuvdagi Shaxs ismi
 DocType: Packing Slip,Gross Weight UOM,Brüt Og&#39;irlik UOM
+DocType: Asset Maintenance Task,Preventive Maintenance,Profilaktik xizmat
 DocType: Delivery Note Item,Against Sales Invoice,Sotuvdagi schyot-fakturaga qarshi
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +141,Please enter serial numbers for serialized item ,Serileştirilmiş element uchun seriya raqamlarini kiriting
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +151,Please enter serial numbers for serialized item ,Serileştirilmiş element uchun seriya raqamlarini kiriting
 DocType: Bin,Reserved Qty for Production,Ishlab chiqarish uchun belgilangan miqdor
 DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,"Kursga asoslangan guruhlarni tashkil qilishda partiyani ko&#39;rib chiqishni istamasangiz, belgilanmasdan qoldiring."
 DocType: Asset,Frequency of Depreciation (Months),Amortizatsiya chastotasi (oy)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +493,Credit Account,Kredit hisobi
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +501,Credit Account,Kredit hisobi
 DocType: Landed Cost Item,Landed Cost Item,Chiqindilar narxlari
 apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57,Show zero values,Nolinchi qiymatlarni ko&#39;rsatish
 DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Berilgan miqdorda xom ashyoni ishlab chiqarish / qayta ishlashdan so&#39;ng olingan mahsulot miqdori
 DocType: Lab Test,Test Group,Test guruhi
 DocType: Payment Reconciliation,Receivable / Payable Account,Oladigan / to&#39;lanadigan hisob
 DocType: Delivery Note Item,Against Sales Order Item,Savdo Buyurtma Mahsulotiga qarshi
-apps/erpnext/erpnext/stock/doctype/item/item.py +694,Please specify Attribute Value for attribute {0},"Iltimos, attribut qiymati uchun {0}"
+apps/erpnext/erpnext/stock/doctype/item/item.py +680,Please specify Attribute Value for attribute {0},"Iltimos, attribut qiymati uchun {0}"
 DocType: Item,Default Warehouse,Standart ombor
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45,Budget cannot be assigned against Group Account {0},Byudjetga {0} Guruh hisobi bo&#39;yicha topshirish mumkin emas
 DocType: Healthcare Settings,Patient Registration,Bemorni ro&#39;yxatdan o&#39;tkazish
@@ -4892,23 +5251,27 @@
 DocType: Appraisal,Total Score (Out of 5),Jami ball (5 dan)
 DocType: Fee Structure,FS.,FS.
 DocType: Student Attendance Tool,Batch,Partiya
+DocType: Donor,Donor Type,Donor turi
 apps/erpnext/erpnext/stock/doctype/item/item.js +27,Balance,Balans
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66,Please select the Company,"Iltimos, kompaniyani tanlang"
 DocType: Room,Seating Capacity,Yashash imkoniyati
 DocType: Issue,ISS-,ISS-
 DocType: Lab Test Groups,Lab Test Groups,Laborotoriya guruhlari
 DocType: Project,Total Expense Claim (via Expense Claims),Jami xarajat talabi (xarajatlar bo&#39;yicha da&#39;vo)
 DocType: GST Settings,GST Summary,GST Xulosa
 DocType: Assessment Result,Total Score,Umumiy reyting
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +116,Please set the Default Cost Center in {0} company,"Iltimos, {0} kompaniyasidagi Standart xarajatlar markazini tanlang"
 DocType: Journal Entry,Debit Note,Debet eslatmasi
 DocType: Stock Entry,As per Stock UOM,Har bir korxona uchun
 apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,Muddati tugamadi
 DocType: Student Log,Achievement,Muvaffaqiyat
 DocType: Batch,Source Document Type,Manba hujjat turi
+apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24,Following course schedules were created,Kurs jadvallarini tuzishdan keyin yaratildi
 DocType: Journal Entry,Total Debit,Jami debet
 DocType: Manufacturing Settings,Default Finished Goods Warehouse,Standart tayyorlangan tovarlar ombori
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +77,Sales Person,Savdo vakili
-apps/erpnext/erpnext/config/accounts.py +241,Budget and Cost Center,Byudjet va xarajatlar markazi
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +60,Multiple default mode of payment is not allowed,Ko&#39;p ko&#39;rsatiladigan to&#39;lov shakli yo&#39;l qo&#39;yilmaydi
+apps/erpnext/erpnext/config/accounts.py +233,Budget and Cost Center,Byudjet va xarajatlar markazi
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65,Multiple default mode of payment is not allowed,Ko&#39;p ko&#39;rsatiladigan to&#39;lov shakli yo&#39;l qo&#39;yilmaydi
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,for the,uchun
 ,Appointment Analytics,Uchrashuv tahlillari
 DocType: Vehicle Service,Half Yearly,Yarim yillik
@@ -4917,17 +5280,18 @@
 DocType: Healthcare Settings,Consultations in valid days,To&#39;g&#39;ri kunlarda maslahatlar
 DocType: Assessment Plan Criteria,Maximum Score,Maksimal reyting
 apps/erpnext/erpnext/config/setup.py +83,Create rules to restrict transactions based on values.,Jarayonlarni qadriyatlar asosida cheklash uchun qoidalar yarating.
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,Guruhlar uchun to&#39;plam №
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Narxni yaratish muvaffaqiyatsiz tugadi
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,Guruhlar uchun to&#39;plam №
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Narxni yaratish muvaffaqiyatsiz tugadi
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Agar talabalar guruhlarini yil davomida qilsangiz, bo&#39;sh qoldiring"
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Belgilangan bo&#39;lsa, Jami no. Ish kunlari davomida bayramlar bo&#39;ladi va bu kunlik ish haqining qiymatini kamaytiradi"
 DocType: Purchase Invoice,Total Advance,Jami avans
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27,Change Template Code,Andoza kodini o&#39;zgartirish
-apps/erpnext/erpnext/schools/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.,"Davrning oxirgi sanasi Davrning boshlanishi sanasidan oldin bo&#39;lishi mumkin emas. Iltimos, sanalarni tahrirlang va qaytadan urinib ko&#39;ring."
+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.,"Davrning oxirgi sanasi Davrning boshlanishi sanasidan oldin bo&#39;lishi mumkin emas. Iltimos, sanalarni tahrirlang va qaytadan urinib ko&#39;ring."
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,Hisob soni
 ,BOM Stock Report,BOM birjasi
 DocType: Stock Reconciliation Item,Quantity Difference,Miqdor farq
-apps/erpnext/erpnext/config/hr.py +315,Processing Payroll,To&#39;lovni qayta ishlash
+DocType: Employee Advance,EA-,EA-
+apps/erpnext/erpnext/config/hr.py +320,Processing Payroll,To&#39;lovni qayta ishlash
 DocType: Opportunity Item,Basic Rate,Asosiy darajasi
 DocType: GL Entry,Credit Amount,Kredit miqdori
 DocType: Cheque Print Template,Signatory Position,Imzo varaqasi
@@ -4935,7 +5299,7 @@
 DocType: Timesheet,Total Billable Hours,Jami hisoblangan soatlar
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4,Payment Receipt Note,To&#39;lov ma&#39;lumotnomasi
 apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,This is based on transactions against this Customer. See timeline below for details,"Bu esa, ushbu xaridorga qarshi qilingan operatsiyalarga asoslanadi. Tafsilotlar uchun quyidagi jadvalga qarang"
-DocType: Supplier,Credit Days Based On,Kredit kuni asosli
+DocType: Company,Credit Days Based On,Kredit kuni asosli
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +161,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Row {0}: ajratilgan miqdor {1} To&#39;lovni kiritish miqdoridan kam yoki teng bo&#39;lishi kerak {2}
 ,Course wise Assessment Report,Kursni dono baholash haqida hisobot
 DocType: Tax Rule,Tax Rule,Soliq qoidalari
@@ -4943,66 +5307,73 @@
 DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Ish stantsiyasining ish soatlari tashqarisida vaqtni qayd etish.
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +92,Dr {0} does not have a Physician Schedule. Add it in Physician master,Doktor {0} da shifokor dasturlari mavjud emas. Uni shifokor ustasiga qo&#39;shing
 apps/erpnext/erpnext/public/js/pos/pos.html +87,Customers in Queue,Navbatdagi mijozlar
+DocType: Driver,Issuing Date,Taqdim etilgan sana
 DocType: Student,Nationality,Fuqarolik
 ,Items To Be Requested,Talab qilinadigan narsalar
 DocType: Company,Company Info,Kompaniya haqida ma&#39;lumot
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1359,Select or add new customer,Yangi mijozni tanlang yoki qo&#39;shing
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +154,Cost center is required to book an expense claim,Xarajat markazidan mablag &#39;sarflashni talab qilish kerak
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1374,Select or add new customer,Yangi mijozni tanlang yoki qo&#39;shing
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +179,Cost center is required to book an expense claim,Xarajat markazidan mablag &#39;sarflashni talab qilish kerak
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Jamg&#39;armalar (aktivlar) ni qo&#39;llash
 apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6,This is based on the attendance of this Employee,Bu ushbu xodimning ishtirokiga asoslangan
-apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Markni tomosha qilish
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +487,Debit Account,Hisob qaydnomasi
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Markni tomosha qilish
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +495,Debit Account,Hisob qaydnomasi
 DocType: Fiscal Year,Year Start Date,Yil boshlanish sanasi
 DocType: Attendance,Employee Name,Xodimlarning nomi
 DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Restoran Buyurtma bandini buyurtma qiling
-DocType: Sales Invoice,Rounded Total (Company Currency),Yalpi jami (Kompaniya valyutasi)
-apps/erpnext/erpnext/accounts/doctype/account/account.py +99,Cannot covert to Group because Account Type is selected.,Hisob turi tanlanganligi sababli guruhga yashirin bo&#39;lmaydi.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +240,{0} {1} has been modified. Please refresh.,"{0} {1} o&#39;zgartirilgan. Iltimos, yangilang."
+DocType: Purchase Invoice,Rounded Total (Company Currency),Yalpi jami (Kompaniya valyutasi)
+apps/erpnext/erpnext/accounts/doctype/account/account.py +98,Cannot covert to Group because Account Type is selected.,Hisob turi tanlanganligi sababli guruhga yashirin bo&#39;lmaydi.
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260,{0} {1} has been modified. Please refresh.,"{0} {1} o&#39;zgartirilgan. Iltimos, yangilang."
 DocType: Leave Block List,Stop users from making Leave Applications on following days.,Foydalanuvchilarni foydalanuvchilarga qo&#39;yishni keyingi kunlarda to&#39;xtatib turish.
+DocType: Asset Maintenance Team,Maintenance Team Members,Xizmat jamoasi a&#39;zolari
 apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63,Purchase Amount,Xarid miqdori
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +259,Supplier Quotation {0} created,Yetkazib beruvchi quo {0} yaratildi
 apps/erpnext/erpnext/accounts/report/financial_statements.py +97,End Year cannot be before Start Year,End Year Year Year oldin bo&#39;lishi mumkin emas
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +222,Employee Benefits,Ishchilarning nafaqalari
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232,Employee Benefits,Ishchilarning nafaqalari
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +255,Packed quantity must equal quantity for Item {0} in row {1},To&#39;ldirilgan miqdor {1} qatorda {0} uchun teng miqdorga ega bo&#39;lishi kerak
 DocType: Production Order,Manufactured Qty,Ishlab chiqarilgan Miqdor
 apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64,Invoice Created,Hisob-faktura yaratildi
+DocType: Asset,Out of Order,Tartibsiz
 DocType: Purchase Receipt Item,Accepted Quantity,Qabul qilingan miqdor
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +238,Please set a default Holiday List for Employee {0} or Company {1},"Iltimos, xizmatdoshlar uchun {0} yoki Kompaniya {1}"
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +242,Please set a default Holiday List for Employee {0} or Company {1},"Iltimos, xizmatdoshlar uchun {0} yoki Kompaniya {1}"
 apps/erpnext/erpnext/accounts/party.py +31,{0}: {1} does not exists,{0}: {1} mavjud emas
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +75,Select Batch Numbers,Partiya raqamlarini tanlang
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76,Select Batch Numbers,Partiya raqamlarini tanlang
 apps/erpnext/erpnext/config/accounts.py +12,Bills raised to Customers.,Xarajatlar mijozlarga yetkazildi.
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,Loyiha Id
-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},No {0} qatori: Miqdor kutilgan qarz miqdori bo&#39;yicha da&#39;volardan {1} dan yuqori bo&#39;lishi mumkin emas. Kutilayotgan miqdor {2}
-DocType: Maintenance Schedule,Schedule,Jadval
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +532,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},No {0} qatori: Miqdor kutilgan qarz miqdori bo&#39;yicha da&#39;volardan {1} dan yuqori bo&#39;lishi mumkin emas. Kutilayotgan miqdor {2}
+DocType: Assessment Plan,Schedule,Jadval
 DocType: Account,Parent Account,Ota-hisob
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +253,Available,Mavjud
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266,Available,Mavjud
 DocType: Quality Inspection Reading,Reading 3,O&#39;qish 3
 ,Hub,Hub
 DocType: GL Entry,Voucher Type,Voucher turi
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1691,Price List not found or disabled,Narxlar ro&#39;yxati topilmadi yoki o&#39;chirib qo&#39;yilgan
-DocType: Lab Test,Approved,Tasdiqlandi
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1706,Price List not found or disabled,Narxlar ro&#39;yxati topilmadi yoki o&#39;chirib qo&#39;yilgan
+DocType: Student Applicant,Approved,Tasdiqlandi
 DocType: Pricing Rule,Price,Narxlari
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +266,Employee relieved on {0} must be set as 'Left',{0} da bo&#39;shagan xodim &quot;chapga&quot;
 DocType: Hub Settings,Last Sync On,So&#39;nggi sinxronlash yoqilgan
 DocType: Guardian,Guardian,Guardian
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,Appraisal {0} created for Employee {1} in the given date range,Belgilangan sana oralig&#39;ida xodim {1} uchun baholangan {0} baholanadi
-DocType: Employee,Education,Ta&#39;lim
+DocType: Academic Term,Education,Ta&#39;lim
 apps/erpnext/erpnext/public/js/pos/pos.html +78,Del,Del
 DocType: Selling Settings,Campaign Naming By,Kampaniya nomi bilan nomlash
 DocType: Employee,Current Address Is,Hozirgi manzili
 apps/erpnext/erpnext/utilities/user_progress.py +48,Monthly Sales Target (,Oylik Sotuvdagi Nishon (
 apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9,modified,o&#39;zgartirilgan
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +41,"Optional. Sets company's default currency, if not specified.","Majburiy emas. Belgilansa, kompaniyaning standart valyutasini o&#39;rnatadi."
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43,"Optional. Sets company's default currency, if not specified.","Majburiy emas. Belgilansa, kompaniyaning standart valyutasini o&#39;rnatadi."
 DocType: Sales Invoice,Customer GSTIN,Xaridor GSTIN
+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 ,"Bu sohada aniqlangan kasalliklar ro&#39;yxati. Tanlangan bo&#39;lsa, u avtomatik ravishda kasallik bilan shug&#39;ullanadigan vazifalar ro&#39;yxatini qo&#39;shib qo&#39;yadi"
+DocType: Asset Repair,Repair Status,Ta&#39;mirlash holati
 apps/erpnext/erpnext/config/accounts.py +67,Accounting journal entries.,Buxgalteriya jurnali yozuvlari.
 DocType: Delivery Note Item,Available Qty at From Warehouse,QXIdagi mavjud Quti
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +295,Please select Employee Record first.,Avval Employee Record-ni tanlang.
 DocType: POS Profile,Account for Change Amount,O&#39;zgarish miqdorini hisobga olish
-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}: Partiya / Hisob {3} {4} da {1} / {2}
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Course Code: ,Kurs kodi:
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +215,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Row {0}: Partiya / Hisob {3} {4} da {1} / {2}
+DocType: Maintenance Team Member,Maintenance Team Member,Xizmat jamoasi a&#39;zosi
+DocType: Agriculture Analysis Criteria,Soil Analysis,Tuproq tahlil qilish
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Course Code: ,Kurs kodi:
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +238,Please enter Expense Account,"Marhamat, hisobni kiriting"
 DocType: Account,Stock,Aksiyalar
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1042,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","# {0} satri: Hujjatning Hujjat turi Buyurtma Buyurtma, Buyurtma Xarajati yoki Jurnal Yozuvi bo&#39;lishi kerak"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1068,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","# {0} satri: Hujjatning Hujjat turi Buyurtma Buyurtma, Buyurtma Xarajati yoki Jurnal Yozuvi bo&#39;lishi kerak"
 DocType: Employee,Current Address,Joriy manzil
 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","Agar element boshqa narsaning varianti bo&#39;lsa, u holda tavsif, tasvir, narxlanish, soliq va boshqalar shablondan aniq belgilanmagan bo&#39;lsa"
 DocType: Serial No,Purchase / Manufacture Details,Sotib olish / ishlab chiqarish detali
@@ -5013,53 +5384,52 @@
 DocType: Sales Invoice Item,Discount and Margin,Dasturi va margin
 DocType: Lab Test,Prescription,Ortga nazar tashlash
 DocType: Production Planning Tool,Pull sales orders (pending to deliver) based on the above criteria,Yuqoridagi mezonlarga asosan savdo buyurtmalarini (etkazib berishni kutish) kutib turing
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +90,Not Available,Mavjud emas
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +98,Not Available,Mavjud emas
 DocType: Pricing Rule,Min Qty,Min. Miqdor
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36,Disable Template,Andoza o&#39;chirish
-DocType: Asset Movement,Transaction Date,Jurnal tarixi
+DocType: GL Entry,Transaction Date,Jurnal tarixi
 DocType: Production Plan Item,Planned Qty,Rejalangan Miqdor
 apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Jami Soliq
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +177,For Quantity (Manufactured Qty) is mandatory,Miqdor uchun (ishlab chiqarilgan Qty) majburiydir
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +182,For Quantity (Manufactured Qty) is mandatory,Miqdor uchun (ishlab chiqarilgan Qty) majburiydir
 DocType: Stock Entry,Default Target Warehouse,Standart maqsadli ombor
 DocType: Purchase Invoice,Net Total (Company Currency),Net Jami (Kompaniya valyuta)
-apps/erpnext/erpnext/schools/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.,"Yil oxiri kuni Yil boshlanish sanasidan oldingi bo&#39;la olmaydi. Iltimos, sanalarni tahrirlang va qaytadan urinib ko&#39;ring."
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105,Row {0}: Party Type and Party is only applicable against Receivable / Payable account,Row {0}: Partiya turi va partiyasi faqatgina Qabul / to&#39;lash hisobiga nisbatan qo&#39;llaniladi
+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.,"Yil oxiri kuni Yil boshlanish sanasidan oldingi bo&#39;la olmaydi. Iltimos, sanalarni tahrirlang va qaytadan urinib ko&#39;ring."
 DocType: Notification Control,Purchase Receipt Message,Qabul qaydnomasini sotib oling
 DocType: BOM,Scrap Items,Hurda buyumlari
 DocType: Production Order,Actual Start Date,Haqiqiy boshlash sanasi
 DocType: Sales Order,% of materials delivered against this Sales Order,Ushbu Buyurtma Buyurtma uchun etkazilgan materiallarning%
-apps/erpnext/erpnext/config/stock.py +12,Record item movement.,Ob&#39;ekt harakatini yozib oling.
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +57,Set default mode of payment,Standart to&#39;lov usulini belgilang
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62,Set default mode of payment,Standart to&#39;lov usulini belgilang
+DocType: Grant Application,Withdrawn,Qaytarildi
 DocType: Hub Settings,Hub Settings,Hub sozlamalari
 DocType: Project,Gross Margin %,Yalpi marj%
 DocType: BOM,With Operations,Operatsiyalar bilan
-apps/erpnext/erpnext/accounts/party.py +264,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,"Kompaniya {1} uchun valyuta {0} da buxgalteriya hisobi allaqachon olib borilgan. Iltimos, {0} valyutasi bilan oladigan yoki to&#39;lovli hisobni tanlang."
+apps/erpnext/erpnext/accounts/party.py +262,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,"Kompaniya {1} uchun valyuta {0} da buxgalteriya hisobi allaqachon olib borilgan. Iltimos, {0} valyutasi bilan oladigan yoki to&#39;lovli hisobni tanlang."
 DocType: Asset,Is Existing Asset,Mavjud aktiv
 DocType: Salary Detail,Statistical Component,Statistik komponent
 DocType: Warranty Claim,If different than customer address,Mijozning manzilidan farq qilsa
 DocType: Purchase Invoice,Without Payment of Tax,Soliq to&#39;lamasdan
 DocType: BOM Operation,BOM Operation,BOM operatsiyasi
+apps/erpnext/erpnext/config/stock.py +141,Fulfilment,Tugatish
 DocType: Purchase Taxes and Charges,On Previous Row Amount,Oldingi qatorlar miqdori bo&#39;yicha
-DocType: Student,Home Address,Uy manzili
 DocType: Item,Has Expiry Date,Tugatish sanasi
-apps/erpnext/erpnext/config/stock.py +111,Item Variant Settings.,Variant sozlamalari.
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +249,Transfer Asset,Transfer vositasi
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +269,Transfer Asset,Transfer vositasi
 DocType: POS Profile,POS Profile,Qalin profil
 DocType: Training Event,Event Name,Voqealar nomi
 DocType: Physician,Phone (Office),Telefon (ofis)
-apps/erpnext/erpnext/hooks.py +147,Admission,Qabul qilish
-apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +29,Admissions for {0},{0} uchun qabul
-apps/erpnext/erpnext/config/accounts.py +265,"Seasonality for setting budgets, targets etc.","Byudjetni belgilashning mavsumiyligi, maqsadlari va boshqalar."
+apps/erpnext/erpnext/hooks.py +151,Admission,Qabul qilish
+apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29,Admissions for {0},{0} uchun qabul
+apps/erpnext/erpnext/config/accounts.py +257,"Seasonality for setting budgets, targets etc.","Byudjetni belgilashning mavsumiyligi, maqsadlari va boshqalar."
 DocType: Supplier Scorecard Scoring Variable,Variable Name,Argumentlar nomi
-apps/erpnext/erpnext/stock/get_item_details.py +147,"Item {0} is a template, please select one of its variants","{0} element shablon bo&#39;lib, uning variantlaridan birini tanlang"
+apps/erpnext/erpnext/stock/get_item_details.py +142,"Item {0} is a template, please select one of its variants","{0} element shablon bo&#39;lib, uning variantlaridan birini tanlang"
 DocType: Asset,Asset Category,Asset kategoriyasi
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31,Net pay cannot be negative,Net to&#39;lov salbiy bo&#39;lishi mumkin emas
 DocType: Assessment Plan,Room,Xona
 DocType: Purchase Order,Advance Paid,Avans to&#39;langan
 DocType: Item,Item Tax,Mahsulot solig&#39;i
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +843,Material to Supplier,Yetkazib beruvchiga material
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +384,Excise Invoice,Aksiz billing
-apps/erpnext/erpnext/schools/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Treshold {0}% bir martadan ortiq ko&#39;rinadi
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +868,Material to Supplier,Yetkazib beruvchiga material
+DocType: Soil Texture,Loamy Sand,Loamy Sand
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +594,Excise Invoice,Aksiz billing
+apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Treshold {0}% bir martadan ortiq ko&#39;rinadi
 DocType: Expense Claim,Employees Email Id,Xodimlarning elektron pochta manzili
 DocType: Employee Attendance Tool,Marked Attendance,Belgilangan ishtirok
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138,Current Liabilities,Joriy majburiyatlar
@@ -5067,16 +5437,17 @@
 DocType: Patient,A Positive,Ijobiy
 DocType: Program,Program Name,Dastur nomi
 DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Soliqni yoki to&#39;lovni ko&#39;rib chiqing
+DocType: Driver,Driving License Category,Haydovchilik guvohnomasi kategoriyasi
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,Haqiqiy miqdori majburiydir
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +80,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0} hozirda {1} Yetkazib beruvchi reyting kartasiga ega va ushbu etkazib beruvchiga Buyurtma buyurtmalari ehtiyotkorlik bilan berilishi kerak.
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +81,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0} hozirda {1} Yetkazib beruvchi reyting kartasiga ega va ushbu etkazib beruvchiga Buyurtma buyurtmalari ehtiyotkorlik bilan berilishi kerak.
+DocType: Asset Maintenance Team,Asset Maintenance Team,Aktivlarni texnik xizmat ko&#39;rsatish guruhi
 DocType: Employee Loan,Loan Type,Kredit turi
 DocType: Scheduling Tool,Scheduling Tool,Vositachi rejalashtirish
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +176,Credit Card,Kredit karta
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180,Credit Card,Kredit karta
 DocType: BOM,Item to be manufactured or repacked,Mahsulot ishlab chiqariladi yoki qayta paketlanadi
-apps/erpnext/erpnext/config/stock.py +184,Default settings for stock transactions.,Birja bitimlari uchun standart sozlamalar.
 DocType: Employee Education,Major/Optional Subjects,Asosiy / Tanlovlar
 DocType: Sales Invoice Item,Drop Ship,Drop Ship
-DocType: Hub Settings,Suspended,To&#39;xtatildi
+DocType: Driver,Suspended,To&#39;xtatildi
 DocType: Training Event,Attendees,Ishtirokchilar
 DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Bu erda ota-onangiz, turmush o&#39;rtog&#39;ingiz va farzandlaringizning ismi va ishi kabi oilaviy ma&#39;lumotlarni saqlashingiz mumkin"
 DocType: Academic Term,Term End Date,Davr oxiri kuni
@@ -5085,12 +5456,12 @@
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23,From Currency and To Currency cannot be same,Valyuta va valyutaga nisbatan bir xil bo&#39;lmaydi
 DocType: Stock Entry,Repack,Qaytarib oling
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,Davom etishdan oldin anketani saqlashingiz kerak
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +96,Please select the Company first,Avval Kompaniya-ni tanlang
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113,Please select the Company first,Avval Kompaniya-ni tanlang
 DocType: Item Attribute,Numeric Values,Raqamli qiymatlar
-apps/erpnext/erpnext/public/js/setup_wizard.js +52,Attach Logo,Asosiy joylashtiring
+apps/erpnext/erpnext/public/js/setup_wizard.js +56,Attach Logo,Asosiy joylashtiring
 apps/erpnext/erpnext/stock/doctype/batch/batch.js +43,Stock Levels,Kabinetga darajalari
 DocType: Customer,Commission Rate,Komissiya stavkasi
-apps/erpnext/erpnext/stock/doctype/item/item.js +346,Make Variant,Variant qiling
+apps/erpnext/erpnext/stock/doctype/item/item.js +472,Make Variant,Variant qiling
 apps/erpnext/erpnext/config/hr.py +87,Block leave applications by department.,Bo&#39;lim tomonidan ilovalarni blokirovka qilish.
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +144,"Payment Type must be one of Receive, Pay and Internal Transfer","To&#39;lov shakli olish, to&#39;lash va ichki to&#39;lovlardan biri bo&#39;lishi kerak"
 apps/erpnext/erpnext/config/selling.py +179,Analytics,Tahlillar
@@ -5098,7 +5469,8 @@
 DocType: Vehicle,Model,Model
 DocType: Production Order,Actual Operating Cost,Haqiqiy Operatsion Narx
 DocType: Payment Entry,Cheque/Reference No,Tekshirish / Yo&#39;naltiruvchi No
-apps/erpnext/erpnext/accounts/doctype/account/account.py +84,Root cannot be edited.,Ildiz tahrirlanmaydi.
+DocType: Soil Texture,Clay Loam,Clay Loam
+apps/erpnext/erpnext/accounts/doctype/account/account.py +83,Root cannot be edited.,Ildiz tahrirlanmaydi.
 DocType: Item,Units of Measure,O&#39;lchov birliklari
 DocType: Manufacturing Settings,Allow Production on Holidays,Bayramlarda ishlab chiqarishga ruxsat berish
 DocType: Sales Order,Customer's Purchase Order Date,Buyurtmachining Buyurtma tarixi
@@ -5111,39 +5483,37 @@
 DocType: Company,Existing Company,Mavjud kompaniya
 DocType: Healthcare Settings,Result Emailed,Elektron pochta orqali natija
 apps/erpnext/erpnext/controllers/buying_controller.py +84,"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Soliq kategoriyasi &quot;Hammasi&quot; deb o&#39;zgartirildi, chunki barcha narsalar qimmatli qog&#39;ozlar emas"
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Mahsulot kodi&gt; Mahsulot guruhi&gt; Tovar
 apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103,Please select a csv file,CSV faylini tanlang
 DocType: Student Leave Application,Mark as Present,Mavjud deb belgilash
 DocType: Supplier Scorecard,Indicator Color,Ko&#39;rsatkich rangi
 DocType: Purchase Order,To Receive and Bill,Qabul qilish va tasdiqlash uchun
 apps/erpnext/erpnext/templates/pages/home.html +14,Featured Products,Tanlangan mahsulotlar
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +132,Designer,Dizayner
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136,Designer,Dizayner
 apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Shartlar va shartlar shabloni
 DocType: Serial No,Delivery Details,Yetkazib berish haqida ma&#39;lumot
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +487,Cost Center is required in row {0} in Taxes table for type {1},Narxlar markazi {1} qatoridagi Vergiler jadvalidagi {0} qatorida talab qilinadi
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +491,Cost Center is required in row {0} in Taxes table for type {1},Narxlar markazi {1} qatoridagi Vergiler jadvalidagi {0} qatorida talab qilinadi
 DocType: Program,Program Code,Dastur kodi
 DocType: Terms and Conditions,Terms and Conditions Help,Shartlar va shartlar Yordam
 ,Item-wise Purchase Register,Ob&#39;ektga qarab sotib olish Register
-DocType: Batch,Expiry Date,Tugash muddati
+DocType: Driver,Expiry Date,Tugash muddati
 DocType: Healthcare Settings,Employee name and designation in print,Xodimlarning nomi va nashri chop etilgan
 ,accounts-browser,hisob-brauzer
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +351,Please select Category first,"Iltimos, oldin Turkum tanlang"
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368,Please select Category first,"Iltimos, oldin Turkum tanlang"
 apps/erpnext/erpnext/config/projects.py +13,Project master.,Loyiha bo&#39;yicha mutaxassis.
 apps/erpnext/erpnext/controllers/status_updater.py +209,"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.",Haddan ortiq hisob-kitob qilish yoki buyurtma berishga ruxsat berish uchun Stokirovka sozlamalarida yoki Item-da &quot;Allowance&quot; -ni yangilang.
 DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Valyutalar yonida $ va shunga o&#39;xshash biron bir belgi ko&#39;rsatilmasin.
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +459, (Half Day),(Yarim kun)
-DocType: Supplier,Credit Days,Kredit kuni
+DocType: Payment Term,Credit Days,Kredit kuni
 apps/erpnext/erpnext/utilities/activation.py +128,Make Student Batch,Talabalar guruhini yaratish
 DocType: Fee Schedule,FRQ.,FRQ.
 DocType: Leave Type,Is Carry Forward,Oldinga harakat qilmoqda
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +815,Get Items from BOM,BOM&#39;dan ma&#39;lumotlar ol
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +840,Get Items from BOM,BOM&#39;dan ma&#39;lumotlar ol
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,Uchrashuv vaqtlari
-apps/erpnext/erpnext/controllers/accounts_controller.py +556,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},# {0} qatori: joylashtirish sanasi {1} aktivining {1} sotib olish sanasi bilan bir xil bo&#39;lishi kerak
+apps/erpnext/erpnext/controllers/accounts_controller.py +600,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},# {0} qatori: joylashtirish sanasi {1} aktivining {1} sotib olish sanasi bilan bir xil bo&#39;lishi kerak
 DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,Talabaning Institut Pansionida istiqomat qilishini tekshiring.
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125,Please enter Sales Orders in the above table,Yuqoridagi jadvalda Savdo buyurtmalarini kiriting
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +182,Not Submitted Salary Slips,Ish haqi noto&#39;g&#39;ri berilmagan
 ,Stock Summary,Qisqacha tavsifi
-apps/erpnext/erpnext/config/accounts.py +280,Transfer an asset from one warehouse to another,Ob&#39;ektni bitta ombordan ikkinchisiga o&#39;tkazish
+apps/erpnext/erpnext/config/assets.py +50,Transfer an asset from one warehouse to another,Ob&#39;ektni bitta ombordan ikkinchisiga o&#39;tkazish
 DocType: Vehicle,Petrol,Benzin
 apps/erpnext/erpnext/config/learn.py +217,Bill of Materials,Materiallar to&#39;plami
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +103,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Row {0}: Partiya turi va partiyasi oladigan / to&#39;lanadigan hisobvaraq uchun {1}
@@ -5153,9 +5523,9 @@
 DocType: Employee Loan Application,Rate of Interest,Foiz stavkasi
 DocType: Expense Claim Detail,Sanctioned Amount,Sanktsiya miqdori
 DocType: GL Entry,Is Opening,Ochilishmi?
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196,Row {0}: Debit entry can not be linked with a {1},Row {0}: Debit yozuvini {1} bilan bog&#39;lash mumkin emas
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +194,Row {0}: Debit entry can not be linked with a {1},Row {0}: Debit yozuvini {1} bilan bog&#39;lash mumkin emas
 DocType: Journal Entry,Subscription Section,Obuna bo&#39;limi
-apps/erpnext/erpnext/accounts/doctype/account/account.py +193,Account {0} does not exist,{0} hisobi mavjud emas
+apps/erpnext/erpnext/accounts/doctype/account/account.py +179,Account {0} does not exist,{0} hisobi mavjud emas
 DocType: Training Event,Training Program,O&#39;quv dasturi
 DocType: Account,Cash,Naqd pul
 DocType: Employee,Short biography for website and other publications.,Veb-sayt va boshqa adabiyotlar uchun qisqacha biografiya.
