diff --git a/erpnext/translations/sq.csv b/erpnext/translations/sq.csv
index bc7ffc7..0ab8d96 100644
--- a/erpnext/translations/sq.csv
+++ b/erpnext/translations/sq.csv
@@ -3,12 +3,12 @@
 DocType: Patient,Divorced,I divorcuar
 DocType: Buying Settings,Allow Item to be added multiple times in a transaction,Lejoni Pika për të shtuar disa herë në një transaksion
 apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,Cancel materiale Vizitoni {0} para se anulimi këtë kërkuar garancinë
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +19,Consumer Products,Consumer Products
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19,Consumer Products,Consumer Products
 DocType: Purchase Receipt,Subscription Detail,Detaji i Abonimit
 DocType: Supplier Scorecard,Notify Supplier,Njoftoni Furnizuesin
 DocType: Item,Customer Items,Items të konsumatorëve
 DocType: Project,Costing and Billing,Kushton dhe Faturimi
-apps/erpnext/erpnext/accounts/doctype/account/account.py +52,Account {0}: Parent account {1} can not be a ledger,Llogaria {0}: llogari Parent {1} nuk mund të jetë libri
+apps/erpnext/erpnext/accounts/doctype/account/account.py +48,Account {0}: Parent account {1} can not be a ledger,Llogaria {0}: llogari Parent {1} nuk mund të jetë libri
 DocType: Item,Publish Item to hub.erpnext.com,Publikojë pika për hub.erpnext.com
 apps/erpnext/erpnext/config/setup.py +88,Email Notifications,Njoftime Email
 apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26,Evaluation,vlerësim
@@ -20,10 +20,9 @@
 DocType: Restaurant Order Entry,Click Enter To Add,Kliko Enter To Add
 DocType: Employee,Rented,Me qira
 DocType: Purchase Order,PO-,poli-
-DocType: POS Profile,Applicable for User,E aplikueshme për anëtarët
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +196,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","Ndaloi Rendit prodhimit nuk mund të anulohet, tapën atë më parë për të anulluar"
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +216,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","Ndaloi Rendit prodhimit nuk mund të anulohet, tapën atë më parë për të anulluar"
 DocType: Vehicle Service,Mileage,Largësi
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +220,Do you really want to scrap this asset?,A jeni të vërtetë doni për të hequr këtë pasuri?
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +240,Do you really want to scrap this asset?,A jeni të vërtetë doni për të hequr këtë pasuri?
 DocType: Drug Prescription,Update Schedule,Orari i azhurnimit
 apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44,Select Default Supplier,Zgjidh Default Furnizuesi
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37,Currency is required for Price List {0},Valuta është e nevojshme për Lista Çmimi {0}
@@ -32,8 +31,8 @@
 DocType: Patient Appointment,Check availability,Kontrolloni disponueshmërinë
 DocType: Job Applicant,Job Applicant,Job Aplikuesi
 apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6,This is based on transactions against this Supplier. See timeline below for details,Kjo është e bazuar në transaksionet kundër këtij Furnizuesi. Shih afat kohor më poshtë për detaje
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +34,Legal,Legal
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,Actual type tax cannot be included in Item rate in row {0},Tatimi aktual lloji nuk mund të përfshihen në normë Item në rresht {0}
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120,Legal,Legal
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191,Actual type tax cannot be included in Item rate in row {0},Tatimi aktual lloji nuk mund të përfshihen në normë Item në rresht {0}
 DocType: Bank Guarantee,Customer,Klient
 DocType: Purchase Receipt Item,Required By,Kërkohet nga
 DocType: Delivery Note,Return Against Delivery Note,Kthehu Kundër dorëzimit Shënim
@@ -41,79 +40,91 @@
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43,Exchange Rate must be same as {0} {1} ({2}),Exchange Rate duhet të jetë i njëjtë si {0} {1} ({2})
 DocType: Sales Invoice,Customer Name,Emri i Klientit
 DocType: Vehicle,Natural Gas,Gazit natyror
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +120,Bank account cannot be named as {0},Llogari bankare nuk mund të quhet si {0}
+apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64,Bank account cannot be named as {0},Llogari bankare nuk mund të quhet si {0}
 DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,Kokat (ose grupe) kundër të cilit Hyrjet e kontabilitetit janë bërë dhe bilancet janë të mirëmbajtura.
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196,Outstanding for {0} cannot be less than zero ({1}),Shquar për {0} nuk mund të jetë më pak se zero ({1})
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +357,There are no submitted Salary Slips to process.,Nuk ka skeda të pagave të paraqitura për t&#39;u përpunuar.
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +343,There are no submitted Salary Slips to process.,Nuk ka skeda të pagave të paraqitura për t&#39;u përpunuar.
 DocType: Manufacturing Settings,Default 10 mins,Default 10 minuta
 DocType: Leave Type,Leave Type Name,Lini Lloji Emri
 apps/erpnext/erpnext/templates/pages/projects.js +62,Show open,Trego të hapur
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8,It is necessary to take this action today itself for the above mentioned recurring,Është e nevojshme që sot të merret vetë ky veprim për ato që përmenden më sipër
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +151,Series Updated Successfully,Seria Përditësuar sukses
 apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +18,Checkout,arkë
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +175,Accural Journal Entry Submitted,Accural Journal Hyrja Dërguar
 DocType: Pricing Rule,Apply On,Apliko On
 DocType: Item Price,Multiple Item prices.,Çmimet shumta artikull.
 ,Purchase Order Items To Be Received,Items Rendit Blerje të pranohen
 DocType: SMS Center,All Supplier Contact,Të gjitha Furnizuesi Kontakt
 DocType: Support Settings,Support Settings,Cilësimet mbështetje
-apps/erpnext/erpnext/projects/doctype/project/project.py +70,Expected End Date can not be less than Expected Start Date,Pritet Data e Përfundimit nuk mund të jetë më pak se sa pritej Data e fillimit
+apps/erpnext/erpnext/projects/doctype/project/project.py +72,Expected End Date can not be less than Expected Start Date,Pritet Data e Përfundimit nuk mund të jetë më pak se sa pritej Data e fillimit
 apps/erpnext/erpnext/utilities/transaction_base.py +110,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Row # {0}: Norma duhet të jetë i njëjtë si {1}: {2} ({3} / {4})
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +282,New Leave Application,New Pushimi Aplikimi
 ,Batch Item Expiry Status,Batch Item Status skadimit
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +180,Bank Draft,Draft Bank
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184,Bank Draft,Draft Bank
+DocType: Membership,membership validaty section,seksioni validaty anëtarësimit
 DocType: Mode of Payment Account,Mode of Payment Account,Mënyra e Llogarisë Pagesave
 DocType: Consultation,Consultation,këshillim
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +21,Sales and Returns,Shitjet dhe Kthimet
+DocType: Accounts Settings,Show Payment Schedule in Print,Trego orarin e pagesës në Print
+apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19,Sales and Returns,Shitjet dhe Kthimet
 apps/erpnext/erpnext/stock/doctype/item/item.js +56,Show Variants,Shfaq Variantet
 DocType: Academic Term,Academic Term,Term akademik
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,material
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +670,Quantity,Sasi
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546,Accounts table cannot be blank.,Llogaritë tabelë nuk mund të jetë bosh.
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66,Making website,Marrja e faqes
+DocType: Opening Invoice Creation Tool Item,Quantity,Sasi
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +544,Accounts table cannot be blank.,Llogaritë tabelë nuk mund të jetë bosh.
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154,Loans (Liabilities),Kredi (obligimeve)
 DocType: Employee Education,Year of Passing,Viti i kalimit
 DocType: Item,Country of Origin,Vendi i origjinës
+DocType: Soil Texture,Soil Texture Criteria,Kriteret e Cilësi të Tokës
 apps/erpnext/erpnext/templates/includes/product_page.js +24,In Stock,Në magazinë
+apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16,Primary Contact Details,Detajet e Fillimit të Kontaktit
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46,Open Issues,Çështjet e hapura
 DocType: Production Plan Item,Production Plan Item,Prodhimit Plani i artikullit
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +144,User {0} is already assigned to Employee {1},Përdoruesi {0} është caktuar tashmë për punonjësit {1}
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +149,User {0} is already assigned to Employee {1},Përdoruesi {0} është caktuar tashmë për punonjësit {1}
 DocType: Lab Test Groups,Add new line,Shto një rresht të ri
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +31,Health Care,Kujdes shëndetësor
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31,Health Care,Kujdes shëndetësor
 apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,Delay in payment (Days),Vonesa në pagesa (ditë)
+DocType: Payment Terms Template Detail,Payment Terms Template Detail,Kushtet e Pagesës Detailin e Modelit
 DocType: Lab Prescription,Lab Prescription,Kërkimi i laboratorit
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +185,Sort by Price,Rendit sipas Çmimit
 apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26,Service Expense,shpenzimeve të shërbimit
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +888,Serial Number: {0} is already referenced in Sales Invoice: {1},Numri Serial: {0} është referuar tashmë në shitje Faturë: {1}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +849,Invoice,Faturë
-DocType: Maintenance Schedule Item,Periodicity,Periodicitet
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +893,Serial Number: {0} is already referenced in Sales Invoice: {1},Numri Serial: {0} është referuar tashmë në shitje Faturë: {1}
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874,Invoice,Faturë
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +109,Make Retention Stock Entry,Bëni regjistrimin e aksioneve të mbajtjes
+DocType: Purchase Invoice Item,Item Weight Details,Pesha Detajet e artikullit
+DocType: Asset Maintenance Log,Periodicity,Periodicitet
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21,Fiscal Year {0} is required,Viti Fiskal {0} është e nevojshme
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +21,Defense,Mbrojtje
+DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,Distanca minimale midis rreshtave të bimëve për rritje optimale
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21,Defense,Mbrojtje
 DocType: Salary Component,Abbr,Abbr
 DocType: Appraisal Goal,Score (0-5),Rezultati (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} nuk përputhet me {3}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +223,Row {0}: {1} {2} does not match with {3},Row {0}: {1} {2} nuk përputhet me {3}
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +75,Row # {0}:,Row # {0}:
 DocType: Timesheet,Total Costing Amount,Total Shuma kushton
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Klienti&gt; Grupi i Klientit&gt; Territori
 DocType: Delivery Note,Vehicle No,Automjeteve Nuk ka
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +160,Please select Price List,"Ju lutem, përzgjidhni Lista e Çmimeve"
 DocType: Accounts Settings,Currency Exchange Settings,Cilësimet e këmbimit valutor
 apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +78,Row #{0}: Payment document is required to complete the trasaction,Row # {0}: dokument Pagesa është e nevojshme për të përfunduar trasaction
 DocType: Production Order Operation,Work In Progress,Punë në vazhdim
-apps/erpnext/erpnext/schools/report/absent_student_report/absent_student_report.py +13,Please select date,Ju lutemi zgjidhni data
+apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13,Please select date,Ju lutemi zgjidhni data
 DocType: Employee,Holiday List,Festa Lista
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +123,Accountant,Llogaritar
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127,Accountant,Llogaritar
 DocType: Hub Settings,Selling Price List,Lista e Çmimeve të Shitjes
 DocType: Patient,Tobacco Current Use,Përdorimi aktual i duhanit
+apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +21,Selling Rate,Shitja e normës
 DocType: Cost Center,Stock User,Stock User
+DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
 DocType: Company,Phone No,Telefoni Asnjë
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +50,Course Schedules created:,Oraret e kursit krijuar:
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +237,New {0}: #{1},New {0}: # {1}
+DocType: Delivery Trip,Initial Email Notification Sent,Dërgimi fillestar i email-it është dërguar
 ,Sales Partners Commission,Shitjet Partnerët Komisioni
+DocType: Soil Texture,Sandy Clay Loam,Sandy Clay Loam
 DocType: Purchase Invoice,Rounding Adjustment,Rregullimi i rrumbullakosjes
 apps/erpnext/erpnext/setup/doctype/company/company.py +45,Abbreviation cannot have more than 5 characters,Shkurtesa nuk mund të ketë më shumë se 5 karaktere
 DocType: Physician Schedule Time Slot,Physician Schedule Time Slot,Orari Orari Orari i kohës
 DocType: Payment Request,Payment Request,Kërkesë Pagesa
 DocType: Asset,Value After Depreciation,Vlera Pas Zhvlerësimi
-DocType: Employee,O+,O +
+DocType: Student,O+,O +
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt_dashboard.py +18,Related,i lidhur
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43,Attendance date can not be less than employee's joining date,date Pjesëmarrja nuk mund të jetë më pak se data bashkuar punëmarrësit
 DocType: Grading Scale,Grading Scale Name,Nota Scale Emri
@@ -126,150 +137,155 @@
 apps/erpnext/erpnext/accounts/utils.py +73,{0} {1} not in any active Fiscal Year.,{0} {1} ne asnje vitit aktiv Fiskal.
 DocType: Packed Item,Parent Detail docname,Docname prind Detail
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69,"Reference: {0}, Item Code: {1} and Customer: {2}",Referenca: {0} Artikull Code: {1} dhe klientit: {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.,Hapja për një punë.
-apps/erpnext/erpnext/schools/doctype/assessment_result_tool/assessment_result_tool.js +147,{0} Result submittted,{0} Rezultati i paraqitur
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +103,BOM is not specified for subcontracting item {0} at row {1},BOM nuk është specifikuar për nënkontraktimin e sendit {0} në rreshtin {1}
+apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149,{0} Result submittted,{0} Rezultati i paraqitur
 DocType: Item Attribute,Increment,Rritje
 apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +61,Timespan,Intervalin kohor
 apps/erpnext/erpnext/public/js/stock_analytics.js +61,Select Warehouse...,Zgjidh Magazina ...
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +6,Advertising,Reklamat
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6,Advertising,Reklamat
 apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22,Same Company is entered more than once,Njëjta kompani është futur më shumë se një herë
 DocType: Patient,Married,I martuar
 apps/erpnext/erpnext/accounts/party.py +44,Not permitted for {0},Nuk lejohet për {0}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +568,Get items from,Të marrë sendet nga
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +457,Stock cannot be updated against Delivery Note {0},Stock nuk mund të rifreskohet kundër dorëzimit Shënim {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593,Get items from,Të marrë sendet nga
+DocType: Price List,Price Not UOM Dependant,Çmimi nuk është UOM i varur
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +461,Stock cannot be updated against Delivery Note {0},Stock nuk mund të rifreskohet kundër dorëzimit Shënim {0}
 apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},Product {0}
 apps/erpnext/erpnext/templates/generators/item_group.html +43,No items listed,Nuk ka artikuj të listuara
+DocType: Asset Repair,Error Description,Përshkrimi i gabimit
 DocType: Payment Reconciliation,Reconcile,Pajtojë
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +30,Grocery,Ushqimore
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30,Grocery,Ushqimore
 DocType: Quality Inspection Reading,Reading 1,Leximi 1
-DocType: Process Payroll,Make Bank Entry,Bëni Banka Hyrja
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +40,Pension Funds,Fondet pensionale
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +88,Next Depreciation Date cannot be before Purchase Date,Zhvlerësimi Date tjetër nuk mund të jetë më parë data e blerjes
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40,Pension Funds,Fondet pensionale
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +88,Next Depreciation Date cannot be before Purchase Date,Zhvlerësimi Date tjetër nuk mund të jetë më parë data e blerjes
+DocType: Crop,Perennial,gjithëvjetor
 DocType: Consultation,Consultation Date,Data e konsultimit
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +131,Product listing and discovery for ERPNext users,Listimi i produktit dhe zbulimi për përdoruesit ERPNext
 DocType: SMS Center,All Sales Person,Të gjitha Person Sales
 DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,** Shpërndarja mujore ** ju ndihmon të shpërndani Buxhetore / Target gjithë muaj nëse keni sezonalitetit në biznesin tuaj.
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1727,Not items found,Nuk sende gjetur
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1742,Not items found,Nuk sende gjetur
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183,Salary Structure Missing,Struktura Paga Missing
 DocType: Lead,Person Name,Emri personi
 DocType: Sales Invoice Item,Sales Invoice Item,Item Shitjet Faturë
 DocType: Account,Credit,Kredi
 DocType: POS Profile,Write Off Cost Center,Shkruani Off Qendra Kosto
-apps/erpnext/erpnext/public/js/setup_wizard.js +114,"e.g. ""Primary School"" or ""University""",p.sh. &quot;Shkolla fillore&quot; ose &quot;University&quot;
-apps/erpnext/erpnext/config/stock.py +32,Stock Reports,Stock Raportet
+apps/erpnext/erpnext/public/js/setup_wizard.js +117,"e.g. ""Primary School"" or ""University""",p.sh. &quot;Shkolla fillore&quot; ose &quot;University&quot;
+apps/erpnext/erpnext/config/stock.py +28,Stock Reports,Stock Raportet
 DocType: Warehouse,Warehouse Detail,Magazina Detail
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +164,Credit limit has been crossed for customer {0} {1}/{2},Kufiri i kreditit ka kaluar për konsumator {0} {1} / {2}
-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.,"Term End Date nuk mund të jetë më vonë se Data Year fund të vitit akademik në të cilin termi është i lidhur (Viti Akademik {}). Ju lutem, Korrigjo datat dhe provoni përsëri."
-apps/erpnext/erpnext/stock/doctype/item/item.py +479,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","&quot;A është e aseteve fikse&quot; nuk mund të jetë e pakontrolluar, pasi ekziston rekord Pasurive ndaj artikullit"
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +192,Credit limit has been crossed for customer {0} {1}/{2},Kufiri i kreditit ka kaluar për konsumator {0} {1} / {2}
+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.,"Term End Date nuk mund të jetë më vonë se Data Year fund të vitit akademik në të cilin termi është i lidhur (Viti Akademik {}). Ju lutem, Korrigjo datat dhe provoni përsëri."
+apps/erpnext/erpnext/stock/doctype/item/item.py +258,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","&quot;A është e aseteve fikse&quot; nuk mund të jetë e pakontrolluar, pasi ekziston rekord Pasurive ndaj artikullit"
+DocType: Delivery Trip,Departure Time,Koha e Nisjes
 DocType: Vehicle Service,Brake Oil,Brake Oil
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Klienti&gt; Grupi i Klientit&gt; Territori
 DocType: Tax Rule,Tax Type,Lloji Tatimore
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +555,Taxable Amount,Shuma e tatueshme
+apps/erpnext/erpnext/controllers/taxes_and_totals.py +561,Taxable Amount,Shuma e tatueshme
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160,You are not authorized to add or update entries before {0},Ju nuk jeni i autorizuar për të shtuar ose shënimet e para përditësim {0}
 DocType: BOM,Item Image (if not slideshow),Item Image (nëse nuk Slideshow)
 DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,(Ore Rate / 60) * aktuale Operacioni Koha
-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,Rreshti # {0}: Referenca Lloji i Dokumentit duhet të jetë një nga Kërkesat e Shpenzimeve ose Hyrja në Regjistrim
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +917,Select BOM,Zgjidh BOM
+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,Rreshti # {0}: Referenca Lloji i Dokumentit duhet të jetë një nga Kërkesat e Shpenzimeve ose Hyrja në Regjistrim
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +964,Select BOM,Zgjidh BOM
 DocType: SMS Log,SMS Log,SMS Identifikohu
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Kostoja e Artikujve dorëzohet
+apps/erpnext/erpnext/config/hr.py +127,Manage advance amount given to the Employee,Menaxhoni shumën paraprake që i jepet punonjësit
 apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38,The holiday on {0} is not between From Date and To Date,Festa në {0} nuk është në mes Nga Data dhe To Date
 DocType: Student Log,Student Log,Student Identifikohu
 DocType: Quality Inspection,Get Specification Details,Get Specifikimi Details
 apps/erpnext/erpnext/config/buying.py +165,Templates of supplier standings.,Modelet e renditjes së furnizuesit.
 DocType: Lead,Interested,I interesuar
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +171,Opening,Hapje
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +28,From {0} to {1},Nga {0} në {1}
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +219,Opening,Hapje
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +29,From {0} to {1},Nga {0} në {1}
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50,Failed to setup taxes,Dështoi në vendosjen e taksave
 DocType: Item,Copy From Item Group,Kopje nga grupi Item
+DocType: Delivery Trip,Delivery Notification,Njoftimi i Dorëzimit
 DocType: Journal Entry,Opening Entry,Hyrja Hapja
 apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25,Account Pay Only,Llogaria Pay Vetëm
 DocType: Employee Loan,Repay Over Number of Periods,Paguaj Over numri i periudhave
 DocType: Stock Entry,Additional Costs,Kostot shtesë
-apps/erpnext/erpnext/accounts/doctype/account/account.py +141,Account with existing transaction can not be converted to group.,Llogaria me transaksion ekzistuese nuk mund të konvertohet në grup.
+apps/erpnext/erpnext/accounts/doctype/account/account.py +140,Account with existing transaction can not be converted to group.,Llogaria me transaksion ekzistuese nuk mund të konvertohet në grup.
 DocType: Lead,Product Enquiry,Produkt Enquiry
-DocType: Academic Term,Schools,shkollat
-DocType: School Settings,Validate Batch for Students in Student Group,Vlereso Batch për Studentët në Grupin e Studentëve
+DocType: Education Settings,Validate Batch for Students in Student Group,Vlereso Batch për Studentët në Grupin e Studentëve
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35,No leave record found for employee {0} for {1},Nuk ka rekord leje gjetur për punonjës {0} për {1}
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23,Please enter company first,Ju lutemi shkruani kompani parë
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +358,Please select Company first,Ju lutemi zgjidhni kompania e parë
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366,Please select Company first,Ju lutemi zgjidhni kompania e parë
 DocType: Employee Education,Under Graduate,Nën diplomuar
 apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27,Target On,Target Në
 DocType: BOM,Total Cost,Kostoja Totale
+DocType: Soil Analysis,Ca/K,Ca / K
 DocType: Journal Entry Account,Employee Loan,Kredi punonjës
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +108,Activity Log:,Identifikohu Aktiviteti:
 DocType: Fee Schedule,Send Payment Request Email,Dërgoni Email Kërkesën për Pagesë
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +256,Item {0} does not exist in the system or has expired,Item {0} nuk ekziston në sistemin apo ka skaduar
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +44,Real Estate,Real Estate
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +259,Item {0} does not exist in the system or has expired,Item {0} nuk ekziston në sistemin apo ka skaduar
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44,Real Estate,Real Estate
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,Deklarata e llogarisë
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +41,Pharmaceuticals,Farmaceutike
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41,Pharmaceuticals,Farmaceutike
 DocType: Purchase Invoice Item,Is Fixed Asset,Është i aseteve fikse
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +234,"Available qty is {0}, you need {1}","Qty në dispozicion është {0}, ju duhet {1}"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +251,"Available qty is {0}, you need {1}","Qty në dispozicion është {0}, ju duhet {1}"
 DocType: Expense Claim Detail,Claim Amount,Shuma Claim
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +51,Duplicate customer group found in the cutomer group table,Grupi i konsumatorëve Duplicate gjenden në tabelën e grupit cutomer
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56,Duplicate customer group found in the cutomer group table,Grupi i konsumatorëve Duplicate gjenden në tabelën e grupit cutomer
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31,Supplier Type / Supplier,Furnizuesi Lloji / Furnizuesi
 DocType: Naming Series,Prefix,Parashtesë
 apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7,Event Location,Vendi i ngjarjes
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +64,Consumable,Harxhuese
-DocType: Employee,B-,B-
-DocType: Upload Attendance,Import Log,Import Identifikohu
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68,Consumable,Harxhuese
+DocType: Student,B-,B-
 DocType: Production Planning Tool,Pull Material Request of type Manufacture based on the above criteria,Pull materiale Kërkesa e tipit Prodhime bazuar në kriteret e mësipërme
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +100,Successfully unregistered.,S&#39;aktivizohet me sukses.
-DocType: Training Result Employee,Grade,Gradë
+DocType: Assessment Result,Grade,Gradë
 DocType: Restaurant Table,No of Seats,Jo e Vendeve
 DocType: Subscription,"To add dynamic subject, use jinja tags like
 
 <div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>","Për të shtuar lëndë dinamike, përdorni etiketat jinja si <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>"
 DocType: Sales Invoice Item,Delivered By Supplier,Dorëzuar nga furnizuesi
+DocType: Asset Maintenance Task,Asset Maintenance Task,Detyra e mirëmbajtjes së aseteve
 DocType: SMS Center,All Contact,Të gjitha Kontakt
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +905,Production Order already created for all items with BOM,Rendit prodhimi krijuar tashmë për të gjitha sendet me bom
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +220,Annual Salary,Paga vjetore
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +952,Production Order already created for all items with BOM,Rendit prodhimi krijuar tashmë për të gjitha sendet me bom
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +230,Annual Salary,Paga vjetore
 DocType: Daily Work Summary,Daily Work Summary,Daily Përmbledhje Work
 DocType: Period Closing Voucher,Closing Fiscal Year,Mbyllja e Vitit Fiskal
-apps/erpnext/erpnext/accounts/party.py +368,{0} {1} is frozen,{0} {1} është e ngrirë
-apps/erpnext/erpnext/setup/doctype/company/company.py +132,Please select Existing Company for creating Chart of Accounts,"Ju lutem, përzgjidhni kompanie ekzistuese për krijimin Skemën e Kontabilitetit"
+apps/erpnext/erpnext/accounts/party.py +380,{0} {1} is frozen,{0} {1} është e ngrirë
+apps/erpnext/erpnext/setup/doctype/company/company.py +129,Please select Existing Company for creating Chart of Accounts,"Ju lutem, përzgjidhni kompanie ekzistuese për krijimin Skemën e Kontabilitetit"
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80,Stock Expenses,Stock Shpenzimet
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +96,Select Target Warehouse,Zgjidhni Target Magazina
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +96,Select Target Warehouse,Zgjidhni Target Magazina
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +103,Select Target Warehouse,Zgjidhni Target Magazina
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +103,Select Target Warehouse,Zgjidhni Target Magazina
 apps/erpnext/erpnext/hr/doctype/employee/employee.js +80,Please enter Preferred Contact Email,Ju lutemi shkruani Preferred miqve
-DocType: Program Enrollment,School Bus,Autobus shkolle
 DocType: Journal Entry,Contra Entry,Contra Hyrja
 DocType: Journal Entry Account,Credit in Company Currency,Kreditit në kompanisë Valuta
 DocType: Lab Test UOM,Lab Test UOM,Lab Test UOM
 DocType: Delivery Note,Installation Status,Instalimi Statusi
-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}",A doni për të rinovuar pjesëmarrjen? <br> Prezent: {0} \ <br> Mungon: {1}
-apps/erpnext/erpnext/controllers/buying_controller.py +325,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Pranuar + Refuzuar Qty duhet të jetë e barabartë me sasinë e pranuara për Item {0}
+apps/erpnext/erpnext/controllers/buying_controller.py +326,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Pranuar + Refuzuar Qty duhet të jetë e barabartë me sasinë e pranuara për Item {0}
 DocType: Request for Quotation,RFQ-,RFQ-
 DocType: Item,Supply Raw Materials for Purchase,Furnizimit të lëndëve të para për Blerje
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +149,At least one mode of payment is required for POS invoice.,Të paktën një mënyra e pagesës është e nevojshme për POS faturë.
+DocType: Agriculture Analysis Criteria,Fertilizer,pleh
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +150,At least one mode of payment is required for POS invoice.,Të paktën një mënyra e pagesës është e nevojshme për POS faturë.
 DocType: Products Settings,Show Products as a List,Shfaq Produkte si një Lista
-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","Shkarko template, plotësoni të dhënat e duhura dhe të bashkëngjitni e tanishëm. Të gjitha datat dhe punonjës kombinim në periudhën e zgjedhur do të vijë në template, me të dhënat ekzistuese frekuentimit"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +482,Item {0} is not active or end of life has been reached,Item {0} nuk është aktiv apo fundi i jetës është arritur
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +507,Item {0} is not active or end of life has been reached,Item {0} nuk është aktiv apo fundi i jetës është arritur
 DocType: Student Admission Program,Minimum Age,Mosha minimale
-apps/erpnext/erpnext/utilities/user_progress.py +169,Example: Basic Mathematics,Shembull: Matematikë themelore
-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","Të përfshijnë tatimin në rresht {0} në shkallën Item, taksat në rreshtat {1} duhet të përfshihen edhe"
-apps/erpnext/erpnext/config/hr.py +218,Settings for HR Module,Cilësimet për HR Module
+apps/erpnext/erpnext/utilities/user_progress.py +187,Example: Basic Mathematics,Shembull: Matematikë themelore
+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","Të përfshijnë tatimin në rresht {0} në shkallën Item, taksat në rreshtat {1} duhet të përfshihen edhe"
+apps/erpnext/erpnext/config/hr.py +223,Settings for HR Module,Cilësimet për HR Module
 DocType: SMS Center,SMS Center,SMS Center
 DocType: Sales Invoice,Change Amount,Ndryshimi Shuma
 DocType: BOM Update Tool,New BOM,Bom i ri
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +117,Please enter Delivery Date,Ju lutemi shkruani datën e dorëzimit
+DocType: Driver,Driving License Categories,Kategoritë e Licencës së Drejtimit
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118,Please enter Delivery Date,Ju lutemi shkruani datën e dorëzimit
 DocType: Depreciation Schedule,Make Depreciation Entry,Bëni Amortizimi Hyrja
 DocType: Appraisal Template Goal,KRA,KRA
 DocType: Lead,Request Type,Kërkesë Type
 apps/erpnext/erpnext/hr/doctype/offer_letter/offer_letter.js +17,Make Employee,bëni punonjës
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +14,Broadcasting,Transmetimi
-apps/erpnext/erpnext/config/accounts.py +321,Setup mode of POS (Online / Offline),Modaliteti i konfigurimit të POS (Online / Offline)
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +187,Execution,Ekzekutim
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14,Broadcasting,Transmetimi
+apps/erpnext/erpnext/config/accounts.py +313,Setup mode of POS (Online / Offline),Modaliteti i konfigurimit të POS (Online / Offline)
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191,Execution,Ekzekutim
 apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Detajet e operacioneve të kryera.
-DocType: Serial No,Maintenance Status,Mirëmbajtja Statusi
+DocType: Asset Maintenance Log,Maintenance Status,Mirëmbajtja Statusi
+apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10,Membership Details,Detajet e Anëtarësimit
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Furnizuesi është i detyruar kundrejt llogarisë pagueshme {2}
 apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,Artikuj dhe Çmimeve
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2,Total hours: {0},Gjithsej orë: {0}
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,From Date should be within the Fiscal Year. Assuming From Date = {0},Nga Data duhet të jetë brenda vitit fiskal. Duke supozuar Nga Data = {0}
 DocType: Drug Prescription,Interval,interval
-DocType: Customer,Individual,Individ
-DocType: Interest,Academics User,akademikët User
+DocType: Grant Application,Individual,Individ
+DocType: Academic Term,Academics User,akademikët User
 DocType: Cheque Print Template,Amount In Figure,Shuma Në Figurën
 DocType: Employee Loan Application,Loan Info,kredi Info
 apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,Plani për vizita të mirëmbajtjes.
@@ -282,17 +298,19 @@
 apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,Lista çmimi duhet të jetë i zbatueshëm për blerjen ose shitjen e
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79,Installation date cannot be before delivery date for Item {0},Data Instalimi nuk mund të jetë para datës së dorëzimit për pika {0}
 DocType: Pricing Rule,Discount on Price List Rate (%),Zbritje në listën e çmimeve Norma (%)
-apps/erpnext/erpnext/healthcare/setup.py +214,Biochemistry,biokimi
+apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112,Item Template,Modeli i artikullit
+apps/erpnext/erpnext/healthcare/setup.py +215,Biochemistry,biokimi
 DocType: Offer Letter,Select Terms and Conditions,Zgjidhni Termat dhe Kushtet
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +60,Out Value,Vlera out
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70,Out Value,Vlera out
 DocType: Production Planning Tool,Sales Orders,Sales Urdhërat
 DocType: Purchase Taxes and Charges,Valuation,Vlerësim
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +373,Set as Default,Vendosur si default
 ,Purchase Order Trends,Rendit Blerje Trendet
 apps/erpnext/erpnext/utilities/user_progress.py +75,Go to Customers,Shkoni tek Konsumatorët
 apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7,The request for quotation can be accessed by clicking on the following link,Kërkesa për kuotim mund të arrihen duke klikuar në linkun e mëposhtëm
 apps/erpnext/erpnext/config/hr.py +81,Allocate leaves for the year.,Alokimi i lë për vitin.
 DocType: SG Creation Tool Course,SG Creation Tool Course,SG Kursi Krijimi Tool
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +236,Insufficient Stock,Stock pamjaftueshme
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +253,Insufficient Stock,Stock pamjaftueshme
 DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Planifikimi Disable kapaciteteve dhe Ndjekja Koha
 DocType: Email Digest,New Sales Orders,Shitjet e reja Urdhërat
 DocType: Bank Guarantee,Bank Account,Llogarisë Bankare
@@ -300,67 +318,69 @@
 apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13,You cannot delete Project Type 'External',Ju nuk mund të fshini llojin e projektit &#39;Jashtë&#39;
 DocType: Employee,Create User,Krijo përdoruesin
 DocType: Selling Settings,Default Territory,Gabim Territorit
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +53,Television,Televizion
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53,Television,Televizion
 DocType: Production Order Operation,Updated via 'Time Log',Përditësuar nëpërmjet &#39;Koha Identifikohu &quot;
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +427,Advance amount cannot be greater than {0} {1},shuma paraprakisht nuk mund të jetë më i madh se {0} {1}
+apps/erpnext/erpnext/controllers/taxes_and_totals.py +428,Advance amount cannot be greater than {0} {1},shuma paraprakisht nuk mund të jetë më i madh se {0} {1}
 DocType: Naming Series,Series List for this Transaction,Lista Seria për këtë transaksion
 DocType: Company,Enable Perpetual Inventory,Aktivizo Inventari Përhershëm
 DocType: Company,Default Payroll Payable Account,Default Payroll Llogaria e pagueshme
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +51,Update Email Group,Update Email Group
+apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51,Update Email Group,Update Email Group
 DocType: Sales Invoice,Is Opening Entry,Është Hapja Hyrja
 DocType: Lab Test Template,"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Nëse nuk kontrollohet, artikulli nuk do të shfaqet në Faturën e Shitjes, por mund të përdoret në krijimin e testeve në grup."
 DocType: Customer Group,Mention if non-standard receivable account applicable,Përmend në qoftë se jo-standarde llogari të arkëtueshme të zbatueshme
 DocType: Course Schedule,Instructor Name,instruktor Emri
 DocType: Supplier Scorecard,Criteria Setup,Vendosja e kritereve
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +179,For Warehouse is required before Submit,Për Magazina është e nevojshme para se të Submit
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +199,For Warehouse is required before Submit,Për Magazina është e nevojshme para se të Submit
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8,Received On,Marrë më
 DocType: Sales Partner,Reseller,Reseller
 DocType: Codification Table,Medical Code,Kodi mjekësor
 DocType: Production Planning Tool,"If checked, Will include non-stock items in the Material Requests.","Nëse zgjidhet, do të përfshijë çështje jo-aksioneve në kërkesat materiale."
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20,Please enter Company,Ju lutemi shkruani Company
 DocType: Delivery Note Item,Against Sales Invoice Item,Kundër Item Shitjet Faturë
+DocType: Agriculture Analysis Criteria,Linked Doctype,Doktrup i lidhur
 ,Production Orders in Progress,Urdhërat e prodhimit në Progres
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +39,Net Cash from Financing,Paraja neto nga Financimi
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2313,"LocalStorage is full , did not save","LocalStorage është e plotë, nuk ka shpëtuar"
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2332,"LocalStorage is full , did not save","LocalStorage është e plotë, nuk ka shpëtuar"
 DocType: Lead,Address & Contact,Adresa &amp; Kontakt
 DocType: Leave Allocation,Add unused leaves from previous allocations,Shtoni gjethe të papërdorura nga alokimet e mëparshme
 DocType: Sales Partner,Partner website,website partner
 DocType: Restaurant Order Entry,Add Item,Shto Item
 DocType: Lab Test,Custom Result,Rezultati personal
-apps/erpnext/erpnext/utilities/user_progress.py +71,Contact Name,Kontakt Emri
+DocType: Delivery Stop,Contact Name,Kontakt Emri
 DocType: Course Assessment Criteria,Course Assessment Criteria,Kriteret e vlerësimit kurs
-DocType: Process Payroll,Creates salary slip for above mentioned criteria.,Krijon shqip pagave për kriteret e përmendura më sipër.
 DocType: POS Customer Group,POS Customer Group,POS Group Customer
+DocType: Land Unit,Land Unit describing various land assets,Njësia e Tokës që përshkruan pasuritë e ndryshme të tokës
 DocType: Cheque Print Template,Line spacing for amount in words,Hapësira Line për shumën në fjalë
 DocType: Vehicle,Additional Details,Detaje shtesë
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Assessment Plan: ,Plani i Vlerësimit:
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Assessment Plan: ,Plani i Vlerësimit:
 apps/erpnext/erpnext/templates/generators/bom.html +85,No description given,Nuk ka përshkrim dhënë
 apps/erpnext/erpnext/config/buying.py +13,Request for purchase.,Kërkesë për blerje.
 DocType: Lab Test,Submitted Date,Data e Dërguar
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6,This is based on the Time Sheets created against this project,Kjo është e bazuar në Fletët Koha krijuara kundër këtij projekti
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +390,Net Pay cannot be less than 0,Pay Net nuk mund të jetë më pak se 0
+DocType: Payment Term,Credit Months,Muajt e Kredisë
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +409,Net Pay cannot be less than 0,Pay Net nuk mund të jetë më pak se 0
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,"To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription","Për të ndaluar dërgimin e njoftimeve të përsëritura të gabimit nga sistemi, ne kemi kontrolluar fushën e Kufizuar në pajtim"
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +224,Only the selected Leave Approver can submit this Leave Application,Vetëm aprovuesi zgjedhur Pushimi mund ta paraqesë këtë kërkesë lini
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +116,Relieving Date must be greater than Date of Joining,Lehtësimin Data duhet të jetë më i madh se data e bashkimit
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +228,Leaves per Year,Lë në vit
-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}: Ju lutem kontrolloni &#39;A Advance&#39; kundër llogaria {1} në qoftë se kjo është një hyrje paraprakisht.
-apps/erpnext/erpnext/stock/utils.py +212,Warehouse {0} does not belong to company {1},Magazina {0} nuk i përkasin kompanisë {1}
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +121,Relieving Date must be greater than Date of Joining,Lehtësimin Data duhet të jetë më i madh se data e bashkimit
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238,Leaves per Year,Lë në vit
+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}: Ju lutem kontrolloni &#39;A Advance&#39; kundër llogaria {1} në qoftë se kjo është një hyrje paraprakisht.
+apps/erpnext/erpnext/stock/utils.py +217,Warehouse {0} does not belong to company {1},Magazina {0} nuk i përkasin kompanisë {1}
 DocType: Email Digest,Profit & Loss,Fitimi dhe Humbja
-apps/erpnext/erpnext/utilities/user_progress.py +126,Litre,Litra
+apps/erpnext/erpnext/utilities/user_progress.py +144,Litre,Litra
 DocType: Task,Total Costing Amount (via Time Sheet),Total Kostoja Shuma (via Koha Sheet)
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.py +63,Please setup Students under Student Groups,Ju lutemi të organizoni Studentët nën Grupet Studentore
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +69,Please setup Students under Student Groups,Ju lutemi të organizoni Studentët nën Grupet Studentore
 DocType: Item Website Specification,Item Website Specification,Item Faqja Specifikimi
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +477,Leave Blocked,Lini Blocked
-apps/erpnext/erpnext/stock/doctype/item/item.py +723,Item {0} has reached its end of life on {1},Item {0} ka arritur në fund të saj të jetës në {1}
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +88,Bank Entries,Banka Entries
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +119,Annual,Vjetor
+apps/erpnext/erpnext/stock/doctype/item/item.py +709,Item {0} has reached its end of life on {1},Item {0} ka arritur në fund të saj të jetës në {1}
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +99,Bank Entries,Banka Entries
+DocType: Crop,Annual,Vjetor
 DocType: Stock Reconciliation Item,Stock Reconciliation Item,Stock Pajtimi Item
 DocType: Stock Entry,Sales Invoice No,Shitjet Faturë Asnjë
 DocType: Material Request Item,Min Order Qty,Rendit min Qty
 DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Kursi Group Student Krijimi Tool
 DocType: Lead,Do Not Contact,Mos Kontaktoni
-apps/erpnext/erpnext/utilities/user_progress.py +189,People who teach at your organisation,Njerëzit të cilët japin mësim në organizatën tuaj
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +131,Software Developer,Software Developer
+apps/erpnext/erpnext/utilities/user_progress.py +207,People who teach at your organisation,Njerëzit të cilët japin mësim në organizatën tuaj
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135,Software Developer,Software Developer
 DocType: Item,Minimum Order Qty,Minimale Rendit Qty
 DocType: Pricing Rule,Supplier Type,Furnizuesi Type
 DocType: Course Scheduling Tool,Course Start Date,Sigurisht Data e fillimit
@@ -369,58 +389,64 @@
 DocType: Item,Publish in Hub,Publikojë në Hub
 DocType: Student Admission,Student Admission,Pranimi Student
 ,Terretory,Terretory
-apps/erpnext/erpnext/stock/doctype/item/item.py +743,Item {0} is cancelled,Item {0} është anuluar
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +923,Material Request,Kërkesë materiale
+apps/erpnext/erpnext/stock/doctype/item/item.py +729,Item {0} is cancelled,Item {0} është anuluar
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +948,Material Request,Kërkesë materiale
 DocType: Bank Reconciliation,Update Clearance Date,Update Pastrimi Data
 DocType: Item,Purchase Details,Detajet Blerje
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +357,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Item {0} nuk u gjet në &#39;e para materiale të furnizuara &quot;tryezë në Rendit Blerje {1}
-DocType: Patient Relation,Relation,Lidhje
-DocType: Shipping Rule,Worldwide Shipping,Shipping në mbarë botën
-DocType: Patient Relation,Mother,nënë
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +382,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Item {0} nuk u gjet në &#39;e para materiale të furnizuara &quot;tryezë në Rendit Blerje {1}
+DocType: Salary Slip,Total Principal Amount,Shuma Totale Totale
+DocType: Student Guardian,Relation,Lidhje
+DocType: Student Guardian,Mother,nënë
 DocType: Restaurant Reservation,Reservation End Time,Koha e përfundimit të rezervimit
+DocType: Crop,Biennial,dyvjeçar
 apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Urdhra të konfirmuara nga konsumatorët.
 DocType: Purchase Receipt Item,Rejected Quantity,Sasi të refuzuar
-apps/erpnext/erpnext/schools/doctype/fees/fees.py +80,Payment request {0} created,Kërkesa për pagesë {0} u krijua
-apps/erpnext/erpnext/healthcare/setup.py +254,Low Sensitivity,Ndjeshmëri e ulët
+apps/erpnext/erpnext/education/doctype/fees/fees.py +80,Payment request {0} created,Kërkesa për pagesë {0} u krijua
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Open Orders,Urdhërat e Hapur
+apps/erpnext/erpnext/healthcare/setup.py +255,Low Sensitivity,Ndjeshmëri e ulët
 DocType: Notification Control,Notification Control,Kontrolli Njoftim
 apps/erpnext/erpnext/templates/emails/training_event.html +17,Please confirm once you have completed your training,Ju lutemi konfirmoni sapo të keni përfunduar trajnimin tuaj
 DocType: Lead,Suggestions,Sugjerime
 DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Set Item buxhetet Grupi-i mençur në këtë territor. Ju gjithashtu mund të përfshijë sezonalitetin duke vendosur të Shpërndarjes.
+DocType: Payment Term,Payment Term Name,Emri i Termit të Pagesës
 DocType: Healthcare Settings,Create documents for sample collection,Krijo dokumente për mbledhjen e mostrave
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Pagesës kundër {0} {1} nuk mund të jetë më i madh se Outstanding Sasia {2}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +274,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Pagesës kundër {0} {1} nuk mund të jetë më i madh se Outstanding Sasia {2}
 DocType: Supplier,Address HTML,Adresa HTML
 DocType: Lead,Mobile No.,Mobile Nr
 DocType: Maintenance Schedule,Generate Schedule,Generate Orari
 DocType: Purchase Invoice Item,Expense Head,Shpenzim Shef
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +146,Please select Charge Type first,"Ju lutem, përzgjidhni Ngarkesa Lloji i parë"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +163,Please select Charge Type first,"Ju lutem, përzgjidhni Ngarkesa Lloji i parë"
+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.. ","Ju mund të përcaktoni të gjitha detyrat që duhet të kryhen për këtë kulture këtu. Fusha ditore përdoret për të përmendur ditën në të cilën duhet kryer detyra, 1 është dita e parë, etj."
 DocType: Student Group Student,Student Group Student,Student Group Student
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,Fundit
+DocType: Asset Maintenance Task,2 Yearly,2 vjetore
+DocType: Education Settings,Education Settings,Cilësimet e edukimit
 DocType: Vehicle Service,Inspection,inspektim
 DocType: Supplier Scorecard Scoring Standing,Max Grade,Max Grade
 DocType: Email Digest,New Quotations,Citate të reja
 DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,Emails paga shqip për punonjës të bazuar në email preferuar zgjedhur në punonjësi
 DocType: Employee,The first Leave Approver in the list will be set as the default Leave Approver,Aprovuesi i parë Leave në listë do të jetë vendosur si default Leave aprovuesi
 DocType: Tax Rule,Shipping County,Shipping County
-apps/erpnext/erpnext/config/desktop.py +159,Learn,Mëso
+apps/erpnext/erpnext/config/desktop.py +167,Learn,Mëso
 DocType: Asset,Next Depreciation Date,Zhvlerësimi Data Next
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Aktiviteti Kosto për punonjës
 DocType: Accounts Settings,Settings for Accounts,Cilësimet për Llogaritë
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +663,Supplier Invoice No exists in Purchase Invoice {0},Furnizuesi Fatura Nuk ekziston në Blerje Faturë {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +667,Supplier Invoice No exists in Purchase Invoice {0},Furnizuesi Fatura Nuk ekziston në Blerje Faturë {0}
 apps/erpnext/erpnext/config/selling.py +118,Manage Sales Person Tree.,Manage shitjes person Tree.
 DocType: Job Applicant,Cover Letter,Cover Letter
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37,Outstanding Cheques and Deposits to clear,Çeqet e papaguara dhe Depozitat për të pastruar
 DocType: Item,Synced With Hub,Synced Me Hub
-DocType: Vehicle,Fleet Manager,Fleet Menaxher
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +517,Row #{0}: {1} can not be negative for item {2},Row # {0}: {1} nuk mund të jetë negative për artikull {2}
+DocType: Driver,Fleet Manager,Fleet Menaxher
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542,Row #{0}: {1} can not be negative for item {2},Row # {0}: {1} nuk mund të jetë negative për artikull {2}
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59,Wrong Password,Gabuar Fjalëkalimi
 DocType: Item,Variant Of,Variant i
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +367,Completed Qty can not be greater than 'Qty to Manufacture',Kompletuar Qty nuk mund të jetë më i madh se &quot;Qty për Prodhimi&quot;
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +387,Completed Qty can not be greater than 'Qty to Manufacture',Kompletuar Qty nuk mund të jetë më i madh se &quot;Qty për Prodhimi&quot;
 DocType: Period Closing Voucher,Closing Account Head,Mbyllja Shef Llogaria
 DocType: Employee,External Work History,Historia e jashtme
 DocType: Physician,Time per Appointment,Koha për Emërim
 apps/erpnext/erpnext/projects/doctype/task/task.py +110,Circular Reference Error,Qarkorja Referenca Gabim
 DocType: Appointment Type,Is Inpatient,Është pacient
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Emri Guardian1
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Emri Guardian1
 DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,Me fjalë (eksport) do të jetë i dukshëm një herë ju ruani notën shpërndarëse.
 DocType: Cheque Print Template,Distance from left edge,Largësia nga buzë e majtë
 apps/erpnext/erpnext/utilities/bot.py +29,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} njësitë e [{1}] (# Forma / Item / {1}) gjenden në [{2}] (# Forma / Magazina / {2})
@@ -429,20 +455,22 @@
 DocType: BOM Item,Rate & Amount,Rate &amp; Shuma
 apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6,This is based on transactions against this Company. See timeline below for details,Kjo bazohet në transaksione kundër kësaj kompanie. Shiko detajet më poshtë për detaje
 DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Njoftojë me email për krijimin e kërkesës automatike materiale
-apps/erpnext/erpnext/healthcare/setup.py +258,Resistant,i qëndrueshëm
+apps/erpnext/erpnext/healthcare/setup.py +259,Resistant,i qëndrueshëm
 DocType: Journal Entry,Multi Currency,Multi Valuta
-DocType: Payment Reconciliation Invoice,Invoice Type,Lloji Faturë
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +865,Delivery Note,Ofrimit Shënim
+DocType: Opening Invoice Creation Tool,Invoice Type,Lloji Faturë
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +933,Delivery Note,Ofrimit Shënim
 DocType: Consultation,Encounter Impression,Impresioni i takimit
 apps/erpnext/erpnext/config/learn.py +82,Setting up Taxes,Ngritja Tatimet
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +131,Cost of Sold Asset,Kostoja e asetit të shitur
-apps/erpnext/erpnext/accounts/utils.py +345,Payment Entry has been modified after you pulled it. Please pull it again.,"Pagesa Hyrja është ndryshuar, pasi që ju nxorrën atë. Ju lutemi të tërheqë atë përsëri."
-apps/erpnext/erpnext/stock/doctype/item/item.py +448,{0} entered twice in Item Tax,{0} hyrë dy herë në Tatimin Item
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134,Cost of Sold Asset,Kostoja e asetit të shitur
+DocType: Volunteer,Morning,mëngjes
+apps/erpnext/erpnext/accounts/utils.py +347,Payment Entry has been modified after you pulled it. Please pull it again.,"Pagesa Hyrja është ndryshuar, pasi që ju nxorrën atë. Ju lutemi të tërheqë atë përsëri."
+apps/erpnext/erpnext/stock/doctype/item/item.py +464,{0} entered twice in Item Tax,{0} hyrë dy herë në Tatimin Item
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113,Summary for this week and pending activities,Përmbledhje për këtë javë dhe aktivitete në pritje
 DocType: Student Applicant,Admitted,pranuar
 DocType: Workstation,Rent Cost,Qira Kosto
 apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81,Amount After Depreciation,Shuma Pas Zhvlerësimi
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97,Upcoming Calendar Events,Ardhshme Ngjarje Kalendari
+apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1,Variant Attributes,Atributet variant
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85,Please select month and year,"Ju lutem, përzgjidhni muaji dhe viti"
 DocType: Employee,Company Email,Kompania Email
 DocType: GL Entry,Debit Amount in Account Currency,Shuma Debi në llogarinë në valutë
@@ -452,33 +480,35 @@
 apps/erpnext/erpnext/config/accounts.py +27,Bank/Cash transactions against party or for internal transfer,Bank / Cash transaksionet kundër partisë apo për transferimin e brendshëm
 DocType: Shipping Rule,Valid for Countries,I vlefshëm për vendet
 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,Ky artikull është një Template dhe nuk mund të përdoret në transaksionet. Atribute pika do të kopjohet gjatë në variantet nëse nuk është vendosur &quot;Jo Copy &#39;
+DocType: Grant Application,Grant Application,Aplikimi i Grantit
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69,Total Order Considered,Rendit Gjithsej konsideruar
-apps/erpnext/erpnext/config/hr.py +238,"Employee designation (e.g. CEO, Director etc.).","Përcaktimi Punonjës (p.sh. CEO, drejtor etj)."
+apps/erpnext/erpnext/config/hr.py +243,"Employee designation (e.g. CEO, Director etc.).","Përcaktimi Punonjës (p.sh. CEO, drejtor etj)."
 DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,Shkalla në të cilën Valuta Customer është konvertuar në bazë monedhën klientit
 DocType: Course Scheduling Tool,Course Scheduling Tool,Sigurisht caktimin Tool
-apps/erpnext/erpnext/controllers/accounts_controller.py +558,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Row # {0}: Blerje Fatura nuk mund të bëhet kundër një aktiv ekzistues {1}
+apps/erpnext/erpnext/controllers/accounts_controller.py +602,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Row # {0}: Blerje Fatura nuk mund të bëhet kundër një aktiv ekzistues {1}
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +255,[Urgent] Error while creating recurring %s for %s,[Urgjent] Gabim gjatë krijimit të përsëritjes% s për% s
+DocType: Land Unit,LInked Analysis,LInked Analiza
 DocType: Item Tax,Tax Rate,Shkalla e tatimit
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59,{0} already allocated for Employee {1} for period {2} to {3},{0} ndarë tashmë për punonjësit {1} për periudhën {2} në {3}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +890,Select Item,Zgjidh Item
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +915,Select Item,Zgjidh Item
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +140,Purchase Invoice {0} is already submitted,Blerje Fatura {0} është dorëzuar tashmë
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +91,Row # {0}: Batch No must be same as {1} {2},Row # {0}: Batch Nuk duhet të jetë i njëjtë si {1} {2}
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52,Convert to non-Group,Convert për të jo-Group
-apps/erpnext/erpnext/config/stock.py +127,Batch (lot) of an Item.,Batch (shumë) e një artikulli.
 DocType: C-Form Invoice Detail,Invoice Date,Data e faturës
 DocType: GL Entry,Debit Amount,Shuma Debi
-apps/erpnext/erpnext/accounts/party.py +253,There can only be 1 Account per Company in {0} {1},Nuk mund të jetë vetëm 1 Llogaria për Kompaninë në {0} {1}
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +407,Please see attachment,Ju lutem shikoni shtojcën
+apps/erpnext/erpnext/accounts/party.py +251,There can only be 1 Account per Company in {0} {1},Nuk mund të jetë vetëm 1 Llogaria për Kompaninë në {0} {1}
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +426,Please see attachment,Ju lutem shikoni shtojcën
 DocType: Purchase Order,% Received,% Marra
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Krijo Grupet Student
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +21,Setup Already Complete!!,Setup Tashmë komplet !!
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Krijo Grupet Student
+DocType: Volunteer,Weekends,fundjavë
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Credit Note Amount,Credit Note Shuma
 DocType: Setup Progress Action,Action Document,Dokumenti i Veprimit
+DocType: Chapter Member,Website URL,Website URL
 ,Finished Goods,Mallrat përfunduar
 DocType: Delivery Note,Instructions,Udhëzime
 DocType: Quality Inspection,Inspected By,Inspektohen nga
-DocType: Maintenance Visit,Maintenance Type,Mirëmbajtja Type
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +45,{0} - {1} is not enrolled in the Course {2},{0} - {1} nuk është i regjistruar në lëndës {2}
+DocType: Asset Maintenance Log,Maintenance Type,Mirëmbajtja Type
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45,{0} - {1} is not enrolled in the Course {2},{0} - {1} nuk është i regjistruar në lëndës {2}
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Serial No {0} does not belong to Delivery Note {1},Serial Asnjë {0} nuk i përket dorëzimit Shënim {1}
 apps/erpnext/erpnext/templates/pages/demo.html +47,ERPNext Demo,ERPNext Demo
 apps/erpnext/erpnext/public/js/utils/item_selector.js +20,Add Items,Shto Items
@@ -489,33 +519,35 @@
 DocType: Packed Item,Packed Item,Item mbushur
 apps/erpnext/erpnext/config/buying.py +65,Default settings for buying transactions.,Default settings për blerjen e transaksioneve.
 apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29,Activity Cost exists for Employee {0} against Activity Type - {1},Kosto Aktiviteti ekziston për punonjësit {0} kundër Aktivizimi Tipi - {1}
-apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +14,Mandatory field - Get Students From,Fushë e detyrueshme - Get Studentët nga
-apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +14,Mandatory field - Get Students From,Fushë e detyrueshme - Get Studentët nga
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +14,Mandatory field - Get Students From,Fushë e detyrueshme - Get Studentët nga
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +14,Mandatory field - Get Students From,Fushë e detyrueshme - Get Studentët nga
 DocType: Program Enrollment,Enrolled courses,kurse regjistruar
 DocType: Program Enrollment,Enrolled courses,kurse regjistruar
 DocType: Currency Exchange,Currency Exchange,Currency Exchange
-DocType: Asset,Item Name,Item Emri
+DocType: Opening Invoice Creation Tool Item,Item Name,Item Emri
 DocType: Authorization Rule,Approving User  (above authorized value),Miratimi përdoruesin (mbi vlerën e autorizuar)
 DocType: Email Digest,Credit Balance,Bilanci krediti
 DocType: Employee,Widowed,Ve
 DocType: Request for Quotation,Request for Quotation,Kërkesa për kuotim
 DocType: Healthcare Settings,Require Lab Test Approval,Kërkoni miratimin e testit të laboratorit
 DocType: Salary Slip Timesheet,Working Hours,Orari i punës
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +10,Total Outstanding,Gjithsej Outstanding
 DocType: Naming Series,Change the starting / current sequence number of an existing series.,Ndryshimi filluar / numrin e tanishëm sekuencë e një serie ekzistuese.
 DocType: Dosage Strength,Strength,Forcë
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1508,Create a new Customer,Krijo një klient i ri
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1523,Create a new Customer,Krijo një klient i ri
 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.","Nëse Rregullat shumta Çmimeve të vazhdojë të mbizotërojë, përdoruesit janë të kërkohet për të vendosur përparësi dorë për të zgjidhur konfliktin."
 apps/erpnext/erpnext/utilities/activation.py +90,Create Purchase Orders,Krijo urdhëron Blerje
 ,Purchase Register,Blerje Regjistrohu
-DocType: Course Scheduling Tool,Rechedule,Rechedule
+DocType: Scheduling Tool,Rechedule,Rechedule
 DocType: Landed Cost Item,Applicable Charges,Akuzat e aplikueshme
 DocType: Workstation,Consumable Cost,Kosto harxhuese
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +220,{0} ({1}) must have role 'Leave Approver',{0} ({1}) duhet të ketë rol &#39;Leave aprovuesi&#39;
 DocType: Purchase Receipt,Vehicle Date,Data e Automjeteve
 DocType: Student Log,Medical,Mjekësor
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +177,Reason for losing,Arsyeja për humbjen
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +41,Lead Owner cannot be same as the Lead,Owner Lead nuk mund të jetë i njëjtë si Lead
-apps/erpnext/erpnext/accounts/utils.py +351,Allocated amount can not greater than unadjusted amount,Shuma e ndarë nuk mund të më e madhe se shuma e parregulluara
+apps/erpnext/erpnext/accounts/doctype/account/account.js +52,Update Account Number,Përditëso numrin e llogarisë
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +42,Lead Owner cannot be same as the Lead,Owner Lead nuk mund të jetë i njëjtë si Lead
+apps/erpnext/erpnext/accounts/utils.py +353,Allocated amount can not greater than unadjusted amount,Shuma e ndarë nuk mund të më e madhe se shuma e parregulluara
 DocType: Announcement,Receiver,marrës
 apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83,Workstation is closed on the following dates as per Holiday List: {0},Workstation është i mbyllur në datat e mëposhtme sipas Holiday Lista: {0}
 apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32,Opportunities,Mundësitë
@@ -531,7 +563,7 @@
 DocType: Lab Test Template,No Result,asnjë Rezultat
 DocType: Purchase Invoice Item,Quantity and Rate,Sasia dhe Rate
 DocType: Delivery Note,% Installed,% Installed
-apps/erpnext/erpnext/utilities/user_progress.py +209,Classrooms/ Laboratories etc where lectures can be scheduled.,"Klasat / laboratore etj, ku mësimi mund të jenë të planifikuara."
+apps/erpnext/erpnext/utilities/user_progress.py +227,Classrooms/ Laboratories etc where lectures can be scheduled.,"Klasat / laboratore etj, ku mësimi mund të jenë të planifikuara."
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46,Please enter company name first,Ju lutem shkruani emrin e kompanisë e parë
 DocType: Purchase Invoice,Supplier Name,Furnizuesi Emri
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25,Read the ERPNext Manual,Lexoni Manualin ERPNext
@@ -539,42 +571,47 @@
 DocType: Email Digest,Pending Purchase Orders,Në pritje urdhëron Blerje
 DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Automatikisht Set Serial Nos bazuar në FIFO
 DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,Kontrolloni Furnizuesi faturës Numri Unike
+apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34,Primary Address Details,Detajet e Fillores
 DocType: Vehicle Service,Oil Change,Ndryshimi Oil
+DocType: Asset Maintenance Log,Asset Maintenance Log,Regjistri i mirëmbajtjes së aseteve
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.',&quot;Për Rasti Nr &#39; nuk mund të jetë më pak se &quot;nga rasti nr &#39;
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +142,Non Profit,Non Profit
+DocType: Chapter,Non Profit,Non Profit
 DocType: Production Order,Not Started,Nuk ka filluar
 DocType: Lead,Channel Partner,Channel Partner
 DocType: Account,Old Parent,Vjetër Parent
-apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +18,Mandatory field - Academic Year,Fushë e detyrueshme - Viti akademik
-apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +18,Mandatory field - Academic Year,Fushë e detyrueshme - Viti akademik
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +18,Mandatory field - Academic Year,Fushë e detyrueshme - Viti akademik
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +18,Mandatory field - Academic Year,Fushë e detyrueshme - Viti akademik
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,{0} {1} is not associated with {2} {3},{0} {1} nuk është i lidhur me {2} {3}
 DocType: Notification Control,Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,Rregulloje tekstin hyrës që shkon si një pjesë e asaj email. Secili transaksion ka një tekst të veçantë hyrëse.
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +157,Please set default payable account for the company {0},Ju lutemi të vendosur llogari parazgjedhur pagueshëm për kompaninë {0}
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +182,Please set default payable account for the company {0},Ju lutemi të vendosur llogari parazgjedhur pagueshëm për kompaninë {0}
 DocType: Setup Progress Action,Min Doc Count,Min Dokumenti i Numrit
 apps/erpnext/erpnext/config/manufacturing.py +84,Global settings for all manufacturing processes.,Konfigurimet Global për të gjitha proceset e prodhimit.
 DocType: Accounts Settings,Accounts Frozen Upto,Llogaritë ngrira Upto
 DocType: SMS Log,Sent On,Dërguar në
-apps/erpnext/erpnext/stock/doctype/item/item.py +685,Attribute {0} selected multiple times in Attributes Table,Atribut {0} zgjedhur disa herë në atributet Tabelën
+apps/erpnext/erpnext/stock/doctype/item/item.py +671,Attribute {0} selected multiple times in Attributes Table,Atribut {0} zgjedhur disa herë në atributet Tabelën
 DocType: HR Settings,Employee record is created using selected field. ,Rekord punonjës është krijuar duke përdorur fushën e zgjedhur.
 DocType: Sales Order,Not Applicable,Nuk aplikohet
 apps/erpnext/erpnext/config/hr.py +70,Holiday master.,Mjeshtër pushime.
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +77,Opening Invoice Item,Çështja e hapjes së faturës
 DocType: Request for Quotation Item,Required Date,Data e nevojshme
 DocType: Delivery Note,Billing Address,Faturimi Adresa
 DocType: BOM,Costing,Kushton
 DocType: Tax Rule,Billing County,County Billing
 DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Nëse kontrolluar, shuma e taksave do të konsiderohen si të përfshirë tashmë në Printo Tarifa / Shuma Shtyp"
 DocType: Request for Quotation,Message for Supplier,Mesazh për Furnizuesin
+DocType: Driver,DRIVER-.#####,DRIVER -. #####
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Total Qty,Gjithsej Qty
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2 Email ID
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2 Email ID
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2 Email ID
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2 Email ID
 DocType: Item,Show in Website (Variant),Show në Website (Variant)
 DocType: Employee,Health Concerns,Shqetësimet shëndetësore
-DocType: Process Payroll,Select Payroll Period,Zgjidhni Periudha Payroll
+DocType: Payroll Entry,Select Payroll Period,Zgjidhni Periudha Payroll
 DocType: Purchase Invoice,Unpaid,I papaguar
 apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49,Reserved for sale,Rezervuar për shitje
 DocType: Packing Slip,From Package No.,Nga Paketa nr
 DocType: Item Attribute,To Range,Në rang
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29,Securities and Deposits,Të letrave me vlerë dhe depozita
-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","Nuk mund të ndryshojë metodën e vlerësimit, pasi ka transaksione kundër disa artikuj që nuk kanë se është metodë e vlerësimit"
+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","Nuk mund të ndryshojë metodën e vlerësimit, pasi ka transaksione kundër disa artikuj që nuk kanë se është metodë e vlerësimit"
 apps/erpnext/erpnext/config/healthcare.py +133,Test Sample Master.,Test Master kampion.
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82,Total leaves allocated is mandatory,Gjithsej lë alokuara është i detyrueshëm
 DocType: Patient,AB Positive,AB Pozitiv
@@ -596,37 +633,41 @@
 DocType: Training Event,Workshop,punishte
 DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Paralajmëroni Urdhërat e Blerjes
 apps/erpnext/erpnext/utilities/user_progress.py +64,List a few of your customers. They could be organizations or individuals.,Lista disa nga klientët tuaj. Ata mund të jenë organizata ose individë.
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Furnizuesi&gt; Lloji i Furnizuesit
 apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +21,Enough Parts to Build,Pjesë mjaftueshme për të ndërtuar
 DocType: POS Profile User,POS Profile User,Profili i POS-ut
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128,Direct Income,Të ardhurat direkte
 DocType: Patient Appointment,Date TIme,Data Përmbledhje
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +36,"Can not filter based on Account, if grouped by Account","Nuk mund të filtruar në bazë të llogarisë, në qoftë se të grupuara nga Llogaria"
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +126,Administrative Officer,Zyrtar Administrativ
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +22,Please select Course,"Ju lutem, përzgjidhni Course"
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +22,Please select Course,"Ju lutem, përzgjidhni Course"
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +130,Administrative Officer,Zyrtar Administrativ
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39,Setting up company and taxes,Vendosja e kompanisë dhe taksave
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,"Ju lutem, përzgjidhni Course"
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,"Ju lutem, përzgjidhni Course"
 DocType: Codification Table,Codification Table,Tabela e kodifikimit
 DocType: Timesheet Detail,Hrs,orë
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +342,Please select Company,"Ju lutem, përzgjidhni Company"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +350,Please select Company,"Ju lutem, përzgjidhni Company"
 DocType: Stock Entry Detail,Difference Account,Llogaria Diferenca
 DocType: Purchase Invoice,Supplier GSTIN,furnizuesi GSTIN
 apps/erpnext/erpnext/projects/doctype/task/task.py +47,Cannot close task as its dependant task {0} is not closed.,Nuk mund detyrë afër sa detyra e saj të varur {0} nuk është e mbyllur.
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +433,Please enter Warehouse for which Material Request will be raised,Ju lutem shkruani Magazina për të cilat do të ngrihen materiale Kërkesë
 DocType: Production Order,Additional Operating Cost,Shtesë Kosto Operative
 DocType: Lab Test Template,Lab Routine,Rutina e laboratorit
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +20,Cosmetics,Kozmetikë
-apps/erpnext/erpnext/stock/doctype/item/item.py +545,"To merge, following properties must be same for both items","Të bashkojë, pronat e mëposhtme duhet të jenë të njëjta për të dy artikujve"
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20,Cosmetics,Kozmetikë
+apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18,Please select Completion Date for Completed Asset Maintenance Log,Ju lutemi zgjidhni Datën e Përfundimit për Mirëmbajtjen e Mbaruar të Mirëmbajtjes së Aseteve
+apps/erpnext/erpnext/stock/doctype/item/item.py +526,"To merge, following properties must be same for both items","Të bashkojë, pronat e mëposhtme duhet të jenë të njëjta për të dy artikujve"
 DocType: Shipping Rule,Net Weight,Net Weight
 DocType: Employee,Emergency Phone,Urgjencës Telefon
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29,Buy,blej
 ,Serial No Warranty Expiry,Serial No Garanci Expiry
 DocType: Sales Invoice,Offline POS Name,Offline POS Emri
-apps/erpnext/erpnext/utilities/user_progress.py +159,Student Application,Aplikimi i studentëve
-apps/erpnext/erpnext/schools/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Ju lutemi të përcaktuar klasën për Prag 0%
-apps/erpnext/erpnext/schools/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Ju lutemi të përcaktuar klasën për Prag 0%
+apps/erpnext/erpnext/utilities/user_progress.py +177,Student Application,Aplikimi i studentëve
+apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Ju lutemi të përcaktuar klasën për Prag 0%
+apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Ju lutemi të përcaktuar klasën për Prag 0%
 DocType: Sales Order,To Deliver,Për të ofruar
 DocType: Purchase Invoice Item,Item,Artikull
-apps/erpnext/erpnext/healthcare/setup.py +255,High Sensitivity,Ndjeshmëri e lartë
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2493,Serial no item cannot be a fraction,Serial asnjë artikull nuk mund të jetë një pjesë
+apps/erpnext/erpnext/healthcare/setup.py +256,High Sensitivity,Ndjeshmëri e lartë
+apps/erpnext/erpnext/config/non_profit.py +48,Volunteer Type information.,Informacione Lloji Vullnetar.
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2512,Serial no item cannot be a fraction,Serial asnjë artikull nuk mund të jetë një pjesë
 DocType: Journal Entry,Difference (Dr - Cr),Diferenca (Dr - Cr)
 DocType: Account,Profit and Loss,Fitimi dhe Humbja
 DocType: Patient,Risk Factors,Faktoret e rrezikut
@@ -635,6 +676,7 @@
 apps/erpnext/erpnext/config/stock.py +330,Managing Subcontracting,Menaxhimi Nënkontraktimi
 DocType: Vital Signs,Body Temperature,Temperatura e trupit
 DocType: Project,Project will be accessible on the website to these users,Projekti do të jetë në dispozicion në faqen e internetit të këtyre përdoruesve
+DocType: Detected Disease,Disease,sëmundje
 apps/erpnext/erpnext/config/projects.py +24,Define Project type.,Përcaktoni llojin e Projektit.
 DocType: Supplier Scorecard,Weighting Function,Funksioni i peshimit
 DocType: Physician,OP Consulting Charge,Ngarkimi OP Consulting
@@ -643,27 +685,29 @@
 apps/erpnext/erpnext/setup/doctype/company/company.py +62,Account {0} does not belong to company: {1},Llogaria {0} nuk i përkasin kompanisë: {1}
 apps/erpnext/erpnext/setup/doctype/company/company.py +51,Abbreviation already used for another company,Shkurtesa e përdorur tashmë për një kompani tjetër
 DocType: Selling Settings,Default Customer Group,Gabim Grupi Klientit
+DocType: Asset Repair,ARLOG-,ARLOG-
 DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Nëse disable, fushë &quot;rrumbullakosura Totali i &#39;nuk do të jenë të dukshme në çdo transaksion"
 DocType: BOM,Operating Cost,Kosto Operative
+DocType: Crop,Produced Items,Artikujt e prodhuar
 DocType: Sales Order Item,Gross Profit,Fitim bruto
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49,Increment cannot be 0,Rritja nuk mund të jetë 0
 DocType: Production Planning Tool,Material Requirement,Kërkesa materiale
 DocType: Company,Delete Company Transactions,Fshij Transaksionet Company
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +350,Reference No and Reference Date is mandatory for Bank transaction,I Referencës dhe Referenca Date është e detyrueshme për transaksion Bank
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +351,Reference No and Reference Date is mandatory for Bank transaction,I Referencës dhe Referenca Date është e detyrueshme për transaksion Bank
 DocType: Purchase Receipt,Add / Edit Taxes and Charges,Add / Edit taksat dhe tatimet
 DocType: Payment Entry Reference,Supplier Invoice No,Furnizuesi Fatura Asnjë
 DocType: Territory,For reference,Për referencë
 DocType: Healthcare Settings,Appointment Confirmation,Konfirmimi i Emërimit
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158,"Cannot delete Serial No {0}, as it is used in stock transactions","Nuk mund të fshini serial {0}, ashtu siç është përdorur në transaksionet e aksioneve"
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +246,Closing (Cr),Mbyllja (Cr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +253,Closing (Cr),Mbyllja (Cr)
 apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1,Hello,Përshëndetje
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +110,Move Item,Leviz Item
 DocType: Serial No,Warranty Period (Days),Garanci Periudha (ditë)
 DocType: Installation Note Item,Installation Note Item,Instalimi Shënim Item
 DocType: Production Plan Item,Pending Qty,Në pritje Qty
 DocType: Budget,Ignore,Injoroj
-apps/erpnext/erpnext/accounts/party.py +372,{0} {1} is not active,{0} {1} nuk është aktiv
-apps/erpnext/erpnext/config/accounts.py +285,Setup cheque dimensions for printing,Dimensionet kontrolloni Setup për printim
+apps/erpnext/erpnext/accounts/party.py +384,{0} {1} is not active,{0} {1} nuk është aktiv
+apps/erpnext/erpnext/config/accounts.py +272,Setup cheque dimensions for printing,Dimensionet kontrolloni Setup për printim
 DocType: Salary Slip,Salary Slip Timesheet,Paga Slip pasqyrë e mungesave
 apps/erpnext/erpnext/controllers/buying_controller.py +157,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Furnizuesi Magazina i detyrueshëm për të nën-kontraktuar Blerje marrjes
 DocType: Pricing Rule,Valid From,Valid Nga
@@ -671,19 +715,21 @@
 DocType: Pricing Rule,Sales Partner,Sales Partner
 apps/erpnext/erpnext/config/buying.py +150,All Supplier scorecards.,Të gjitha tabelat e rezultateve të furnizuesit.
 DocType: Buying Settings,Purchase Receipt Required,Pranimi Blerje kërkuar
-apps/erpnext/erpnext/stock/doctype/item/item.py +142,Valuation Rate is mandatory if Opening Stock entered,Vlerësimi Vlerësoni është i detyrueshëm në qoftë Hapja Stock hyrë
+apps/erpnext/erpnext/stock/doctype/item/item.py +144,Valuation Rate is mandatory if Opening Stock entered,Vlerësimi Vlerësoni është i detyrueshëm në qoftë Hapja Stock hyrë
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +142,No records found in the Invoice table,Nuk u gjetën në tabelën Faturë të dhënat
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +17,Please select Company and Party Type first,"Ju lutem, përzgjidhni kompanisë dhe Partisë Lloji i parë"
-apps/erpnext/erpnext/config/accounts.py +301,Financial / accounting year.,Financiare / vit kontabilitetit.
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31,"Already set default in pos profile {0} for user {1}, kindly disabled default","Tashmë vendosni parazgjedhjen në pozicionin {0} për përdoruesin {1}, me mirësi default me aftësi të kufizuara"
+apps/erpnext/erpnext/config/accounts.py +293,Financial / accounting year.,Financiare / vit kontabilitetit.
 apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9,Accumulated Values,Vlerat e akumuluara
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162,"Sorry, Serial Nos cannot be merged","Na vjen keq, Serial Nos nuk mund të bashkohen"
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +63,Territory is Required in POS Profile,Territori kërkohet në Profilin e POS
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +68,Territory is Required in POS Profile,Territori kërkohet në Profilin e POS
 DocType: Supplier,Prevent RFQs,Parandalimi i RFQ-ve
 apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Bëni Sales Order
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168,Salary Slip submitted for period from {0} to {1},Lëshimi i pagës i paraqitur për periudhën nga {0} në {1}
 DocType: Project Task,Project Task,Projekti Task
 ,Lead Id,Lead Id
 DocType: C-Form Invoice Detail,Grand Total,Grand Total
-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,Item Shporta
 apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38,Fiscal Year Start Date should not be greater than Fiscal Year End Date,Fiskale Viti Data e Fillimit nuk duhet të jetë më i madh se vitin fiskal End Date
@@ -696,7 +742,9 @@
 DocType: Job Applicant,Resume Attachment,Resume Attachment
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Konsumatorët të përsëritur
 DocType: Leave Control Panel,Allocate,Alokimi
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +804,Sales Return,Shitjet Kthehu
+apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108,Create Variant,Krijo Variant
+DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Hapja e Faturave të Faturës
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +851,Sales Return,Shitjet Kthehu
 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,Shënim: gjethet total alokuara {0} nuk duhet të jetë më pak se gjethet e miratuara tashmë {1} për periudhën
 ,Total Stock Summary,Total Stock Përmbledhje
 DocType: Announcement,Posted By,postuar Nga
@@ -707,9 +755,9 @@
 apps/erpnext/erpnext/config/selling.py +28,Customer database.,Baza e të dhënave të konsumatorëve.
 DocType: Quotation,Quotation To,Citat Për
 DocType: Lead,Middle Income,Të ardhurat e Mesme
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +218,Opening (Cr),Hapja (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.,Default njësinë e matjes për artikullit {0} nuk mund të ndryshohet drejtpërdrejt sepse ju keni bërë tashmë një transaksioni (et) me një tjetër UOM. Ju do të duhet për të krijuar një artikull të ri për të përdorur një Default ndryshme UOM.
-apps/erpnext/erpnext/accounts/utils.py +349,Allocated amount can not be negative,Shuma e ndarë nuk mund të jetë negative
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +225,Opening (Cr),Hapja (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.,Default njësinë e matjes për artikullit {0} nuk mund të ndryshohet drejtpërdrejt sepse ju keni bërë tashmë një transaksioni (et) me një tjetër UOM. Ju do të duhet për të krijuar një artikull të ri për të përdorur një Default ndryshme UOM.
+apps/erpnext/erpnext/accounts/utils.py +351,Allocated amount can not be negative,Shuma e ndarë nuk mund të jetë negative
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Ju lutemi të vendosur Kompaninë
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Ju lutemi të vendosur Kompaninë
 DocType: Purchase Order Item,Billed Amt,Faturuar Amt
@@ -717,31 +765,36 @@
 DocType: Warehouse,A logical Warehouse against which stock entries are made.,Një Magazina logjik kundër të cilit janë bërë të hyra të aksioneve.
 DocType: Repayment Schedule,Principal Amount,shumën e principalit
 DocType: Employee Loan Application,Total Payable Interest,Interesi i përgjithshëm për t&#39;u paguar
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.js +59,Total Outstanding: {0},Totali Outstanding: {0}
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +60,Total Outstanding: {0},Totali Outstanding: {0}
 DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Sales Fatura pasqyrë e mungesave
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118,Reference No & Reference Date is required for {0},Referenca Nuk &amp; Referenca Data është e nevojshme për {0}
-DocType: Process Payroll,Select Payment Account to make Bank Entry,Zgjidhni Pagesa Llogaria për të bërë Banka Hyrja
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +116,Reference No & Reference Date is required for {0},Referenca Nuk &amp; Referenca Data është e nevojshme për {0}
+DocType: Payroll Entry,Select Payment Account to make Bank Entry,Zgjidhni Pagesa Llogaria për të bërë Banka Hyrja
 apps/erpnext/erpnext/utilities/activation.py +136,"Create Employee records to manage leaves, expense claims and payroll","Krijo dhënat e punonjësve për të menaxhuar gjethe, pretendimet e shpenzimeve dhe pagave"
 apps/erpnext/erpnext/config/healthcare.py +118,Prescription Period,Periudha e parashkrimit
 DocType: Restaurant Reservation,Restaurant Reservation,Rezervim Restoranti
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +186,Proposal Writing,Propozimi Shkrimi
+DocType: Land Unit,Land Unit Name,Emri i Njësisë së Tokës
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190,Proposal Writing,Propozimi Shkrimi
 DocType: Payment Entry Deduction,Payment Entry Deduction,Pagesa Zbritja Hyrja
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14,Wrapping up,Mbarimi
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35,Notify Customers via Email,Njoftoni Konsumatorët përmes Email-it
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,Another Sales Person {0} exists with the same Employee id,Një person tjetër Sales {0} ekziston me të njëjtin id punonjës
+DocType: Employee Advance,Claimed Amount,Shuma e kërkuar
 DocType: Production Planning Tool,"If checked, raw materials for items that are sub-contracted will be included in the Material Requests","Nëse kontrolluar, lëndëve të para për sendet që janë të nën-kontraktuar do të përfshihen në Kërkesave materiale"
 apps/erpnext/erpnext/config/healthcare.py +61,Masters,Masters
 DocType: Assessment Plan,Maximum Assessment Score,Vlerësimi maksimal Score
-apps/erpnext/erpnext/config/accounts.py +146,Update Bank Transaction Dates,Datat e transaksionit Update Banka
+apps/erpnext/erpnext/config/accounts.py +138,Update Bank Transaction Dates,Datat e transaksionit Update Banka
 apps/erpnext/erpnext/config/projects.py +36,Time Tracking,Koha Tracking
 DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,Duplicate TRANSPORTUESIT
+apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49,Row {0}# Paid Amount cannot be greater than requested advance amount,Rresht {0} # Vlera e paguar nuk mund të jetë më e madhe se shuma e parapaguar e kërkuar
 DocType: Fiscal Year Company,Fiscal Year Company,Fiskale Viti i kompanisë
 DocType: Packing Slip Item,DN Detail,DN Detail
 DocType: Training Event,Conference,konferencë
 DocType: Timesheet,Billed,Faturuar
 DocType: Batch,Batch Description,Batch Përshkrim
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Krijimi i grupeve të studentëve
-apps/erpnext/erpnext/accounts/utils.py +721,"Payment Gateway Account not created, please create one manually.","Pagesa Gateway Llogaria nuk është krijuar, ju lutemi krijoni një të tillë me dorë."
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Krijimi i grupeve të studentëve
+apps/erpnext/erpnext/accounts/utils.py +724,"Payment Gateway Account not created, please create one manually.","Pagesa Gateway Llogaria nuk është krijuar, ju lutemi krijoni një të tillë me dorë."
 DocType: Supplier Scorecard,Per Year,Në vit
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.py +51,Not eligible for the admission in this program as per DOB,Nuk ka të drejtë për pranim në këtë program sipas DOB
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51,Not eligible for the admission in this program as per DOB,Nuk ka të drejtë për pranim në këtë program sipas DOB
 DocType: Sales Invoice,Sales Taxes and Charges,Shitjet Taksat dhe Tarifat
 DocType: Employee,Organization Profile,Organizata Profilin
 DocType: Vital Signs,Height (In Meter),Lartësia (në metër)
@@ -749,25 +802,25 @@
 DocType: Vehicle Service,Vehicle Service,Shërbimi Vehicle
 apps/erpnext/erpnext/config/setup.py +101,Automatically triggers the feedback request based on conditions.,Automatikisht shkakton kërkesa reagime në bazë të kushteve.
 DocType: Employee,Reason for Resignation,Arsyeja për dorëheqjen
-apps/erpnext/erpnext/config/hr.py +147,Template for performance appraisals.,Template për vlerësimit të punës.
+apps/erpnext/erpnext/config/hr.py +152,Template for performance appraisals.,Template për vlerësimit të punës.
 DocType: Sales Invoice,Credit Note Issued,Credit Note Hedhur në qarkullim
 DocType: Project Task,Weight,peshë
 DocType: Payment Reconciliation,Invoice/Journal Entry Details,Fatura / Journal Hyrja Detajet
 apps/erpnext/erpnext/accounts/utils.py +83,{0} '{1}' not in Fiscal Year {2},{0} &#39;{1}&#39; nuk është në Vitin Fiskal {2}
 DocType: Buying Settings,Settings for Buying Module,Cilësimet për Blerja Module
-apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +21,Asset {0} does not belong to company {1},Asset {0} nuk i përkasin kompanisë {1}
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +21,Asset {0} does not belong to company {1},Asset {0} nuk i përkasin kompanisë {1}
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70,Please enter Purchase Receipt first,Ju lutemi shkruani vërtetim Blerje parë
 DocType: Buying Settings,Supplier Naming By,Furnizuesi Emërtimi By
 DocType: Activity Type,Default Costing Rate,Default kushton Vlerësoni
 DocType: Maintenance Schedule,Maintenance Schedule,Mirëmbajtja Orari
 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.","Pastaj Çmimeve Rregullat janë filtruar në bazë të konsumatorëve, Grupi Customer, Territorit, Furnizuesin, Furnizuesi Lloji, fushatën, Sales Partner etj"
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24,Net Change in Inventory,Ndryshimi neto në Inventarin
-apps/erpnext/erpnext/config/hr.py +157,Employee Loan Management,Menaxhimi Loan punonjës
+apps/erpnext/erpnext/config/hr.py +162,Employee Loan Management,Menaxhimi Loan punonjës
 DocType: Employee,Passport Number,Pasaporta Numri
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,Raporti me Guardian2
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +120,Manager,Menaxher
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,Raporti me Guardian2
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124,Manager,Menaxher
 DocType: Payment Entry,Payment From / To,Pagesa nga /
-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},Kufiri i ri i kredisë është më pak se shuma aktuale të papaguar për konsumatorin. kufiri i kreditit duhet të jetë atleast {0}
+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},Kufiri i ri i kredisë është më pak se shuma aktuale të papaguar për konsumatorin. kufiri i kreditit duhet të jetë atleast {0}
 apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,&quot;Bazuar Në &#39;dhe&#39; Grupit nga &#39;nuk mund të jetë e njëjtë
 DocType: Sales Person,Sales Person Targets,Synimet Sales Person
 DocType: Installation Note,IN-,NË-
@@ -776,43 +829,46 @@
 DocType: Lab Test Template,Compound,kompleks
 DocType: Student Batch Name,Batch Name,Batch Emri
 DocType: Fee Validity,Max number of visit,Numri maksimal i vizitës
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +319,Timesheet created:,Pasqyrë e mungesave krijuar:
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +908,Please set default Cash or Bank account in Mode of Payment {0},Ju lutemi të vendosur Cash parazgjedhur apo llogari bankare në mënyra e pagesës {0}
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +24,Enroll,regjistroj
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +339,Timesheet created:,Pasqyrë e mungesave krijuar:
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +920,Please set default Cash or Bank account in Mode of Payment {0},Ju lutemi të vendosur Cash parazgjedhur apo llogari bankare në mënyra e pagesës {0}
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24,Enroll,regjistroj
 DocType: GST Settings,GST Settings,GST Settings
 DocType: Selling Settings,Customer Naming By,Emërtimi Customer Nga
 DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,Do të tregojë nxënësin si të pranishme në Student Raporti mujor Pjesëmarrja
 DocType: Depreciation Schedule,Depreciation Amount,Amortizimi Shuma
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56,Convert to Group,Convert të Grupit
+DocType: Delivery Trip,TOUR-.#####,TOUR -. #####
 DocType: Activity Cost,Activity Type,Aktiviteti Type
 DocType: Request for Quotation,For individual supplier,Për furnizuesit individual
 DocType: BOM Operation,Base Hour Rate(Company Currency),Base Hour Vlerësoni (Company Valuta)
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Amount,Shuma Dorëzuar
-DocType: Supplier,Fixed Days,Ditët fikse
-apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14,Lab Tests,Testet e laboratorit
+DocType: Company,Fixed Days,Ditët fikse
 DocType: Quotation Item,Item Balance,Item Balance
 DocType: Sales Invoice,Packing List,Lista paketim
 apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,Blerje Urdhërat jepet Furnizuesit.
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +43,Publishing,Botime
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43,Publishing,Botime
 DocType: Activity Cost,Projects User,Projektet i përdoruesit
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Consumed,Konsumuar
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +157,{0}: {1} not found in Invoice Details table,{0}: {1} nuk u gjet në detaje Fatura tryezë
+DocType: Asset,Asset Owner Company,Shoqëria Pronar i Pasurisë
 DocType: Company,Round Off Cost Center,Rrumbullakët Off Qendra Kosto
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +227,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Mirëmbajtja Vizitoni {0} duhet të anulohet para se anulimi këtë Radhit Sales
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Mirëmbajtja Vizitoni {0} duhet të anulohet para se anulimi këtë Radhit Sales
+DocType: Asset Maintenance Log,AML-,AML-
 DocType: Item,Material Transfer,Transferimi materiale
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24,Could not find path for ,Nuk mund të gjente rrugën
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +211,Opening (Dr),Hapja (Dr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +218,Opening (Dr),Hapja (Dr)
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39,Posting timestamp must be after {0},Timestamp postimi duhet të jetë pas {0}
 apps/erpnext/erpnext/config/accounts.py +39,To make recurring documents,Për të bërë dokumente të përsëritura
 ,GST Itemised Purchase Register,GST e detajuar Blerje Regjistrohu
+DocType: Course Scheduling Tool,Reschedule,riskedulimin
 DocType: Employee Loan,Total Interest Payable,Interesi i përgjithshëm për t&#39;u paguar
 DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Taksat zbarkoi Kosto dhe Tarifat
 DocType: Production Order Operation,Actual Start Time,Aktuale Koha e fillimit
 DocType: BOM Operation,Operation Time,Operacioni Koha
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +293,Finish,fund
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +395,Base,bazë
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +315,Finish,fund
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412,Base,bazë
 DocType: Timesheet,Total Billed Hours,Orët totale faturuara
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1351,Write Off Amount,Shkruani Off Shuma
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1438,Write Off Amount,Shkruani Off Shuma
 DocType: Leave Block List Allow,Allow User,Lejojë përdoruesin
 DocType: Journal Entry,Bill No,Bill Asnjë
 DocType: Company,Gain/Loss Account on Asset Disposal,Llogaria Gain / Humbja në hedhjen e Aseteve
@@ -828,33 +884,38 @@
 DocType: Student Attendance,Student Attendance,Pjesëmarrja Student
 DocType: Sales Invoice Timesheet,Time Sheet,Koha Sheet
 DocType: Manufacturing Settings,Backflush Raw Materials Based On,Backflush të lëndëve të para në bazë të
-DocType: Interest,Interest,interes
+DocType: Lead,Lead is an Organization,Udhëheqësi është një organizatë
+DocType: Guardian Interest,Interest,interes
 apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Sales para
 DocType: Purchase Receipt,Other Details,Detaje të tjera
 apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,suplier
 DocType: Lab Test,Test Template,Template Test
 DocType: Restaurant Order Entry Item,Served,Served
+apps/erpnext/erpnext/config/non_profit.py +13,Chapter information.,Informacioni i kapitullit.
 DocType: Account,Accounts,Llogaritë
 DocType: Vehicle,Odometer Value (Last),Vlera rrugëmatës (i fundit)
 apps/erpnext/erpnext/config/buying.py +160,Templates of supplier scorecard criteria.,Modelet e kritereve të rezultateve të ofruesve.
-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,Pagesa Hyrja është krijuar tashmë
 DocType: Request for Quotation,Get Suppliers,Merrni Furnizuesit
 DocType: Purchase Receipt Item Supplied,Current Stock,Stock tanishme
-apps/erpnext/erpnext/controllers/accounts_controller.py +545,Row #{0}: Asset {1} does not linked to Item {2},Row # {0}: Asset {1} nuk lidhet me pikën {2}
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +377,Preview Salary Slip,Preview Paga Shqip
+apps/erpnext/erpnext/controllers/accounts_controller.py +589,Row #{0}: Asset {1} does not linked to Item {2},Row # {0}: Asset {1} nuk lidhet me pikën {2}
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +394,Preview Salary Slip,Preview Paga Shqip
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54,Account {0} has been entered multiple times,Llogaria {0} ka hyrë disa herë
 DocType: Account,Expenses Included In Valuation,Shpenzimet e përfshira në Vlerësimit
+apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +23,You can only renew if your membership expires within 30 days,Ju mund të rinovoni vetëm nëse anëtarësimi juaj mbaron brenda 30 ditëve
+DocType: Land Unit,Longitude,gjatësi
 ,Absent Student Report,Mungon Raporti Student
+DocType: Crop,Crop Spacing UOM,Spastrimi i drithrave UOM
 DocType: Email Digest,Next email will be sent on:,Email ardhshëm do të dërgohet në:
 DocType: Offer Letter Term,Offer Letter Term,Oferta Letër Term
 DocType: Supplier Scorecard,Per Week,Në javë
-apps/erpnext/erpnext/stock/doctype/item/item.py +658,Item has variants.,Item ka variante.
-apps/erpnext/erpnext/schools/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,Student Gjithsej
+apps/erpnext/erpnext/stock/doctype/item/item.py +639,Item has variants.,Item ka variante.
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,Student Gjithsej
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65,Item {0} not found,Item {0} nuk u gjet
 DocType: Bin,Stock Value,Stock Vlera
-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.,"Të dhënat e tarifave do të krijohen në sfond. Në rast të ndonjë gabimi, mesazhi i gabimit do të përditësohet në Orarin."
-apps/erpnext/erpnext/accounts/doctype/account/account.py +26,Company {0} does not exist,Kompania {0} nuk ekziston
+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.,"Të dhënat e tarifave do të krijohen në sfond. Në rast të ndonjë gabimi, mesazhi i gabimit do të përditësohet në Orarin."
+apps/erpnext/erpnext/accounts/doctype/account/account.py +241,Company {0} does not exist,Kompania {0} nuk ekziston
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40,{0} has fee validity till {1},{0} ka vlefshmërinë e tarifës deri në {1}
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +57,Tree Type,Tree Type
 DocType: BOM Explosion Item,Qty Consumed Per Unit,Qty konsumuar për njësi
@@ -862,42 +923,46 @@
 DocType: Material Request Item,Quantity and Warehouse,Sasia dhe Magazina
 DocType: Hub Settings,Unregister,unregister
 DocType: Sales Invoice,Commission Rate (%),Vlerësoni komision (%)
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +24,Please select Program,"Ju lutem, përzgjidhni Program"
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24,Please select Program,"Ju lutem, përzgjidhni Program"
 DocType: Project,Estimated Cost,Kostoja e vlerësuar
 DocType: Purchase Order,Link to material requests,Link të kërkesave materiale
 DocType: Hub Settings,Publish,publikoj
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +7,Aerospace,Hapësirës ajrore
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7,Aerospace,Hapësirës ajrore
 DocType: Journal Entry,Credit Card Entry,Credit Card Hyrja
 apps/erpnext/erpnext/config/accounts.py +57,Company and Accounts,Company dhe Llogaritë
 apps/erpnext/erpnext/config/healthcare.py +108,Appointment Type Master,Lloji i takimit Master
-apps/erpnext/erpnext/config/stock.py +22,Goods received from Suppliers.,Mallrat e marra nga furnizuesit.
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +58,In Value,në Vlera
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68,In Value,në Vlera
 DocType: Lead,Campaign Name,Emri fushatë
 DocType: Selling Settings,Close Opportunity After Days,Mbylle Opportunity pas ditë
 ,Reserved,I rezervuar
+DocType: Driver,License Details,Detajet e Licencës
 DocType: Purchase Order,Supply Raw Materials,Furnizimit të lëndëve të para
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,Pasuritë e tanishme
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +94,{0} is not a stock Item,{0} nuk është një gjendje Item
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +99,{0} is not a stock Item,{0} nuk është një gjendje Item
 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',Ju lutemi ndani komentet tuaja në trajnim duke klikuar në &#39;Trajnimi i Feedback&#39; dhe pastaj &#39;New&#39;
 DocType: Mode of Payment Account,Default Account,Gabim Llogaria
+apps/erpnext/erpnext/stock/doctype/item/item.py +262,Please select Sample Retention Warehouse in Stock Settings first,Ju lutemi zgjidhni Sample Retention Warehouse në Stock Settings për herë të parë
 DocType: Payment Entry,Received Amount (Company Currency),Shuma e marrë (Company Valuta)
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192,Lead must be set if Opportunity is made from Lead,"Lead duhet të vendosen, nëse Opportunity është bërë nga Lead"
 apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29,Please select weekly off day,"Ju lutem, përzgjidhni ditë javore jashtë"
 DocType: Patient,O Negative,O Negative
 DocType: Production Order Operation,Planned End Time,Planifikuar Fundi Koha
 ,Sales Person Target Variance Item Group-Wise,Sales Person i synuar Varianca Item Grupi i urti
-apps/erpnext/erpnext/accounts/doctype/account/account.py +96,Account with existing transaction cannot be converted to ledger,Llogaria me transaksion ekzistues nuk mund të konvertohet në Ledger
+apps/erpnext/erpnext/accounts/doctype/account/account.py +95,Account with existing transaction cannot be converted to ledger,Llogaria me transaksion ekzistues nuk mund të konvertohet në Ledger
+apps/erpnext/erpnext/config/non_profit.py +33,Memebership Type Details,Detajet e tipit të anëtarësisë
 DocType: Delivery Note,Customer's Purchase Order No,Konsumatorit Blerje Rendit Jo
 DocType: Budget,Budget Against,Kundër buxheti
 DocType: Employee,Cell Number,Numri Cell
-apps/erpnext/erpnext/stock/reorder_item.py +177,Auto Material Requests Generated,Kërkesat Auto Materiale Generated
+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.,Nuk ka punonjës për kriteret e dhëna. Kontrolloni që Slipet e pagave nuk janë krijuar.
+apps/erpnext/erpnext/stock/reorder_item.py +190,Auto Material Requests Generated,Kërkesat Auto Materiale Generated
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,I humbur
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +152,You can not enter current voucher in 'Against Journal Entry' column,Ju nuk mund të hyjë kupon aktual në &quot;Kundër Journal hyrjes &#39;kolonë
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +150,You can not enter current voucher in 'Against Journal Entry' column,Ju nuk mund të hyjë kupon aktual në &quot;Kundër Journal hyrjes &#39;kolonë
 apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,Rezervuar për prodhimin
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +25,Energy,Energji
+DocType: Soil Texture,Sand,rërë
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25,Energy,Energji
 DocType: Opportunity,Opportunity From,Opportunity Nga
 apps/erpnext/erpnext/config/hr.py +98,Monthly salary statement.,Deklarata mujore e pagave.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +876,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Rreshti {0}: {1} Numrat serialë të kërkuar për artikullin {2}. Ju keni dhënë {3}.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +881,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Rreshti {0}: {1} Numrat serialë të kërkuar për artikullin {2}. Ju keni dhënë {3}.
 apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79,Please select a table,Zgjidh një tabelë
 DocType: BOM,Website Specifications,Specifikimet Website
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78,{0} is an invalid email address in 'Recipients',{0} është një adresë e pavlefshme email në &#39;Përfituesit&#39;
@@ -905,12 +970,14 @@
 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}: Nga {0} nga lloji {1}
 DocType: Warranty Claim,CI-,Pri-
-apps/erpnext/erpnext/controllers/buying_controller.py +291,Row {0}: Conversion Factor is mandatory,Row {0}: Konvertimi Faktori është e detyrueshme
-DocType: Employee,A+,A +
+apps/erpnext/erpnext/controllers/buying_controller.py +292,Row {0}: Conversion Factor is mandatory,Row {0}: Konvertimi Faktori është e detyrueshme
+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}","Rregullat e çmimeve të shumta ekziston me kritere të njëjta, ju lutemi të zgjidhur konfliktin duke caktuar prioritet. Rregullat Çmimi: {0}"
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +501,Cannot deactivate or cancel BOM as it is linked with other BOMs,Nuk mund të çaktivizuar ose të anulojë bom si ajo është e lidhur me BOM-in e tjera
-DocType: Opportunity,Maintenance,Mirëmbajtje
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +504,Cannot deactivate or cancel BOM as it is linked with other BOMs,Nuk mund të çaktivizuar ose të anulojë bom si ajo është e lidhur me BOM-in e tjera
+DocType: Asset,Maintenance,Mirëmbajtje
 DocType: Item Attribute Value,Item Attribute Value,Item atribut Vlera
+DocType: Item,Maximum sample quantity that can be retained,Sasia maksimale e mostrës që mund të ruhet
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +393,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},{0} # Njësia {1} nuk mund të transferohet më shumë se {2} kundër Urdhëresës së Blerjes {3}
 apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Shitjet fushata.
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +117,Make Timesheet,bëni pasqyrë e mungesave
 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.
@@ -941,21 +1008,25 @@
 DocType: Expense Claim Detail,Expense Claim Type,Shpenzimet e kërkesës Lloji
 DocType: Shopping Cart Settings,Default settings for Shopping Cart,Default settings për Shportë
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +26,Add Timeslots,Shto Timeslots
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +138,Asset scrapped via Journal Entry {0},Asset braktiset via Journal Hyrja {0}
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138,Asset scrapped via Journal Entry {0},Asset braktiset via Journal Hyrja {0}
 DocType: Employee Loan,Interest Income Account,Llogaria ardhurat nga interesi
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +13,Biotechnology,Bioteknologji
+apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58,Review Invitation Sent,Thirrja e Shqyrtimit të dërguar
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13,Biotechnology,Bioteknologji
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Office Maintenance Expenses,Shpenzimet Zyra Mirëmbajtja
 apps/erpnext/erpnext/utilities/user_progress.py +51,Go to ,Shko te
 apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,Ngritja llogari PE
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.js +114,Please enter Item first,Ju lutemi shkruani pika e parë
+DocType: Asset Repair,Downtime,kohë joproduktive
 DocType: Account,Liability,Detyrim
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +186,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Shuma e sanksionuar nuk mund të jetë më e madhe se shuma e kërkesës në Row {0}.
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +234,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Shuma e sanksionuar nuk mund të jetë më e madhe se shuma e kërkesës në Row {0}.
 DocType: Salary Detail,Do not include in total,Mos përfshini në total
 DocType: Company,Default Cost of Goods Sold Account,Gabim Kostoja e mallrave të shitura Llogaria
-apps/erpnext/erpnext/stock/get_item_details.py +319,Price List not selected,Lista e Çmimeve nuk zgjidhet
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +964,Sample quantity {0} cannot be more than received quantity {1},Sasia e mostrës {0} nuk mund të jetë më e madhe sesa {1}
+apps/erpnext/erpnext/stock/get_item_details.py +362,Price List not selected,Lista e Çmimeve nuk zgjidhet
 DocType: Employee,Family Background,Historiku i familjes
 DocType: Request for Quotation Supplier,Send Email,Dërgo Email
-apps/erpnext/erpnext/stock/doctype/item/item.py +216,Warning: Invalid Attachment {0},Warning: Attachment Invalid {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +218,Warning: Invalid Attachment {0},Warning: Attachment Invalid {0}
+DocType: Item,Max Sample Quantity,Sasi Maksimale e mostrës
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +764,No Permission,Nuk ka leje
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +438,Quote Requested,Cito kërkohet
 DocType: Vital Signs,Heart Rate / Pulse,Shkalla e zemrës / Pulsi
@@ -963,32 +1034,34 @@
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +50,"To filter based on Party, select Party Type first","Për të filtruar në bazë të Partisë, Partia zgjidhni llojin e parë"
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48,'Update Stock' can not be checked because items are not delivered via {0},"&#39;Update Stock &quot;nuk mund të kontrollohet, sepse sendet nuk janë dorëzuar nëpërmjet {0}"
 DocType: Vehicle,Acquisition Date,Blerja Data
-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,Gjërat me weightage më të lartë do të tregohet më e lartë
+apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14,Lab Tests and Vital Signs,Testet Lab dhe Shenjat Vital
 DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Detail Banka Pajtimit
-apps/erpnext/erpnext/controllers/accounts_controller.py +549,Row #{0}: Asset {1} must be submitted,Row # {0}: Asset {1} duhet të dorëzohet
+apps/erpnext/erpnext/controllers/accounts_controller.py +593,Row #{0}: Asset {1} must be submitted,Row # {0}: Asset {1} duhet të dorëzohet
 apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40,No employee found,Asnjë punonjës gjetur
 DocType: Subscription,Stopped,U ndal
 DocType: Item,If subcontracted to a vendor,Në qoftë se nënkontraktuar për një shitës
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +111,Student Group is already updated.,Grupi Student është përditësuar tashmë.
+apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111,Student Group is already updated.,Grupi Student është përditësuar tashmë.
 DocType: SMS Center,All Customer Contact,Të gjitha Customer Kontakt
-apps/erpnext/erpnext/config/stock.py +158,Upload stock balance via csv.,Ngarko ekuilibër aksioneve nëpërmjet CSV.
-DocType: Warehouse,Tree Details,Tree Details
+DocType: Land Unit,Tree Details,Tree Details
 DocType: Training Event,Event Status,Status Event
+DocType: Volunteer,Availability Timeslot,Koha e disponueshmërisë
 ,Support Analytics,Analytics Mbështetje
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +352,"If you have any questions, please get back to us.","Nëse keni ndonjë pyetje, ju lutem të kthehet tek ne."
 DocType: Item,Website Warehouse,Website Magazina
 DocType: Payment Reconciliation,Minimum Invoice Amount,Shuma minimale Faturë
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Qendra Kosto {2} nuk i përkasin kompanisë {3}
+apps/erpnext/erpnext/utilities/user_progress.py +89,Upload your letter head (Keep it web friendly as 900px by 100px),Ngarko kokën tënde me shkronja (Mbani atë në internet si 900px me 100px)
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88,{0} {1}: Account {2} cannot be a Group,{0} {1}: Llogaria {2} nuk mund të jetë një grup
 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,Item Row {IDX}: {} {DOCTYPE docname} nuk ekziston në më sipër &#39;{DOCTYPE}&#39; tabelë
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +289,Timesheet {0} is already completed or cancelled,Pasqyrë e mungesave {0} është përfunduar tashmë ose anuluar
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +291,Timesheet {0} is already completed or cancelled,Pasqyrë e mungesave {0} është përfunduar tashmë ose anuluar
 apps/erpnext/erpnext/templates/pages/projects.html +42,No tasks,Nuk ka detyrat
 DocType: Item Variant Settings,Copy Fields to Variant,Kopjoni Fushat në Variant
 DocType: Asset,Opening Accumulated Depreciation,Hapja amortizimi i akumuluar
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49,Score must be less than or equal to 5,Rezultati duhet të jetë më pak se ose e barabartë me 5
 DocType: Program Enrollment Tool,Program Enrollment Tool,Program Regjistrimi Tool
-apps/erpnext/erpnext/config/accounts.py +343,C-Form records,Të dhënat C-Forma
+apps/erpnext/erpnext/config/accounts.py +335,C-Form records,Të dhënat C-Forma
 apps/erpnext/erpnext/config/selling.py +311,Customer and Supplier,Customer dhe Furnizues
 DocType: Email Digest,Email Digest Settings,Email Settings Digest
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +354,Thank you for your business!,Ju faleminderit për biznesin tuaj!
@@ -999,43 +1072,48 @@
 DocType: HR Settings,Retirement Age,Daljes në pension Age
 DocType: Bin,Moving Average Rate,Moving norma mesatare
 DocType: Production Planning Tool,Select Items,Zgjidhni Items
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372,{0} against Bill {1} dated {2},"{0} kundër Bill {1} {2}, datë"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +370,{0} against Bill {1} dated {2},"{0} kundër Bill {1} {2}, datë"
 apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Institution,Institucioni i instalimit
 DocType: Program Enrollment,Vehicle/Bus Number,Vehicle / Numri Bus
-apps/erpnext/erpnext/schools/doctype/course/course.js +17,Course Schedule,Orari i kursit
+apps/erpnext/erpnext/education/doctype/course/course.js +17,Course Schedule,Orari i kursit
 DocType: Request for Quotation Supplier,Quote Status,Statusi i citatit
 DocType: Maintenance Visit,Completion Status,Përfundimi Statusi
 DocType: HR Settings,Enter retirement age in years,Shkruani moshën e pensionit në vitet
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +252,Target Warehouse,Target Magazina
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +118,Please select a warehouse,"Ju lutem, përzgjidhni një depo"
+DocType: Crop,Target Warehouse,Target Magazina
+DocType: Payroll Employee Detail,Payroll Employee Detail,Detajet e punonjësve të pagave
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128,Please select a warehouse,"Ju lutem, përzgjidhni një depo"
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Ju lutem vendosni numrat e numrave për Pjesëmarrjen përmes Setup&gt; Seritë e Numërimit
 DocType: Cheque Print Template,Starting location from left edge,Duke filluar vend nga buzë e majtë
 DocType: Item,Allow over delivery or receipt upto this percent,Lejo mbi ofrimin ose pranimin upto këtë qind
 DocType: Stock Entry,STE-,STE-
 DocType: Upload Attendance,Import Attendance,Pjesëmarrja e importit
 apps/erpnext/erpnext/public/js/pos/pos.html +113,All Item Groups,Të gjitha Item Grupet
-DocType: Process Payroll,Activity Log,Aktiviteti Identifikohu
 apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Net Profit / Loss,Fitimi neto / Humbja
 apps/erpnext/erpnext/config/setup.py +89,Automatically compose message on submission of transactions.,Automatikisht shkruaj mesazh për dorëzimin e transaksioneve.
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +201,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Vendosni Serinë Naming për {0} nëpërmjet Setup&gt; Settings&gt; Naming Series
 DocType: Production Order,Item To Manufacture,Item Për Prodhimi
 apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},{0} {1} statusi është {2}
+DocType: Water Analysis,Collection Temperature ,Temperatura e mbledhjes
 DocType: Employee,Provide Email Address registered in company,Sigurojë Adresa Email i regjistruar në kompaninë
 DocType: Shopping Cart Settings,Enable Checkout,Aktivizo Checkout
 apps/erpnext/erpnext/config/learn.py +202,Purchase Order to Payment,Blerje Rendit për Pagesa
 apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,Projektuar Qty
 DocType: Sales Invoice,Payment Due Date,Afati i pageses
 DocType: Drug Prescription,Interval UOM,Interval UOM
-apps/erpnext/erpnext/stock/doctype/item/item.js +363,Item Variant {0} already exists with same attributes,Item Varianti {0} tashmë ekziston me atributet e njëjta
+apps/erpnext/erpnext/stock/doctype/item/item.js +489,Item Variant {0} already exists with same attributes,Item Varianti {0} tashmë ekziston me atributet e njëjta
 DocType: Item,Hub Publishing Details,Detajet e botimit të Hub
 apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +115,'Opening',&quot;Hapja&quot;
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,Hapur për të bërë
 DocType: Notification Control,Delivery Note Message,Ofrimit Shënim Mesazh
 DocType: Lab Test Template,Result Format,Formati i rezultatit
 DocType: Expense Claim,Expenses,Shpenzim
+DocType: Delivery Stop,Delivery Notes,Shënimet e Dorëzimit
 DocType: Item Variant Attribute,Item Variant Attribute,Item Varianti Atributi
 ,Purchase Receipt Trends,Trendet Receipt Blerje
-DocType: Process Payroll,Bimonthly,dy herë në muaj
+DocType: Payroll Entry,Bimonthly,dy herë në muaj
 DocType: Vehicle Service,Brake Pad,Brake Pad
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +115,Research & Development,Hulumtim dhe Zhvillim
+DocType: Fertilizer,Fertilizer Contents,Përmbajtja e plehut
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119,Research & Development,Hulumtim dhe Zhvillim
 apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20,Amount to Bill,Shuma për Bill
 DocType: Company,Registration Details,Detajet e regjistrimit
 DocType: Timesheet,Total Billed Amount,Shuma totale e faturuar
@@ -1047,16 +1125,18 @@
 DocType: Sales Team,Incentives,Nxitjet
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +64,Register for Hub,Regjistrohu për Hub
 DocType: SMS Log,Requested Numbers,Numrat kërkuara
+DocType: Volunteer,Evening,mbrëmje
 DocType: Production Planning Tool,Only Obtain Raw Materials,Vetëm Merrni lëndëve të para
-apps/erpnext/erpnext/config/hr.py +142,Performance appraisal.,Vlerësimit të performancës.
+DocType: Customer,Bypass credit limit check at Sales Order,Kufizo limitin e kreditit në Urdhërin e Shitjes
+apps/erpnext/erpnext/config/hr.py +147,Performance appraisal.,Vlerësimit të performancës.
 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","Duke bërë të mundur &#39;Përdorimi për Shportë&#39;, si Shporta është aktivizuar dhe duhet të ketë të paktën një Rule Tax per Shporta"
-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.","Pagesa Hyrja {0} është e lidhur kundrejt Rendit {1}, kontrolloni nëse ajo duhet të largohen sa më parë në këtë faturë."
+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.","Pagesa Hyrja {0} është e lidhur kundrejt Rendit {1}, kontrolloni nëse ajo duhet të largohen sa më parë në këtë faturë."
 DocType: Sales Invoice Item,Stock Details,Stock Detajet
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Vlera e Projektit
 apps/erpnext/erpnext/config/selling.py +321,Point-of-Sale,Point-of-Sale
 DocType: Fee Schedule,Fee Creation Status,Statusi i Krijimit të Tarifave
 DocType: Vehicle Log,Odometer Reading,Leximi rrugëmatës
-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'","Bilanci i llogarisë tashmë në kredi, ju nuk jeni i lejuar për të vendosur &quot;Bilanci Must Be &#39;si&#39; Debitimit &#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'","Bilanci i llogarisë tashmë në kredi, ju nuk jeni i lejuar për të vendosur &quot;Bilanci Must Be &#39;si&#39; Debitimit &#39;"
 DocType: Account,Balance must be,Bilanci duhet të jetë
 DocType: Hub Settings,Publish Pricing,Publikimi i Çmimeve
 DocType: Notification Control,Expense Claim Rejected Message,Shpenzim Kërkesa Refuzuar mesazh
@@ -1065,12 +1145,15 @@
 DocType: Purchase Invoice Item,Rejected Qty,refuzuar Qty
 DocType: Setup Progress Action,Action Field,Fusha e Veprimit
 DocType: Healthcare Settings,Manage Customer,Menaxho Klientin
+DocType: Delivery Trip,Delivery Stops,Dorëzimi ndalon
 DocType: Salary Slip,Working Days,Ditët e punës
 DocType: Serial No,Incoming Rate,Hyrëse Rate
 DocType: Packing Slip,Gross Weight,Peshë Bruto
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47,Enable Hub,Aktivizo Hub
-apps/erpnext/erpnext/public/js/setup_wizard.js +107,The name of your company for which you are setting up this system.,Emri i kompanisë suaj për të cilën ju jeni të vendosur këtë sistem.
+apps/erpnext/erpnext/public/js/setup_wizard.js +110,The name of your company for which you are setting up this system.,Emri i kompanisë suaj për të cilën ju jeni të vendosur këtë sistem.
 DocType: HR Settings,Include holidays in Total no. of Working Days,Përfshijnë pushimet në total nr. i ditëve të punës
+apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +108,Setup your Institute in ERPNext,Instaloni Institutin tuaj në ERPNext
+DocType: Agriculture Analysis Criteria,Plant Analysis,Analiza e bimëve
 DocType: Job Applicant,Hold,Mbaj
 DocType: Employee,Date of Joining,Data e Bashkimi
 DocType: Naming Series,Update Series,Update Series
@@ -1078,27 +1161,31 @@
 DocType: Restaurant Table,Minimum Seating,Vendndodhja minimale
 DocType: Item Attribute,Item Attribute Values,Vlerat Item ia atribuojnë
 DocType: Examination Result,Examination Result,Ekzaminimi Result
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +817,Purchase Receipt,Pranimi Blerje
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +843,Purchase Receipt,Pranimi Blerje
 ,Received Items To Be Billed,Items marra Për të faturohet
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +173,Submitted Salary Slips,Dërguar pagave rrëshqet
-apps/erpnext/erpnext/config/accounts.py +311,Currency exchange rate master.,Kursi i këmbimit të monedhës mjeshtër.
+apps/erpnext/erpnext/config/accounts.py +303,Currency exchange rate master.,Kursi i këmbimit të monedhës mjeshtër.
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +198,Reference Doctype must be one of {0},Referenca DOCTYPE duhet të jetë një nga {0}
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +302,Unable to find Time Slot in the next {0} days for Operation {1},Në pamundësi për të gjetur vend i caktuar kohë në {0} ditëve të ardhshme për funksionimin {1}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +322,Unable to find Time Slot in the next {0} days for Operation {1},Në pamundësi për të gjetur vend i caktuar kohë në {0} ditëve të ardhshme për funksionimin {1}
 DocType: Production Order,Plan material for sub-assemblies,Materiali plan për nën-kuvendet
 apps/erpnext/erpnext/config/selling.py +97,Sales Partners and Territory,Sales Partners dhe Territori
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +581,BOM {0} must be active,BOM {0} duhet të jetë aktiv
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +585,BOM {0} must be active,BOM {0} duhet të jetë aktiv
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +221,Closing (Opening + Total),Mbyllja (Hapja + Gjithsej)
 DocType: Journal Entry,Depreciation Entry,Zhvlerësimi Hyrja
 apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +36,Please select the document type first,Ju lutem zgjidhni llojin e dokumentit të parë
 apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,Anuloje Vizitat Materiale {0} para anulimit të kësaj vizite Mirëmbajtja
+DocType: Crop Cycle,ISO 8016 standard,ISO 8016 standard
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,Serial No {0} does not belong to Item {1},Serial Asnjë {0} nuk i përkasin Item {1}
 DocType: Purchase Receipt Item Supplied,Required Qty,Kerkohet Qty
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +127,Warehouses with existing transaction can not be converted to ledger.,Depot me transaksion ekzistues nuk mund të konvertohet në librin.
 DocType: Bank Reconciliation,Total Amount,Shuma totale
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +32,Internet Publishing,Botime Internet
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32,Internet Publishing,Botime Internet
 DocType: Prescription Duration,Number,numër
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25,Creating {0} Invoice,Krijimi i {0} faturës
 DocType: Medical Code,Medical Code Standard,Kodi i Mjekësisë Standard
+DocType: Soil Texture,Clay Composition (%),Përbërja e argjilës (%)
 DocType: Production Planning Tool,Production Orders,Urdhërat e prodhimit
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +62,Balance Value,Vlera e bilancit
+apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81,Please save before assigning task.,Ju lutemi ruani para se të caktoni detyrën.
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72,Balance Value,Vlera e bilancit
 DocType: Lab Test,Lab Technician,Teknik i laboratorit
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,Lista Sales Çmimi
 DocType: Healthcare Settings,"If checked, a customer will be created, mapped to Patient.
@@ -1110,31 +1197,33 @@
 DocType: Supplier,Default Payable Accounts,Default Llogaritë e pagueshme
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49,Employee {0} is not active or does not exist,Punonjës {0} nuk është aktiv apo nuk ekziston
 DocType: Fee Structure,Components,komponentet
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +251,Please enter Asset Category in Item {0},Ju lutem shkruani Pasurive Kategoria në pikën {0}
-apps/erpnext/erpnext/stock/doctype/item/item.py +653,Item Variants {0} updated,Item Variantet {0} përditësuar
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +272,Please enter Asset Category in Item {0},Ju lutem shkruani Pasurive Kategoria në pikën {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +634,Item Variants {0} updated,Item Variantet {0} përditësuar
 DocType: Quality Inspection Reading,Reading 6,Leximi 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","për tu gjeneruar. Nëse vonohet, do të duhet të ndryshoni manualisht fushën &quot;Repeat on Day of Month&quot; të kësaj"
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +919,Cannot {0} {1} {2} without any negative outstanding invoice,"Nuk mund {0} {1} {2}, pa asnjë faturë negative shquar"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +945,Cannot {0} {1} {2} without any negative outstanding invoice,"Nuk mund {0} {1} {2}, pa asnjë faturë negative shquar"
 DocType: Purchase Invoice Advance,Purchase Invoice Advance,Blerje Faturë Advance
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199,Row {0}: Credit entry can not be linked with a {1},Row {0}: Hyrja e kredisë nuk mund të jetë i lidhur me një {1}
-apps/erpnext/erpnext/config/accounts.py +254,Define budget for a financial year.,Të përcaktojë buxhetin për një vit financiar.
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +197,Row {0}: Credit entry can not be linked with a {1},Row {0}: Hyrja e kredisë nuk mund të jetë i lidhur me një {1}
+apps/erpnext/erpnext/config/accounts.py +246,Define budget for a financial year.,Të përcaktojë buxhetin për një vit financiar.
 DocType: Mode of Payment Account,Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,Parazgjedhur llogari Banka / Cash do të rifreskohet automatikisht në POS Faturës kur kjo mënyrë është zgjedhur.
 DocType: Lead,LEAD-,plumb
 DocType: Employee,Permanent Address Is,Adresa e përhershme është
 DocType: Production Order Operation,Operation completed for how many finished goods?,Operacioni përfundoi për mënyrën se si shumë mallra të gatshme?
-apps/erpnext/erpnext/public/js/setup_wizard.js +47,The Brand,Markë
+DocType: Payment Terms Template,Payment Terms Template,Modeli i kushteve të pagesës
+apps/erpnext/erpnext/public/js/setup_wizard.js +51,The Brand,Markë
 DocType: Employee,Exit Interview Details,Detajet Dil Intervista
 DocType: Item,Is Purchase Item,Është Blerje Item
-DocType: Asset,Purchase Invoice,Blerje Faturë
+DocType: Journal Entry Account,Purchase Invoice,Blerje Faturë
 DocType: Stock Ledger Entry,Voucher Detail No,Voucher Detail Asnjë
-apps/erpnext/erpnext/accounts/page/pos/pos.js +765,New Sales Invoice,Sales New Fatura
+apps/erpnext/erpnext/accounts/page/pos/pos.js +780,New Sales Invoice,Sales New Fatura
 DocType: Stock Entry,Total Outgoing Value,Vlera Totale largohet
 DocType: Physician,Appointments,emërimet
 apps/erpnext/erpnext/public/js/account_tree_grid.js +224,Opening Date and Closing Date should be within same Fiscal Year,Hapja Data dhe Data e mbylljes duhet të jetë brenda të njëjtit vit fiskal
 DocType: Lead,Request for Information,Kërkesë për Informacion
 ,LeaderBoard,Fituesit
-apps/erpnext/erpnext/accounts/page/pos/pos.js +778,Sync Offline Invoices,Sync Offline Faturat
+DocType: Sales Invoice Item,Rate With Margin (Company Currency),Shkalla me margjinë (Valuta e kompanisë)
+apps/erpnext/erpnext/accounts/page/pos/pos.js +793,Sync Offline Invoices,Sync Offline Faturat
 DocType: Payment Request,Paid,I paguar
 DocType: Program Fee,Program Fee,Tarifa program
 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.
@@ -1144,13 +1233,14 @@
 DocType: Guardian,Guardian Name,Emri Guardian
 DocType: Cheque Print Template,Has Print Format,Ka Print Format
 DocType: Employee Loan,Sanctioned,sanksionuar
-apps/erpnext/erpnext/accounts/page/pos/pos.js +73, is mandatory. Maybe Currency Exchange record is not created for ,është i detyrueshëm. Ndoshta rekord Currency Exchange nuk është krijuar për
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +112,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Ju lutem specifikoni Serial Jo për Item {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.","Për sendet e &#39;Produkt Bundle&#39;, depo, pa serial dhe Serisë Nuk do të konsiderohet nga &#39;Paketimi listë&#39; tryezë. Nëse Magazina dhe Serisë Nuk janë të njëjta për të gjitha sendet e paketimit për çdo send &#39;produkt Bundle&#39;, këto vlera mund të futen në tabelën kryesore Item, vlerat do të kopjohet në &#39;Paketimi listë&#39; tryezë."
-DocType: Job Opening,Publish on website,Publikojë në faqen e internetit
-apps/erpnext/erpnext/config/stock.py +17,Shipments to customers.,Dërgesat për klientët.
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +641,Supplier Invoice Date cannot be greater than Posting Date,Furnizuesi Data e faturës nuk mund të jetë më i madh se mbi postimet Data
+apps/erpnext/erpnext/accounts/page/pos/pos.js +75, is mandatory. Maybe Currency Exchange record is not created for ,është i detyrueshëm. Ndoshta rekord Currency Exchange nuk është krijuar për
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +117,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Ju lutem specifikoni Serial Jo për Item {1}
+DocType: Crop Cycle,Crop Cycle,Cikli i kulturave
+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.","Për sendet e &#39;Produkt Bundle&#39;, depo, pa serial dhe Serisë Nuk do të konsiderohet nga &#39;Paketimi listë&#39; tryezë. Nëse Magazina dhe Serisë Nuk janë të njëjta për të gjitha sendet e paketimit për çdo send &#39;produkt Bundle&#39;, këto vlera mund të futen në tabelën kryesore Item, vlerat do të kopjohet në &#39;Paketimi listë&#39; tryezë."
+DocType: Student Admission,Publish on website,Publikojë në faqen e internetit
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +645,Supplier Invoice Date cannot be greater than Posting Date,Furnizuesi Data e faturës nuk mund të jetë më i madh se mbi postimet Data
 DocType: Purchase Invoice Item,Purchase Order Item,Rendit Blerje Item
+DocType: Agriculture Task,Agriculture Task,Detyra e Bujqësisë
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,Indirect Income,Të ardhurat indirekte
 DocType: Student Attendance Tool,Student Attendance Tool,Pjesëmarrja Student Tool
 DocType: Restaurant Menu,Price List (Auto created),Lista e çmimeve (krijuar automatikisht)
@@ -1158,57 +1248,62 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48,Variance,Grindje
 ,Company Name,Emri i kompanisë
 DocType: SMS Center,Total Message(s),Përgjithshme mesazh (s)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +888,Select Item for Transfer,Përzgjidh Item për transferimin
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +913,Select Item for Transfer,Përzgjidh Item për transferimin
 DocType: Purchase Invoice,Additional Discount Percentage,Përqindja shtesë Discount
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24,View a list of all the help videos,Shiko një listë të të gjitha ndihmë videot
+DocType: Agriculture Analysis Criteria,Soil Texture,Cilësi e tokës
 DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,Zgjidh llogaria kreu i bankës ku kontrolli ishte depozituar.
 DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Lejo përdoruesit të redaktoni listën e çmimeve Vlerësoni në transaksionet
 DocType: Pricing Rule,Max Qty,Max 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}: Fatura {1} është i pavlefshëm, ajo mund të anulohet / nuk ekziston. \ Ju lutem shkruani një faturë e vlefshme"
-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}: Pagesa kundër Sales / Rendit Blerje gjithmonë duhet të shënohet si më parë
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +16,Chemical,Kimik
+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}: Pagesa kundër Sales / Rendit Blerje gjithmonë duhet të shënohet si më parë
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16,Chemical,Kimik
 DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Default Llogaria bankare / Cash do të rifreskohet automatikisht në Paga Journal hyrjes kur ky modalitet zgjidhet.
 DocType: BOM,Raw Material Cost(Company Currency),Raw Material Kosto (Company Valuta)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +732,All items have already been transferred for this Production Order.,Të gjitha sendet janë tashmë të transferuar për këtë Rendit Production.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +758,All items have already been transferred for this Production Order.,Të gjitha sendet janë tashmë të transferuar për këtë Rendit Production.
 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}: norma nuk mund të jetë më e madhe se norma e përdorur në {1} {2}
 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}: norma nuk mund të jetë më e madhe se norma e përdorur në {1} {2}
-apps/erpnext/erpnext/utilities/user_progress.py +126,Meter,metër
+apps/erpnext/erpnext/utilities/user_progress.py +144,Meter,metër
 DocType: Workstation,Electricity Cost,Kosto të energjisë elektrike
 DocType: HR Settings,Don't send Employee Birthday Reminders,Mos dërgoni punonjës Ditëlindja Përkujtesat
+DocType: Expense Claim,Total Advance Amount,Shuma totale e parapagimit
+DocType: Delivery Stop,Estimated Arrival,Arritja e parashikuar
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +34,Save Settings,Ruaj cilësimet
+DocType: Delivery Stop,Notified by Email,Njoftuar me Email
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +683,Requested Products,Produkte të kërkuara
 DocType: Item,Inspection Criteria,Kriteret e Inspektimit
 apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Transfered,Transferuar
 DocType: BOM Website Item,BOM Website Item,BOM Website Item
-apps/erpnext/erpnext/public/js/setup_wizard.js +48,Upload your letter head and logo. (you can edit them later).,Ngarko kokën tuaj letër dhe logo. (Ju mund të modifikoni ato më vonë).
+apps/erpnext/erpnext/public/js/setup_wizard.js +52,Upload your letter head and logo. (you can edit them later).,Ngarko kokën tuaj letër dhe logo. (Ju mund të modifikoni ato më vonë).
 DocType: Timesheet Detail,Bill,Fature
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +85,Next Depreciation Date is entered as past date,Zhvlerësimi Date tjetër është futur si datë të fundit
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +204,White,E bardhë
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +85,Next Depreciation Date is entered as past date,Zhvlerësimi Date tjetër është futur si datë të fundit
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208,White,E bardhë
 DocType: SMS Center,All Lead (Open),Të gjitha Lead (Open)
-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}: Qty nuk është në dispozicion për {4} në depo {1} të postimi kohën e hyrjes ({2} {3})
+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}: Qty nuk është në dispozicion për {4} në depo {1} të postimi kohën e hyrjes ({2} {3})
 DocType: Purchase Invoice,Get Advances Paid,Get Paid Përparimet
 DocType: Item,Automatically Create New Batch,Automatikisht Krijo grumbull të ri
 DocType: Item,Automatically Create New Batch,Automatikisht Krijo grumbull të ri
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +782,Make ,Bëj
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +808,Make ,Bëj
 DocType: Student Admission,Admission Start Date,Pranimi Data e fillimit
 DocType: Journal Entry,Total Amount in Words,Shuma totale në fjalë
+apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29,New Employee,Punonjës i ri
 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.,Pati një gabim. Një arsye e mundshme mund të jetë që ju nuk e keni ruajtur formën. Ju lutemi te kontaktoni support@erpnext.com nëse problemi vazhdon.
 apps/erpnext/erpnext/templates/pages/cart.html +5,My Cart,Shporta ime
-apps/erpnext/erpnext/controllers/selling_controller.py +158,Order Type must be one of {0},Rendit Lloji duhet të jetë një nga {0}
+apps/erpnext/erpnext/controllers/selling_controller.py +126,Order Type must be one of {0},Rendit Lloji duhet të jetë një nga {0}
 DocType: Lead,Next Contact Date,Tjetër Kontakt Data
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Opening Qty,Hapja Qty
 DocType: Healthcare Settings,Appointment Reminder,Kujtesë për Emër
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +468,Please enter Account for Change Amount,"Ju lutem, jepni llogari për Ndryshim Shuma"
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +472,Please enter Account for Change Amount,"Ju lutem, jepni llogari për Ndryshim Shuma"
 DocType: Student Batch Name,Student Batch Name,Student Batch Emri
 DocType: Consultation,Doctor,mjek
 DocType: Holiday List,Holiday List Name,Festa Lista Emri
 DocType: Repayment Schedule,Balance Loan Amount,Bilanci Shuma e Kredisë
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.js +13,Schedule Course,Orari i kursit
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +224,Stock Options,Stock Options
+apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,Orari i kursit
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234,Stock Options,Stock Options
 DocType: Journal Entry Account,Expense Claim,Shpenzim Claim
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +234,Do you really want to restore this scrapped asset?,A jeni të vërtetë doni për të rivendosur këtë pasuri braktiset?
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +358,Qty for {0},Qty për {0}
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +254,Do you really want to restore this scrapped asset?,A jeni të vërtetë doni për të rivendosur këtë pasuri braktiset?
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +380,Qty for {0},Qty për {0}
 DocType: Leave Application,Leave Application,Lini Aplikimi
 DocType: Patient,Patient Relation,Lidhja e pacientit
 apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,Lini Alokimi Tool
@@ -1224,19 +1319,23 @@
 apps/erpnext/erpnext/public/js/queries.js +96,Please specify a {0},Ju lutem specifikoni një {0}
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +71,Removed items with no change in quantity or value.,Artikuj hequr me asnjë ndryshim në sasi ose në vlerë.
 DocType: Delivery Note,Delivery To,Ofrimit të
-apps/erpnext/erpnext/stock/doctype/item/item.py +682,Attribute table is mandatory,Tabela atribut është i detyrueshëm
+apps/erpnext/erpnext/stock/doctype/item/item.js +384,Variant creation has been queued.,Krijimi i variantit ka qenë në radhë.
+apps/erpnext/erpnext/stock/doctype/item/item.py +668,Attribute table is mandatory,Tabela atribut është i detyrueshëm
 DocType: Production Planning Tool,Get Sales Orders,Get Sales urdhëron
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +67,{0} can not be negative,{0} nuk mund të jetë negative
 DocType: Training Event,Self-Study,Self-Study
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +480,Discount,Zbritje
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +537,Discount,Zbritje
+DocType: Membership,Membership,Anëtarësia
 DocType: Asset,Total Number of Depreciations,Numri i përgjithshëm i nënçmime
 DocType: Sales Invoice Item,Rate With Margin,Shkalla me diferencë
 DocType: Sales Invoice Item,Rate With Margin,Shkalla me diferencë
 DocType: Workstation,Wages,Pagat
-DocType: Task,Urgent,Urgjent
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +157,Please specify a valid Row ID for row {0} in table {1},Ju lutem specifikoni një ID te vlefshme Row për rresht {0} në tryezë {1}
+DocType: Asset Maintenance,Maintenance Manager Name,Emri Menaxheri i Mirëmbajtjes
+DocType: Agriculture Task,Urgent,Urgjent
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,Please specify a valid Row ID for row {0} in table {1},Ju lutem specifikoni një ID te vlefshme Row për rresht {0} në tryezë {1}
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84,Unable to find variable: ,Nuk mund të gjeni ndryshore:
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +664,Please select a field to edit from numpad,Ju lutemi zgjidhni një fushë për të redaktuar nga numpad
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +723,Please select a field to edit from numpad,Ju lutemi zgjidhni një fushë për të redaktuar nga numpad
+apps/erpnext/erpnext/stock/doctype/item/item.py +253,Cannot be a fixed asset item as Stock Ledger is created.,Nuk mund të jetë një element i aseteve fikse si Ledger Stock është krijuar.
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,Shko në Desktop dhe të fillojë përdorimin ERPNext
 DocType: Item,Manufacturer,Prodhues
 DocType: Landed Cost Item,Purchase Receipt Item,Blerje Pranimi i artikullit
@@ -1245,12 +1344,11 @@
 DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Rezervuar Magazina në Sales Order / Finished mallrave Magazina
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Selling Amount,Shuma Shitja
 DocType: Repayment Schedule,Interest Amount,Shuma e interesit
-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,Ju jeni aprovuesi Shpenzimet për këtë rekord. Ju lutem Update &#39;Status&#39; dhe për të shpëtuar
+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,Ju jeni aprovuesi Shpenzimet për këtë rekord. Ju lutem Update &#39;Status&#39; dhe për të shpëtuar
 DocType: Serial No,Creation Document No,Krijimi Dokumenti Asnjë
 DocType: Issue,Issue,Çështje
 apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11,Records,të dhëna
 DocType: Asset,Scrapped,braktiset
-apps/erpnext/erpnext/config/stock.py +200,"Attributes for Item Variants. e.g Size, Color etc.","Atributet për Item variante. p.sh. madhësia, ngjyra etj"
 DocType: Purchase Invoice,Returns,Kthim
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +42,WIP Warehouse,WIP Magazina
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195,Serial No {0} is under maintenance contract upto {1},Serial Asnjë {0} është nën kontratë të mirëmbajtjes upto {1}
@@ -1259,7 +1357,8 @@
 DocType: Tax Rule,Shipping State,Shteti Shipping
 ,Projected Quantity as Source,Sasia e parashikuar si Burimi
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,Item must be added using 'Get Items from Purchase Receipts' button,Item duhet të shtohen duke përdorur &#39;të marrë sendet nga blerjen Pranimet&#39; button
-DocType: Employee,A-,A-
+DocType: Delivery Trip,Delivery Trip,Udhëtimi i udhëtimit
+DocType: Student,A-,A-
 DocType: Production Planning Tool,Include non-stock items,Përfshijnë zëra jo-aksioneve
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Sales Expenses,Shitjet Shpenzimet
 DocType: Consultation,Diagnosis,diagnozë
@@ -1267,8 +1366,8 @@
 DocType: GL Entry,Against,Kundër
 DocType: Item,Default Selling Cost Center,Gabim Qendra Shitja Kosto
 DocType: Sales Partner,Implementation Partner,Partner Zbatimi
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1598,ZIP Code,Kodi Postal
-apps/erpnext/erpnext/controllers/selling_controller.py +271,Sales Order {0} is {1},Sales Order {0} është {1}
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1613,ZIP Code,Kodi Postal
+apps/erpnext/erpnext/controllers/selling_controller.py +245,Sales Order {0} is {1},Sales Order {0} është {1}
 DocType: Opportunity,Contact Info,Informacionet Kontakt
 apps/erpnext/erpnext/config/stock.py +315,Making Stock Entries,Marrja e aksioneve Entries
 DocType: Packing Slip,Net Weight UOM,Net Weight UOM
@@ -1280,20 +1379,23 @@
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33,End Date can not be less than Start Date,End Date nuk mund të jetë më pak se Data e fillimit
 DocType: Sales Person,Select company name first.,Përzgjidh kompani emri i parë.
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +181,Low to High,I ulët në të lartë
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +202,Email sent to {0},Email dërguar për {0}
 apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Kuotimet e marra nga furnizuesit.
 apps/erpnext/erpnext/config/manufacturing.py +74,Replace BOM and update latest price in all BOMs,Replace BOM dhe update çmimin e fundit në të gjitha BOMs
 apps/erpnext/erpnext/controllers/selling_controller.py +24,To {0} | {1} {2},Për {0} | {1} {2}
+DocType: Delivery Trip,Driver Name,Emri i shoferit
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Mesatare Moshë
-DocType: School Settings,Attendance Freeze Date,Pjesëmarrja Freeze Data
-DocType: School Settings,Attendance Freeze Date,Pjesëmarrja Freeze Data
-apps/erpnext/erpnext/utilities/user_progress.py +89,List a few of your suppliers. They could be organizations or individuals.,Lista disa nga furnizuesit tuaj. Ata mund të jenë organizata ose individë.
+DocType: Education Settings,Attendance Freeze Date,Pjesëmarrja Freeze Data
+DocType: Education Settings,Attendance Freeze Date,Pjesëmarrja Freeze Data
+apps/erpnext/erpnext/utilities/user_progress.py +107,List a few of your suppliers. They could be organizations or individuals.,Lista disa nga furnizuesit tuaj. Ata mund të jenë organizata ose individë.
 apps/erpnext/erpnext/templates/pages/home.html +31,View All Products,Shiko të gjitha Produktet
 apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Lead Minimumi moshes (ditë)
 apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Lead Minimumi moshes (ditë)
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +57,All BOMs,Të gjitha BOM
 DocType: Patient,Default Currency,Gabim Valuta
 DocType: Expense Claim,From Employee,Nga punonjësi
-apps/erpnext/erpnext/controllers/accounts_controller.py +407,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Kujdes: Sistemi nuk do të kontrollojë overbilling që shuma për Item {0} në {1} është zero
+DocType: Driver,Cellphone Number,Numri i celularit
+apps/erpnext/erpnext/controllers/accounts_controller.py +451,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Kujdes: Sistemi nuk do të kontrollojë overbilling që shuma për Item {0} në {1} është zero
 DocType: Journal Entry,Make Difference Entry,Bëni Diferenca Hyrja
 DocType: Upload Attendance,Attendance From Date,Pjesëmarrja Nga Data
 DocType: Appraisal Template Goal,Key Performance Area,Key Zona Performance
@@ -1302,20 +1404,22 @@
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +229,{0} {1} must be submitted,{0} {1} duhet të dorëzohet
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +151,Quantity must be less than or equal to {0},Sasia duhet të jetë më e vogël se ose e barabartë me {0}
 DocType: SMS Center,Total Characters,Totali Figurë
+DocType: Employee Advance,Claimed,pretenduar
+DocType: Crop,Row Spacing,Hapësira e Rreshtit
 apps/erpnext/erpnext/controllers/buying_controller.py +161,Please select BOM in BOM field for Item {0},"Ju lutem, përzgjidhni bom në fushën BOM për Item {0}"
 DocType: C-Form Invoice Detail,C-Form Invoice Detail,Detail C-Forma Faturë
 DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Pagesa Pajtimi Faturë
 apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +42,Contribution %,Kontributi%
-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}","Sipas Settings Blerja në qoftë Rendit Blerje Kërkohet == &#39;PO&#39;, pastaj për krijimin Blerje Faturën, përdoruesi duhet të krijoni Rendit Blerje parë për pikën {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}","Sipas Settings Blerja në qoftë Rendit Blerje Kërkohet == &#39;PO&#39;, pastaj për krijimin Blerje Faturën, përdoruesi duhet të krijoni Rendit Blerje parë për pikën {0}"
 DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Numrat e regjistrimit kompani për referencë tuaj. Numrat e taksave etj
 DocType: Sales Partner,Distributor,Shpërndarës
 DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Shporta Transporti Rregulla
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +233,Production Order {0} must be cancelled before cancelling this Sales Order,Prodhimi Rendit {0} duhet të anulohet para se anulimi këtë Radhit Sales
-apps/erpnext/erpnext/public/js/controllers/transaction.js +68,Please set 'Apply Additional Discount On',Ju lutemi të vendosur &#39;Aplikoni Discount shtesë në&#39;
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252,Production Order {0} must be cancelled before cancelling this Sales Order,Prodhimi Rendit {0} duhet të anulohet para se anulimi këtë Radhit Sales
+apps/erpnext/erpnext/public/js/controllers/transaction.js +71,Please set 'Apply Additional Discount On',Ju lutemi të vendosur &#39;Aplikoni Discount shtesë në&#39;
 ,Ordered Items To Be Billed,Items urdhëruar të faturuar
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46,From Range has to be less than To Range,Nga një distancë duhet të jetë më pak se në rang
 DocType: Global Defaults,Global Defaults,Defaults Global
-apps/erpnext/erpnext/projects/doctype/project/project.py +215,Project Collaboration Invitation,Bashkëpunimi Project Ftesë
+apps/erpnext/erpnext/projects/doctype/project/project.py +226,Project Collaboration Invitation,Bashkëpunimi Project Ftesë
 DocType: Salary Slip,Deductions,Zbritjet
 DocType: Leave Allocation,LAL/,LAL /
 DocType: Setup Progress Action,Action Name,Emri i Veprimit
@@ -1323,49 +1427,51 @@
 apps/erpnext/erpnext/regional/india/utils.py +24,First 2 digits of GSTIN should match with State number {0},Para 2 shifrat e GSTIN duhet të përputhen me numrin e Shtetit {0}
 DocType: Purchase Invoice,Start date of current invoice's period,Data e fillimit të periudhës së fatura aktual
 DocType: Salary Slip,Leave Without Pay,Lini pa pagesë
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +346,Capacity Planning Error,Kapaciteti Planifikimi Gabim
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +366,Capacity Planning Error,Kapaciteti Planifikimi Gabim
 ,Trial Balance for Party,Bilanci gjyqi për Partinë
 DocType: Lead,Consultant,Konsulent
 DocType: Salary Slip,Earnings,Fitim
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +391,Finished Item {0} must be entered for Manufacture type entry,Mbaroi Item {0} duhet të jetë hyrë në për hyrje të tipit Prodhimi
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +416,Finished Item {0} must be entered for Manufacture type entry,Mbaroi Item {0} duhet të jetë hyrë në për hyrje të tipit Prodhimi
 apps/erpnext/erpnext/config/learn.py +87,Opening Accounting Balance,Hapja Bilanci Kontabilitet
 ,GST Sales Register,GST Sales Regjistrohu
 DocType: Sales Invoice Advance,Sales Invoice Advance,Shitjet Faturë Advance
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550,Nothing to request,Asgjë për të kërkuar
+apps/erpnext/erpnext/public/js/setup_wizard.js +18,Select your Domains,Zgjidh Domains tuaj
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34,Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3},Një tjetër rekord i buxhetit &#39;{0}&#39; ekziston kundër {1} &#39;{2}&#39; për vitin fiskal {3}
+DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Fushat do të kopjohen vetëm në kohën e krijimit.
 apps/erpnext/erpnext/projects/doctype/task/task.py +41,'Actual Start Date' can not be greater than 'Actual End Date','Data e Fillimit' nuk mund të jetë më i madh se 'Data e Mbarimit'
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +113,Management,Drejtuesit
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117,Management,Drejtuesit
 DocType: Cheque Print Template,Payer Settings,Cilësimet paguesit
 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""","Kjo do t&#39;i bashkëngjitet Kodit Pika e variant. Për shembull, në qoftë se shkurtim juaj është &quot;SM&quot;, dhe kodin pika është &quot;T-shirt&quot;, kodi pika e variantit do të jetë &quot;T-shirt-SM&quot;"
 DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,Neto Pay (me fjalë) do të jetë i dukshëm një herë ju ruani gabim pagave.
 DocType: Purchase Invoice,Is Return,Është Kthimi
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +80,Caution,Kujdes
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +787,Return / Debit Note,Kthimi / Debiti Note
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +81,Caution,Kujdes
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +813,Return / Debit Note,Kthimi / Debiti Note
 DocType: Price List Country,Price List Country,Lista e Çmimeve Vendi
 DocType: Item,UOMs,UOMs
-apps/erpnext/erpnext/stock/utils.py +205,{0} valid serial nos for Item {1},{0} nos vlefshme serik për Item {1}
+apps/erpnext/erpnext/stock/utils.py +210,{0} valid serial nos for Item {1},{0} nos vlefshme serik për Item {1}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57,Item Code cannot be changed for Serial No.,Kodi artikull nuk mund të ndryshohet për të Serial Nr
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +26,POS Profile {0} already created for user: {1} and company {2},POS Profilin {0} krijuar tashmë për përdorues: {1} dhe kompani {2}
-DocType: Sales Invoice Item,UOM Conversion Factor,UOM Konvertimi Faktori
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +23,Please enter Item Code to get Batch Number,Ju lutemi shkruani kodin Item për të marrë Numri i Serisë
+DocType: Purchase Invoice Item,UOM Conversion Factor,UOM Konvertimi Faktori
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40,Please enter Item Code to get Batch Number,Ju lutemi shkruani kodin Item për të marrë Numri i Serisë
 DocType: Stock Settings,Default Item Group,Gabim Item Grupi
 DocType: Employee Loan,Partially Disbursed,lëvrohet pjesërisht
+apps/erpnext/erpnext/config/non_profit.py +73,Grant information.,Dhënia e informacionit.
 apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Bazës së të dhënave Furnizuesi.
 DocType: Account,Balance Sheet,Bilanci i gjendjes
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +701,Cost Center For Item with Item Code ',Qendra Kosto Per Item me Kodin Item &quot;
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +748,Cost Center For Item with Item Code ',Qendra Kosto Per Item me Kodin Item &quot;
 DocType: Fee Validity,Valid Till,E vlefshme deri
-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.","Mode pagesa nuk është i konfiguruar. Ju lutem kontrolloni, nëse llogaria është vendosur në Mode të pagesave ose në POS Profilin."
+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.","Mode pagesa nuk është i konfiguruar. Ju lutem kontrolloni, nëse llogaria është vendosur në Mode të pagesave ose në POS Profilin."
 apps/erpnext/erpnext/buying/utils.py +74,Same item cannot be entered multiple times.,Same artikull nuk mund të futen shumë herë.
-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","Llogaritë e mëtejshme mund të bëhen në bazë të grupeve, por hyra mund të bëhet kundër jo-grupeve"
+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","Llogaritë e mëtejshme mund të bëhen në bazë të grupeve, por hyra mund të bëhet kundër jo-grupeve"
 DocType: Lead,Lead,Lead
 DocType: Email Digest,Payables,Pagueshme
 DocType: Course,Course Intro,Sigurisht Intro
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Ju lutem vendosni numrat e numrave për Pjesëmarrjen përmes Setup&gt; Seritë e Numërimit
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +90,Stock Entry {0} created,Stock Hyrja {0} krijuar
-apps/erpnext/erpnext/controllers/buying_controller.py +297,Row #{0}: Rejected Qty can not be entered in Purchase Return,Row # {0}: Refuzuar Qty nuk mund të futen në Blerje Kthim
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +97,Stock Entry {0} created,Stock Hyrja {0} krijuar
+apps/erpnext/erpnext/controllers/buying_controller.py +298,Row #{0}: Rejected Qty can not be entered in Purchase Return,Row # {0}: Refuzuar Qty nuk mund të futen në Blerje Kthim
 ,Purchase Order Items To Be Billed,Items Rendit Blerje Për të faturohet
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +45,Updating estimated arrival times.,Përditësimi i afatit të mbërritjes.
 DocType: Purchase Invoice Item,Net Rate,Net Rate
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +151,Please select a customer,Ju lutemi zgjidhni një klient
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +147,Please select a customer,Ju lutemi zgjidhni një klient
 DocType: Purchase Invoice Item,Purchase Invoice Item,Blerje Item Faturë
 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,Stock Ledger Hyrje dhe GL Entries janë reposted për Pranimeve zgjedhura Blerje
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,Pika 1
@@ -1380,28 +1486,31 @@
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Rendit Count
 DocType: Global Defaults,Current Fiscal Year,Vitin aktual fiskal
 DocType: Purchase Order,Group same items,Grupi njëjta artikuj
-DocType: Global Defaults,Disable Rounded Total,Disable rrumbullakosura Total
+DocType: Purchase Invoice,Disable Rounded Total,Disable rrumbullakosura Total
 DocType: Employee Loan Application,Repayment Info,Info Ripagimi
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448,'Entries' cannot be empty,&quot;Hyrjet&quot; nuk mund të jetë bosh
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +446,'Entries' cannot be empty,&quot;Hyrjet&quot; nuk mund të jetë bosh
+DocType: Maintenance Team Member,Maintenance Role,Roli i Mirëmbajtjes
 apps/erpnext/erpnext/utilities/transaction_base.py +81,Duplicate row {0} with same {1},Duplicate rresht {0} me të njëjtën {1}
 ,Trial Balance,Bilanci gjyqi
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +449,Fiscal Year {0} not found,Viti Fiskal {0} nuk u gjet
-apps/erpnext/erpnext/config/hr.py +300,Setting up Employees,Ngritja Punonjësit
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +438,Fiscal Year {0} not found,Viti Fiskal {0} nuk u gjet
+apps/erpnext/erpnext/config/hr.py +305,Setting up Employees,Ngritja Punonjësit
 DocType: Sales Order,SO-,KËSHTU QË-
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +153,Please select prefix first,"Ju lutem, përzgjidhni prefiks parë"
-DocType: Employee,O-,O-
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +185,Research,Hulumtim
+DocType: Student,O-,O-
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189,Research,Hulumtim
 DocType: Maintenance Visit Purpose,Work Done,Punën e bërë
 apps/erpnext/erpnext/controllers/item_variant.py +33,Please specify at least one attribute in the Attributes table,Ju lutem specifikoni të paktën një atribut në tabelë Atributet
 DocType: Announcement,All Students,Të gjitha Studentët
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +45,Item {0} must be a non-stock item,{0} artikull duhet të jetë një element jo-aksioneve
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +45,Item {0} must be a non-stock item,{0} artikull duhet të jetë një element jo-aksioneve
 apps/erpnext/erpnext/stock/doctype/batch/batch.js +18,View Ledger,Shiko Ledger
 DocType: Grading Scale,Intervals,intervalet
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Hershme
-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","Një Grup Item ekziston me të njëjtin emër, ju lutemi të ndryshojë emrin pika ose riemërtoj grupin pika"
-apps/erpnext/erpnext/schools/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Student Mobile No.
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +367,Rest Of The World,Pjesa tjetër e botës
+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","Një Grup Item ekziston me të njëjtin emër, ju lutemi të ndryshojë emrin pika ose riemërtoj grupin pika"
+DocType: Crop Cycle,Less than a year,Më pak se një vit
+apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Student Mobile No.
+apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +105,Rest Of The World,Pjesa tjetër e botës
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,The Item {0} cannot have Batch,Item {0} nuk mund të ketë Serisë
+DocType: Crop,Yield UOM,Yield UOM
 ,Budget Variance Report,Buxheti Varianca Raport
 DocType: Salary Slip,Gross Pay,Pay Bruto
 DocType: Item,Is Item from Hub,Është pika nga Hub
@@ -1420,8 +1529,6 @@
 DocType: Student,STUD.,Kurvar.
 DocType: Production Order,Qty To Manufacture,Qty Për Prodhimi
 DocType: Email Digest,New Income,Të ardhurat e re
-DocType: School Settings,School Settings,mjediset shkollore
-DocType: School Settings,School Settings,mjediset shkollore
 DocType: Buying Settings,Maintain same rate throughout purchase cycle,Ruajtja njëjtin ritëm gjatë gjithë ciklit të blerjes
 DocType: Opportunity Item,Opportunity Item,Mundësi Item
 ,Student and Guardian Contact Details,Student dhe Guardian Detajet e Kontaktit
@@ -1433,26 +1540,27 @@
 DocType: Patient Appointment,More Info,More Info
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +178,Valuation Rate required for Item in row {0},Vlerësoni Vlerësimi nevojshme për Item në rresht {0}
 DocType: Supplier Scorecard,Scorecard Actions,Veprimet Scorecard
-apps/erpnext/erpnext/utilities/user_progress.py +148,Example: Masters in Computer Science,Shembull: Master në Shkenca Kompjuterike
+apps/erpnext/erpnext/utilities/user_progress.py +166,Example: Masters in Computer Science,Shembull: Master në Shkenca Kompjuterike
 DocType: Purchase Invoice,Rejected Warehouse,Magazina refuzuar
 DocType: GL Entry,Against Voucher,Kundër Bonon
 DocType: Item,Default Buying Cost Center,Gabim Qendra Blerja Kosto
 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.","Për të marrë më të mirë nga ERPNext, ne ju rekomandojmë që të marrë disa kohë dhe të shikojnë këto video ndihmë."
-apps/erpnext/erpnext/accounts/page/pos/pos.js +74, to ,në
+apps/erpnext/erpnext/accounts/page/pos/pos.js +76, to ,në
 DocType: Supplier Quotation Item,Lead Time in days,Lead Koha në ditë
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +58,Accounts Payable Summary,Llogaritë e pagueshme Përmbledhje
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +337,Payment of salary from {0} to {1},Pagesa e pagës nga {0} në {1}
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +321,Payment of salary from {0} to {1},Pagesa e pagës nga {0} në {1}
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213,Not authorized to edit frozen Account {0},Nuk është i autorizuar për të redaktuar Llogari ngrirë {0}
 DocType: Journal Entry,Get Outstanding Invoices,Get Faturat e papaguara
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +70,Sales Order {0} is not valid,Sales Order {0} nuk është e vlefshme
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +84,Sales Order {0} is not valid,Sales Order {0} nuk është e vlefshme
 DocType: Supplier Scorecard,Warn for new Request for Quotations,Paralajmëroni për Kërkesë të re për Kuotime
 apps/erpnext/erpnext/utilities/activation.py +91,Purchase orders help you plan and follow up on your purchases,urdhrat e blerjes t&#39;ju ndihmuar të planit dhe të ndjekin deri në blerjet tuaja
-apps/erpnext/erpnext/setup/doctype/company/company.py +218,"Sorry, companies cannot be merged","Na vjen keq, kompanitë nuk mund të bashkohen"
+apps/erpnext/erpnext/setup/doctype/company/company.py +215,"Sorry, companies cannot be merged","Na vjen keq, kompanitë nuk mund të bashkohen"
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151,Lab Test Prescriptions,Recetat e testit të laboratorit
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +162,"The total Issue / Transfer quantity {0} in Material Request {1}  \
 							cannot be greater than requested quantity {2} for Item {3}",totale sasia Çështja / Transfer {0} në materiale Kërkesë {1} \ nuk mund të jetë më e madhe se sasia e kërkuar {2} për pikën {3}
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +193,Small,I vogël
-DocType: Employee,Employee Number,Numri punonjës
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197,Small,I vogël
+DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Hapja e artikullit të krijimit të faturës
+DocType: Education Settings,Employee Number,Numri punonjës
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67,Case No(s) already in use. Try from Case No {0},Rast No (s) në përdorim. Provoni nga Rasti Nr {0}
 DocType: Project,% Completed,% Kompletuar
 ,Invoiced Amount (Exculsive Tax),Shuma e faturuar (Tax Exculsive)
@@ -1462,17 +1570,20 @@
 DocType: Item,Auto re-order,Auto ri-qëllim
 apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Achieved,Gjithsej Arritur
 DocType: Employee,Place of Issue,Vendi i lëshimit
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +97,Contract,Kontratë
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101,Contract,Kontratë
+DocType: Plant Analysis,Laboratory Testing Datetime,Datat e testimit laboratorik
 DocType: Email Digest,Add Quote,Shto Citim
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +869,UOM coversion factor required for UOM: {0} in Item: {1},Faktori UOM Coversion nevojshme për UOM: {0} në Item: {1}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +932,UOM coversion factor required for UOM: {0} in Item: {1},Faktori UOM Coversion nevojshme për UOM: {0} në Item: {1}
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92,Indirect Expenses,Shpenzimet indirekte
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +83,Row {0}: Qty is mandatory,Row {0}: Qty është e detyrueshme
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +8,Agriculture,Bujqësi
-apps/erpnext/erpnext/accounts/page/pos/pos.js +770,Sync Master Data,Sync Master Data
-apps/erpnext/erpnext/utilities/user_progress.py +117,Your Products or Services,Produktet ose shërbimet tuaja
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +88,Row {0}: Qty is mandatory,Row {0}: Qty është e detyrueshme
+DocType: Agriculture Analysis Criteria,Agriculture,Bujqësi
+apps/erpnext/erpnext/accounts/page/pos/pos.js +785,Sync Master Data,Sync Master Data
+DocType: Asset Repair,Repair Cost,Kostoja e riparimit
+apps/erpnext/erpnext/utilities/user_progress.py +135,Your Products or Services,Produktet ose shërbimet tuaja
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15,Failed to login,Dështoi të identifikohej
 DocType: Special Test Items,Special Test Items,Artikujt e veçantë të testimit
 DocType: Mode of Payment,Mode of Payment,Mënyra e pagesës
-apps/erpnext/erpnext/stock/doctype/item/item.py +190,Website Image should be a public file or website URL,Faqja Image duhet të jetë një file publik ose URL website
+apps/erpnext/erpnext/stock/doctype/item/item.py +192,Website Image should be a public file or website URL,Faqja Image duhet të jetë një file publik ose URL website
 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.,Ky është një grup artikull rrënjë dhe nuk mund të redaktohen.
@@ -1480,50 +1591,53 @@
 DocType: Vehicle,Fuel UOM,Fuel UOM
 DocType: Warehouse,Warehouse Contact Info,Magazina Kontaktimit
 DocType: Payment Entry,Write Off Difference Amount,Shkruaj Off Diferenca Shuma
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +415,"{0}: Employee email not found, hence email not sent","{0}: email Punonjësi nuk gjendet, kështu nuk email dërguar"
+DocType: Volunteer,Volunteer Name,Emri Vullnetar
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +434,"{0}: Employee email not found, hence email not sent","{0}: email Punonjësi nuk gjendet, kështu nuk email dërguar"
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85,Shipping rule not applicable for country {0},Rregullimi i transportit nuk zbatohet për vendin {0}
 DocType: Item,Foreign Trade Details,Jashtëm Details Tregtisë
 ,Assessment Plan Status,Statusi i Planit të Vlerësimit
 DocType: Email Digest,Annual Income,Të ardhurat vjetore
 DocType: Serial No,Serial No Details,Serial No Detajet
 DocType: Purchase Invoice Item,Item Tax Rate,Item Tax Rate
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +67,Please select Physician and Date,Ju lutemi zgjidhni Mjek dhe Data
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +75,Please select Physician and Date,Ju lutemi zgjidhni Mjek dhe Data
 DocType: Student Group Student,Group Roll Number,Grupi Roll Number
 DocType: Student Group Student,Group Roll Number,Grupi Roll Number
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145,"For {0}, only credit accounts can be linked against another debit entry","Për {0}, vetëm llogaritë e kreditit mund të jetë i lidhur kundër një tjetër hyrje debiti"
-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,Total i të gjitha peshave duhet të jetë detyrë 1. Ju lutemi të rregulluar peshat e të gjitha detyrave të Projektit në përputhje me rrethanat
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +578,Delivery Note {0} is not submitted,Ofrimit Shënim {0} nuk është dorëzuar
-apps/erpnext/erpnext/stock/get_item_details.py +151,Item {0} must be a Sub-contracted Item,Item {0} duhet të jetë një nënkontraktohet Item
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +143,"For {0}, only credit accounts can be linked against another debit entry","Për {0}, vetëm llogaritë e kreditit mund të jetë i lidhur kundër një tjetër hyrje debiti"
+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,Total i të gjitha peshave duhet të jetë detyrë 1. Ju lutemi të rregulluar peshat e të gjitha detyrave të Projektit në përputhje me rrethanat
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +582,Delivery Note {0} is not submitted,Ofrimit Shënim {0} nuk është dorëzuar
+apps/erpnext/erpnext/stock/get_item_details.py +146,Item {0} must be a Sub-contracted Item,Item {0} duhet të jetë një nënkontraktohet Item
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43,Capital Equipments,Pajisje kapitale
 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.","Rregulla e Çmimeve është zgjedhur për herë të parë në bazë të &quot;Apliko në &#39;fushë, të cilat mund të jenë të artikullit, Grupi i artikullit ose markë."
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +223,Please set the Item Code first,Ju lutemi të vendosni fillimisht Kodin e Artikullit
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +245,Please set the Item Code first,Ju lutemi të vendosni fillimisht Kodin e Artikullit
 DocType: Item,ITEM-,ITEM-
-apps/erpnext/erpnext/controllers/selling_controller.py +151,Total allocated percentage for sales team should be 100,Gjithsej përqindje ndarë për shitjet e ekipit duhet të jetë 100
+apps/erpnext/erpnext/controllers/selling_controller.py +119,Total allocated percentage for sales team should be 100,Gjithsej përqindje ndarë për shitjet e ekipit duhet të jetë 100
 DocType: Sales Invoice Item,Edit Description,Ndrysho Përshkrimi
 DocType: Antibiotic,Antibiotic,antibiotik
 ,Team Updates,Ekipi Updates
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +885,For Supplier,Për Furnizuesin
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +910,For Supplier,Për Furnizuesin
 DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Vendosja Tipi Llogarisë ndihmon në zgjedhjen e kësaj llogarie në transaksionet.
 DocType: Purchase Invoice,Grand Total (Company Currency),Grand Total (Kompania Valuta)
 apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Create Print Format,Krijo Print Format
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule_list.js +5,Fee Created,Tarifa e krijuar
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5,Fee Created,Tarifa e krijuar
 apps/erpnext/erpnext/utilities/bot.py +39,Did not find any item called {0},A nuk gjeni ndonjë artikull të quajtur {0}
 DocType: Supplier Scorecard Criteria,Criteria Formula,Formula e kritereve
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Total Outgoing,Largohet Total
-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""",Nuk mund të jetë vetëm një Transporti Rregulla Kushti me 0 ose vlerë bosh për &quot;vlerës&quot;
+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""",Nuk mund të jetë vetëm një Transporti Rregulla Kushti me 0 ose vlerë bosh për &quot;vlerës&quot;
 DocType: Authorization Rule,Transaction,Transaksion
 DocType: Patient Appointment,Duration,kohëzgjatje
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Shënim: Ky Qendra Kosto është një grup. Nuk mund të bëjë shënimet e kontabilitetit kundër grupeve.
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +54,Child warehouse exists for this warehouse. You can not delete this warehouse.,depo Child ekziston për këtë depo. Ju nuk mund të fshini këtë depo.
 DocType: Item,Website Item Groups,Faqja kryesore Item Grupet
 DocType: Purchase Invoice,Total (Company Currency),Total (Kompania Valuta)
-apps/erpnext/erpnext/stock/utils.py +200,Serial number {0} entered more than once,Numri serik {0} hyrë më shumë se një herë
-DocType: Depreciation Schedule,Journal Entry,Journal Hyrja
+apps/erpnext/erpnext/stock/utils.py +205,Serial number {0} entered more than once,Numri serik {0} hyrë më shumë se një herë
+DocType: Journal Entry,Journal Entry,Journal Hyrja
+DocType: Expense Claim Advance,Unclaimed amount,Shuma e pakthyeshme
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +148,{0} items in progress,{0} artikuj në progres
 DocType: Workstation,Workstation Name,Workstation Emri
 DocType: Grading Scale Interval,Grade Code,Kodi Grade
 DocType: POS Item Group,POS Item Group,POS Item Group
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17,Email Digest:,Email Digest:
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +587,BOM {0} does not belong to Item {1},BOM {0} nuk i përket Item {1}
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +591,BOM {0} does not belong to Item {1},BOM {0} nuk i përket Item {1}
 DocType: Sales Partner,Target Distribution,Shpërndarja Target
 DocType: Salary Slip,Bank Account No.,Llogarisë Bankare Nr
 DocType: Naming Series,This is the number of the last created transaction with this prefix,Ky është numri i transaksionit të fundit të krijuar me këtë prefiks
@@ -1539,11 +1653,11 @@
 DocType: BOM Operation,Workstation,Workstation
 DocType: Request for Quotation Supplier,Request for Quotation Supplier,Kërkesë për Kuotim Furnizuesit
 DocType: Healthcare Settings,Registration Message,Mesazhi i regjistrimit
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +150,Hardware,Hardware
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154,Hardware,Hardware
 DocType: Prescription Dosage,Prescription Dosage,Dozimi i recetës
 DocType: Attendance,HR Manager,Menaxher HR
-apps/erpnext/erpnext/accounts/party.py +177,Please select a Company,Ju lutem zgjidhni një Company
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +88,Privilege Leave,Privilegj Leave
+apps/erpnext/erpnext/accounts/party.py +178,Please select a Company,Ju lutem zgjidhni një Company
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92,Privilege Leave,Privilegj Leave
 DocType: Purchase Invoice,Supplier Invoice Date,Furnizuesi Data e faturës
 apps/erpnext/erpnext/templates/includes/product_page.js +18,per,për
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90,You need to enable Shopping Cart,Ju duhet të mundësojnë Shporta
@@ -1555,7 +1669,7 @@
 ,BOM Browser,Bom Browser
 apps/erpnext/erpnext/templates/emails/training_event.html +13,Please update your status for this training event,Ju lutemi update statusin tuaj për këtë ngjarje trajnimi
 DocType: Purchase Taxes and Charges,Add or Deduct,Shto ose Zbres
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +82,Overlapping conditions found between:,Kushtet e mbivendosjes gjenden në mes:
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148,Overlapping conditions found between:,Kushtet e mbivendosjes gjenden në mes:
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187,Against Journal Entry {0} is already adjusted against some other voucher,Kundër Fletoren Hyrja {0} është përshtatur tashmë kundër një kupon tjetër
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68,Total Order Value,Vlera Totale Rendit
 apps/erpnext/erpnext/demo/setup/setup_data.py +328,Food,Ushqim
@@ -1563,7 +1677,7 @@
 DocType: Maintenance Schedule Item,No of Visits,Nr i vizitave
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165,Maintenance Schedule {0} exists against {1},Mirëmbajtja Shtojca {0} ekziston kundër {1}
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +118,Do you want to publish your Items to Hub ?,Dëshiron të publikosh artikujt tuaj në hub?
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +36,Enrolling student,studenti regjistrimit
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36,Enrolling student,studenti regjistrimit
 apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33,Currency of the Closing Account must be {0},Monedhën e llogarisë Mbyllja duhet të jetë {0}
 apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},Shuma e pikëve për të gjitha qëllimet duhet të jetë 100. Kjo është {0}
 DocType: Project,Start and End Dates,Filloni dhe Fundi Datat
@@ -1575,7 +1689,7 @@
 DocType: Rename Tool,Utilities,Shërbime komunale
 DocType: POS Profile,Accounting,Llogaritje
 DocType: Employee,EMP/,EMP /
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +123,Please select batches for batched item ,"Ju lutem, përzgjidhni tufa për artikull në pako"
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133,Please select batches for batched item ,"Ju lutem, përzgjidhni tufa për artikull në pako"
 DocType: Asset,Depreciation Schedules,Oraret e amortizimit
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +89,Application period cannot be outside leave allocation period,Periudha e aplikimit nuk mund të jetë periudhë ndarja leje jashtë
 DocType: Activity Cost,Projects,Projektet
@@ -1588,7 +1702,7 @@
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,Avg Daily largohet
 DocType: POS Profile,Campaign,Fushatë
 DocType: Supplier,Name and Type,Emri dhe lloji i
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +64,Approval Status must be 'Approved' or 'Rejected',Miratimi Statusi duhet të jetë &quot;miratuar&quot; ose &quot;Refuzuar &#39;
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +66,Approval Status must be 'Approved' or 'Rejected',Miratimi Statusi duhet të jetë &quot;miratuar&quot; ose &quot;Refuzuar &#39;
 DocType: Physician,Contacts and Address,Kontaktet dhe Adresa
 DocType: Purchase Invoice,Contact Person,Personi kontaktues
 apps/erpnext/erpnext/projects/doctype/task/task.py +38,'Expected Start Date' can not be greater than 'Expected End Date',&quot;Pritet Data e Fillimit &#39;nuk mund të jetë më i madh se&quot; Data e Përfundimit e pritshme&#39;
@@ -1596,14 +1710,15 @@
 DocType: Holiday List,Holidays,Pushime
 DocType: Sales Order Item,Planned Quantity,Sasia e planifikuar
 DocType: Purchase Invoice Item,Item Tax Amount,Shuma Tatimore Item
+DocType: Water Analysis,Water Analysis Criteria,Kriteret e analizës së ujit
 DocType: Item,Maintain Stock,Ruajtja Stock
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +212,Stock Entries already created for Production Order ,Stock Entries krijuar tashmë për Rendin Production
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +217,Stock Entries already created for Production Order ,Stock Entries krijuar tashmë për Rendin Production
 DocType: Employee,Prefered Email,i preferuar Email
 DocType: Student Admission,Eligibility and Details,Pranueshmëria dhe Detajet
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +33,Net Change in Fixed Asset,Ndryshimi neto në aseteve fikse
 DocType: Leave Control Panel,Leave blank if considered for all designations,Lini bosh nëse konsiderohet për të gjitha përcaktimeve
-apps/erpnext/erpnext/controllers/accounts_controller.py +663,Charge of type 'Actual' in row {0} cannot be included in Item Rate,Ngarkesa e tipit &#39;aktuale&#39; në rresht {0} nuk mund të përfshihen në Item Rate
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +359,Max: {0},Max: {0}
+apps/erpnext/erpnext/controllers/accounts_controller.py +775,Charge of type 'Actual' in row {0} cannot be included in Item Rate,Ngarkesa e tipit &#39;aktuale&#39; në rresht {0} nuk mund të përfshihen në Item Rate
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +381,Max: {0},Max: {0}
 apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,Nga datetime
 DocType: Email Digest,For Company,Për Kompaninë
 apps/erpnext/erpnext/config/support.py +17,Communication log.,Log komunikimi.
@@ -1612,18 +1727,19 @@
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +73,Buying Amount,Blerja Shuma
 DocType: Sales Invoice,Shipping Address Name,Transporti Adresa Emri
 DocType: Material Request,Terms and Conditions Content,Termat dhe Kushtet Përmbajtja
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +555,cannot be greater than 100,nuk mund të jetë më i madh se 100
-apps/erpnext/erpnext/stock/doctype/item/item.py +734,Item {0} is not a stock Item,Item {0} nuk është një gjendje Item
+apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18,There were errors creating Course Schedule,Kishte gabime në krijimin e orarit të lëndëve
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +580,cannot be greater than 100,nuk mund të jetë më i madh se 100
+apps/erpnext/erpnext/stock/doctype/item/item.py +720,Item {0} is not a stock Item,Item {0} nuk është një gjendje Item
 DocType: Maintenance Visit,Unscheduled,Paplanifikuar
 DocType: Employee,Owned,Pronësi
 DocType: Salary Detail,Depends on Leave Without Pay,Varet në pushim pa pagesë
 DocType: Pricing Rule,"Higher the number, higher the priority","Më i lartë numri, më i lartë prioriteti"
 ,Purchase Invoice Trends,Blerje Trendet Faturë
 DocType: Employee,Better Prospects,Perspektivë më të mirë
-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","Rresht # {0}: The batch {1} ka vetëm {2} Qty. Ju lutem zgjidhni një tjetër grumbull cila ka {3} Qty në dispozicion ose ndarë rresht në rreshta të shumta, për të ofruar / çështje nga tufa të shumta"
+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","Rresht # {0}: The batch {1} ka vetëm {2} Qty. Ju lutem zgjidhni një tjetër grumbull cila ka {3} Qty në dispozicion ose ndarë rresht në rreshta të shumta, për të ofruar / çështje nga tufa të shumta"
 DocType: Vehicle,License Plate,Targë
 DocType: Appraisal,Goals,Qëllimet
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +326,Select POS Profile,Zgjidh Profilin e POS
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +343,Select POS Profile,Zgjidh Profilin e POS
 DocType: Warranty Claim,Warranty / AMC Status,Garanci / AMC Statusi
 ,Accounts Browser,Llogaritë Browser
 DocType: Payment Entry Reference,Payment Entry Reference,Pagesa Reference Hyrja
@@ -1632,24 +1748,27 @@
 ,Batch-Wise Balance History,Batch-urti Historia Bilanci
 apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73,Print settings updated in respective print format,cilësimet e printimit përditësuar në format përkatëse të shtypura
 DocType: Package Code,Package Code,Kodi paketë
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +101,Apprentice,Nxënës
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105,Apprentice,Nxënës
 DocType: Purchase Invoice,Company GSTIN,Company GSTIN
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +103,Negative Quantity is not allowed,Sasi negativ nuk është e lejuar
 DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
 Used for Taxes and Charges",Detaje taksave tryezë sforcuar nga mjeshtri pika si një varg dhe të depozituara në këtë fushë. Përdoret për taksat dhe tatimet
 DocType: Supplier Scorecard Period,SSC-,SSC-
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +154,Employee cannot report to himself.,Punonjësi nuk mund të raportojnë për veten e tij.
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +159,Employee cannot report to himself.,Punonjësi nuk mund të raportojnë për veten e tij.
 DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Në qoftë se llogaria është e ngrirë, shënimet janë të lejuar për përdoruesit të kufizuara."
 DocType: Email Digest,Bank Balance,Bilanci bankë
-apps/erpnext/erpnext/accounts/party.py +245,Accounting Entry for {0}: {1} can only be made in currency: {2},Hyrja Kontabiliteti për {0}: {1} mund të bëhen vetëm në monedhën: {2}
+apps/erpnext/erpnext/accounts/party.py +243,Accounting Entry for {0}: {1} can only be made in currency: {2},Hyrja Kontabiliteti për {0}: {1} mund të bëhen vetëm në monedhën: {2}
 DocType: Job Opening,"Job profile, qualifications required etc.","Profili i punës, kualifikimet e nevojshme etj"
 DocType: Journal Entry Account,Account Balance,Bilanci i llogarisë
-apps/erpnext/erpnext/config/accounts.py +191,Tax Rule for transactions.,Rregulla taksë për transaksionet.
+apps/erpnext/erpnext/config/accounts.py +183,Tax Rule for transactions.,Rregulla taksë për transaksionet.
 DocType: Rename Tool,Type of document to rename.,Lloji i dokumentit për të riemërtoni.
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53,{0} {1}: Customer is required against Receivable account {2},{0} {1}: Customer është i detyruar kundrejt llogarisë arkëtueshme {2}
 DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Totali Taksat dhe Tarifat (Kompania Valuta)
+DocType: Weather,Weather Parameter,Parametri i motit
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60,Show unclosed fiscal year's P&L balances,Trego P &amp; L bilancet pambyllur vitit fiskal
 DocType: Lab Test Template,Collection Details,Detajet e mbledhjes
+DocType: POS Profile,Allow Print Before Pay,Lejo Printim Para Pagimit
+DocType: Land Unit,Linked Soil Texture,Lidhur me strukturën e tokës
 DocType: Shipping Rule,Shipping Account,Llogaria anijeve
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92,{0} {1}: Account {2} is inactive,{0} {1}: Llogaria {2} është joaktiv
 apps/erpnext/erpnext/utilities/activation.py +82,Make Sales Orders to help you plan your work and deliver on-time,Bëni Sales urdhëron për të ndihmuar ju planifikoni punën tuaj dhe të japë në kohë
@@ -1657,44 +1776,48 @@
 DocType: Stock Entry,Total Additional Costs,Gjithsej kosto shtesë
 DocType: Course Schedule,SH,SH
 DocType: BOM,Scrap Material Cost(Company Currency),Kosto skrap Material (Company Valuta)
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +62,Sub Assemblies,Kuvendet Nën
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66,Sub Assemblies,Kuvendet Nën
 DocType: Asset,Asset Name,Emri i Aseteve
 DocType: Project,Task Weight,Task Pesha
 DocType: Shipping Rule Condition,To Value,Të vlerës
 DocType: Asset Movement,Stock Manager,Stock Menaxher
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +144,Source warehouse is mandatory for row {0},Depo Burimi është i detyrueshëm për rresht {0}
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +809,Packing Slip,Shqip Paketimi
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +149,Source warehouse is mandatory for row {0},Depo Burimi është i detyrueshëm për rresht {0}
+apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38,The Payment Term at row {0} is possibly a duplicate.,Termi i pagesës në rresht {0} është ndoshta një kopje.
+apps/erpnext/erpnext/public/js/setup_wizard.js +30,Agriculture (beta),Bujqësia (beta)
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +856,Packing Slip,Shqip Paketimi
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Office Rent,Zyra Qira
 apps/erpnext/erpnext/config/setup.py +111,Setup SMS gateway settings,Setup SMS settings portë
+DocType: Disease,Common Name,Emer i perbashket
 apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61,Import Failed!,Import dështoi!
 apps/erpnext/erpnext/public/js/templates/address_list.html +20,No address added yet.,Ka adresë shtuar ende.
 DocType: Workstation Working Hour,Workstation Working Hour,Workstation orë pune
 DocType: Vital Signs,Blood Pressure,Presioni i gjakut
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +121,Analyst,Analist
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125,Analyst,Analist
 DocType: Item,Inventory,Inventar
 DocType: Item,Sales Details,Shitjet Detajet
 DocType: Quality Inspection,QI-,QI-
 DocType: Opportunity,With Items,Me Items
+DocType: Asset Maintenance,Maintenance Team,Ekipi i Mirëmbajtjes
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,In Qty,Në Qty
-DocType: School Settings,Validate Enrolled Course for Students in Student Group,Vlereso regjistruar Kursin për Studentët në Grupin e Studentëve
+DocType: Education Settings,Validate Enrolled Course for Students in Student Group,Vlereso regjistruar Kursin për Studentët në Grupin e Studentëve
 DocType: Notification Control,Expense Claim Rejected,Shpenzim Kërkesa Refuzuar
 DocType: Item,Item Attribute,Item Attribute
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +143,Government,Qeveri
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147,Government,Qeveri
 apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40,Expense Claim {0} already exists for the Vehicle Log,Expense Kërkesa {0} ekziston për Log automjeteve
-apps/erpnext/erpnext/public/js/setup_wizard.js +60,Institute Name,Emri Institute
+apps/erpnext/erpnext/public/js/setup_wizard.js +64,Institute Name,Emri Institute
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117,Please enter repayment Amount,Ju lutemi shkruani shlyerjes Shuma
 apps/erpnext/erpnext/config/stock.py +305,Item Variants,Variantet pika
-DocType: Company,Services,Sherbime
+apps/erpnext/erpnext/public/js/setup_wizard.js +29,Services,Sherbime
 DocType: HR Settings,Email Salary Slip to Employee,Email Paga Slip për të punësuarit
 DocType: Cost Center,Parent Cost Center,Qendra prind Kosto
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1017,Select Possible Supplier,Zgjidhni mundshëm Furnizuesi
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1039,Select Possible Supplier,Zgjidhni mundshëm Furnizuesi
 DocType: Sales Invoice,Source,Burim
 apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,Shfaq të mbyllura
 DocType: Leave Type,Is Leave Without Pay,Lini është pa pagesë
-apps/erpnext/erpnext/stock/doctype/item/item.py +248,Asset Category is mandatory for Fixed Asset item,Asset Kategoria është i detyrueshëm për artikull Aseteve Fikse
+apps/erpnext/erpnext/stock/doctype/item/item.py +250,Asset Category is mandatory for Fixed Asset item,Asset Kategoria është i detyrueshëm për artikull Aseteve Fikse
 DocType: Fee Validity,Fee Validity,Vlefshmëria e tarifës
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +145,No records found in the Payment table,Nuk u gjetën në tabelën e Pagesave të dhënat
-apps/erpnext/erpnext/schools/utils.py +19,This {0} conflicts with {1} for {2} {3},Kjo {0} konfliktet me {1} për {2} {3}
+apps/erpnext/erpnext/education/utils.py +19,This {0} conflicts with {1} for {2} {3},Kjo {0} konfliktet me {1} për {2} {3}
 DocType: Student Attendance Tool,Students HTML,studentët HTML
 DocType: POS Profile,Apply Discount,aplikoni Discount
 DocType: GST HSN Code,GST HSN Code,GST Code HSN
@@ -1709,16 +1832,18 @@
 apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Taken,Marrë
 DocType: Student,Date of Leaving,Datën e largimit
 DocType: Pricing Rule,For Price List,Për listën e çmimeve
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +27,Executive Search,Ekzekutiv Kërko
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27,Executive Search,Ekzekutiv Kërko
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55,Setting defaults,Vendosja e parazgjedhjeve
 apps/erpnext/erpnext/utilities/activation.py +63,Create Leads,Krijo kryeson
 DocType: Maintenance Schedule,Schedules,Oraret
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +331,POS Profile is required to use Point-of-Sale,Profil POS duhet të përdorë Point-of-Sale
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +451,POS Profile is required to use Point-of-Sale,Profil POS duhet të përdorë Point-of-Sale
 DocType: Purchase Invoice Item,Net Amount,Shuma neto
 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} nuk ka qenë i paraqitur në mënyrë veprimi nuk mund të përfundojë
 DocType: Purchase Order Item Supplied,BOM Detail No,Bom Detail Asnjë
 DocType: Landed Cost Voucher,Additional Charges,akuza të tjera
 DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Shtesë Shuma Discount (Valuta Company)
 DocType: Supplier Scorecard,Supplier Scorecard,Nota e Furnizuesit
+DocType: Plant Analysis,Result Datetime,Rezultat Datetime
 apps/erpnext/erpnext/accounts/doctype/account/account.js +21,Please create new account from Chart of Accounts.,Ju lutem të krijuar një llogari të re nga Chart e Llogarive.
 ,Support Hour Distribution,Shpërndarja e orëve të mbështetjes
 DocType: Maintenance Visit,Maintenance Visit,Mirëmbajtja Vizitoni
@@ -1728,10 +1853,12 @@
 apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Update Print Format,Update Print Format
 DocType: Landed Cost Voucher,Landed Cost Help,Zbarkoi Kosto Ndihmë
 DocType: Purchase Invoice,Select Shipping Address,Zgjidh Shipping Adresa
+apps/erpnext/erpnext/config/non_profit.py +28,Memebership Details,Detajet e Memphership
 DocType: Leave Block List,Block Holidays on important days.,Festat bllok në ditë të rëndësishme.
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +71,Accounts Receivable Summary,Llogaritë Arkëtueshme Përmbledhje
 DocType: Employee Loan,Monthly Repayment Amount,Shuma mujore e pagesës
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +191,Please set User ID field in an Employee record to set Employee Role,Ju lutemi të vendosur User fushë ID në një rekord të Punonjësve të vendosur Roli punonjës
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9,Opening Invoices,Hapja e faturave
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +195,Please set User ID field in an Employee record to set Employee Role,Ju lutemi të vendosur User fushë ID në një rekord të Punonjësve të vendosur Roli punonjës
 DocType: UOM,UOM Name,Emri UOM
 DocType: GST HSN Code,HSN Code,Kodi HSN
 apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +43,Contribution Amount,Shuma Kontribut
@@ -1739,26 +1866,26 @@
 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.,Ky mjet ju ndihmon për të rinovuar ose të rregulluar sasinë dhe vlerësimin e aksioneve në sistemin. Ajo është përdorur zakonisht për të sinkronizuar vlerat e sistemit dhe çfarë në të vërtetë ekziston në depo tuaj.
 DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,Me fjalë do të jetë i dukshëm një herë ju ruani notën shpërndarëse.
 DocType: Expense Claim,EXP,EXP
-apps/erpnext/erpnext/config/stock.py +205,Brand master.,Mjeshtër markë.
-apps/erpnext/erpnext/schools/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} shfaqet disa herë në rresht {2} dhe {3}
+DocType: Water Analysis,Container,enë
+apps/erpnext/erpnext/education/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} shfaqet disa herë në rresht {2} dhe {3}
 DocType: Healthcare Settings,Manage Sample Collection,Menaxho mbledhjen e mostrave
 DocType: Program Enrollment Tool,Program Enrollments,Program Regjistrimet
 DocType: Patient,Tobacco Past Use,Përdorimi i Kaluar i Duhanit
 DocType: Sales Invoice Item,Brand Name,Brand Name
 DocType: Purchase Receipt,Transporter Details,Detajet Transporter
 apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +65,User {0} is already assigned to Physician {1},Përdoruesi {0} është caktuar tashmë tek Mjeku {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2638,Default warehouse is required for selected item,depo Default është e nevojshme për pika të zgjedhura
-apps/erpnext/erpnext/utilities/user_progress.py +125,Box,Kuti
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1014,Possible Supplier,mundur Furnizuesi
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2657,Default warehouse is required for selected item,depo Default është e nevojshme për pika të zgjedhura
+apps/erpnext/erpnext/utilities/user_progress.py +143,Box,Kuti
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1036,Possible Supplier,mundur Furnizuesi
 DocType: Budget,Monthly Distribution,Shpërndarja mujore
 apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68,Receiver List is empty. Please create Receiver List,Marresit Lista është e zbrazët. Ju lutem krijoni Marresit Lista
-apps/erpnext/erpnext/public/js/setup_wizard.js +29,Healthcare (beta),Shëndetësia (beta)
+apps/erpnext/erpnext/public/js/setup_wizard.js +31,Healthcare (beta),Shëndetësia (beta)
 DocType: Production Plan Sales Order,Production Plan Sales Order,Prodhimit Plani Rendit Sales
 DocType: Sales Partner,Sales Partner Target,Sales Partner Target
 DocType: Loan Type,Maximum Loan Amount,Shuma maksimale e kredisë
 DocType: Pricing Rule,Pricing Rule,Rregulla e Çmimeve
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Numri Duplicate roll për nxënës {0}
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Numri Duplicate roll për nxënës {0}
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Numri Duplicate roll për nxënës {0}
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Numri Duplicate roll për nxënës {0}
 DocType: Budget,Action if Annual Budget Exceeded,Veprimi në qoftë Buxheti vjetor Tejkaluar
 apps/erpnext/erpnext/config/learn.py +197,Material Request to Purchase Order,Kërkesë materiale për të blerë Radhit
 DocType: Shopping Cart Settings,Payment Success URL,Pagesa Suksesi URL
@@ -1773,50 +1900,55 @@
 DocType: C-Form,III,III
 apps/erpnext/erpnext/config/stock.py +310,Opening Stock Balance,Hapja Stock Bilanci
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58,{0} must appear only once,{0} duhet të shfaqen vetëm një herë
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +368,Not allowed to tranfer more {0} than {1} against Purchase Order {2},Nuk lejohet të tranfer më {0} se {1} kundër Rendit Blerje {2}
 apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59,Leaves Allocated Successfully for {0},Lë alokuar sukses për {0}
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42,No Items to pack,Asnjë informacion që të dal
 DocType: Shipping Rule Condition,From Value,Nga Vlera
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +555,Manufacturing Quantity is mandatory,Prodhim Sasia është e detyrueshme
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +581,Manufacturing Quantity is mandatory,Prodhim Sasia është e detyrueshme
 DocType: Employee Loan,Repayment Method,Metoda Ripagimi
 DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Nëse zgjidhet, faqja Faqja do të jetë paracaktuar Item Grupi për faqen e internetit"
 DocType: Quality Inspection Reading,Reading 4,Leximi 4
-apps/erpnext/erpnext/config/hr.py +127,Claims for company expense.,Kërkesat për shpenzimet e kompanisë.
+apps/erpnext/erpnext/config/hr.py +132,Claims for company expense.,Kërkesat për shpenzimet e kompanisë.
 apps/erpnext/erpnext/utilities/activation.py +118,"Students are at the heart of the system, add all your students","Studentët janë në zemër të sistemit, shtoni të gjithë studentët tuaj"
 apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +81,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Row # {0}: date Pastrimi {1} nuk mund të jetë para datës çek {2}
+DocType: Asset Maintenance Task,Certificate Required,Certifikata e kërkuar
 DocType: Company,Default Holiday List,Default Festa Lista
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +190,Row {0}: From Time and To Time of {1} is overlapping with {2},Row {0}: Nga kohë dhe për kohën e {1} është mbivendosje me {2}
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145,Stock Liabilities,Stock Detyrimet
 DocType: Purchase Invoice,Supplier Warehouse,Furnizuesi Magazina
 DocType: Opportunity,Contact Mobile No,Kontaktoni Mobile Asnjë
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +356,Select Company,Zgjidh kompanisë
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +382,Select Company,Zgjidh kompanisë
 ,Material Requests for which Supplier Quotations are not created,Kërkesat materiale për të cilat Kuotimet Furnizuesi nuk janë krijuar
+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.,Përdoruesi {0} nuk ka ndonjë Profil POS të parazgjedhur. Kontrolloni Default në Row {1} për këtë Përdorues.
 DocType: Student Group,Set 0 for no limit,Set 0 për pa limit
 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.,Dita (s) në të cilin ju po aplikoni për leje janë festa. Ju nuk duhet të aplikoni për leje.
+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,Rreshti {idx}: {field} kërkohet për të krijuar Faturat e Hapjes {invoice_type}
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20,Resend Payment Email,Ridergo Pagesa Email
 apps/erpnext/erpnext/templates/pages/projects.html +27,New task,Detyra e re
 DocType: Consultation,Appointment,takim
 apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,Bëni Kuotim
 apps/erpnext/erpnext/config/selling.py +216,Other Reports,Raportet tjera
+apps/erpnext/erpnext/public/js/setup_wizard.js +39,Please select at least one domain.,Ju lutem zgjidhni të paktën një domain.
 DocType: Dependent Task,Dependent Task,Detyra e varur
-apps/erpnext/erpnext/stock/doctype/item/item.py +414,Conversion factor for default Unit of Measure must be 1 in row {0},Faktori i konvertimit për Njësinë e parazgjedhur të Masës duhet të jetë 1 në rreshtin e {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +430,Conversion factor for default Unit of Measure must be 1 in row {0},Faktori i konvertimit për Njësinë e parazgjedhur të Masës duhet të jetë 1 në rreshtin e {0}
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +208,Leave of type {0} cannot be longer than {1},Pushimi i tipit {0} nuk mund të jetë më i gjatë se {1}
 DocType: Manufacturing Settings,Try planning operations for X days in advance.,Provoni planifikimin e operacioneve për ditë X paraprakisht.
 DocType: HR Settings,Stop Birthday Reminders,Stop Ditëlindja Harroni
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +250,Please set Default Payroll Payable Account in Company {0},Ju lutemi të vendosur Default Payroll Llogaria e pagueshme në Kompaninë {0}
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +235,Please set Default Payroll Payable Account in Company {0},Ju lutemi të vendosur Default Payroll Llogaria e pagueshme në Kompaninë {0}
 DocType: SMS Center,Receiver List,Marresit Lista
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1068,Search Item,Kërko Item
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1083,Search Item,Kërko Item
+DocType: Payment Schedule,Payment Amount,Shuma e pagesës
 DocType: Patient Appointment,Referring Physician,Mjeku referues
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,Shuma konsumuar
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +98,Net Change in Cash,Ndryshimi neto në para të gatshme
 DocType: Assessment Plan,Grading Scale,Scale Nota
-apps/erpnext/erpnext/stock/doctype/item/item.py +409,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Njësia e masës {0} ka hyrë më shumë se një herë në Konvertimi Faktori Tabelën
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +612,Already completed,përfunduar tashmë
+apps/erpnext/erpnext/stock/doctype/item/item.py +425,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Njësia e masës {0} ka hyrë më shumë se një herë në Konvertimi Faktori Tabelën
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +616,Already completed,përfunduar tashmë
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock In Hand,Stock In Hand
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64,Import Successful!,Importi i suksesshëm!
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29,Payment Request already exists {0},Kërkesa pagesa tashmë ekziston {0}
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Kostoja e Artikujve emetuara
 DocType: Physician,Hospital,spital
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +362,Quantity must not be more than {0},Sasia nuk duhet të jetë më shumë se {0}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +384,Quantity must not be more than {0},Sasia nuk duhet të jetë më shumë se {0}
 apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117,Previous Financial Year is not closed,Previous Viti financiar nuk është e mbyllur
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46,Age (Days),Mosha (ditë)
 DocType: Quotation Item,Quotation Item,Citat Item
@@ -1826,14 +1958,15 @@
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198,Serial No {0} quantity {1} cannot be a fraction,Serial No {0} sasi {1} nuk mund të jetë një pjesë
 apps/erpnext/erpnext/config/buying.py +43,Supplier Type master.,Furnizuesi Lloji mjeshtër.
 DocType: Purchase Order Item,Supplier Part Number,Furnizuesi Pjesa Numër
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +105,Conversion rate cannot be 0 or 1,Shkalla e konvertimit nuk mund të jetë 0 ose 1
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108,Conversion rate cannot be 0 or 1,Shkalla e konvertimit nuk mund të jetë 0 ose 1
 DocType: Subscription,Reference Document,Dokumenti Referenca
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +208,{0} {1} is cancelled or stopped,{0} {1} është anuluar ose ndaluar
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +209,{0} {1} is cancelled or stopped,{0} {1} është anuluar ose ndaluar
 DocType: Accounts Settings,Credit Controller,Kontrolluesi krediti
+DocType: Grant Application,Applicant Type,Lloji i aplikantit
 DocType: Delivery Note,Vehicle Dispatch Date,Automjeteve Dërgimi Data
 DocType: Healthcare Settings,Default Medical Code Standard,Standardi i Kodit të Mjekësisë Default
 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,Blerje Pranimi {0} nuk është dorëzuar
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237,Purchase Receipt {0} is not submitted,Blerje Pranimi {0} nuk është dorëzuar
 DocType: Company,Default Payable Account,Gabim Llogaria pagueshme
 apps/erpnext/erpnext/config/website.py +17,"Settings for online shopping cart such as shipping rules, price list etc.","Cilësimet për internet shopping cart tilla si rregullat e transportit detar, lista e çmimeve etj"
 apps/erpnext/erpnext/controllers/website_list_for_contact.py +113,{0}% Billed,{0}% faturuar
@@ -1842,43 +1975,46 @@
 DocType: Party Account,Party Account,Llogaria Partia
 apps/erpnext/erpnext/config/setup.py +122,Human Resources,Burimeve Njerëzore
 DocType: Lead,Upper Income,Të ardhurat e sipërme
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +41,Reject,hedh poshtë
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17,Reject,hedh poshtë
 DocType: Journal Entry Account,Debit in Company Currency,Debit në kompanisë Valuta
 DocType: BOM Item,BOM Item,Bom Item
 DocType: Appraisal,For Employee,Për punonjësit
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49,Make Disbursement Entry,Bëni disbursimi Hyrja
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138,Row {0}: Advance against Supplier must be debit,Row {0}: Advance kundër Furnizuesit duhet të debiti
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Supplier must be debit,Row {0}: Advance kundër Furnizuesit duhet të debiti
 DocType: Company,Default Values,Vlerat Default
+DocType: Membership,INR,INR
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60,{frequency} Digest,{Frekuencë} Digest
 DocType: Expense Claim,Total Amount Reimbursed,Shuma totale rimbursohen
 apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5,This is based on logs against this Vehicle. See timeline below for details,Kjo është e bazuar në shkrimet kundër këtij automjeteve. Shih afat kohor më poshtë për detaje
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +87,Against Supplier Invoice {0} dated {1},Kundër Furnizuesin Fatura {0} datë {1}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90,Against Supplier Invoice {0} dated {1},Kundër Furnizuesin Fatura {0} datë {1}
 DocType: Customer,Default Price List,E albumit Lista e Çmimeve
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +244,Asset Movement record {0} created,Rekord Lëvizja Asset {0} krijuar
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +265,Asset Movement record {0} created,Rekord Lëvizja Asset {0} krijuar
 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,Ju nuk mund të fshini Viti Fiskal {0}. Viti Fiskal {0} është vendosur si default në Settings Global
 apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,A customer with the same name already exists,Një klient me të njëjtin emër tashmë ekziston
+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?,Kjo do të paraqesë Slipin e Pagave dhe do të krijojë regjistrimin e përhershëm të ditarit. A doni të vazhdoni?
+DocType: Purchase Invoice,Total Net Weight,Pesha totale neto
 DocType: Journal Entry,Entry Type,Hyrja Lloji
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.py +44,No assessment plan linked with this assessment group,Nuk ka plan vlerësimi lidhur me këtë grup të vlerësimit
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +44,No assessment plan linked with this assessment group,Nuk ka plan vlerësimi lidhur me këtë grup të vlerësimit
 ,Customer Credit Balance,Bilanci Customer Credit
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23,Net Change in Accounts Payable,Ndryshimi neto në llogaritë e pagueshme
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',Customer kërkohet për &#39;Customerwise Discount &quot;
-apps/erpnext/erpnext/config/accounts.py +148,Update bank payment dates with journals.,Update pagesës datat bankare me revista.
+apps/erpnext/erpnext/config/accounts.py +140,Update bank payment dates with journals.,Update pagesës datat bankare me revista.
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21,Pricing,çmimi
 DocType: Quotation,Term Details,Detajet Term
-DocType: Project,Total Sales Cost (via Sales Order),Sales Total Kosto (via Sales Order)
-DocType: Project,Total Sales Cost (via Sales Order),Sales Total Kosto (via Sales Order)
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +30,Cannot enroll more than {0} students for this student group.,Nuk mund të regjistrohen më shumë se {0} nxënësve për këtë grup të studentëve.
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30,Cannot enroll more than {0} students for this student group.,Nuk mund të regjistrohen më shumë se {0} nxënësve për këtë grup të studentëve.
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Numërimi Lead
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Numërimi Lead
-apps/erpnext/erpnext/accounts/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} duhet të jetë më i madh se 0
+apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} duhet të jetë më i madh se 0
+apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +17,Stock Available,Në dispozicion
 DocType: Manufacturing Settings,Capacity Planning For (Days),Planifikimi i kapaciteteve për (ditë)
 apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10,Procurement,Prokurimit
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +64,None of the items have any change in quantity or value.,Asnjë nga pikat ketë ndonjë ndryshim në sasi ose vlerë.
-apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +16,Mandatory field - Program,Fushë e detyrueshme - Program
-apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +16,Mandatory field - Program,Fushë e detyrueshme - Program
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +16,Mandatory field - Program,Fushë e detyrueshme - Program
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +16,Mandatory field - Program,Fushë e detyrueshme - Program
 DocType: Special Test Template,Result Component,Komponenti i rezultatit
 apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46,Warranty Claim,Garanci Claim
 ,Lead Details,Detajet Lead
+DocType: Volunteer,Availability and Skills,Disponueshmëria dhe Aftësitë
 DocType: Salary Slip,Loan repayment,shlyerjen e kredisë
 DocType: Purchase Invoice,End date of current invoice's period,Data e fundit e periudhës së fatura aktual
 DocType: Pricing Rule,Applicable For,Të zbatueshme për
@@ -1889,14 +2025,14 @@
 DocType: Shipping Rule Country,Shipping Rule Country,Rregulla Shipping Vendi
 apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10,Leave and Attendance,Lini dhe Pjesëmarrja
 DocType: Maintenance Visit,Partially Completed,Kompletuar Pjesërisht
-apps/erpnext/erpnext/healthcare/setup.py +256,Moderate Sensitivity,Ndjeshmëri e moderuar
+apps/erpnext/erpnext/healthcare/setup.py +257,Moderate Sensitivity,Ndjeshmëri e moderuar
 DocType: Leave Type,Include holidays within leaves as leaves,Përfshijnë pushimet brenda lë si gjethe
 DocType: Sales Invoice,Packed Items,Items të mbushura
 apps/erpnext/erpnext/config/support.py +27,Warranty Claim against Serial No.,Garanci Padia kundër Serial Nr
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +65,'Total',&quot;Total&quot;
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +71,'Total',&quot;Total&quot;
 DocType: Shopping Cart Settings,Enable Shopping Cart,Aktivizo Shporta
 DocType: Employee,Permanent Address,Adresa e përhershme
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +260,"Advance paid against {0} {1} cannot be greater \
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +258,"Advance paid against {0} {1} cannot be greater \
 						than Grand Total {2}",Advance paguar kundër {0} {1} nuk mund të jetë më e madhe \ se Grand Total {2}
 DocType: Patient,Medication,mjekim
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147,Please select item code,Ju lutemi zgjidhni kodin pika
@@ -1907,37 +2043,43 @@
 DocType: Purchase Invoice,Additional Discount,Discount shtesë
 DocType: Selling Settings,Selling Settings,Shitja Settings
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +83,Confirm Action,Konfirmo veprimin
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +39,Online Auctions,Auctions Online
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39,Online Auctions,Auctions Online
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +98,Please specify either Quantity or Valuation Rate or both,Ju lutem specifikoni ose Sasia apo vlerësimin Vlerësoni apo të dyja
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18,Fulfillment,përmbushje
 apps/erpnext/erpnext/templates/generators/item.html +67,View in Cart,Shiko në Shportë
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103,Marketing Expenses,Shpenzimet e marketingut
 ,Item Shortage Report,Item Mungesa Raport
-apps/erpnext/erpnext/stock/doctype/item/item.js +279,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Pesha është përmendur, \ nJu lutemi të përmendim &quot;Weight UOM&quot; shumë"
+apps/erpnext/erpnext/stock/doctype/item/item.js +275,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Pesha është përmendur, \ nJu lutemi të përmendim &quot;Weight UOM&quot; shumë"
 DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Kërkesa material përdoret për të bërë këtë Stock Hyrja
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Zhvlerësimi Data Next është i detyrueshëm për pasuri të re
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Zhvlerësimi Data Next është i detyrueshëm për pasuri të re
 DocType: Student Group Creation Tool,Separate course based Group for every Batch,Sigurisht veçantë bazuar Grupi për çdo Batch
 DocType: Student Group Creation Tool,Separate course based Group for every Batch,Sigurisht veçantë bazuar Grupi për çdo Batch
 apps/erpnext/erpnext/config/support.py +32,Single unit of an Item.,Njësi e vetme e një artikulli.
 DocType: Fee Category,Fee Category,Tarifa Kategoria
+DocType: Agriculture Task,Next Business Day,Dita e ardhshme e punës
+DocType: Customer,Primary Contact Detail,Detajet kryesore të kontaktit
 DocType: Drug Prescription,Dosage by time interval,Dozimi sipas intervalit kohor
 ,Student Fee Collection,Tarifa Student Collection
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +23,Appointment Duration (mins),Kohëzgjatja e takimit (minuta)
 DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Bëni hyrje të kontabilitetit për çdo veprim Stock
 DocType: Leave Allocation,Total Leaves Allocated,Totali Lë alokuar
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +160,Warehouse required at Row No {0},Magazina kërkohet në radhë nr {0}
-apps/erpnext/erpnext/public/js/setup_wizard.js +139,Please enter valid Financial Year Start and End Dates,Ju lutem shkruani Viti Financiar i vlefshëm Start dhe Datat Fundi
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163,Warehouse required at Row No {0},Magazina kërkohet në radhë nr {0}
+apps/erpnext/erpnext/public/js/setup_wizard.js +142,Please enter valid Financial Year Start and End Dates,Ju lutem shkruani Viti Financiar i vlefshëm Start dhe Datat Fundi
 DocType: Employee,Date Of Retirement,Data e daljes në pension
 DocType: Upload Attendance,Get Template,Get Template
 DocType: Material Request,Transferred,transferuar
 DocType: Vehicle,Doors,Dyer
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +196,ERPNext Setup Complete!,ERPNext Setup Complete!
+apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +117,ERPNext Setup Complete!,ERPNext Setup Complete!
 DocType: Healthcare Settings,Collect Fee for Patient Registration,Mblidhni Tarifën për Regjistrimin e Pacientëve
+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,Nuk mund të ndryshojë Atributet pas transaksionit të aksioneve. Bëni një artikull të ri dhe transferoni stokun në artikullin e ri
 DocType: Course Assessment Criteria,Weightage,Weightage
 DocType: Purchase Invoice,Tax Breakup,Breakup Tax
 DocType: Packing Slip,PS-,PS-
+DocType: Member,Non Profit Member,Anëtar Jo Profit
 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}: Qendra Kosto është e nevojshme për &quot;Fitimi dhe Humbja &#39;llogarisë {2}. Ju lutemi të ngritur një qendër me kosto të paracaktuar për kompaninë.
-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,"Një grup të konsumatorëve ekziston me të njëjtin emër, ju lutem të ndryshojë emrin Customer ose riemërtoni grup të konsumatorëve"
+DocType: Payment Schedule,Payment Term,Kushtet e pagesës
+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,"Një grup të konsumatorëve ekziston me të njëjtin emër, ju lutem të ndryshojë emrin Customer ose riemërtoni grup të konsumatorëve"
+DocType: Land Unit,Area,zonë
 apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,Kontakti i ri
 DocType: Territory,Parent Territory,Territori prind
 DocType: Sales Invoice,Place of Supply,Vendi i furnizimit
@@ -1947,40 +2089,41 @@
 DocType: Announcement,Instructor,instruktor
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +61,Select Item (optional),Zgjidh artikullin (opsional)
 DocType: Fee Schedule Student Group,Fee Schedule Student Group,Orari i tarifave Grupi i Studentëve
-DocType: Employee,AB+,AB +
+DocType: Student,AB+,AB +
 DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Nëse ky artikull ka variante, atëherë ajo nuk mund të zgjidhen në shitje urdhrat etj"
 DocType: Lead,Next Contact By,Kontakt Next By
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +311,Quantity required for Item {0} in row {1},Sasia e nevojshme për Item {0} në rresht {1}
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +314,Quantity required for Item {0} in row {1},Sasia e nevojshme për Item {0} në rresht {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +46,Warehouse {0} can not be deleted as quantity exists for Item {1},Magazina {0} nuk mund të fshihet si ekziston sasia e artikullit {1}
 DocType: Quotation,Order Type,Rendit Type
 ,Item-wise Sales Register,Pika-mençur Sales Regjistrohu
 DocType: Asset,Gross Purchase Amount,Shuma Blerje Gross
 apps/erpnext/erpnext/utilities/user_progress.py +36,Opening Balances,Hapjet e hapjes
 DocType: Asset,Depreciation Method,Metoda e amortizimit
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +67,Offline,në linjë
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +64,Offline,në linjë
 DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,A është kjo Tatimore të përfshira në normën bazë?
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Target,Target Total
+DocType: Soil Texture,Sand Composition (%),Përbërja e rërës (%)
 DocType: Job Applicant,Applicant for a Job,Aplikuesi për një punë
 DocType: Production Plan Material Request,Production Plan Material Request,Prodhimi Plan Material Request
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231,No Production Orders created,Nuk urdhërat e prodhimit të krijuara
 DocType: Stock Reconciliation,Reconciliation JSON,Pajtimi JSON
 apps/erpnext/erpnext/accounts/report/financial_statements.html +3,Too many columns. Export the report and print it using a spreadsheet application.,Shumë kolona. Eksportit raportin dhe të shtypura duke përdorur një aplikim spreadsheet.
 DocType: Purchase Invoice Item,Batch No,Batch Asnjë
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +141,Request for Quotation: {0},Kërkesa për kuotim: {0}
 DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Lejo Sales shumta urdhra kundër Rendit Blerje një konsumatorit
 DocType: Student Group Instructor,Student Group Instructor,Grupi Student Instruktor
 DocType: Student Group Instructor,Student Group Instructor,Grupi Student Instruktor
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Guardian2 Mobile No
-apps/erpnext/erpnext/setup/doctype/company/company.py +197,Main,Kryesor
-apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant,Variant
+DocType: Grant Application,Assessment  Mark (Out of 10),Vlerësimi Mark (Nga 10)
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Guardian2 Mobile No
+apps/erpnext/erpnext/setup/doctype/company/company.py +194,Main,Kryesor
+apps/erpnext/erpnext/stock/doctype/item/item.js +72,Variant,Variant
 DocType: Naming Series,Set prefix for numbering series on your transactions,Prefiksi vendosur për numëron seri mbi transaksionet tuaja
 DocType: Employee Attendance Tool,Employees HTML,punonjësit HTML
-apps/erpnext/erpnext/stock/doctype/item/item.py +428,Default BOM ({0}) must be active for this item or its template,Gabim BOM ({0}) duhet të jetë aktiv për këtë artikull ose template saj
+apps/erpnext/erpnext/stock/doctype/item/item.py +444,Default BOM ({0}) must be active for this item or its template,Gabim BOM ({0}) duhet të jetë aktiv për këtë artikull ose template saj
 DocType: Employee,Leave Encashed?,Dërgo arkëtuar?
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,Opportunity Nga fushë është e detyrueshme
 DocType: Email Digest,Annual Expenses,Shpenzimet vjetore
 DocType: Item,Variants,Variantet
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1088,Make Purchase Order,Bëni Rendit Blerje
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1137,Make Purchase Order,Bëni Rendit Blerje
 DocType: SMS Center,Send To,Send To
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +152,There is not enough leave balance for Leave Type {0},Nuk ka bilanc mjaft leje për pushim Lloji {0}
 DocType: Payment Reconciliation Payment,Allocated amount,Shuma e ndarë
@@ -1988,37 +2131,39 @@
 DocType: Sales Invoice Item,Customer's Item Code,Item Kodi konsumatorit
 DocType: Stock Reconciliation,Stock Reconciliation,Stock Pajtimit
 DocType: Territory,Territory Name,Territori Emri
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +177,Work-in-Progress Warehouse is required before Submit,Puna në progres Magazina është e nevojshme para se të Submit
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +197,Work-in-Progress Warehouse is required before Submit,Puna në progres Magazina është e nevojshme para se të Submit
 apps/erpnext/erpnext/config/hr.py +40,Applicant for a Job.,Aplikuesi për një punë.
 DocType: Purchase Order Item,Warehouse and Reference,Magazina dhe Referenca
 DocType: Supplier,Statutory info and other general information about your Supplier,Info Statutore dhe informacione të tjera të përgjithshme në lidhje me furnizuesit tuaj
 DocType: Item,Serial Nos and Batches,Serial Nr dhe Batches
-apps/erpnext/erpnext/schools/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Grupi Student Forca
-apps/erpnext/erpnext/schools/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Grupi Student Forca
+apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Grupi Student Forca
+apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Grupi Student Forca
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +250,Against Journal Entry {0} does not have any unmatched {1} entry,Kundër Fletoren Hyrja {0} nuk ka asnjë pashoq {1} hyrje
-apps/erpnext/erpnext/config/hr.py +137,Appraisals,vlerësime
+apps/erpnext/erpnext/config/hr.py +142,Appraisals,vlerësime
 apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8,Training Events,Ngjarje Trajnimi
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205,Duplicate Serial No entered for Item {0},Duplicate Serial Asnjë hyrë për Item {0}
 DocType: Shipping Rule Condition,A condition for a Shipping Rule,Një kusht për Sundimin Shipping
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +161,Please enter ,Ju lutemi shkruani
-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","nuk mund overbill për artikullit {0} në rradhë {1} më shumë se {2}. Për të lejuar mbi-faturimit, ju lutemi të vendosur në Blerja Settings"
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +212,Please set filter based on Item or Warehouse,Ju lutemi të vendosur filtër në bazë të artikullit ose Magazina
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +167,Please enter ,Ju lutemi shkruani
+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","nuk mund overbill për artikullit {0} në rradhë {1} më shumë se {2}. Për të lejuar mbi-faturimit, ju lutemi të vendosur në Blerja Settings"
+apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43,Maintenance Log,Mirëmbajtja e regjistrit
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +234,Please set filter based on Item or Warehouse,Ju lutemi të vendosur filtër në bazë të artikullit ose Magazina
 DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Pesha neto i kësaj pakete. (Llogaritet automatikisht si shumë të peshës neto të artikujve)
 DocType: Sales Order,To Deliver and Bill,Për të ofruar dhe Bill
 DocType: Student Group,Instructors,instruktorët
 DocType: GL Entry,Credit Amount in Account Currency,Shuma e kredisë në llogari në monedhë të
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +584,BOM {0} must be submitted,BOM {0} duhet të dorëzohet
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +588,BOM {0} must be submitted,BOM {0} duhet të dorëzohet
 DocType: Authorization Control,Authorization Control,Kontrolli Autorizimi
-apps/erpnext/erpnext/controllers/buying_controller.py +308,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Row # {0}: Rejected Magazina është e detyrueshme kundër Item refuzuar {1}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +782,Payment,Pagesa
+apps/erpnext/erpnext/controllers/buying_controller.py +309,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Row # {0}: Rejected Magazina është e detyrueshme kundër Item refuzuar {1}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +808,Payment,Pagesa
 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}.","Magazina {0} nuk është e lidhur me ndonjë llogari, ju lutemi të përmendim llogari në procesverbal depo apo vendosur llogari inventarit parazgjedhur në kompaninë {1}."
 apps/erpnext/erpnext/utilities/activation.py +81,Manage your orders,Menaxho urdhërat tuaj
 DocType: Production Order Operation,Actual Time and Cost,Koha aktuale dhe kostos
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +54,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Kërkesa material i maksimumi {0} mund të jetë bërë për Item {1} kundër Sales Rendit {2}
+DocType: Crop,Crop Spacing,Hapësira e prerjes
 DocType: Course,Course Abbreviation,Shkurtesa Course
 DocType: Student Leave Application,Student Leave Application,Student Leave Aplikimi
 DocType: Item,Will also apply for variants,Gjithashtu do të aplikojë për variantet
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +160,"Asset cannot be cancelled, as it is already {0}","Asset nuk mund të anulohet, pasi ajo tashmë është {0}"
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +160,"Asset cannot be cancelled, as it is already {0}","Asset nuk mund të anulohet, pasi ajo tashmë është {0}"
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} on Half day on {1},I punësuar {0} në gjysmë ditë në {1}
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42,Total working hours should not be greater than max working hours {0},Orët totale të punës nuk duhet të jetë më e madhe se sa orë pune max {0}
 apps/erpnext/erpnext/templates/pages/task_info.html +90,On,Në
@@ -2028,9 +2173,9 @@
 DocType: Quality Inspection Reading,Reading 10,Leximi 10
 DocType: Hub Category,Hub Node,Hub Nyja
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,Ju keni hyrë artikuj kopjuar. Ju lutemi të ndrequr dhe provoni përsëri.
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +125,Associate,Koleg
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129,Associate,Koleg
 DocType: Asset Movement,Asset Movement,Lëvizja e aseteve
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2165,New Cart,Shporta e re
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2180,New Cart,Shporta e re
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Item {0} is not a serialized Item,Item {0} nuk është një Item serialized
 DocType: SMS Center,Create Receiver List,Krijo Marresit Lista
 DocType: Vehicle,Wheels,rrota
@@ -2041,18 +2186,21 @@
 DocType: Activity Cost,Activity Cost,Kosto Aktiviteti
 DocType: Sales Invoice Timesheet,Timesheet Detail,Detail pasqyrë e mungesave
 DocType: Purchase Receipt Item Supplied,Consumed Qty,Konsumuar Qty
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +52,Telecommunications,Telekomunikacionit
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52,Telecommunications,Telekomunikacionit
+apps/erpnext/erpnext/accounts/party.py +266,Billing currency must be equal to either default company's currency or party account currency,Monedha e faturimit duhet të jetë e barabartë me monedhën e parave të kompanisë ose monedhën e llogarisë së partisë
 DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),Tregon se paketa është pjesë e këtij ofrimit (Vetëm draft)
+DocType: Soil Texture,Loam,tokë pjellore
+apps/erpnext/erpnext/controllers/accounts_controller.py +680,Row {0}: Due Date cannot be before posting date,Rreshti {0}: Data e duhur nuk mund të jetë para datës së postimit
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36,Make Payment Entry,Kryej pagesa Hyrja
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129,Quantity for Item {0} must be less than {1},Sasia e artikullit {0} duhet të jetë më pak se {1}
 ,Sales Invoice Trends,Shitjet Trendet faturave
 DocType: Leave Application,Apply / Approve Leaves,Aplikoni / Miratimi Leaves
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,For,Për
-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',Mund t&#39;i referohet rresht vetëm nëse tipi është ngarkuar &quot;Për Previous Shuma Row &#39;ose&#39; Previous Row Total&quot;
+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',Mund t&#39;i referohet rresht vetëm nëse tipi është ngarkuar &quot;Për Previous Shuma Row &#39;ose&#39; Previous Row Total&quot;
 DocType: Sales Order Item,Delivery Warehouse,Ofrimit Magazina
-apps/erpnext/erpnext/config/accounts.py +249,Tree of financial Cost Centers.,Pema e Qendrave te Kostos financiare.
+apps/erpnext/erpnext/config/accounts.py +241,Tree of financial Cost Centers.,Pema e Qendrave te Kostos financiare.
 DocType: Serial No,Delivery Document No,Ofrimit Dokumenti Asnjë
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +191,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Ju lutemi të vendosur &#39;Gain llogari / humbje neto nga shitja aseteve&#39; në kompaninë {0}
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Ju lutemi të vendosur &#39;Gain llogari / humbje neto nga shitja aseteve&#39; në kompaninë {0}
 DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Të marrë sendet nga Pranimeve Blerje
 DocType: Serial No,Creation Date,Krijimi Data
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33,Item {0} appears multiple times in Price List {1},Item {0} shfaqet herë të shumta në Çmimi Lista {1}
@@ -2065,20 +2213,21 @@
 apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,Përditësoni përgjigjen
 apps/erpnext/erpnext/public/js/utils.js +226,You have already selected items from {0} {1},Ju keni zgjedhur tashmë artikuj nga {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Emri i Shpërndarjes Mujore
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +25,Batch ID is mandatory,Grumbull ID është i detyrueshëm
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +25,Batch ID is mandatory,Grumbull ID është i detyrueshëm
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +26,Batch ID is mandatory,Grumbull ID është i detyrueshëm
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +26,Batch ID is mandatory,Grumbull ID është i detyrueshëm
 DocType: Sales Person,Parent Sales Person,Shitjet prind Person
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +180,High to Low,Lartë në të ulët
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.py +24,Select the program first,Zgjidhni programin e parë
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24,Select the program first,Zgjidhni programin e parë
 DocType: Patient Appointment,Patient Age,Mosha e pacientit
 apps/erpnext/erpnext/config/learn.py +263,Managing Projects,Menaxhimi i Projekteve
 DocType: Supplier,Supplier of Goods or Services.,Furnizuesi i mallrave ose shërbimeve.
 DocType: Budget,Fiscal Year,Viti Fiskal
+DocType: Asset Maintenance Log,Planned,planifikuar
 DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Consultation charges.,Llogaritë e llogarive të arkëtueshme që do të përdoren nëse nuk vendosen në pacient për të rezervuar akuzat e Konsultimit.
 DocType: Vehicle Log,Fuel Price,Fuel Price
 DocType: Budget,Budget,Buxhet
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +43,Set Open,Cakto hapur
-apps/erpnext/erpnext/stock/doctype/item/item.py +245,Fixed Asset Item must be a non-stock item.,Fixed Item Aseteve duhet të jetë një element jo-aksioneve.
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +51,Set Open,Cakto hapur
+apps/erpnext/erpnext/stock/doctype/item/item.py +247,Fixed Asset Item must be a non-stock item.,Fixed Item Aseteve duhet të jetë një element jo-aksioneve.
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Buxheti nuk mund të caktohet {0} kundër, pasi kjo nuk është një llogari të ardhura ose shpenzime"
 apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,Arritur
 DocType: Student Admission,Application Form Route,Formular Aplikimi Route
@@ -2092,12 +2241,13 @@
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69,Item {0} is not setup for Serial Nos. Check Item master,Item {0} nuk është setup për Serial Nr. Kontrolloni mjeshtër Item
 DocType: Maintenance Visit,Maintenance Time,Mirëmbajtja Koha
 ,Amount to Deliver,Shuma për të Ofruar
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +321,Same item has been entered multiple times. {0},Artikulli i njëjtë është futur disa herë. {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.,"Term Data e fillimit nuk mund të jetë më herët se Year Data e fillimit të vitit akademik në të cilin termi është i lidhur (Viti Akademik {}). Ju lutem, Korrigjo datat dhe provoni përsëri."
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +324,Same item has been entered multiple times. {0},Artikulli i njëjtë është futur disa herë. {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.,"Term Data e fillimit nuk mund të jetë më herët se Year Data e fillimit të vitit akademik në të cilin termi është i lidhur (Viti Akademik {}). Ju lutem, Korrigjo datat dhe provoni përsëri."
+apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +192,There were errors.,Ka pasur gabime.
 DocType: Guardian,Guardian Interests,Guardian Interesat
 DocType: Naming Series,Current Value,Vlera e tanishme
-apps/erpnext/erpnext/controllers/accounts_controller.py +240,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,vite të shumta fiskale ekzistojnë për datën {0}. Ju lutemi të vënë kompaninë në vitin fiskal
-DocType: School Settings,Instructor Records to be created by,Regjistruesi i instruktorit të krijohet nga
+apps/erpnext/erpnext/controllers/accounts_controller.py +263,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,vite të shumta fiskale ekzistojnë për datën {0}. Ju lutemi të vënë kompaninë në vitin fiskal
+DocType: Education Settings,Instructor Records to be created by,Regjistruesi i instruktorit të krijohet nga
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229,{0} created,{0} krijuar
 DocType: Delivery Note Item,Against Sales Order,Kundër Sales Rendit
 ,Serial No Status,Serial Asnjë Statusi
@@ -2108,19 +2258,20 @@
 						must be greater than or equal to {2}","Row {0}: Për të vendosur {1} periodiciteti, dallimi në mes të dhe në datën \ duhet të jetë më e madhe se ose e barabartë me {2}"
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6,This is based on stock movement. See {0} for details,Kjo është e bazuar në lëvizjen e aksioneve. Shih {0} për detaje
 DocType: Pricing Rule,Selling,Shitja
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +378,Amount {0} {1} deducted against {2},Shuma {0} {1} zbritur kundër {2}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +379,Amount {0} {1} deducted against {2},Shuma {0} {1} zbritur kundër {2}
 DocType: Employee,Salary Information,Informacione paga
 DocType: Sales Person,Name and Employee ID,Emri dhe punonjës ID
-apps/erpnext/erpnext/accounts/party.py +310,Due Date cannot be before Posting Date,Për shkak Data nuk mund të jetë para se të postimi Data
+apps/erpnext/erpnext/accounts/party.py +311,Due Date cannot be before Posting Date,Për shkak Data nuk mund të jetë para se të postimi Data
 DocType: Website Item Group,Website Item Group,Faqja kryesore Item Grupi
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150,Duties and Taxes,Detyrat dhe Taksat
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356,Please enter Reference date,Ju lutem shkruani datën Reference
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354,Please enter Reference date,Ju lutem shkruani datën Reference
 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} shënimet e pagesës nuk mund të filtrohen nga {1}
 DocType: Item Website Specification,Table for Item that will be shown in Web Site,Tabela për çështje që do të shfaqet në Web Site
 DocType: Purchase Order Item Supplied,Supplied Qty,Furnizuar Qty
 DocType: Purchase Order Item,Material Request Item,Materiali Kërkesë Item
 apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Pema e sendit grupeve.
-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,"Nuk mund t&#39;i referohet numrit rresht më të madhe se, ose të barabartë me numrin e tanishëm rresht për këtë lloj Ngarkesa"
+DocType: Payroll Entry,Get Employee Details,Merrni Detajet e Punonjësve
+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,"Nuk mund t&#39;i referohet numrit rresht më të madhe se, ose të barabartë me numrin e tanishëm rresht për këtë lloj Ngarkesa"
 DocType: Asset,Sold,i shitur
 ,Item-wise Purchase History,Historia Blerje pika-mençur
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},Ju lutem klikoni në &quot;Generate&quot; Listën për të shkoj të marr Serial Asnjë shtuar për Item {0}
@@ -2132,7 +2283,7 @@
 DocType: Sales Invoice,Accounting Details,Detajet Kontabilitet
 apps/erpnext/erpnext/setup/doctype/company/company.js +84,Delete all the Transactions for this Company,Fshij gjitha transaksionet për këtë kompani
 DocType: Patient,O Positive,O Pozitive
-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,Row # {0}: Operacioni {1} nuk është përfunduar për {2} Qty e mallrave të kryer në prodhimin Order # {3}. Ju lutem Përditëso statusin operacion anë Koha Shkrime
+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,Row # {0}: Operacioni {1} nuk është përfunduar për {2} Qty e mallrave të kryer në prodhimin Order # {3}. Ju lutem Përditëso statusin operacion anë Koha Shkrime
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,Investments,Investimet
 DocType: Issue,Resolution Details,Rezoluta Detajet
 apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3,Allocations,alokimet
@@ -2144,6 +2295,7 @@
 DocType: Employee Loan Application,Total Payable Amount,Shuma totale e pagueshme
 DocType: Task,Expected Time (in hours),Koha pritet (në orë)
 DocType: Item Reorder,Check in (group),Kontrolloni në (grupi)
+DocType: Soil Texture,Silt,baltë
 ,Qty to Order,Qty të Rendit
 DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Kreu Llogaria nën pasiv ose kapital, në të cilën Fitimi / Humbja do të jetë e rezervuar"
 apps/erpnext/erpnext/config/projects.py +31,Gantt chart of all tasks.,Grafiku Gantt e të gjitha detyrave.
@@ -2153,7 +2305,7 @@
 DocType: Course,Default Grading Scale,Default Nota Scale
 DocType: Appraisal,For Employee Name,Për Emri punonjës
 DocType: Holiday List,Clear Table,Tabela e qartë
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +98,Available slots,Hapësirat e disponueshme
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +106,Available slots,Hapësirat e disponueshme
 DocType: C-Form Invoice Detail,Invoice No,Fatura Asnjë
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +350,Make Payment,Bëj pagesën
 DocType: Room,Room Name,Room Emri
@@ -2165,6 +2317,7 @@
 ,Campaign Efficiency,Efikasiteti fushatë
 DocType: Discussion,Discussion,diskutim
 DocType: Payment Entry,Transaction ID,ID Transaction
+DocType: Volunteer,Anytime,Kurdo
 DocType: Patient,Surgical History,Historia kirurgjikale
 DocType: Employee,Resignation Letter Date,Dorëheqja Letër Data
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39,Pricing Rules are further filtered based on quantity.,Rregullat e Çmimeve të filtruar më tej në bazë të sasisë.
@@ -2172,9 +2325,11 @@
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335,Please set the Date Of Joining for employee {0},Ju lutemi të vendosur datën e bashkuar për të punësuar {0}
 DocType: Task,Total Billing Amount (via Time Sheet),Total Shuma Faturimi (via Koha Sheet)
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Përsëriteni ardhurat Klientit
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +175,{0} ({1}) must have role 'Expense Approver',{0} ({1}) duhet të ketë rol &#39;aprovuesi kurriz&#39;
-apps/erpnext/erpnext/utilities/user_progress.py +125,Pair,Palë
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +912,Select BOM and Qty for Production,Zgjidhni bom dhe Qty për Prodhimin
+DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
+DocType: Chapter,Chapter,kapitull
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +200,{0} ({1}) must have role 'Expense Approver',{0} ({1}) duhet të ketë rol &#39;aprovuesi kurriz&#39;
+apps/erpnext/erpnext/utilities/user_progress.py +143,Pair,Palë
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +959,Select BOM and Qty for Production,Zgjidhni bom dhe Qty për Prodhimin
 DocType: Asset,Depreciation Schedule,Zhvlerësimi Orari
 apps/erpnext/erpnext/config/selling.py +124,Sales Partner Addresses And Contacts,Adresat Sales partner dhe Kontakte
 DocType: Bank Reconciliation Detail,Against Account,Kundër Llogaria
@@ -2182,37 +2337,41 @@
 DocType: Maintenance Schedule Detail,Actual Date,Aktuale Data
 DocType: Item,Has Batch No,Ka Serisë Asnjë
 apps/erpnext/erpnext/public/js/utils.js +100,Annual Billing: {0},Faturimi vjetore: {0}
-apps/erpnext/erpnext/config/accounts.py +208,Goods and Services Tax (GST India),Mallrat dhe Shërbimet Tatimore (GST India)
+apps/erpnext/erpnext/config/accounts.py +200,Goods and Services Tax (GST India),Mallrat dhe Shërbimet Tatimore (GST India)
 DocType: Delivery Note,Excise Page Number,Akciza Faqja Numër
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +157,"Company, From Date and To Date is mandatory","Kompania, Nga Data dhe deri më sot është e detyrueshme"
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +225,"Company, From Date and To Date is mandatory","Kompania, Nga Data dhe deri më sot është e detyrueshme"
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33,Get from Consultation,Merrni nga Konsultimi
 DocType: Asset,Purchase Date,Blerje Date
-DocType: Employee,Personal Details,Detajet personale
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +193,Please set 'Asset Depreciation Cost Center' in Company {0},Ju lutemi të vendosur &#39;të mjeteve Qendra Amortizimi Kosto&#39; në Kompaninë {0}
+DocType: Volunteer,Volunteer Type,Lloji vullnetar
+DocType: Student,Personal Details,Detajet personale
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193,Please set 'Asset Depreciation Cost Center' in Company {0},Ju lutemi të vendosur &#39;të mjeteve Qendra Amortizimi Kosto&#39; në Kompaninë {0}
 ,Maintenance Schedules,Mirëmbajtja Oraret
 DocType: Task,Actual End Date (via Time Sheet),Aktuale End Date (via Koha Sheet)
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +373,Amount {0} {1} against {2} {3},Shuma {0} {1} kundër {2} {3}
+DocType: Soil Texture,Soil Type,Lloji i dheut
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374,Amount {0} {1} against {2} {3},Shuma {0} {1} kundër {2} {3}
 ,Quotation Trends,Kuotimit Trendet
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +159,Item Group not mentioned in item master for item {0},Grupi pika nuk përmendet në pikën për të zotëruar pikën {0}
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +358,Debit To account must be a Receivable account,Debiti te llogaria duhet të jetë një llogari të arkëtueshme
-DocType: Shipping Rule Condition,Shipping Amount,Shuma e anijeve
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +362,Debit To account must be a Receivable account,Debiti te llogaria duhet të jetë një llogari të arkëtueshme
+DocType: Shipping Rule,Shipping Amount,Shuma e anijeve
 DocType: Supplier Scorecard Period,Period Score,Vota e periudhës
 apps/erpnext/erpnext/utilities/user_progress.py +63,Add Customers,Shto Konsumatorët
 apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Pending Amount,Në pritje Shuma
 DocType: Lab Test Template,Special,i veçantë
-DocType: Purchase Invoice Item,Conversion Factor,Konvertimi Faktori
+DocType: Purchase Order Item Supplied,Conversion Factor,Konvertimi Faktori
 DocType: Purchase Order,Delivered,Dorëzuar
 ,Vehicle Expenses,Shpenzimet automjeteve
 DocType: Serial No,Invoice Details,detajet e faturës
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +155,Expected value after useful life must be greater than or equal to {0},Vlera e pritshme pas jetës së dobishme duhet të jetë më e madhe se ose e barabartë me {0}
-apps/erpnext/erpnext/schools/doctype/student_admission/templates/student_admission.html +29,Start on,Filloni
+DocType: Grant Application,Show on Website,Trego në Website
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +155,Expected value after useful life must be greater than or equal to {0},Vlera e pritshme pas jetës së dobishme duhet të jetë më e madhe se ose e barabartë me {0}
+apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29,Start on,Filloni
 DocType: Hub Category,Hub Category,Kategoria Hub
 DocType: Purchase Invoice,SEZ,SEZ
 DocType: Purchase Receipt,Vehicle Number,Numri i Automjeteve
 DocType: Employee Loan,Loan Amount,Shuma e kredisë
+apps/erpnext/erpnext/utilities/user_progress.py +88,Add Letterhead,Shto me shkronja
 DocType: Program Enrollment,Self-Driving Vehicle,Self-Driving automjeteve
 DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Përputhësi i rezultatit të furnitorit
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +419,Row {0}: Bill of Materials not found for the Item {1},Row {0}: Bill e materialeve nuk u gjet për pika {1}
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +420,Row {0}: Bill of Materials not found for the Item {1},Row {0}: Bill e materialeve nuk u gjet për pika {1}
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +98,Total allocated leaves {0} cannot be less than already approved leaves {1} for the period,Gjithsej gjethet e ndara {0} nuk mund të jetë më pak se gjethet tashmë të miratuara {1} për periudhën
 DocType: Journal Entry,Accounts Receivable,Llogaritë e arkëtueshme
 ,Supplier-Wise Sales Analytics,Furnizuesi-i mençur Sales Analytics
@@ -2224,28 +2383,29 @@
 DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Kursi Parent (Lini bosh, në qoftë se kjo nuk është pjesë e mëmë natyrisht)"
 DocType: Leave Control Panel,Leave blank if considered for all employee types,Lini bosh nëse konsiderohet për të gjitha llojet e punonjësve
 DocType: Landed Cost Voucher,Distribute Charges Based On,Shpërndarjen Akuzat Bazuar Në
-apps/erpnext/erpnext/hooks.py +140,Timesheets,timesheets
+apps/erpnext/erpnext/hooks.py +144,Timesheets,timesheets
 DocType: HR Settings,HR Settings,HR Cilësimet
 DocType: Salary Slip,net pay info,info net pay
 DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Kjo vlerë përditësohet në Listën e Çmimeve të Shitjes së Parazgjedhur.
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +111,Expense Claim is pending approval. Only the Expense Approver can update status.,Shpenzim Kërkesa është në pritje të miratimit. Vetëm aprovuesi shpenzimeve mund update statusin.
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +122,Expense Claim is pending approval. Only the Expense Approver can update status.,Shpenzim Kërkesa është në pritje të miratimit. Vetëm aprovuesi shpenzimeve mund update statusin.
 DocType: Email Digest,New Expenses,Shpenzimet e reja
 DocType: Purchase Invoice,Additional Discount Amount,Shtesë Shuma Discount
 DocType: Consultation,Patient Details,Detajet e pacientit
 DocType: Patient,B Positive,B Pozitiv
-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}: Qty duhet të jetë 1, pasi pika është një pasuri fikse. Ju lutem përdorni rresht të veçantë për Qty shumëfishtë."
+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}: Qty duhet të jetë 1, pasi pika është një pasuri fikse. Ju lutem përdorni rresht të veçantë për Qty shumëfishtë."
 DocType: Leave Block List Allow,Leave Block List Allow,Dërgo Block Lista Lejoni
-apps/erpnext/erpnext/setup/doctype/company/company.py +291,Abbr can not be blank or space,Abbr nuk mund të jetë bosh ose hapësirë
+apps/erpnext/erpnext/setup/doctype/company/company.py +288,Abbr can not be blank or space,Abbr nuk mund të jetë bosh ose hapësirë
 DocType: Patient Medical Record,Patient Medical Record,Regjistrimi mjekësor pacient
-apps/erpnext/erpnext/accounts/doctype/account/account.js +62,Group to Non-Group,Grup për jo-Group
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +50,Sports,Sportiv
+apps/erpnext/erpnext/accounts/doctype/account/account.js +68,Group to Non-Group,Grup për jo-Group
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50,Sports,Sportiv
 DocType: Loan Type,Loan Name,kredi Emri
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Actual,Gjithsej aktuale
 DocType: Lab Test UOM,Test UOM,Test UOM
 DocType: Student Siblings,Student Siblings,Vëllai dhe motra e studentëve
-apps/erpnext/erpnext/utilities/user_progress.py +125,Unit,Njësi
-apps/erpnext/erpnext/stock/get_item_details.py +141,Please specify Company,Ju lutem specifikoni Company
+apps/erpnext/erpnext/utilities/user_progress.py +143,Unit,Njësi
+apps/erpnext/erpnext/stock/get_item_details.py +136,Please specify Company,Ju lutem specifikoni Company
 ,Customer Acquisition and Loyalty,Customer Blerja dhe Besnik
+DocType: Asset Maintenance Task,Maintenance Task,Detyra e mirëmbajtjes
 DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,Magazina ku ju jeni mbajtjen e aksioneve të artikujve refuzuar
 DocType: Production Order,Skip Material Transfer,Kalo Material Transferimi
 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,Në pamundësi për të gjetur kursin e këmbimit për {0} në {1} për datën kyçe {2}. Ju lutem të krijuar një rekord Currency Exchange dorë
@@ -2255,70 +2415,73 @@
 DocType: Issue,Support,Mbështetje
 ,BOM Search,Bom Kërko
 DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Publikoni &quot;Në Stock&quot; ose &quot;Not in Stock&quot; në Hub bazuar në stokun në dispozicion në këtë depo.
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +189,Closing (Opening + Totals),Mbyllja (Hapja + arrin)
 DocType: Vehicle,Fuel Type,Fuel Lloji
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27,Please specify currency in Company,Ju lutem specifikoni monedhës në Kompaninë
 DocType: Workstation,Wages per hour,Rrogat në orë
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Bilanci aksioneve në Serisë {0} do të bëhet negative {1} për Item {2} në {3} Magazina
 apps/erpnext/erpnext/templates/emails/reorder_item.html +1,Following Material Requests have been raised automatically based on Item's re-order level,Pas kërkesave materiale janë ngritur automatikisht bazuar në nivelin e ri të rendit zërit
 DocType: Email Digest,Pending Sales Orders,Në pritje Sales urdhëron
-apps/erpnext/erpnext/controllers/accounts_controller.py +279,Account {0} is invalid. Account Currency must be {1},Llogari {0} është i pavlefshëm. Llogaria Valuta duhet të jetë {1}
+apps/erpnext/erpnext/controllers/accounts_controller.py +302,Account {0} is invalid. Account Currency must be {1},Llogari {0} është i pavlefshëm. Llogaria Valuta duhet të jetë {1}
 DocType: Healthcare Settings,Remind Before,Kujtoj Para
 apps/erpnext/erpnext/buying/utils.py +34,UOM Conversion factor is required in row {0},Faktori UOM Konvertimi është e nevojshme në rresht {0}
 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","Row # {0}: Reference Lloji i dokumentit duhet të jetë një nga Sales Rendit, Sales Fatura ose Journal Entry"
+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","Row # {0}: Reference Lloji i dokumentit duhet të jetë një nga Sales Rendit, Sales Fatura ose Journal Entry"
 DocType: Salary Component,Deduction,Zbritje
+DocType: Item,Retain Sample,Mbajeni mostër
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,Row {0}: From Time and To Time is mandatory.,Row {0}: Nga koha dhe në kohë është i detyrueshëm.
 DocType: Stock Reconciliation Item,Amount Difference,shuma Diferenca
-apps/erpnext/erpnext/stock/get_item_details.py +306,Item Price added for {0} in Price List {1},Item Çmimi shtuar për {0} në çmim Lista {1}
+apps/erpnext/erpnext/stock/get_item_details.py +349,Item Price added for {0} in Price List {1},Item Çmimi shtuar për {0} në çmim Lista {1}
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8,Please enter Employee Id of this sales person,Ju lutemi shkruani punonjës Id i këtij personi të shitjes
 DocType: Territory,Classification of Customers by region,Klasifikimi i Konsumatorëve sipas rajonit
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +57,Difference Amount must be zero,Dallimi Shuma duhet të jetë zero
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +71,In Production,Në prodhim
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +59,Difference Amount must be zero,Dallimi Shuma duhet të jetë zero
 DocType: Project,Gross Margin,Marzhi bruto
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +61,Please enter Production Item first,Ju lutemi shkruani Prodhimi pikën e parë
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Calculated Bank Statement balance,Llogaritur Banka bilanci Deklarata
 DocType: Normal Test Template,Normal Test Template,Modeli i Testimit Normal
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,përdorues me aftësi të kufizuara
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.js +764,Quotation,Citat
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +957,Cannot set a received RFQ to No Quote,Nuk mund të caktohet një RFQ e pranuar në asnjë kuotë
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +913,Quotation,Citat
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +982,Cannot set a received RFQ to No Quote,Nuk mund të caktohet një RFQ e pranuar në asnjë kuotë
 DocType: Quotation,QTN-,QTN-
 DocType: Salary Slip,Total Deduction,Zbritje Total
 ,Production Analytics,Analytics prodhimit
 apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6,This is based on transactions against this Patient. See timeline below for details,Kjo bazohet në transaksione kundër këtij Pacienti. Shiko detajet më poshtë për detaje
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +201,Cost Updated,Kosto Përditësuar
-DocType: Employee,Date of Birth,Data e lindjes
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Kodi i artikullit&gt; Grupi i artikullit&gt; Markë
+DocType: Patient,Date of Birth,Data e lindjes
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +129,Item {0} has already been returned,Item {0} tashmë është kthyer
 DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Viti Fiskal ** përfaqëson një viti financiar. Të gjitha shënimet e kontabilitetit dhe transaksionet tjera të mëdha janë gjurmuar kundër Vitit Fiskal ** **.
 DocType: Opportunity,Customer / Lead Address,Customer / Adresa Lead
-DocType: Patient,DOB,DOB
 DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Vendosja e Scorecard Furnizues
-apps/erpnext/erpnext/schools/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Emri i Planit të Vlerësimit
-apps/erpnext/erpnext/stock/doctype/item/item.py +220,Warning: Invalid SSL certificate on attachment {0},Warning: certifikatë SSL Invalid në shtojcën {0}
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Emri i Planit të Vlerësimit
+apps/erpnext/erpnext/stock/doctype/item/item.py +222,Warning: Invalid SSL certificate on attachment {0},Warning: certifikatë SSL Invalid në shtojcën {0}
 apps/erpnext/erpnext/utilities/activation.py +64,"Leads help you get business, add all your contacts and more as your leads","Çon ju ndihmojë të merrni të biznesit, shtoni të gjitha kontaktet tuaja dhe më shumë si çon tuaj"
 DocType: Production Order Operation,Actual Operation Time,Aktuale Operacioni Koha
 DocType: Authorization Rule,Applicable To (User),Për të zbatueshme (User)
 DocType: Purchase Taxes and Charges,Deduct,Zbres
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +226,Job Description,Përshkrimi i punës
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +236,Job Description,Përshkrimi i punës
 DocType: Student Applicant,Applied,i aplikuar
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +834,Re-open,Ri-hapur
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +859,Re-open,Ri-hapur
 DocType: Sales Invoice Item,Qty as per Stock UOM,Qty sipas Stock UOM
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Emri Guardian2
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Emri Guardian2
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +127,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Karaktere speciale përveç &quot;-&quot; &quot;.&quot;, &quot;#&quot;, dhe &quot;/&quot; nuk lejohet në emërtimin seri"
 DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Mbani gjurmët e Fushatave Sales. Mbani gjurmët e kryeson, citatet, Sales Rendit etj nga Fushata për të vlerësuar kthimit mbi investimin."
 DocType: Expense Claim,Approver,Aprovuesi
 ,SO Qty,SO Qty
 DocType: Guardian,Work Address,puna Adresa
 DocType: Appraisal,Calculate Total Score,Llogaritur Gjithsej Vota
-DocType: Request for Quotation,Manufacturing Manager,Prodhim Menaxher
+DocType: Asset Repair,Manufacturing Manager,Prodhim Menaxher
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191,Serial No {0} is under warranty upto {1},Serial Asnjë {0} është nën garanci upto {1}
-apps/erpnext/erpnext/config/stock.py +163,Split Delivery Note into packages.,Shënim Split dorëzimit në pako.
-apps/erpnext/erpnext/hooks.py +107,Shipments,Dërgesat
+DocType: Plant Analysis Criteria,Minimum Permissible Value,Vlera minimale e lejueshme
+apps/erpnext/erpnext/education/doctype/guardian/guardian.py +42,User {0} already exists,Përdoruesi {0} tashmë ekziston
+apps/erpnext/erpnext/hooks.py +109,Shipments,Dërgesat
 DocType: Payment Entry,Total Allocated Amount (Company Currency),Gjithsej shuma e akorduar (Company Valuta)
 DocType: Purchase Order Item,To be delivered to customer,Që do të dërgohen për të klientit
 DocType: BOM,Scrap Material Cost,Scrap Material Kosto
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227,Serial No {0} does not belong to any Warehouse,Serial Asnjë {0} nuk i përkasin ndonjë Magazina
+DocType: Grant Application,Email Notification Sent,Njoftimi me email u dërgua
 DocType: Purchase Invoice,In Words (Company Currency),Me fjalë (Kompania Valuta)
-DocType: Asset,Supplier,Furnizuesi
+DocType: Pricing Rule,Supplier,Furnizuesi
 DocType: Consultation,Consultation Time,Koha e konsultimit
 DocType: C-Form,Quarter,Çerek
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,Miscellaneous Expenses,Shpenzimet Ndryshme
@@ -2332,115 +2495,123 @@
 DocType: Email Digest,Note: Email will not be sent to disabled users,Shënim: Email nuk do të dërgohet për përdoruesit me aftësi të kufizuara
 apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Numri i bashkëveprimit
 apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Numri i bashkëveprimit
-apps/erpnext/erpnext/stock/doctype/item/item.js +102,Item Variant Settings,Cilësimet e variantit të artikullit
+apps/erpnext/erpnext/stock/doctype/item/item.js +105,Item Variant Settings,Cilësimet e variantit të artikullit
 apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +39,Select Company...,Zgjidh kompanisë ...
 DocType: Leave Control Panel,Leave blank if considered for all departments,Lini bosh nëse konsiderohet për të gjitha departamentet
-apps/erpnext/erpnext/config/hr.py +223,"Types of employment (permanent, contract, intern etc.).","Llojet e punësimit (, kontratë të përhershme, etj intern)."
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +424,{0} is mandatory for Item {1},{0} është e detyrueshme për Item {1}
-DocType: Process Payroll,Fortnightly,dyjavor
+apps/erpnext/erpnext/config/hr.py +228,"Types of employment (permanent, contract, intern etc.).","Llojet e punësimit (, kontratë të përhershme, etj intern)."
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +428,{0} is mandatory for Item {1},{0} është e detyrueshme për Item {1}
+DocType: Payroll Entry,Fortnightly,dyjavor
 DocType: Currency Exchange,From Currency,Nga Valuta
 DocType: Vital Signs,Weight (In Kilogram),Pesha (në kilogram)
+DocType: Chapter,"chapters/chapter_name
+leave blank automatically set after saving chapter.",kapitujt / emri i kapitullit lënë boshin automatikisht të vendosur pas ruajtjes së kapitullit.
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +170,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Ju lutem, përzgjidhni Shuma e ndarë, tip fature, si dhe numrin e faturës në atleast një rresht"
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +125,Cost of New Purchase,Kostoja e blerjes së Re
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +128,Cost of New Purchase,Kostoja e blerjes së Re
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97,Sales Order required for Item {0},Rendit Shitjet e nevojshme për Item {0}
+DocType: Grant Application,Grant Description,Përshkrimi i Grantit
 DocType: Purchase Invoice Item,Rate (Company Currency),Shkalla (Kompania Valuta)
 DocType: Student Guardian,Others,Të tjerët
 DocType: Payment Entry,Unallocated Amount,Shuma pashpërndarë
 apps/erpnext/erpnext/templates/includes/product_page.js +71,Cannot find a matching Item. Please select some other value for {0}.,Nuk mund të gjeni një përputhen Item. Ju lutem zgjidhni një vlerë tjetër {0} për.
 DocType: POS Profile,Taxes and Charges,Taksat dhe Tarifat
 DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Një produkt apo një shërbim që është blerë, shitur apo mbajtur në magazinë."
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +24,Please setup Employee Naming System in Human Resource &gt; HR Settings,Ju lutem vendosni Sistemin e Emërimit të Punonjësve në Burimet Njerëzore&gt; Cilësimet e HR
 apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44,No more updates,Nuk ka përditësime më shumë
-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,Nuk mund të zgjidhni llojin e ngarkuar si &quot;Për Shuma Previous Row &#39;ose&#39; Në Previous Row Total&quot; për rreshtin e parë
+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,Nuk mund të zgjidhni llojin e ngarkuar si &quot;Për Shuma Previous Row &#39;ose&#39; Në Previous Row Total&quot; për rreshtin e parë
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6,This covers all scorecards tied to this Setup,Kjo mbulon të gjitha tabelat e rezultateve të lidhura me këtë Setup
 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,Child Item nuk duhet të jetë një Bundle Product. Ju lutemi të heq arikullin &#39;{0}&#39; dhe për të shpëtuar
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +12,Banking,Bankar
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12,Banking,Bankar
 apps/erpnext/erpnext/utilities/activation.py +108,Add Timesheets,Shto timesheets
 DocType: Vehicle Service,Service Item,Shërbimi Item
 DocType: Bank Guarantee,Bank Guarantee,garanci bankare
 DocType: Bank Guarantee,Bank Guarantee,garanci bankare
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39,Please click on 'Generate Schedule' to get schedule,Ju lutem klikoni në &quot;Generate&quot; Listën për të marrë orarin
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +56,There were errors while deleting following schedules:,"Ka pasur gabime, ndërsa fshirjes oraret e mëposhtme:"
 DocType: Bin,Ordered Quantity,Sasi të Urdhërohet
-apps/erpnext/erpnext/public/js/setup_wizard.js +115,"e.g. ""Build tools for builders""",p.sh. &quot;Ndërtimi mjetet për ndërtuesit&quot;
+apps/erpnext/erpnext/public/js/setup_wizard.js +118,"e.g. ""Build tools for builders""",p.sh. &quot;Ndërtimi mjetet për ndërtuesit&quot;
 DocType: Grading Scale,Grading Scale Intervals,Intervalet Nota Scale
 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}: Accounting Hyrja për {2} mund të bëhet vetëm në monedhën: {3}
-DocType: Production Order,In Process,Në Procesin
+DocType: Fee Schedule,In Process,Në Procesin
 DocType: Authorization Rule,Itemwise Discount,Itemwise Discount
 apps/erpnext/erpnext/config/accounts.py +75,Tree of financial accounts.,Pema e llogarive financiare.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364,{0} against Sales Order {1},{0} kundër Sales Rendit {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +362,{0} against Sales Order {1},{0} kundër Sales Rendit {1}
 DocType: Account,Fixed Asset,Aseteve fikse
 apps/erpnext/erpnext/config/stock.py +320,Serialized Inventory,Inventar serialized
 DocType: Employee Loan,Account Info,Llogaria Info
 DocType: Activity Type,Default Billing Rate,Default Faturimi Vlerësoni
 DocType: Fees,Include Payment,Përfshi Pagesën
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} grupeve studentore krijuar.
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} grupeve studentore krijuar.
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} grupeve studentore krijuar.
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} grupeve studentore krijuar.
 DocType: Sales Invoice,Total Billing Amount,Shuma totale Faturimi
 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.,Nuk duhet të jetë një parazgjedhur në hyrje Email Llogaria aktivizuar për këtë punë. Ju lutemi të setup një parazgjedhur në hyrje Email Llogaria (POP / IMAP) dhe provoni përsëri.
-DocType: Healthcare Settings,Receivable Account,Llogaria e arkëtueshme
-apps/erpnext/erpnext/controllers/accounts_controller.py +553,Row #{0}: Asset {1} is already {2},Row # {0}: Asset {1} është tashmë {2}
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50,Program in the Fee Structure and Student Group {0} are different.,Programi në Strukturën e Tarifave dhe Grupi Studentor {0} janë të ndryshme.
+DocType: Fee Schedule,Receivable Account,Llogaria e arkëtueshme
+apps/erpnext/erpnext/controllers/accounts_controller.py +597,Row #{0}: Asset {1} is already {2},Row # {0}: Asset {1} është tashmë {2}
 DocType: Quotation Item,Stock Balance,Stock Bilanci
 apps/erpnext/erpnext/config/selling.py +316,Sales Order to Payment,Rendit Shitjet për Pagesa
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +119,CEO,CEO
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123,CEO,CEO
 DocType: Purchase Invoice,With Payment of Tax,Me pagesën e tatimit
 DocType: Expense Claim Detail,Expense Claim Detail,Shpenzim Kërkesa Detail
 DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,Tri kopje për furnizuesit
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +868,Please select correct account,"Ju lutem, përzgjidhni llogarinë e saktë"
-DocType: Item,Weight UOM,Pesha UOM
+DocType: Land Unit,Is Container,Është kontejner
+DocType: Crop Cycle,This will be day 1 of the crop cycle,Kjo do të jetë dita e 1 e ciklit të kulturave
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +869,Please select correct account,"Ju lutem, përzgjidhni llogarinë e saktë"
+DocType: Purchase Invoice Item,Weight UOM,Pesha UOM
 DocType: Salary Structure Employee,Salary Structure Employee,Struktura Paga e punonjësve
-DocType: Patient,Blood Group,Grup gjaku
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45,Show Variant Attributes,Trego atributet e variantit
+DocType: Student,Blood Group,Grup gjaku
 DocType: Course,Course Name,Emri i kursit
 DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,Përdoruesit të cilët mund të miratojë aplikacione të lënë një punonjës të veçantë për
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52,Office Equipments,Zyra Pajisje
 DocType: Purchase Invoice Item,Qty,Qty
 DocType: Fiscal Year,Companies,Kompanitë
 DocType: Supplier Scorecard,Scoring Setup,Vendosja e programit
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +24,Electronics,Elektronikë
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24,Electronics,Elektronikë
 DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Ngritja materiale Kërkesë kur bursës arrin nivel të ri-rendit
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +94,Full-time,Me kohë të plotë
-DocType: Salary Structure,Employees,punonjësit
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98,Full-time,Me kohë të plotë
+DocType: Payroll Entry,Employees,punonjësit
 DocType: Employee,Contact Details,Detajet Kontakt
 DocType: C-Form,Received Date,Data e marra
 DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Nëse keni krijuar një template standarde në shitje taksave dhe detyrimeve Stampa, përzgjidh njërin dhe klikoni mbi butonin më poshtë."
 DocType: BOM Scrap Item,Basic Amount (Company Currency),Shuma Basic (Company Valuta)
 DocType: Student,Guardians,Guardians
 DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,Çmimet nuk do të shfaqet në qoftë Lista Çmimi nuk është vendosur
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +28,Please specify a country for this Shipping Rule or check Worldwide Shipping,Ju lutem specifikoni një vend për këtë Rregull Shipping ose kontrolloni anijeve në botë
 DocType: Stock Entry,Total Incoming Value,Vlera Totale hyrëse
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +352,Debit To is required,Debi Për të është e nevojshme
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +356,Debit To is required,Debi Për të është e nevojshme
 apps/erpnext/erpnext/utilities/activation.py +109,"Timesheets help keep track of time, cost and billing for activites done by your team","Timesheets ndihmojë për të mbajtur gjurmët e kohës, kostos dhe faturimit për Aktivitetet e kryera nga ekipi juaj"
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,Blerje Lista e Çmimeve
 apps/erpnext/erpnext/config/buying.py +155,Templates of supplier scorecard variables.,Modelet e variablave të rezultateve të rezultateve të furnizuesit.
 DocType: Offer Letter Term,Offer Term,Term Oferta
-DocType: Quality Inspection,Quality Manager,Menaxheri Cilësia
+DocType: Asset,Quality Manager,Menaxheri Cilësia
 DocType: Job Applicant,Job Opening,Hapja Job
 DocType: Payment Reconciliation,Payment Reconciliation,Pajtimi Pagesa
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153,Please select Incharge Person's name,"Ju lutem, përzgjidhni emrin incharge personi"
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +51,Technology,Teknologji
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51,Technology,Teknologji
 DocType: Hub Settings,Unregister from Hub,Çregjistro nga Hub
 apps/erpnext/erpnext/public/js/utils.js +102,Total Unpaid: {0},Total papaguar: {0}
 DocType: BOM Website Operation,BOM Website Operation,BOM Website Operacioni
 apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,Offer Letter,Oferta Letër
 apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Production Orders.,Generate Kërkesat materiale (MRP) dhe urdhërat e prodhimit.
 DocType: Supplier Scorecard,Supplier Score,Rezultati i Furnizuesit
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +76,Total Invoiced Amt,Gjithsej faturuara Amt
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +87,Total Invoiced Amt,Gjithsej faturuara Amt
 DocType: Supplier,Warn RFQs,Paralajmëroj RFQ-të
 DocType: BOM,Conversion Rate,Shkalla e konvertimit
 apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,Product Kërko
-DocType: Physician Schedule Time Slot,To Time,Për Koha
+DocType: Assessment Plan,To Time,Për Koha
 DocType: Authorization Rule,Approving Role (above authorized value),Miratimi Rolit (mbi vlerën e autorizuar)
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115,Credit To account must be a Payable account,Kredia për llogari duhet të jetë një llogari e pagueshme
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.py +43,Please select Student Admission which is mandatory for the paid student applicant,Ju lutemi zgjidhni Pranimin e Studentit i cili është i detyrueshëm për aplikantin e paguar të studentëve
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +335,BOM recursion: {0} cannot be parent or child of {2},BOM recursion: {0} nuk mund të jetë prindi ose fëmija i {2}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118,Credit To account must be a Payable account,Kredia për llogari duhet të jetë një llogari e pagueshme
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43,Please select Student Admission which is mandatory for the paid student applicant,Ju lutemi zgjidhni Pranimin e Studentit i cili është i detyrueshëm për aplikantin e paguar të studentëve
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +338,BOM recursion: {0} cannot be parent or child of {2},BOM recursion: {0} nuk mund të jetë prindi ose fëmija i {2}
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +23,Please select a Price List to publish pricing,Ju lutemi zgjidhni listën e çmimeve për të publikuar çmimet
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38,Budget List,Lista e buxhetit
 DocType: Production Order Operation,Completed Qty,Kompletuar Qty
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148,"For {0}, only debit accounts can be linked against another credit entry","Për {0}, vetëm llogaritë e debitit mund të jetë i lidhur kundër një tjetër hyrjes krediti"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +146,"For {0}, only debit accounts can be linked against another credit entry","Për {0}, vetëm llogaritë e debitit mund të jetë i lidhur kundër një tjetër hyrjes krediti"
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27,Price List {0} is disabled,Lista e Çmimeve {0} është me aftësi të kufizuara
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127,Row {0}: Completed Qty cannot be more than {1} for operation {2},Row {0}: Kompletuar Qty nuk mund të jetë më shumë se {1} për funksionimin {2}
 DocType: Manufacturing Settings,Allow Overtime,Lejo jashtë orarit
 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} nuk mund të përditësohet duke përdorur Stock pajtimit, ju lutem, përdorni Stock Hyrja"
 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} nuk mund të përditësohet duke përdorur Stock pajtimit, ju lutem, përdorni Stock Hyrja"
 DocType: Training Event Employee,Training Event Employee,Trajnimi Event punonjës
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +976,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Mostrat maksimale - {0} mund të ruhen për Serinë {1} dhe Pikën {2}.
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +6,Add Time Slots,Shtoni Vendndodhjet e Kohës
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} Numrat Serial nevojshme për Item {1}. Ju keni dhënë {2}.
 DocType: Stock Reconciliation Item,Current Valuation Rate,Shkalla aktuale Vlerësimi
@@ -2457,10 +2628,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,Qendrat e mëtejshme e kostos mund të bëhet në bazë të Grupeve por hyra mund të bëhet kundër jo-grupeve
 apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Përdoruesit dhe Lejet
 DocType: Vehicle Log,VLOG.,Vlog.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +945,Production Orders Created: {0},Urdhërat e prodhimit Krijuar: {0}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +994,Production Orders Created: {0},Urdhërat e prodhimit Krijuar: {0}
 DocType: Branch,Branch,Degë
+DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
+DocType: Delivery Trip,Fulfillment User,Përmbushja e përdoruesit
 apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Printime dhe quajtur
 DocType: Company,Total Monthly Sales,Shitjet mujore totale
+DocType: Agriculture Analysis Criteria,Weather,mot
 DocType: Bin,Actual Quantity,Sasia aktuale
 DocType: Shipping Rule,example: Next Day Shipping,shembull: Transporti Dita e ardhshme
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187,Serial No {0} not found,Serial Asnjë {0} nuk u gjet
@@ -2469,16 +2643,17 @@
 DocType: Fee Schedule Program,Student Batch,Batch Student
 apps/erpnext/erpnext/utilities/activation.py +119,Make Student,bëni Student
 DocType: Supplier Scorecard Scoring Standing,Min Grade,Min Grade
-apps/erpnext/erpnext/projects/doctype/project/project.py +203,You have been invited to collaborate on the project: {0},Ju keni qenë të ftuar për të bashkëpunuar në këtë projekt: {0}
+apps/erpnext/erpnext/projects/doctype/project/project.py +214,You have been invited to collaborate on the project: {0},Ju keni qenë të ftuar për të bashkëpunuar në këtë projekt: {0}
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +107,Physician not available on {0},Mjeku nuk është i disponueshëm në {0}
 DocType: Leave Block List Date,Block Date,Data bllok
+DocType: Crop,Crop,prodhim
 DocType: Purchase Receipt,Supplier Delivery Note,Shënimi i dorëzimit të furnitorit
-apps/erpnext/erpnext/schools/doctype/student_admission/templates/student_admission.html +70,Apply Now,Apliko tani
+apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70,Apply Now,Apliko tani
 apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Sasia aktual {0} / pritje Sasia {1}
 apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Sasia aktual {0} / pritje Sasia {1}
 DocType: Purchase Invoice,E-commerce GSTIN,E-commerce GSTIN
 DocType: Sales Order,Not Delivered,Jo Dorëzuar
-apps/erpnext/erpnext/controllers/buying_controller.py +421,Expected Date cannot be before Transaction Date,Data e pritshme nuk mund të jetë para datës së transaksionit
+apps/erpnext/erpnext/controllers/buying_controller.py +422,Expected Date cannot be before Transaction Date,Data e pritshme nuk mund të jetë para datës së transaksionit
 ,Bank Clearance Summary,Pastrimi Përmbledhje Banka
 apps/erpnext/erpnext/config/setup.py +106,"Create and manage daily, weekly and monthly email digests.","Krijuar dhe menaxhuar digests ditore, javore dhe mujore email."
 DocType: Appraisal Goal,Appraisal Goal,Vlerësimi Qëllimi
@@ -2487,21 +2662,23 @@
 DocType: Fee Schedule,Fee Structure,Struktura Fee
 DocType: Timesheet Detail,Costing Amount,Kushton Shuma
 DocType: Student Admission Program,Application Fee,Tarifë aplikimi
-DocType: Process Payroll,Submit Salary Slip,Submit Kuponi pagave
-apps/erpnext/erpnext/controllers/selling_controller.py +165,Maxiumm discount for Item {0} is {1}%,Zbritje Maxiumm për Item {0} është {1}%
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +50,Submit Salary Slip,Submit Kuponi pagave
+apps/erpnext/erpnext/controllers/selling_controller.py +133,Maxiumm discount for Item {0} is {1}%,Zbritje Maxiumm për Item {0} është {1}%
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16,Import in Bulk,Importi në Bulk
 DocType: Sales Partner,Address & Contacts,Adresa dhe Kontaktet
 DocType: SMS Log,Sender Name,Sender Emri
+DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Kriteret e Analizës së Bujqësisë
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +193,Sort by Criteria,Rendit sipas kritereve
 DocType: POS Profile,[Select],[Zgjidh]
 DocType: Vital Signs,Blood Pressure (diastolic),Presioni i gjakut (diastolik)
 DocType: SMS Log,Sent To,Dërguar në
+DocType: Agriculture Task,Holiday Management,Menaxhimi i Festave
 DocType: Payment Request,Make Sales Invoice,Bëni Sales Faturë
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61,Softwares,Programe
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +50,Next Contact Date cannot be in the past,Next Kontakt Data nuk mund të jetë në të kaluarën
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +51,Next Contact Date cannot be in the past,Next Kontakt Data nuk mund të jetë në të kaluarën
 DocType: Company,For Reference Only.,Vetëm për referencë.
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +91,Physician {0} not available on {1},Mjeku {0} nuk është i disponueshëm në {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2519,Select Batch No,Zgjidh Batch No
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +99,Physician {0} not available on {1},Mjeku {0} nuk është i disponueshëm në {1}
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2538,Select Batch No,Zgjidh Batch No
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +52,Invalid {0}: {1},Invalid {0}: {1}
 DocType: Purchase Invoice,PINV-RET-,PINV-RET-
 DocType: Fee Validity,Reference Inv,Referenca Inv
@@ -2513,12 +2690,12 @@
 DocType: Employee,Employment Details,Detajet e punësimit
 DocType: Employee,New Workplace,New Workplace
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Bëje si Mbyllur
-apps/erpnext/erpnext/stock/get_item_details.py +131,No Item with Barcode {0},Nuk ka artikull me Barkodi {0}
+apps/erpnext/erpnext/stock/get_item_details.py +125,No Item with Barcode {0},Nuk ka artikull me Barkodi {0}
 DocType: Normal Test Items,Require Result Value,Kërkoni vlerën e rezultatit
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,Case No. cannot be 0,Rast No. nuk mund të jetë 0
 DocType: Item,Show a slideshow at the top of the page,Tregojnë një Slideshow në krye të faqes
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +514,Boms,BOM
-apps/erpnext/erpnext/stock/doctype/item/item.py +149,Stores,Dyqane
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +517,Boms,BOM
+apps/erpnext/erpnext/stock/doctype/item/item.py +151,Stores,Dyqane
 DocType: Project Type,Projects Manager,Projektet Menaxher
 DocType: Serial No,Delivery Time,Koha e dorëzimit
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,Ageing Based On,Plakjen Bazuar Në
@@ -2533,17 +2710,19 @@
 DocType: Rename Tool,Rename Tool,Rename Tool
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +72,Update Cost,Update Kosto
 DocType: Item Reorder,Item Reorder,Item reorder
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +446,Show Salary Slip,Trego Paga Shqip
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +823,Transfer Material,Material Transferimi
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463,Show Salary Slip,Trego Paga Shqip
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +848,Transfer Material,Material Transferimi
 DocType: Fees,Send Payment Request,Dërgo Kërkesën për Pagesë
 DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.","Specifikoni operacionet, koston operative dhe të japë një operacion i veçantë nuk ka për operacionet tuaja."
+DocType: Water Analysis,Origin,origjinë
 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}?,Ky dokument është mbi kufirin nga {0} {1} për pika {4}. A jeni duke bërë një tjetër {3} kundër të njëjtit {2}?
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1006,Please set recurring after saving,Ju lutemi të vendosur përsëritur pas kursimit
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +758,Select change amount account,Llogaria Shuma Zgjidh ndryshim
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1086,Please set recurring after saving,Ju lutemi të vendosur përsëritur pas kursimit
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +763,Select change amount account,Llogaria Shuma Zgjidh ndryshim
 DocType: Purchase Invoice,Price List Currency,Lista e Çmimeve Valuta
 DocType: Naming Series,User must always select,Përdoruesi duhet të zgjidhni gjithmonë
 DocType: Stock Settings,Allow Negative Stock,Lejo Negativ Stock
 DocType: Installation Note,Installation Note,Instalimi Shënim
+DocType: Soil Texture,Clay,Argjila
 DocType: Topic,Topic,temë
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +40,Cash Flow from Financing,Cash Flow nga Financimi
 DocType: Budget Account,Budget Account,Llogaria buxheti
@@ -2552,34 +2731,38 @@
 DocType: Grading Scale Interval,Grade Description,Grade Përshkrimi
 DocType: Stock Entry,Purchase Receipt No,Pranimi Blerje Asnjë
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Earnest Money,Kaparosje
-DocType: Process Payroll,Create Salary Slip,Krijo Kuponi pagave
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,Gjurmimi
+DocType: Asset Maintenance Log,Actions performed,Veprimet e kryera
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137,Source of Funds (Liabilities),Burimi i Fondeve (obligimeve) të papaguara
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +381,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Sasia në rresht {0} ({1}) duhet të jetë e njëjtë me sasinë e prodhuar {2}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +406,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Sasia në rresht {0} ({1}) duhet të jetë e njëjtë me sasinë e prodhuar {2}
 DocType: Supplier Scorecard Scoring Standing,Employee,Punonjës
+DocType: Asset Repair,Failure Date,Data e dështimit
 DocType: Sample Collection,Collected Time,Koha e mbledhur
 DocType: Company,Sales Monthly History,Historia mujore e shitjeve
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +204,Select Batch,Zgjidh Batch
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244,{0} {1} is fully billed,{0} {1} është faturuar plotësisht
+DocType: Asset Maintenance Task,Next Due Date,Data e ardhshme e afatit
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214,Select Batch,Zgjidh Batch
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +242,{0} {1} is fully billed,{0} {1} është faturuar plotësisht
 apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +48,Vital Signs,Shenja jete
 DocType: Training Event,End Time,Fundi Koha
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,Active Salary Structure {0} found for employee {1} for the given dates,Paga Struktura Active {0} gjetur për punonjës {1} për të dhënë datat
 DocType: Payment Entry,Payment Deductions or Loss,Zbritjet e pagesës ose Loss
+DocType: Soil Analysis,Soil Analysis Criterias,Kriteret e Analizës së Tokës
 apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Kushtet e kontratës standarde për shitje ose blerje.
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +100,Group by Voucher,Grupi nga Bonon
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +186,Are you sure you want to cancel this appointment?,Je i sigurt që dëshiron ta anulosh këtë takim?
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +195,Are you sure you want to cancel this appointment?,Je i sigurt që dëshiron ta anulosh këtë takim?
 apps/erpnext/erpnext/config/crm.py +6,Sales Pipeline,Sales tubacionit
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +216,Please set default account in Salary Component {0},Ju lutemi të vendosur llogarinë e paracaktuar në Paga Komponentin {0}
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201,Please set default account in Salary Component {0},Ju lutemi të vendosur llogarinë e paracaktuar në Paga Komponentin {0}
 apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Kerkohet Në
 DocType: Rename Tool,File to Rename,Paraqesë për Rename
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200,Please select BOM for Item in Row {0},"Ju lutem, përzgjidhni bom për Item në rresht {0}"
 apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28,Account {0} does not match with Company {1} in Mode of Account: {2},Llogaria {0} nuk përputhet me Kompaninë {1} në Mode e Llogarisë: {2}
-apps/erpnext/erpnext/controllers/buying_controller.py +270,Specified BOM {0} does not exist for Item {1},Specifikuar BOM {0} nuk ekziston për Item {1}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +221,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Mirëmbajtja Orari {0} duhet të anulohet para se anulimi këtë Radhit Sales
+apps/erpnext/erpnext/controllers/buying_controller.py +271,Specified BOM {0} does not exist for Item {1},Specifikuar BOM {0} nuk ekziston për Item {1}
+DocType: Soil Texture,Sandy Loam,Loam Sandy
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Mirëmbajtja Orari {0} duhet të anulohet para se anulimi këtë Radhit Sales
 DocType: POS Profile,Applicable for Users,E aplikueshme për përdoruesit
 DocType: Notification Control,Expense Claim Approved,Shpenzim Kërkesa Miratuar
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +321,Salary Slip of employee {0} already created for this period,Slip Paga e punonjësit të {0} krijuar tashmë për këtë periudhë
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +151,Pharmaceutical,Farmaceutike
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155,Pharmaceutical,Farmaceutike
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,Kostoja e artikujve të blerë
 DocType: Selling Settings,Sales Order Required,Sales Rendit kërkuar
 DocType: Purchase Invoice,Credit To,Kredia për
@@ -2589,77 +2772,77 @@
 DocType: Supplier Scorecard,Warn for new Purchase Orders,Paralajmëroni për Urdhërat e reja të Blerjes
 DocType: Quality Inspection Reading,Reading 9,Leximi 9
 DocType: Supplier,Is Frozen,Është ngrira
-apps/erpnext/erpnext/stock/utils.py +217,Group node warehouse is not allowed to select for transactions,depo nyje Group nuk është e lejuar për të zgjedhur për transaksionet
+apps/erpnext/erpnext/stock/utils.py +222,Group node warehouse is not allowed to select for transactions,depo nyje Group nuk është e lejuar për të zgjedhur për transaksionet
 DocType: Buying Settings,Buying Settings,Blerja Cilësimet
 DocType: Stock Entry Detail,BOM No. for a Finished Good Item,BOM Jo për një artikull përfundoi mirë
 DocType: Upload Attendance,Attendance To Date,Pjesëmarrja në datën
 DocType: Request for Quotation Supplier,No Quote,Asnjë citim
 DocType: Warranty Claim,Raised By,Ngritur nga
 DocType: Payment Gateway Account,Payment Account,Llogaria e pagesës
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +880,Please specify Company to proceed,Ju lutemi specifikoni kompanisë për të vazhduar
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +906,Please specify Company to proceed,Ju lutemi specifikoni kompanisë për të vazhduar
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +22,Net Change in Accounts Receivable,Ndryshimi neto në llogarive të arkëtueshme
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +84,Compensatory Off,Kompensues Off
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88,Compensatory Off,Kompensues Off
 DocType: Offer Letter,Accepted,Pranuar
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +25,Organization,organizatë
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +25,Organization,organizatë
+DocType: Grant Application,Organization,organizatë
+DocType: Grant Application,Organization,organizatë
 DocType: BOM Update Tool,BOM Update Tool,BOM Update Tool
-apps/erpnext/erpnext/accounts/party.py +204,"Party account not specified, please setup default party account in company","Llogaria e partisë nuk është e specifikuar, ju lutemi konfiguroni llogarinë e parazgjedhur të partisë në kompani"
 DocType: SG Creation Tool Course,Student Group Name,Emri Group Student
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Krijimi i Tarifave
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Krijimi i Tarifave
 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.,Ju lutem sigurohuni që ju me të vërtetë dëshironi të fshini të gjitha transaksionet për këtë kompani. Të dhënat tuaja mjeshtër do të mbetet ashtu siç është. Ky veprim nuk mund të zhbëhet.
 DocType: Room,Room Number,Numri Room
 apps/erpnext/erpnext/utilities/transaction_base.py +96,Invalid reference {0} {1},Referenca e pavlefshme {0} {1}
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +167,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) nuk mund të jetë më i madh se quanitity planifikuar ({2}) në Prodhimi i rendit {3}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +187,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) nuk mund të jetë më i madh se quanitity planifikuar ({2}) në Prodhimi i rendit {3}
 DocType: Shipping Rule,Shipping Rule Label,Rregulla Transporti Label
+DocType: Journal Entry Account,Payroll Entry,Hyrja në listën e pagave
 apps/erpnext/erpnext/public/js/conf.js +28,User Forum,Forumi User
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +305,Raw Materials cannot be blank.,Lëndëve të para nuk mund të jetë bosh.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +488,"Could not update stock, invoice contains drop shipping item.","Nuk mund të rinovuar aksioneve, fatura përmban anijeve rënie artikull."
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +308,Raw Materials cannot be blank.,Lëndëve të para nuk mund të jetë bosh.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +492,"Could not update stock, invoice contains drop shipping item.","Nuk mund të rinovuar aksioneve, fatura përmban anijeve rënie artikull."
 DocType: Lab Test Sample,Lab Test Sample,Shembulli i testit të laboratorit
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +484,Quick Journal Entry,Quick Journal Hyrja
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +492,Quick Journal Entry,Quick Journal Hyrja
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200,You can not change rate if BOM mentioned agianst any item,Ju nuk mund të ndryshoni normës nëse bom përmendur agianst çdo send
 DocType: Restaurant,Invoice Series Prefix,Prefiksi i Serisë së Faturës
 DocType: Employee,Previous Work Experience,Përvoja e mëparshme e punës
 DocType: Stock Entry,For Quantity,Për Sasia
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205,Please enter Planned Qty for Item {0} at row {1},Ju lutem shkruani e planifikuar Qty për Item {0} në rresht {1}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241,{0} {1} is not submitted,{0} {1} nuk është dorëzuar
-apps/erpnext/erpnext/config/stock.py +27,Requests for items.,Kërkesat për sendet.
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +102,Google Maps integration is not enabled,Integrimi i Google Maps nuk është i aktivizuar
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +239,{0} {1} is not submitted,{0} {1} nuk është dorëzuar
 DocType: Production Planning Tool,Separate production order will be created for each finished good item.,Mënyrë e veçantë prodhimi do të krijohen për secilin artikull përfunduar mirë.
+DocType: Member,Membership Expiry Date,Data e skadimit të anëtarësisë
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +127,{0} must be negative in return document,{0} duhet të jetë negative në dokumentin e kthimit
 ,Minutes to First Response for Issues,Minuta për Përgjigje e parë për Çështje
 DocType: Purchase Invoice,Terms and Conditions1,Termat dhe Conditions1
-apps/erpnext/erpnext/public/js/setup_wizard.js +106,The name of the institute for which you are setting up this system.,Emri i institutit për të cilat ju jeni të vendosur deri këtë sistem.
+apps/erpnext/erpnext/public/js/setup_wizard.js +109,The name of the institute for which you are setting up this system.,Emri i institutit për të cilat ju jeni të vendosur deri këtë sistem.
 DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Rregjistrimi kontabël ngrirë deri në këtë datë, askush nuk mund të bëjë / modifikoj hyrjen përveç rolit të specifikuar më poshtë."
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116,Please save the document before generating maintenance schedule,Ju lutemi ruani dokumentin para se të gjeneruar orar të mirëmbajtjes
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30,Latest price updated in all BOMs,Çmimi i fundit i përditësuar në të gjitha BOM
-DocType: Fee Schedule,Successful,E suksesshme
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,Statusi i Projektit
 DocType: UOM,Check this to disallow fractions. (for Nos),Kontrolloni këtë për të moslejuar fraksionet. (Për Nos)
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +423,The following Production Orders were created:,janë krijuar Urdhërat e mëposhtme prodhimit:
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +424,The following Production Orders were created:,janë krijuar Urdhërat e mëposhtme prodhimit:
 DocType: Student Admission Program,Naming Series (for Student Applicant),Emërtimi Series (për Student Aplikantit)
 DocType: Delivery Note,Transporter Name,Transporter Emri
 DocType: Authorization Rule,Authorized Value,Vlera e autorizuar
 DocType: BOM,Show Operations,Shfaq Operacionet
 ,Minutes to First Response for Opportunity,Minuta për Përgjigje e parë për Opportunity
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Absent,Gjithsej Mungon
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +794,Item or Warehouse for row {0} does not match Material Request,Item ose Magazina për rresht {0} nuk përputhet Materiale Kërkesë
-apps/erpnext/erpnext/config/stock.py +194,Unit of Measure,Njësia e Masës
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +823,Item or Warehouse for row {0} does not match Material Request,Item ose Magazina për rresht {0} nuk përputhet Materiale Kërkesë
+apps/erpnext/erpnext/config/stock.py +187,Unit of Measure,Njësia e Masës
 DocType: Fiscal Year,Year End Date,Viti End Date
 DocType: Task Depends On,Task Depends On,Detyra varet
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +999,Opportunity,Mundësi
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1024,Opportunity,Mundësi
 ,Completed Production Orders,Urdhërat përfunduar prodhimit
 DocType: Operation,Default Workstation,Gabim Workstation
 DocType: Notification Control,Expense Claim Approved Message,Shpenzim Kërkesa Miratuar mesazh
 DocType: Payment Entry,Deductions or Loss,Zbritjet apo Humbje
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +247,{0} {1} is closed,{0} {1} është i mbyllur
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +245,{0} {1} is closed,{0} {1} është i mbyllur
 DocType: Email Digest,How frequently?,Sa shpesh?
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.js +57,Total Collected: {0},Totali i mbledhur: {0}
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +58,Total Collected: {0},Totali i mbledhur: {0}
 DocType: Purchase Receipt,Get Current Stock,Get Stock aktual
 apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,Pema e Bill e materialeve
 DocType: Student,Joining Date,Bashkimi me Date
 ,Employees working on a holiday,Punonjës që punojnë në një festë
 apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,Mark pranishëm
 DocType: Project,% Complete Method,% Complete Metoda
-apps/erpnext/erpnext/healthcare/setup.py +180,Drug,drogë
+apps/erpnext/erpnext/healthcare/setup.py +181,Drug,drogë
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200,Maintenance start date can not be before delivery date for Serial No {0},Data e fillimit të mirëmbajtjes nuk mund të jetë para datës së dorëzimit për Serial Nr {0}
 DocType: Production Order,Actual End Date,Aktuale End Date
 DocType: BOM,Operating Cost (Company Currency),Kosto Operative (Company Valuta)
@@ -2667,12 +2850,12 @@
 DocType: Authorization Rule,Applicable To (Role),Për të zbatueshme (Roli)
 DocType: BOM Update Tool,Replace BOM,Replace BOM
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110,Code {0} already exist,Kodi {0} tashmë ekziston
-DocType: Stock Entry,Purpose,Qëllim
+DocType: Employee Advance,Purpose,Qëllim
 DocType: Company,Fixed Asset Depreciation Settings,Fixed Asset Settings zhvlerësimit
 DocType: Item,Will also apply for variants unless overrridden,Gjithashtu do të aplikojë për variantet nëse overrridden
 DocType: Purchase Invoice,Advances,Përparimet
 DocType: Production Order,Manufacture against Material Request,Prodhimi kundër kërkesës materiale
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +10,Assessment Group: ,Grupi i Vlerësimit:
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +10,Assessment Group: ,Grupi i Vlerësimit:
 DocType: Item Reorder,Request for,Kërkesë për
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,Miratimi përdoruesin nuk mund të jetë i njëjtë si përdorues rregulli është i zbatueshëm për
 DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Norma bazë (sipas Stock UOM)
@@ -2680,24 +2863,27 @@
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +245,Leave Without Pay does not match with approved Leave Application records,Dërgo Pa Paguhet nuk përputhet me të dhënat Leave Aplikimi miratuara
 DocType: Campaign,Campaign-.####,Fushata -. ####
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Hapat e ardhshëm
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +769,Please supply the specified items at the best possible rates,Ju lutemi të furnizimit me artikuj të specifikuara në normat më të mirë të mundshme
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +794,Please supply the specified items at the best possible rates,Ju lutemi të furnizimit me artikuj të specifikuara në normat më të mirë të mundshme
+DocType: Membership,USD,USD
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Make Invoice,Bëni Faturë
 DocType: Selling Settings,Auto close Opportunity after 15 days,Auto Opportunity afër pas 15 ditësh
-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}.,Urdhërat e blerjes nuk janë të lejuara për {0} për shkak të një pozicioni të rezultateve të {1}.
+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}.,Urdhërat e blerjes nuk janë të lejuara për {0} për shkak të një pozicioni të rezultateve të {1}.
 apps/erpnext/erpnext/public/js/financial_statements.js +83,End Year,Fundi Viti
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Quot /% Lead
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Quot /% Lead
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +119,Contract End Date must be greater than Date of Joining,Kontrata Data e përfundimit duhet të jetë më i madh se data e bashkimit
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +124,Contract End Date must be greater than Date of Joining,Kontrata Data e përfundimit duhet të jetë më i madh se data e bashkimit
+DocType: Driver,Driver,shofer
 DocType: Vital Signs,Nutrition Values,Vlerat e të ushqyerit
 DocType: Lab Test Template,Is billable,Është e pagueshme
 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}",Të dyja &quot;Orari i Mjekut&quot; dhe Koha për Emërim &quot;duhet të vendosen për Dr {0}
 DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,Një shpërndarës i palës së tretë / tregtari / komision agjent / degë / reseller që shet produkte kompani për një komision.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +376,{0} against Purchase Order {1},{0} kundër Rendit Blerje {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +374,{0} against Purchase Order {1},{0} kundër Rendit Blerje {1}
 DocType: Patient,Patient Demographics,Demografia e pacientëve
 DocType: Task,Actual Start Date (via Time Sheet),Aktuale Start Date (via Koha Sheet)
 apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15,This is an example website auto-generated from ERPNext,Kjo është një website shembull auto-generated nga ERPNext
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +37,Ageing Range 1,Gama plakjen 1
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +226,Total advance amount cannot be greater than total claimed amount,Shuma totale e paradhënies nuk mund të jetë më e madhe se shuma totale e kërkuar
 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
@@ -2721,22 +2907,26 @@
 10. Add or Deduct: Whether you want to add or deduct the tax.","Template Standard taksave që mund të aplikohet për të gjitha transaksionet e blerjes. Kjo template mund të përmbajë listë të krerëve të taksave si dhe kokat e tjera të shpenzimeve, si &quot;tregtar&quot;, &quot;Sigurimi&quot;, &quot;Trajtimi&quot; etj #### Shënim norma e tatimit që ju të përcaktuar këtu do të jetë norma standarde e taksave për të gjitha ** Items * *. Nëse ka Items ** ** që kanë norma të ndryshme, ato duhet të shtohet në ** Item Tatimit ** Tabela në ** Item ** zotit. #### Përshkrimi i Shtyllave 1. Llogaritja Type: - Kjo mund të jetë në ** neto totale ** (që është shuma e shumës bazë). - ** Në rreshtit të mëparshëm totalit / Shuma ** (për taksat ose tarifat kumulative). Në qoftë se ju zgjidhni këtë opsion, tatimi do të aplikohet si një përqindje e rreshtit të mëparshëm (në tabelën e taksave) shumën apo total. - ** ** Aktuale (siç u përmend). 2. Llogaria Udhëheqës: Libri Llogaria nën të cilat kjo taksë do të jetë e rezervuar 3. Qendra Kosto: Nëse tatimi i / Akuza është një ardhura (si anijet) ose shpenzime ajo duhet të jetë e rezervuar ndaj Qendrës kosto. 4. Përshkrimi: Përshkrimi i tatimit (që do të shtypen në faturat / thonjëza). 5. Rate: Shkalla tatimore. 6. Shuma: Shuma Tatimore. 7. Gjithsej: totale kumulative në këtë pikë. 8. Shkruani Row: Nëse në bazë të &quot;rreshtit të mëparshëm Total&quot; ju mund të zgjidhni numrin e rreshtit të cilat do të merren si bazë për këtë llogaritje (default është rreshtit të mëparshëm). 9. Konsideroni tatim apo detyrim per: Në këtë seksion ju mund të specifikoni nëse taksa / çmimi është vetëm për vlerësimin (jo një pjesë e totalit) apo vetëm për totalin (nuk shtojnë vlerën e sendit), ose për të dyja. 10. Add ose Zbres: Nëse ju dëshironi të shtoni ose të zbres tatimin."
 DocType: Homepage,Homepage,Faqe Hyrëse
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +71,Select Physician...,Zgjidh mjekun ...
+DocType: Grant Application,Grant Application Details ,Detajet e Aplikimit të Grantit
 DocType: Purchase Receipt Item,Recd Quantity,Recd Sasia
-apps/erpnext/erpnext/schools/doctype/program_enrollment/program_enrollment.py +57,Fee Records Created - {0},Records tarifë Krijuar - {0}
+apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +59,Fee Records Created - {0},Records tarifë Krijuar - {0}
 DocType: Asset Category Account,Asset Category Account,Asset Kategoria Llogaria
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +117,Cannot produce more Item {0} than Sales Order quantity {1},Nuk mund të prodhojë më shumë Item {0} se sasia Sales Rendit {1}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +539,Stock Entry {0} is not submitted,Stock Hyrja {0} nuk është dorëzuar
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +137,Cannot produce more Item {0} than Sales Order quantity {1},Nuk mund të prodhojë më shumë Item {0} se sasia Sales Rendit {1}
+apps/erpnext/erpnext/stock/doctype/item/item.js +360,Select Attribute Values,Zgjidhni vlerat e atributeve
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +537,Stock Entry {0} is not submitted,Stock Hyrja {0} nuk është dorëzuar
 DocType: Payment Reconciliation,Bank / Cash Account,Llogarisë Bankare / Cash
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +44,Next Contact By cannot be same as the Lead Email Address,Next kontaktoni me nuk mund të jetë i njëjtë si adresë Lead Email
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +45,Next Contact By cannot be same as the Lead Email Address,Next kontaktoni me nuk mund të jetë i njëjtë si adresë Lead Email
 DocType: Tax Rule,Billing City,Faturimi i qytetit
 DocType: Asset,Manual,udhëzues
 DocType: Salary Component Account,Salary Component Account,Llogaria Paga Komponenti
 DocType: Global Defaults,Hide Currency Symbol,Fshih Valuta size
-apps/erpnext/erpnext/config/accounts.py +338,"e.g. Bank, Cash, Credit Card","psh Banka, Cash, Credit Card"
+apps/erpnext/erpnext/config/non_profit.py +58,Donor information.,Informacioni i donatorëve.
+apps/erpnext/erpnext/config/accounts.py +330,"e.g. Bank, Cash, Credit Card","psh Banka, Cash, Credit Card"
 DocType: Lead Source,Source Name,burimi Emri
 DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Tensioni normal i pushimit të gjakut në një të rritur është afërsisht 120 mmHg systolic, dhe 80 mmHg diastolic, shkurtuar &quot;120/80 mmHg&quot;"
 DocType: Journal Entry,Credit Note,Credit Shënim
 DocType: Warranty Claim,Service Address,Shërbimi Adresa
+DocType: Asset Maintenance Task,Calibration,kalibrim
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49,Furnitures and Fixtures,Furnitures dhe Regjistrimet
 DocType: Item,Manufacture,Prodhim
 apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Company,Kompani e konfigurimit
@@ -2748,8 +2938,9 @@
 DocType: Opportunity,Customer / Lead Name,Customer / Emri Lead
 apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +99,Clearance Date not mentioned,Pastrimi Data nuk përmendet
 apps/erpnext/erpnext/config/manufacturing.py +7,Production,Prodhim
-DocType: Patient,Occupation,profesion
+DocType: Guardian,Occupation,profesion
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74,Row {0}:Start Date must be before End Date,Row {0}: Filloni Data duhet të jetë përpara End Date
+DocType: Crop,Planting Area,Sipërfaqja e mbjelljes
 apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),Gjithsej (Qty)
 DocType: Installation Note Item,Installed Qty,Instaluar Qty
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4,This could be because of some invalid Email Addresses in the,Kjo mund të jetë për shkak të disa adresave të pavlefshme të
@@ -2759,26 +2950,26 @@
 DocType: Purchase Invoice,Is Paid,është Paid
 DocType: Salary Structure,Total Earning,Fituar Total
 DocType: Purchase Receipt,Time at which materials were received,Koha në të cilën janë pranuar materialet e
+DocType: Products Settings,Products per Page,Produktet per
 DocType: Stock Ledger Entry,Outgoing Rate,Largohet Rate
-apps/erpnext/erpnext/config/hr.py +228,Organization branch master.,Mjeshtër degë organizatë.
-apps/erpnext/erpnext/controllers/accounts_controller.py +280, or ,ose
+apps/erpnext/erpnext/config/hr.py +233,Organization branch master.,Mjeshtër degë organizatë.
+apps/erpnext/erpnext/controllers/accounts_controller.py +303, or ,ose
 DocType: Sales Order,Billing Status,Faturimi Statusi
 apps/erpnext/erpnext/public/js/conf.js +32,Report an Issue,Raportoni një çështje
-apps/erpnext/erpnext/public/js/setup_wizard.js +28,Education (beta),Edukimi (beta)
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,Utility Expenses,Shpenzimet komunale
 apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64,90-Above,90-Mbi
 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,Row # {0}: Ditari Hyrja {1} nuk ka llogari {2} ose tashmë krahasohen kundër një kupon
 DocType: Supplier Scorecard Criteria,Criteria Weight,Pesha e kritereve
 DocType: Buying Settings,Default Buying Price List,E albumit Lista Blerja Çmimi
-DocType: Process Payroll,Salary Slip Based on Timesheet,Slip Paga Bazuar në pasqyrë e mungesave
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +113,No employee for the above selected criteria OR salary slip already created,Nuk ka punonjës me kriteret e zgjedhura sipër apo rrogës pip krijuar tashmë
+DocType: Payroll Entry,Salary Slip Based on Timesheet,Slip Paga Bazuar në pasqyrë e mungesave
+apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +19,Buying Rate,Shkalla e Blerjes
 DocType: Notification Control,Sales Order Message,Sales Rendit Mesazh
 apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Set Vlerat Default si Company, Valuta, vitin aktual fiskal, etj"
 DocType: Payment Entry,Payment Type,Lloji Pagesa
-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,"Ju lutem, përzgjidhni një grumbull për pika {0}. Në pamundësi për të gjetur një grumbull të vetme që përmbush këtë kërkesë"
-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,"Ju lutem, përzgjidhni një grumbull për pika {0}. Në pamundësi për të gjetur një grumbull të vetme që përmbush këtë kërkesë"
+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,"Ju lutem, përzgjidhni një grumbull për pika {0}. Në pamundësi për të gjetur një grumbull të vetme që përmbush këtë kërkesë"
+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,"Ju lutem, përzgjidhni një grumbull për pika {0}. Në pamundësi për të gjetur një grumbull të vetme që përmbush këtë kërkesë"
 DocType: Hub Category,Parent Category,Kategoria e prindërve
-DocType: Process Payroll,Select Employees,Zgjidhni Punonjësit
+DocType: Payroll Entry,Select Employees,Zgjidhni Punonjësit
 DocType: Opportunity,Potential Sales Deal,Shitjet e mundshme marrëveshjen
 DocType: Complaint,Complaints,Ankese
 DocType: Payment Entry,Cheque/Reference Date,Çek / Reference Data
@@ -2787,7 +2978,7 @@
 DocType: Bank Reconciliation Detail,Payment Entry,pagesa Hyrja
 DocType: Item,Quality Parameters,Parametrave të cilësisë
 ,sales-browser,Shitjet-browser
-apps/erpnext/erpnext/accounts/doctype/account/account.js +73,Ledger,Libër i llogarive
+apps/erpnext/erpnext/accounts/doctype/account/account.js +79,Ledger,Libër i llogarive
 DocType: Patient Medical Record,PMR-,PMR-
 DocType: Drug Prescription,Drug Code,Kodi i drogës
 DocType: Target Detail,Target  Amount,Target Shuma
@@ -2795,12 +2986,12 @@
 DocType: Shopping Cart Settings,Shopping Cart Settings,Cilësimet Shporta
 DocType: Journal Entry,Accounting Entries,Entries Kontabilitetit
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},Duplicate Hyrja. Ju lutem kontrolloni Autorizimi Rregulla {0}
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +29,Global POS Profile {0} already created for company {1},Global POS Profilin {0} krijuar tashmë për kompaninë {1}
+DocType: Journal Entry Account,Reference Due Date,Data e duhur e referimit
 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,Dokumenti Pranimi duhet të dorëzohet
 DocType: Purchase Invoice Item,Received Qty,Marrë Qty
 DocType: Stock Entry Detail,Serial No / Batch,Serial No / Batch
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +320,Not Paid and Not Delivered,Nuk është paguar dhe nuk dorëzohet
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340,Not Paid and Not Delivered,Nuk është paguar dhe nuk dorëzohet
 DocType: Product Bundle,Parent Item,Item prind
 DocType: Account,Account Type,Lloji i Llogarisë
 DocType: Delivery Note,DN-RET-,DN-RET-
@@ -2809,33 +3000,36 @@
 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',Mirëmbajtja Orari nuk është krijuar për të gjitha sendet. Ju lutem klikoni në &quot;Generate Listën &#39;
 ,To Produce,Për të prodhuar
 apps/erpnext/erpnext/config/hr.py +93,Payroll,Payroll
-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","Për rresht {0} në {1}. Të përfshijnë {2} në shkallën Item, {3} duhet të përfshihen edhe rreshtave"
+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","Për rresht {0} në {1}. Të përfshijnë {2} në shkallën Item, {3} duhet të përfshihen edhe rreshtave"
 apps/erpnext/erpnext/utilities/activation.py +101,Make User,bëni përdoruesin
 DocType: Packing Slip,Identification of the package for the delivery (for print),Identifikimi i paketës për shpërndarjen (për shtyp)
 DocType: Bin,Reserved Quantity,Sasia e rezervuara
 apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,Ju lutemi shkruani adresën vlefshme email
 apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,Ju lutemi shkruani adresën vlefshme email
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +654,Please select an item in the cart,Ju lutemi zgjidhni një artikull në karrocë
+DocType: Volunteer Skill,Volunteer Skill,Aftësi vullnetare
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +713,Please select an item in the cart,Ju lutemi zgjidhni një artikull në karrocë
 DocType: Landed Cost Voucher,Purchase Receipt Items,Items Receipt Blerje
 apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,Format customizing
-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,Zhvlerësimi Shuma gjatë periudhës
+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,Zhvlerësimi Shuma gjatë periudhës
 apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +38,Disabled template must not be default template,template me aftësi të kufizuara nuk duhet të jetë template parazgjedhur
 DocType: Account,Income Account,Llogaria ardhurat
 DocType: Payment Request,Amount in customer's currency,Shuma në monedhë të klientit
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +776,Delivery,Ofrimit të
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +823,Delivery,Ofrimit të
+DocType: Volunteer,Weekdays,gjatë ditëve të javës
 DocType: Stock Reconciliation Item,Current Qty,Qty tanishme
 DocType: Restaurant Menu,Restaurant Menu,Menuja e Restorantit
 apps/erpnext/erpnext/templates/generators/item_group.html +36,Prev,prev
 DocType: Appraisal Goal,Key Responsibility Area,Key Zona Përgjegjësia
 apps/erpnext/erpnext/utilities/activation.py +127,"Student Batches help you track attendance, assessments and fees for students","Mallrat e studentëve të ju ndihmojë të gjetur frekuentimit, vlerësimet dhe tarifat për studentët"
 DocType: Payment Entry,Total Allocated Amount,Shuma totale e alokuar
-apps/erpnext/erpnext/setup/doctype/company/company.py +143,Set default inventory account for perpetual inventory,Bëje llogari inventarit parazgjedhur për inventarit të përhershëm
+apps/erpnext/erpnext/setup/doctype/company/company.py +140,Set default inventory account for perpetual inventory,Bëje llogari inventarit parazgjedhur për inventarit të përhershëm
 DocType: Item Reorder,Material Request Type,Material Type Kërkesë
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +268,Accural Journal Entry for salaries from {0} to {1},Accural Gazeta hyrjes pagave nga {0} në {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +824,"LocalStorage is full, did not save","LocalStorage është e plotë, nuk ka shpëtuar"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +85,Row {0}: UOM Conversion Factor is mandatory,Row {0}: UOM Konvertimi Faktori është i detyrueshëm
-apps/erpnext/erpnext/utilities/user_progress.py +214,Room Capacity,Kapaciteti i dhomës
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252,Accural Journal Entry for salaries from {0} to {1},Accural Gazeta hyrjes pagave nga {0} në {1}
+apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17,Send Grant Review Email,Dërgo Grant Rishikimi Email
+apps/erpnext/erpnext/accounts/page/pos/pos.js +839,"LocalStorage is full, did not save","LocalStorage është e plotë, nuk ka shpëtuar"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +90,Row {0}: UOM Conversion Factor is mandatory,Row {0}: UOM Konvertimi Faktori është i detyrueshëm
+apps/erpnext/erpnext/utilities/user_progress.py +232,Room Capacity,Kapaciteti i dhomës
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +14,Ref,Ref
 DocType: Lab Test,LP-,LP-
 DocType: Healthcare Settings,Registration Fee,Taksa e regjistrimit
@@ -2849,16 +3043,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.","Rregulla e Çmimeve është bërë për të prishësh LISTA E ÇMIMEVE / definojnë përqindje zbritje, në bazë të disa kritereve."
 DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Magazina mund të ndryshohet vetëm përmes Stock Hyrja / dorëzimit Shënim / Pranimi Blerje
 DocType: Employee Education,Class / Percentage,Klasa / Përqindja
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +130,Head of Marketing and Sales,Shef i Marketingut dhe Shitjes
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +68,Income Tax,Tatimi mbi të ardhurat
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134,Head of Marketing and Sales,Shef i Marketingut dhe Shitjes
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72,Income Tax,Tatimi mbi të ardhurat
 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.","Nëse Rregulla zgjedhur Çmimeve është bërë për &#39;Çmimi&#39;, ajo do të prishësh listën e çmimeve. Çmimi Rregulla e Çmimeve është çmimi përfundimtar, kështu që nuk ka zbritje të mëtejshme duhet të zbatohet. Për këtë arsye, në transaksione si Sales Rendit, Rendit Blerje etj, ajo do të sjellë në fushën e &#39;norma&#39;, në vend se të fushës &quot;listën e çmimeve normë &#39;."
 apps/erpnext/erpnext/config/selling.py +174,Track Leads by Industry Type.,Track kryeson nga Industrisë Type.
+apps/erpnext/erpnext/utilities/user_progress.py +98,Go to Letterheads,Shkoni te Letrat me Letër
 DocType: Item Supplier,Item Supplier,Item Furnizuesi
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1107,Please enter Item Code to get batch no,Ju lutemi shkruani Kodin artikull për të marrë grumbull asnjë
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +827,Please select a value for {0} quotation_to {1},"Ju lutem, përzgjidhni një vlerë për {0} quotation_to {1}"
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1187,Please enter Item Code to get batch no,Ju lutemi shkruani Kodin artikull për të marrë grumbull asnjë
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +874,Please select a value for {0} quotation_to {1},"Ju lutem, përzgjidhni një vlerë për {0} quotation_to {1}"
 apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Të gjitha adresat.
 DocType: Company,Stock Settings,Stock Cilësimet
-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","Shkrirja është e mundur vetëm nëse prona e mëposhtme janë të njëjta në të dy regjistrat. Është Grupi, Root Type, Kompania"
+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","Shkrirja është e mundur vetëm nëse prona e mëposhtme janë të njëjta në të dy regjistrat. Është Grupi, Root Type, Kompania"
 DocType: Vehicle,Electric,elektrik
 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,Gain / Humbja në hedhjen e Aseteve
@@ -2871,10 +3066,11 @@
 DocType: Leave Control Panel,Leave Control Panel,Lini Control Panel
 DocType: Project,Task Completion,Task Përfundimi
 apps/erpnext/erpnext/templates/includes/product_page.js +21,Not in Stock,Jo në magazinë
+DocType: Volunteer,Volunteer Skills,Aftësitë vullnetare
 DocType: Appraisal,HR User,HR User
-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,Taksat dhe Tarifat zbritet
-apps/erpnext/erpnext/hooks.py +138,Issues,Çështjet
+apps/erpnext/erpnext/hooks.py +142,Issues,Çështjet
 apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Statusi duhet të jetë një nga {0}
 DocType: Sales Invoice,Debit To,Debi Për
 DocType: Restaurant Menu Item,Restaurant Menu Item,Menyja e Restorantit
@@ -2882,60 +3078,62 @@
 DocType: Stock Ledger Entry,Actual Qty After Transaction,Qty aktual Pas Transaksionit
 apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +79,No salary slip found between {0} and {1},Nuk ka paga shqip gjetur mes {0} dhe {1}
 ,Pending SO Items For Purchase Request,Në pritje SO artikuj për Kërkesë Blerje
-apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +35,Student Admissions,Pranimet e studentëve
-apps/erpnext/erpnext/accounts/party.py +364,{0} {1} is disabled,{0} {1} është me aftësi të kufizuara
+apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35,Student Admissions,Pranimet e studentëve
+apps/erpnext/erpnext/accounts/party.py +376,{0} {1} is disabled,{0} {1} është me aftësi të kufizuara
 DocType: Supplier,Billing Currency,Faturimi Valuta
 DocType: Sales Invoice,SINV-RET-,SINV-RET-
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +196,Extra Large,Shumë i madh
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200,Extra Large,Shumë i madh
+DocType: Crop,Scientific Name,Emer shkencor
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Leaves,gjithsej Leaves
 DocType: Consultation,In print,Ne printim
 ,Profit and Loss Statement,Fitimi dhe Humbja Deklarata
 DocType: Bank Reconciliation Detail,Cheque Number,Numri çek
 ,Sales Browser,Shitjet Browser
 DocType: Journal Entry,Total Credit,Gjithsej Credit
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542,Warning: Another {0} # {1} exists against stock entry {2},Warning: Një tjetër {0} # {1} ekziston kundër hyrjes aksioneve {2}
-apps/erpnext/erpnext/utilities/user_progress_utils.py +51,Local,Lokal
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +540,Warning: Another {0} # {1} exists against stock entry {2},Warning: Një tjetër {0} # {1} ekziston kundër hyrjes aksioneve {2}
+apps/erpnext/erpnext/utilities/user_progress_utils.py +66,Local,Lokal
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),Kreditë dhe paradhëniet (aktiveve)
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,Debitorët
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +195,Large,I madh
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199,Large,I madh
 DocType: Homepage Featured Product,Homepage Featured Product,Homepage Featured Product
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +236,All Assessment Groups,Të gjitha grupet e vlerësimit
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +246,All Assessment Groups,Të gjitha grupet e vlerësimit
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,New Magazina Emri
 apps/erpnext/erpnext/accounts/report/financial_statements.py +233,Total {0} ({1}),Total {0} ({1})
 DocType: C-Form Invoice Detail,Territory,Territor
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151,Please mention no of visits required,Ju lutemi përmendni i vizitave të kërkuara
 DocType: Stock Settings,Default Valuation Method,Gabim Vlerësimi Metoda
-apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +26,Fee,tarifë
-apps/erpnext/erpnext/setup/doctype/company/company.js +124,Update in progress. It might take a while.,Përditësohet në progres. Mund të duhet një kohë.
+apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26,Fee,tarifë
+apps/erpnext/erpnext/setup/doctype/company/company.js +125,Update in progress. It might take a while.,Përditësohet në progres. Mund të duhet një kohë.
 DocType: Vehicle Log,Fuel Qty,Fuel Qty
 DocType: Production Order Operation,Planned Start Time,Planifikuar Koha e fillimit
 DocType: Course,Assessment,vlerësim
 DocType: Payment Entry Reference,Allocated,Ndarë
-apps/erpnext/erpnext/config/accounts.py +275,Close Balance Sheet and book Profit or Loss.,Mbylle Bilanci dhe Fitimi libër ose humbja.
+apps/erpnext/erpnext/config/accounts.py +267,Close Balance Sheet and book Profit or Loss.,Mbylle Bilanci dhe Fitimi libër ose humbja.
 DocType: Student Applicant,Application Status,aplikimi Status
 DocType: Sensitivity Test Items,Sensitivity Test Items,Artikujt e testimit të ndjeshmërisë
 DocType: Fees,Fees,tarifat
 DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Specifikoni Exchange Rate për të kthyer një monedhë në një tjetër
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +158,Quotation {0} is cancelled,Citat {0} është anuluar
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159,Quotation {0} is cancelled,Citat {0} është anuluar
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Total Outstanding Amount,Shuma totale Outstanding
 DocType: Sales Partner,Targets,Synimet
 DocType: Price List,Price List Master,Lista e Çmimeve Master
 DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,Gjitha Shitjet Transaksionet mund të tagged kundër shumta ** Personat Sales ** në mënyrë që ju mund të vendosni dhe monitoruar objektivat.
 ,S.O. No.,SO Nr
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +199,Please create Customer from Lead {0},Ju lutem të krijuar Customer nga Lead {0}
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241,Please create Customer from Lead {0},Ju lutem të krijuar Customer nga Lead {0}
 apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3,Select Patient,Zgjidh Patient
 DocType: Price List,Applicable for Countries,Të zbatueshme për vendet
 DocType: Supplier Scorecard Scoring Variable,Parameter Name,Emri i parametrit
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Vetëm Dërgo Aplikacione me status &#39;miratuar&#39; dhe &#39;refuzuar&#39; mund të dorëzohet
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +52,Student Group Name is mandatory in row {0},Student Group Emri është i detyrueshëm në rresht {0}
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52,Student Group Name is mandatory in row {0},Student Group Emri është i detyrueshëm në rresht {0}
 DocType: Homepage,Products to be shown on website homepage,Produktet që do të shfaqet në faqen e internetit
 apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13,This is a root customer group and cannot be edited.,Ky është një grup të konsumatorëve rrënjë dhe nuk mund të redaktohen.
-DocType: Employee,AB-,barkut
+DocType: Student,AB-,barkut
 DocType: POS Profile,Ignore Pricing Rule,Ignore Rregulla e Çmimeve
 DocType: Employee Education,Graduate,I diplomuar
 DocType: Leave Block List,Block Days,Ditët Blloku
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83,"Shipping Address does not have country, which is required for this Shipping Rule","Adresa e transportit nuk ka vend, i cili kërkohet për këtë Rregull të Transportit"
 DocType: Journal Entry,Excise Entry,Akciza Hyrja
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +64,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Kujdes: Sales Order {0} ekziston kundër Rendit Blerje Klientit {1}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Kujdes: Sales Order {0} ekziston kundër Rendit Blerje Klientit {1}
 DocType: Terms and Conditions,"Standard Terms and Conditions that can be added to Sales and Purchases.
 
 Examples:
@@ -2949,55 +3147,57 @@
 1. Terms of shipping, if applicable.
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","Termave dhe Kushteve Standarde që mund të shtohet për shitjet dhe blerjet. Shembuj: 1. Vlefshmëria e ofertës. 1. Kushtet e pagesës (më parë, me kredi, paradhënie pjesë etj). 1. Çfarë është shtesë (ose që duhet paguar nga konsumatori). 1. Siguria / përdorimin paralajmërim. 1. Garanci nëse ka ndonjë. 1. Kthim Politikën. 1. Kushtet e anijeve, nëse zbatohen. 1. Mënyrat e adresimit të kontesteve, dëmshpërblim, përgjegjësi, etj 1. Adresa e Kontaktit e kompanisë tuaj."
+DocType: Issue,Issue Type,Lloji i emetimit
 DocType: Attendance,Leave Type,Lini Type
 DocType: Purchase Invoice,Supplier Invoice Details,Furnizuesi Fatura Detajet
+DocType: Agriculture Task,Ignore holidays,Injoroni pushimet
 apps/erpnext/erpnext/controllers/stock_controller.py +233,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Llogari shpenzim / Diferenca ({0}) duhet të jetë një llogari &quot;fitimit ose humbjes &#39;
 DocType: Project,Copied From,kopjuar nga
 DocType: Project,Copied From,kopjuar nga
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96,Name error: {0},Emri error: {0}
 apps/erpnext/erpnext/stock/doctype/item/item_list.js +12,Shortage,mungesa
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,{0} {1} does not associated with {2} {3},{0} {1} nuk lidhet me {2} {3}
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,Attendance for employee {0} is already marked,Pjesëmarrja për punonjës {0} është shënuar tashmë
 DocType: Packing Slip,If more than one package of the same type (for print),Nëse më shumë se një paketë të të njëjtit lloj (për shtyp)
 apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27,Please set default customer in Restaurant Settings,Vendosni klientin e parazgjedhur në Cilësimet e Restorantit
 ,Salary Register,Paga Regjistrohu
 DocType: Warehouse,Parent Warehouse,Magazina Parent
 DocType: C-Form Invoice Detail,Net Total,Net Total
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +498,Default BOM not found for Item {0} and Project {1},Default BOM nuk u gjet për Item {0} dhe Project {1}
-apps/erpnext/erpnext/config/hr.py +163,Define various loan types,Përcaktojnë lloje të ndryshme të kredive
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +526,Default BOM not found for Item {0} and Project {1},Default BOM nuk u gjet për Item {0} dhe Project {1}
+apps/erpnext/erpnext/config/hr.py +168,Define various loan types,Përcaktojnë lloje të ndryshme të kredive
 DocType: Bin,FCFS Rate,FCFS Rate
-DocType: Payment Reconciliation Invoice,Outstanding Amount,Shuma Outstanding
+DocType: Opening Invoice Creation Tool Item,Outstanding Amount,Shuma Outstanding
 apps/erpnext/erpnext/templates/generators/bom.html +71,Time(in mins),Koha (në minuta)
 DocType: Project Task,Working,Punës
 DocType: Stock Ledger Entry,Stock Queue (FIFO),Stock Radhë (FIFO)
-apps/erpnext/erpnext/public/js/setup_wizard.js +124,Financial Year,Viti financiar
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +41,{0} does not belong to Company {1},{0} nuk i përkasin kompanisë {1}
+apps/erpnext/erpnext/public/js/setup_wizard.js +127,Financial Year,Viti financiar
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46,{0} does not belong to Company {1},{0} nuk i përkasin kompanisë {1}
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66,Could not solve criteria score function for {0}. Make sure the formula is valid.,Nuk mund të zgjidhet funksioni i rezultateve të kritereve për {0}. Sigurohuni që formula është e vlefshme.
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +119,Cost as on,Të kushtojë sa më
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122,Cost as on,Të kushtojë sa më
 DocType: Healthcare Settings,Out Patient Settings,Nga cilësimet e pacientit
 DocType: Account,Round Off,Rrumbullohem
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +231,Quantity must be positive,Sasia duhet të jetë pozitive
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +252,Quantity must be positive,Sasia duhet të jetë pozitive
 ,Requested Qty,Kërkohet Qty
 DocType: Tax Rule,Use for Shopping Cart,Përdorni për Shopping Cart
 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},Vlera {0} për atribut {1} nuk ekziston në listën e artikullit vlefshme atribut Vlerat për Item {2}
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +78,Select Serial Numbers,Zgjidh numrat serik
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79,Select Serial Numbers,Zgjidh numrat serik
 DocType: BOM Item,Scrap %,Scrap%
 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","Akuzat do të shpërndahen në mënyrë proporcionale në bazë të Qty pika ose sasi, si për zgjedhjen tuaj"
 DocType: Maintenance Visit,Purposes,Qëllimet
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +111,Atleast one item should be entered with negative quantity in return document,Atleast një artikull duhet të lidhet me sasinë negativ në dokumentin e kthimit
 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","Operacioni {0} gjatë se çdo orë në dispozicion të punës në workstation {1}, prishen operacionin në operacione të shumta"
+DocType: Membership,Membership Status,Statusi i Anëtarësimit
 ,Requested,Kërkuar
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90,No Remarks,Asnjë Vërejtje
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93,No Remarks,Asnjë Vërejtje
+DocType: Asset,In Maintenance,Në Mirëmbajtje
 DocType: Purchase Invoice,Overdue,I vonuar
 DocType: Account,Stock Received But Not Billed,Stock Marrë Por Jo faturuar
-apps/erpnext/erpnext/accounts/doctype/account/account.py +87,Root Account must be a group,Root Llogaria duhet të jetë një grup i
+apps/erpnext/erpnext/accounts/doctype/account/account.py +86,Root Account must be a group,Root Llogaria duhet të jetë një grup i
 DocType: Consultation,Drug Prescription,Prescription e drogës
 DocType: Fees,FEE.,FEE.
 DocType: Employee Loan,Repaid/Closed,Paguhet / Mbyllur
 DocType: Item,Total Projected Qty,Total projektuar Qty
 DocType: Monthly Distribution,Distribution Name,Emri shpërndarja
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Furnizuesi&gt; Lloji i Furnizuesit
-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","Shkalla e vlerësimit nuk është gjetur për Item {0}, e cila kërkohet të bëjë shënime të kontabilitetit për {1} {2}. Nëse artikulli është duke u kryer si një zë zero vlerësimi në {1}, ju lutemi përmendni atë në tabelën {1} Item. Përndryshe, ju lutemi krijoni një transaksion të aksioneve në hyrje për artikullin ose përmendni normën e vlerësimit në regjistrin e artikullit dhe pastaj provoni paraqitjen / anulimin e këtij hyrjes"
+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","Shkalla e vlerësimit nuk është gjetur për Item {0}, e cila kërkohet të bëjë shënime të kontabilitetit për {1} {2}. Nëse artikulli është duke u kryer si një zë zero vlerësimi në {1}, ju lutemi përmendni atë në tabelën {1} Item. Përndryshe, ju lutemi krijoni një transaksion të aksioneve në hyrje për artikullin ose përmendni normën e vlerësimit në regjistrin e artikullit dhe pastaj provoni paraqitjen / anulimin e këtij hyrjes"
 DocType: Course,Course Code,Kodi Kursi
 apps/erpnext/erpnext/controllers/stock_controller.py +331,Quality Inspection required for Item {0},Inspektimi Cilësia e nevojshme për Item {0}
 DocType: POS Settings,Use POS in Offline Mode,Përdorni POS në modalitetin Offline
@@ -3008,20 +3208,20 @@
 apps/erpnext/erpnext/config/selling.py +105,Manage Territory Tree.,Manage Territorit Tree.
 DocType: Journal Entry Account,Sales Invoice,Shitjet Faturë
 DocType: Journal Entry Account,Party Balance,Bilanci i Partisë
-apps/erpnext/erpnext/accounts/page/pos/pos.js +484,Please select Apply Discount On,"Ju lutem, përzgjidhni Aplikoni zbritje në"
+apps/erpnext/erpnext/accounts/page/pos/pos.js +497,Please select Apply Discount On,"Ju lutem, përzgjidhni Aplikoni zbritje në"
+DocType: Stock Settings,Sample Retention Warehouse,Depoja e mbajtjes së mostrës
 DocType: Company,Default Receivable Account,Gabim Llogaria Arkëtueshme
-DocType: Process Payroll,Create Bank Entry for the total salary paid for the above selected criteria,Krijo Banka e hyrjes për pagën totale e paguar për kriteret e përzgjedhura më sipër
 DocType: Physician,Physician Schedule,Orari i mjekut
 DocType: Purchase Invoice,Deemed Export,Shqyrtuar Eksport
 DocType: Stock Entry,Material Transfer for Manufacture,Transferimi materiale për Prodhimin
 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.,Përqindja zbritje mund të aplikohet ose ndaj një listë të çmimeve apo për të gjithë listën e çmimeve.
 DocType: Subscription,Half-yearly,Gjashtëmujor
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +402,Accounting Entry for Stock,Hyrja kontabilitetit për magazinë
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +406,Accounting Entry for Stock,Hyrja kontabilitetit për magazinë
 DocType: Lab Test,LabTest Approver,Aprovuesi i LabTest
-apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.py +49,You have already assessed for the assessment criteria {}.,Ju kanë vlerësuar tashmë me kriteret e vlerësimit {}.
+apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +49,You have already assessed for the assessment criteria {}.,Ju kanë vlerësuar tashmë me kriteret e vlerësimit {}.
 DocType: Vehicle Service,Engine Oil,Vaj makine
 DocType: Sales Invoice,Sales Team1,Shitjet Team1
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +39,Item {0} does not exist,Item {0} nuk ekziston
+apps/erpnext/erpnext/stock/doctype/item/item.py +521,Item {0} does not exist,Item {0} nuk ekziston
 DocType: Sales Invoice,Customer Address,Customer Adresa
 DocType: Employee Loan,Loan Details,kredi Details
 DocType: Company,Default Inventory Account,Llogaria Default Inventar
@@ -3029,6 +3229,7 @@
 DocType: Antibiotic,Antibiotic Name,Emri i Antibiotikut
 DocType: Purchase Invoice,Apply Additional Discount On,Aplikoni shtesë zbritje në
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +69,Select Type...,Zgjidh Type ...
+DocType: Crop Cycle,A link to all the Land Units in which the Crop is growing,Një lidhje me të gjitha Njësitë Tokësore në të cilat Pri rritet
 DocType: Account,Root Type,Root Type
 DocType: Item,FIFO,FIFO
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +132,Row # {0}: Cannot return more than {1} for Item {2},Row # {0}: nuk mund të kthehet më shumë se {1} për Item {2}
@@ -3036,21 +3237,23 @@
 DocType: Item Group,Show this slideshow at the top of the page,Trego këtë slideshow në krye të faqes
 DocType: BOM,Item UOM,Item UOM
 DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Shuma e taksave Pas Shuma ulje (Kompania Valuta)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +150,Target warehouse is mandatory for row {0},Depo objektiv është i detyrueshëm për rresht {0}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +155,Target warehouse is mandatory for row {0},Depo objektiv është i detyrueshëm për rresht {0}
 DocType: Cheque Print Template,Primary Settings,Parametrat kryesore
 DocType: Purchase Invoice,Select Supplier Address,Zgjidh Furnizuesi Adresa
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +380,Add Employees,Shto Punonjës
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397,Add Employees,Shto Punonjës
 DocType: Purchase Invoice Item,Quality Inspection,Cilësia Inspektimi
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +192,Extra Small,Extra Vogla
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196,Extra Small,Extra Vogla
 DocType: Company,Standard Template,Template standard
 DocType: Training Event,Theory,teori
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +780,Warning: Material Requested Qty is less than Minimum Order Qty,Warning: Materiali kërkuar Qty është më pak se minimale Rendit Qty
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +805,Warning: Material Requested Qty is less than Minimum Order Qty,Warning: Materiali kërkuar Qty është më pak se minimale Rendit Qty
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211,Account {0} is frozen,Llogaria {0} është ngrirë
 DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Personit juridik / subsidiare me një tabelë të veçantë e llogarive i përkasin Organizatës.
 DocType: Payment Request,Mute Email,Mute Email
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +29,"Food, Beverage & Tobacco","Ushqim, Pije &amp; Duhani"
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +689,Can only make payment against unbilled {0},Vetëm mund të bëni pagesën kundër pafaturuar {0}
-apps/erpnext/erpnext/controllers/selling_controller.py +130,Commission rate cannot be greater than 100,Shkalla e Komisionit nuk mund të jetë më e madhe se 100
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29,"Food, Beverage & Tobacco","Ushqim, Pije &amp; Duhani"
+DocType: Account,Account Number,Numri i llogarisë
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +714,Can only make payment against unbilled {0},Vetëm mund të bëni pagesën kundër pafaturuar {0}
+apps/erpnext/erpnext/controllers/selling_controller.py +98,Commission rate cannot be greater than 100,Shkalla e Komisionit nuk mund të jetë më e madhe se 100
+DocType: Volunteer,Volunteer,vullnetar
 DocType: Stock Entry,Subcontract,Nënkontratë
 apps/erpnext/erpnext/public/js/utils/party.js +165,Please enter {0} first,Ju lutem shkruani {0} parë
 apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +87,No replies from,Nuk ka përgjigje nga
@@ -3059,61 +3262,69 @@
 DocType: Item,Manufacturer Part Number,Prodhuesi Pjesa Numër
 DocType: Production Order Operation,Estimated Time and Cost,Koha e vlerësuar dhe Kosto
 DocType: Bin,Bin,Bin
+DocType: Crop,Crop Name,Emri i farërave
 DocType: SMS Log,No of Sent SMS,Nr i SMS dërguar
 DocType: Antibiotic,Healthcare Administrator,Administrator i Shëndetësisë
 apps/erpnext/erpnext/utilities/user_progress.py +44,Set a Target,Vendosni një Target
 DocType: Dosage Strength,Dosage Strength,Forca e dozimit
 DocType: Account,Expense Account,Llogaria shpenzim
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +49,Software,Program
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +199,Colour,Ngjyra
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49,Software,Program
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203,Colour,Ngjyra
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Kriteret plan vlerësimi
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Parandalimi i urdhrave të blerjes
-apps/erpnext/erpnext/healthcare/setup.py +257,Susceptible,i prekshëm
+apps/erpnext/erpnext/healthcare/setup.py +258,Susceptible,i prekshëm
 DocType: Patient Appointment,Scheduled,Planifikuar
 apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Kërkesa për kuotim.
 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","Ju lutem zgjidhni Item ku &quot;A Stock Pika&quot; është &quot;Jo&quot; dhe &quot;është pika e shitjes&quot; është &quot;Po&quot;, dhe nuk ka asnjë tjetër Bundle Produktit"
 apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148,Select Customer,Zgjidh Klientin
 DocType: Student Log,Academic,Akademik
 DocType: Patient,Personal and Social History,Historia personale dhe sociale
+apps/erpnext/erpnext/education/doctype/guardian/guardian.py +52,User {0} created,Përdoruesi {0} krijoi
 DocType: Fee Schedule,Fee Breakup for each student,Shkëputja e taksës për secilin nxënës
-apps/erpnext/erpnext/controllers/accounts_controller.py +476,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Gjithsej paraprakisht ({0}) kundër Rendit {1} nuk mund të jetë më e madhe se 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}),Gjithsej paraprakisht ({0}) kundër Rendit {1} nuk mund të jetë më e madhe se Grand Total ({2})
 DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,Zgjidh Shpërndarja mujore të pabarabartë shpërndarë objektiva të gjithë muajve.
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78,Change Code,Ndrysho kodin
 DocType: Purchase Invoice Item,Valuation Rate,Vlerësimi Rate
 DocType: Stock Reconciliation,SR/,SR /
 DocType: Vehicle,Diesel,naftë
-apps/erpnext/erpnext/stock/get_item_details.py +338,Price List Currency not selected,Lista e Çmimeve Valuta nuk zgjidhet
+apps/erpnext/erpnext/stock/get_item_details.py +381,Price List Currency not selected,Lista e Çmimeve Valuta nuk zgjidhet
 apps/erpnext/erpnext/config/healthcare.py +46,Results,Rezultate
 ,Student Monthly Attendance Sheet,Student Pjesëmarrja mujore Sheet
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96,Shipping rule only applicable for Selling,Rregullat e transportit të aplikueshme vetëm për shitjen
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +185,Employee {0} has already applied for {1} between {2} and {3},Punonjës {0} ka aplikuar tashmë për {1} midis {2} dhe {3}
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Projekti Data e Fillimit
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +5,Until,Deri
 DocType: Rename Tool,Rename Log,Rename Kyçu
-apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Grupi Student ose Course Orari është i detyrueshëm
-apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Grupi Student ose Course Orari është i detyrueshëm
+apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Grupi Student ose Course Orari është i detyrueshëm
+apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Grupi Student ose Course Orari është i detyrueshëm
 DocType: HR Settings,Maintain Billing Hours and Working Hours Same on Timesheet,Ruajtur Orari Faturimi dhe orarit të punës njëjtën gjë në pasqyrë e mungesave
 DocType: Maintenance Visit Purpose,Against Document No,Kundër Dokumentin Nr
 DocType: BOM,Scrap,copëz
-apps/erpnext/erpnext/utilities/user_progress.py +196,Go to Instructors,Shkoni te Instruktorët
+apps/erpnext/erpnext/utilities/user_progress.py +214,Go to Instructors,Shkoni te Instruktorët
 apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,Manage Shitje Partnerët.
 DocType: Quality Inspection,Inspection Type,Inspektimi Type
 DocType: Fee Validity,Visited yet,Vizita ende
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +135,Warehouses with existing transaction can not be converted to group.,Depot me transaksion ekzistues nuk mund të konvertohet në grup.
 DocType: Assessment Result Tool,Result HTML,Rezultati HTML
+apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6,Memeber Activity,Aktiviteti Memeber
 apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35,Expires On,Skadon ne
 apps/erpnext/erpnext/utilities/activation.py +117,Add Students,Shto Studentët
+apps/erpnext/erpnext/public/js/utils.js +264,Please select {0},"Ju lutem, përzgjidhni {0}"
 DocType: C-Form,C-Form No,C-Forma Nuk ka
 DocType: BOM,Exploded_items,Exploded_items
-apps/erpnext/erpnext/utilities/user_progress.py +118,List your products or services that you buy or sell.,Listoni produktet ose shërbimet që bleni ose sillni.
+apps/erpnext/erpnext/utilities/user_progress.py +136,List your products or services that you buy or sell.,Listoni produktet ose shërbimet që bleni ose sillni.
+DocType: Water Analysis,Storage Temperature,Temperatura e magazinimit
 DocType: Employee Attendance Tool,Unmarked Attendance,Pjesëmarrja pashënuar
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +133,Researcher,Studiues
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137,Researcher,Studiues
 DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Program Regjistrimi Tool Student
+apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16,Start date should be less than end date for task {0},Data e fillimit duhet të jetë më pak se data e përfundimit të detyrës {0}
 apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Emri ose adresa është e detyrueshme
-apps/erpnext/erpnext/config/stock.py +168,Incoming quality inspection.,Inspektimit të cilësisë hyrëse.
 DocType: Purchase Order Item,Returned Qty,U kthye Qty
-DocType: Employee,Exit,Dalje
-apps/erpnext/erpnext/accounts/doctype/account/account.py +159,Root Type is mandatory,Root Lloji është i detyrueshëm
+DocType: Student,Exit,Dalje
+apps/erpnext/erpnext/accounts/doctype/account/account.py +158,Root Type is mandatory,Root Lloji është i detyrueshëm
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29,Failed to install presets,Dështoi në instalimin e paravendave
 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} aktualisht ka një {1} Scorecard të Furnizuesit, dhe RFQ-të për këtë furnizues duhet të lëshohen me kujdes."
+DocType: Chapter,Non Profit Manager,Menaxheri i Jofitimit
 DocType: BOM,Total Cost(Company Currency),Kosto totale (Company Valuta)
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315,Serial No {0} created,Serial Asnjë {0} krijuar
 DocType: Homepage,Company Description for website homepage,Përshkrimi i kompanisë për faqen e internetit
@@ -3124,41 +3335,42 @@
 DocType: Employee,You can enter any date manually,Ju mund të hyjë në çdo datë me dorë
 DocType: Healthcare Settings,Result Printed,Rezultati Printuar
 DocType: Asset Category Account,Depreciation Expense Account,Llogaria Zhvlerësimi Shpenzimet
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +221,Probationary Period,Periudha provuese
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +231,Probationary Period,Periudha provuese
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32,View {0},Shiko {0}
 DocType: Customer Group,Only leaf nodes are allowed in transaction,Vetëm nyjet fletë janë të lejuara në transaksion
-DocType: Expense Claim,Expense Approver,Shpenzim aprovuesi
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Customer must be credit,Row {0}: Advance kundër Customer duhet të jetë krediti
-apps/erpnext/erpnext/accounts/doctype/account/account.js +83,Non-Group to Group,Non-Group Grupit
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Grumbull është i detyrueshëm në rradhë {0}
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Grumbull është i detyrueshëm në rradhë {0}
+DocType: Project,Total Costing Amount (via Timesheets),Shuma totale e kostos (përmes Timesheets)
+DocType: Employee Advance,Expense Approver,Shpenzim aprovuesi
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +134,Row {0}: Advance against Customer must be credit,Row {0}: Advance kundër Customer duhet të jetë krediti
+apps/erpnext/erpnext/accounts/doctype/account/account.js +89,Non-Group to Group,Non-Group Grupit
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Grumbull është i detyrueshëm në rradhë {0}
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Grumbull është i detyrueshëm në rradhë {0}
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Fatura Blerje Item furnizuar
 DocType: Payment Entry,Pay,Kushtoj
 apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,Për datetime
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +54,Course Schedules deleted:,Oraret e kursit fshirë:
 apps/erpnext/erpnext/config/selling.py +297,Logs for maintaining sms delivery status,Shkrime për ruajtjen e statusit të dorëzimit SMS
 DocType: Accounts Settings,Make Payment via Journal Entry,Të bëjë pagesën përmes Journal Hyrja
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +86,Printed On,Shtypur On
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +97,Printed On,Shtypur On
 DocType: Item,Inspection Required before Delivery,Inspektimi i nevojshëm para dorëzimit
 DocType: Item,Inspection Required before Purchase,Inspektimi i nevojshëm para se Blerja
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93,Pending Activities,Aktivitetet në pritje
 DocType: Patient Appointment,Reminded,kujtoi
 DocType: Patient,PID-,PID-
-apps/erpnext/erpnext/public/js/setup_wizard.js +103,Your Organization,Organizata juaj
+DocType: Chapter Member,Chapter Member,Anëtar i Kapitullit
+apps/erpnext/erpnext/public/js/setup_wizard.js +106,Your Organization,Organizata juaj
 DocType: Fee Component,Fees Category,tarifat Category
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +129,Please enter relieving date.,Ju lutemi të hyrë në lehtësimin datën.
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +134,Please enter relieving date.,Ju lutemi të hyrë në lehtësimin datën.
 apps/erpnext/erpnext/controllers/trends.py +149,Amt,Sasia
 DocType: Supplier Scorecard,Notify Employee,Njoftoni punonjësin
 DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,Shkruani emrin e fushatës nëse burimi i hetimit është fushatë
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +38,Newspaper Publishers,Gazeta Botuesit
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38,Newspaper Publishers,Gazeta Botuesit
 apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30,Select Fiscal Year,Zgjidh Viti Fiskal
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +114,Expected Delivery Date should be after Sales Order Date,Data e dorëzimit të pritshëm duhet të jetë pas datës së porosisë së shitjes
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115,Expected Delivery Date should be after Sales Order Date,Data e dorëzimit të pritshëm duhet të jetë pas datës së porosisë së shitjes
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Reorder Niveli
 DocType: Company,Chart Of Accounts Template,Chart e Llogarive Stampa
 DocType: Attendance,Attendance Date,Pjesëmarrja Data
-apps/erpnext/erpnext/stock/get_item_details.py +302,Item Price updated for {0} in Price List {1},Item Çmimi përditësuar për {0} në çmimore {1}
+apps/erpnext/erpnext/stock/get_item_details.py +345,Item Price updated for {0} in Price List {1},Item Çmimi përditësuar për {0} në çmimore {1}
 DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Shpërbërjes paga në bazë të fituar dhe zbritje.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +131,Account with child nodes cannot be converted to ledger,Llogaria me nyje fëmijëve nuk mund të konvertohet në Ledger
+apps/erpnext/erpnext/accounts/doctype/account/account.py +130,Account with child nodes cannot be converted to ledger,Llogaria me nyje fëmijëve nuk mund të konvertohet në Ledger
 DocType: Purchase Invoice Item,Accepted Warehouse,Magazina pranuar
 DocType: Bank Reconciliation Detail,Posting Date,Posting Data
 DocType: Item,Valuation Method,Vlerësimi Metoda
@@ -3167,15 +3379,15 @@
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +85,Duplicate entry,Hyrja Duplicate
 DocType: Program Enrollment Tool,Get Students,Get Studentët
 DocType: Serial No,Under Warranty,Nën garanci
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +491,[Error],[Gabim]
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +515,[Error],[Gabim]
 DocType: Sales Order,In Words will be visible once you save the Sales Order.,Me fjalë do të jetë i dukshëm një herë ju ruani Rendit Sales.
 ,Employee Birthday,Punonjës Ditëlindja
+apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14,Please select Completion Date for Completed Repair,Ju lutemi zgjidhni Data e Përfundimit për Riparimin e Përfunduar
 DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Student Batch Pjesëmarrja Tool
 apps/erpnext/erpnext/controllers/status_updater.py +210,Limit Crossed,Limit Kaloi
-apps/erpnext/erpnext/schools/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Planifikuar Upto
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +55,Venture Capital,Venture Capital
-apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +40,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Një term akademike me këtë &#39;vitin akademik&#39; {0} dhe &#39;Term Emri&#39; {1} ekziston. Ju lutemi të modifikojë këto të hyra dhe të provoni përsëri.
-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}","Si ka transaksione ekzistuese kundër artikull {0}, ju nuk mund të ndryshojë vlerën e {1}"
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Planifikuar Upto
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55,Venture Capital,Venture Capital
+apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +40,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Një term akademike me këtë &#39;vitin akademik&#39; {0} dhe &#39;Term Emri&#39; {1} ekziston. Ju lutemi të modifikojë këto të hyra dhe të provoni përsëri.
 DocType: UOM,Must be Whole Number,Duhet të jetë numër i plotë
 DocType: Leave Control Panel,New Leaves Allocated (In Days),Lë të reja alokuara (në ditë)
 DocType: Purchase Invoice,Invoice Copy,fatura Copy
@@ -3185,7 +3397,7 @@
 DocType: Payment Reconciliation Invoice,Invoice Number,Numri i faturës
 DocType: Shopping Cart Settings,Orders,Urdhërat
 DocType: Employee Leave Approver,Leave Approver,Lini aprovuesi
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +272,Please select a batch,"Ju lutem, përzgjidhni një grumbull"
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +285,Please select a batch,"Ju lutem, përzgjidhni një grumbull"
 DocType: Assessment Group,Assessment Group Name,Emri Grupi i Vlerësimit
 DocType: Manufacturing Settings,Material Transferred for Manufacture,Material Transferuar për Prodhime
 DocType: Expense Claim,"A user with ""Expense Approver"" role",Një përdorues me &quot;Shpenzimi aprovuesi&quot; rolin
@@ -3194,21 +3406,23 @@
 ,Issued Items Against Production Order,Items lëshuara kundër rendit Production
 DocType: Antibiotic,Healthcare,Kujdesit shëndetësor
 DocType: Target Detail,Target Detail,Detail Target
+apps/erpnext/erpnext/stock/doctype/item/item.js +65,Single Variant,Varianti i vetëm
 apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24,All Jobs,Të gjitha Jobs
 DocType: Sales Order,% of materials billed against this Sales Order,% E materialeve faturuar kundër këtij Rendit Shitje
 DocType: Program Enrollment,Mode of Transportation,Mode e Transportit
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49,Period Closing Entry,Periudha Mbyllja Hyrja
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +75,Select Department...,Zgjidh Departamentin ...
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38,Cost Center with existing transactions can not be converted to group,Qendra Kosto me transaksionet ekzistuese nuk mund të konvertohet në grup
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +360,Amount {0} {1} {2} {3},Shuma {0} {1} {2} {3}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +361,Amount {0} {1} {2} {3},Shuma {0} {1} {2} {3}
 DocType: Account,Depreciation,Amortizim
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,Supplier(s),Furnizuesi (s)
 DocType: Employee Attendance Tool,Employee Attendance Tool,Punonjës Pjesëmarrja Tool
 DocType: Guardian Student,Guardian Student,Guardian Student
 DocType: Supplier,Credit Limit,Limit Credit
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Selling Price List Rate,Avg. Shitja e Çmimit të Çmimeve të Listës
 DocType: Production Plan Sales Order,Salse Order Date,Salse Order Data
 DocType: Salary Component,Salary Component,Paga Komponenti
-apps/erpnext/erpnext/accounts/utils.py +490,Payment Entries {0} are un-linked,Entries pagesës {0} janë të pa-lidhur
+apps/erpnext/erpnext/accounts/utils.py +492,Payment Entries {0} are un-linked,Entries pagesës {0} janë të pa-lidhur
 DocType: GL Entry,Voucher No,Voucher Asnjë
 ,Lead Owner Efficiency,Efikasiteti Lead Owner
 ,Lead Owner Efficiency,Efikasiteti Lead Owner
@@ -3222,12 +3436,12 @@
 apps/erpnext/erpnext/config/selling.py +164,Template of terms or contract.,Template i termave apo kontrate.
 DocType: Purchase Invoice,Address and Contact,Adresa dhe Kontakt
 DocType: Cheque Print Template,Is Account Payable,Është Llogaria e pagueshme
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +273,Stock cannot be updated against Purchase Receipt {0},Stock nuk mund të rifreskohet kundër marrjes Blerje {0}
-DocType: Supplier,Last Day of the Next Month,Dita e fundit e muajit të ardhshëm
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276,Stock cannot be updated against Purchase Receipt {0},Stock nuk mund të rifreskohet kundër marrjes Blerje {0}
+DocType: Company,Last Day of the Next Month,Dita e fundit e muajit të ardhshëm
 DocType: Support Settings,Auto close Issue after 7 days,Auto Issue ngushtë pas 7 ditësh
 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}","Lënë nuk mund të ndahen përpara {0}, si bilanci leja ka qenë tashmë copë dërgohet në regjistrin e ardhshëm alokimit Pushimi {1}"
-apps/erpnext/erpnext/accounts/party.py +319,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Shënim: Për shkak / Data Referenca kalon lejuar ditët e kreditit të konsumatorëve nga {0} ditë (s)
-apps/erpnext/erpnext/schools/doctype/program/program.js +8,Student Applicant,Student Aplikuesi
+apps/erpnext/erpnext/accounts/party.py +320,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Shënim: Për shkak / Data Referenca kalon lejuar ditët e kreditit të konsumatorëve nga {0} ditë (s)
+apps/erpnext/erpnext/education/doctype/program/program.js +8,Student Applicant,Student Aplikuesi
 DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,ORIGINAL për RECIPIENT
 DocType: Asset Category Account,Accumulated Depreciation Account,Llogaria akumuluar Zhvlerësimi
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11,This email is autogenerated,Kjo email është autogenerated
@@ -3238,39 +3452,42 @@
 DocType: Activity Cost,Billing Rate,Rate Faturimi
 ,Qty to Deliver,Qty të Dorëzojë
 ,Stock Analytics,Stock Analytics
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +505,Operations cannot be left blank,Operacionet nuk mund të lihet bosh
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +508,Operations cannot be left blank,Operacionet nuk mund të lihet bosh
 DocType: Maintenance Visit Purpose,Against Document Detail No,Kundër Document Detail Jo
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +98,Party Type is mandatory,Lloji Party është e detyrueshme
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +99,Party Type is mandatory,Lloji Party është e detyrueshme
 DocType: Quality Inspection,Outgoing,Largohet
 DocType: Material Request,Requested For,Kërkuar Për
 DocType: Quotation Item,Against Doctype,Kundër DOCTYPE
-apps/erpnext/erpnext/controllers/buying_controller.py +395,{0} {1} is cancelled or closed,{0} {1} është anuluar apo të mbyllura
+apps/erpnext/erpnext/controllers/buying_controller.py +396,{0} {1} is cancelled or closed,{0} {1} është anuluar apo të mbyllura
+DocType: Asset,Calculate Depreciation,Llogaritni Zhvlerësimin
 DocType: Delivery Note,Track this Delivery Note against any Project,Përcjell këtë notën shpërndarëse kundër çdo Projektit
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +30,Net Cash from Investing,Paraja neto nga Investimi
 DocType: Production Order,Work-in-Progress Warehouse,Puna në progres Magazina
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +111,Asset {0} must be submitted,Asset {0} duhet të dorëzohet
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111,Asset {0} must be submitted,Asset {0} duhet të dorëzohet
 DocType: Fee Schedule Program,Total Students,Studentët Gjithsej
-apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +56,Attendance Record {0} exists against Student {1},Pjesëmarrja Record {0} ekziston kundër Student {1}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354,Reference #{0} dated {1},Referenca # {0} datë {1}
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +161,Depreciation Eliminated due to disposal of assets,Zhvlerësimi Eliminuar shkak të dispozicion të aseteve
+apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56,Attendance Record {0} exists against Student {1},Pjesëmarrja Record {0} ekziston kundër Student {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +352,Reference #{0} dated {1},Referenca # {0} datë {1}
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164,Depreciation Eliminated due to disposal of assets,Zhvlerësimi Eliminuar shkak të dispozicion të aseteve
+DocType: Member,Member,anëtar
 apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Manage Adresat
-DocType: Asset,Item Code,Kodi i artikullit
+DocType: Pricing Rule,Item Code,Kodi i artikullit
 DocType: Production Planning Tool,Create Production Orders,Krijo urdhërat e prodhimit
 DocType: Serial No,Warranty / AMC Details,Garanci / AMC Detajet
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Zgjidh studentët me dorë për aktivitetin bazuar Grupit
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Zgjidh studentët me dorë për aktivitetin bazuar Grupit
+apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Zgjidh studentët me dorë për aktivitetin bazuar Grupit
+apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Zgjidh studentët me dorë për aktivitetin bazuar Grupit
 DocType: Journal Entry,User Remark,Përdoruesi Vërejtje
 DocType: Lead,Market Segment,Segmenti i Tregut
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +924,Paid Amount cannot be greater than total negative outstanding amount {0},Shuma e paguar nuk mund të jetë më e madhe se shuma totale negative papaguar {0}
+DocType: Crop,Agriculture Manager,Menaxheri i Bujqësisë
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +950,Paid Amount cannot be greater than total negative outstanding amount {0},Shuma e paguar nuk mund të jetë më e madhe se shuma totale negative papaguar {0}
 DocType: Supplier Scorecard Period,Variables,Variablat
 DocType: Employee Internal Work History,Employee Internal Work History,Punonjës historia e Brendshme
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +239,Closing (Dr),Mbyllja (Dr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +246,Closing (Dr),Mbyllja (Dr)
 DocType: Cheque Print Template,Cheque Size,Çek Size
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232,Serial No {0} not in stock,Serial Asnjë {0} nuk në magazinë
 apps/erpnext/erpnext/config/selling.py +169,Tax template for selling transactions.,Template taksave për shitjen e transaksioneve.
 DocType: Sales Invoice,Write Off Outstanding Amount,Shkruani Off Outstanding Shuma
 apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27,Account {0} does not match with Company {1},Llogaria {0} nuk përputhet me Kompaninë {1}
-DocType: School Settings,Current Academic Year,Aktual akademik Year
+DocType: Education Settings,Current Academic Year,Aktual akademik Year
 DocType: Stock Settings,Default Stock UOM,Gabim Stock UOM
 DocType: Asset,Number of Depreciations Booked,Numri i nënçmime rezervuar
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32,Against Employee Loan: {0},Kundër Huazim e punonjësve: {0}
@@ -3278,49 +3495,54 @@
 DocType: Production Planning Tool,Create Material Requests,Krijo Kërkesat materiale
 DocType: Employee Education,School/University,Shkolla / Universiteti
 DocType: Payment Request,Reference Details,Referenca Detajet
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +59,Expected Value After Useful Life must be less than Gross Purchase Amount,Vlera e pritshme Pas së dobishme duhet të jetë më pak se bruto Blerje Shuma
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +59,Expected Value After Useful Life must be less than Gross Purchase Amount,Vlera e pritshme Pas së dobishme duhet të jetë më pak se bruto Blerje Shuma
 DocType: Sales Invoice Item,Available Qty at Warehouse,Qty në dispozicion në magazinë
 apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Billed Amount,Shuma e faturuar
 DocType: Asset,Double Declining Balance,Dyfishtë rënie Balance
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +179,Closed order cannot be cancelled. Unclose to cancel.,mënyrë të mbyllura nuk mund të anulohet. Hap për të anulluar.
-DocType: Patient Relation,Father,Atë
-apps/erpnext/erpnext/controllers/accounts_controller.py +562,'Update Stock' cannot be checked for fixed asset sale,&#39;Update Stock&#39; nuk mund të kontrollohet për shitjen e aseteve fikse
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180,Closed order cannot be cancelled. Unclose to cancel.,mënyrë të mbyllura nuk mund të anulohet. Hap për të anulluar.
+DocType: Student Guardian,Father,Atë
+apps/erpnext/erpnext/controllers/accounts_controller.py +606,'Update Stock' cannot be checked for fixed asset sale,&#39;Update Stock&#39; nuk mund të kontrollohet për shitjen e aseteve fikse
 DocType: Bank Reconciliation,Bank Reconciliation,Banka Pajtimit
 DocType: Attendance,On Leave,Në ikje
 apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Get Updates,Get Updates
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Llogaria {2} nuk i përkasin kompanisë {3}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +147,Material Request {0} is cancelled or stopped,Materiali Kërkesë {0} është anuluar ose ndërprerë
-apps/erpnext/erpnext/config/hr.py +305,Leave Management,Lini Menaxhimi
+apps/erpnext/erpnext/stock/doctype/item/item.js +366,Select at least one value from each of the attributes.,Zgjidhni të paktën një vlerë nga secili prej atributeve.
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +156,Material Request {0} is cancelled or stopped,Materiali Kërkesë {0} është anuluar ose ndërprerë
+apps/erpnext/erpnext/config/hr.py +310,Leave Management,Lini Menaxhimi
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +106,Group by Account,Grupi nga Llogaria
 DocType: Sales Order,Fully Delivered,Dorëzuar plotësisht
 DocType: Lead,Lower Income,Të ardhurat më të ulëta
 DocType: Restaurant Order Entry,Current Order,Rendi aktual
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +169,Source and target warehouse cannot be same for row {0},Burimi dhe depo objektiv nuk mund të jetë i njëjtë për të rresht {0}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +174,Source and target warehouse cannot be same for row {0},Burimi dhe depo objektiv nuk mund të jetë i njëjtë për të rresht {0}
 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","Llogaria ndryshim duhet të jetë një llogari lloj Aseteve / Detyrimeve, pasi kjo Stock Pajtimi është një Hyrja Hapja"
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107,Disbursed Amount cannot be greater than Loan Amount {0},Shuma e disbursuar nuk mund të jetë më e madhe se: Kredia {0}
-apps/erpnext/erpnext/utilities/user_progress.py +155,Go to Programs,Shkoni te Programet
+apps/erpnext/erpnext/utilities/user_progress.py +173,Go to Programs,Shkoni te Programet
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +219,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Rresht {0} # Shuma e alokuar {1} nuk mund të jetë më e madhe se shuma e pakushtuar {2}
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89,Purchase Order number required for Item {0},Blerje numrin urdhër që nevojitet për artikullit {0}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +896,Production Order not created,Rendit prodhimit jo krijuar
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +943,Production Order not created,Rendit prodhimit jo krijuar
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date',&#39;Nga Data &quot;duhet të jetë pas&quot; deri më sot &quot;
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.py +39,Cannot change status as student {0} is linked with student application {1},Nuk mund të ndryshojë statusin si nxënës {0} është e lidhur me aplikimin e studentëve {1}
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39,Cannot change status as student {0} is linked with student application {1},Nuk mund të ndryshojë statusin si nxënës {0} është e lidhur me aplikimin e studentëve {1}
 DocType: Asset,Fully Depreciated,amortizuar plotësisht
 ,Stock Projected Qty,Stock Projektuar Qty
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434,Customer {0} does not belong to project {1},Customer {0} nuk i përket projektit {1}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +438,Customer {0} does not belong to project {1},Customer {0} nuk i përket projektit {1}
 DocType: Employee Attendance Tool,Marked Attendance HTML,Pjesëmarrja e shënuar HTML
 apps/erpnext/erpnext/utilities/activation.py +73,"Quotations are proposals, bids you have sent to your customers","Citate janë propozimet, ofertat keni dërguar për klientët tuaj"
 DocType: Sales Order,Customer's Purchase Order,Rendit Blerje konsumatorit
 DocType: Consultation,Patient,pacient
-apps/erpnext/erpnext/config/stock.py +117,Serial No and Batch,Pa serial dhe Batch
+apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47,Bypass credit check at Sales Order ,Kontrolli i kredisë së anashkaluar në Urdhrin e shitjes
+DocType: Land Unit,Check if it is a hydroponic unit,Kontrolloni nëse është njësi hidroponike
+apps/erpnext/erpnext/config/stock.py +109,Serial No and Batch,Pa serial dhe Batch
 DocType: Warranty Claim,From Company,Nga kompanisë
-apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.py +40,Sum of Scores of Assessment Criteria needs to be {0}.,Shuma e pikëve të kritereve të vlerësimit të nevojave të jetë {0}.
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +77,Please set Number of Depreciations Booked,Ju lutemi të vendosur Numri i nënçmime rezervuar
+apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +40,Sum of Scores of Assessment Criteria needs to be {0}.,Shuma e pikëve të kritereve të vlerësimit të nevojave të jetë {0}.
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +77,Please set Number of Depreciations Booked,Ju lutemi të vendosur Numri i nënçmime rezervuar
 DocType: Supplier Scorecard Period,Calculations,llogaritjet
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +89,Value or Qty,Vlera ose Qty
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +425,Productions Orders cannot be raised for:,Urdhërat Productions nuk mund të ngrihen për:
-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,Vendosni Serinë Naming për {0} nëpërmjet Setup&gt; Settings&gt; Naming Series
+DocType: Payment Terms Template,Payment Terms,Kushtet e pagesës
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +426,Productions Orders cannot be raised for:,Urdhërat Productions nuk mund të ngrihen për:
+apps/erpnext/erpnext/utilities/user_progress.py +144,Minute,Minutë
 DocType: Purchase Invoice,Purchase Taxes and Charges,Blerje taksat dhe tatimet
-apps/erpnext/erpnext/utilities/user_progress.py +100,Go to Suppliers,Shko tek Furnizuesit
+DocType: Chapter,Meetup Embed HTML,Meetup Embed HTML
+apps/erpnext/erpnext/utilities/user_progress.py +118,Go to Suppliers,Shko tek Furnizuesit
 ,Qty to Receive,Qty të marrin
 DocType: Leave Block List,Leave Block List Allowed,Dërgo Block Lista Lejohet
 DocType: Grading Scale Interval,Grading Scale Interval,Nota Scale Interval
@@ -3329,33 +3551,34 @@
 DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Discount (%) në listën e çmimeve të votuarat vetëm me Margjina
 apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,Të gjitha Depot
 DocType: Sales Partner,Retailer,Shitës me pakicë
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +112,Credit To account must be a Balance Sheet account,Kredi në llogarinë duhet të jetë një llogari Bilanci i Gjendjes
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115,Credit To account must be a Balance Sheet account,Kredi në llogarinë duhet të jetë një llogari Bilanci i Gjendjes
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +122,All Supplier Types,Gjitha llojet Furnizuesi
+DocType: Donor,Donor,dhurues
 DocType: Global Defaults,Disable In Words,Disable Në fjalë
-apps/erpnext/erpnext/stock/doctype/item/item.py +51,Item Code is mandatory because Item is not automatically numbered,Kodi i artikullit është i detyrueshëm për shkak Item nuk është numëruar në mënyrë automatike
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +97,Quotation {0} not of type {1},Citat {0} nuk e tipit {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +49,Item Code is mandatory because Item is not automatically numbered,Kodi i artikullit është i detyrueshëm për shkak Item nuk është numëruar në mënyrë automatike
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +98,Quotation {0} not of type {1},Citat {0} nuk e tipit {1}
 DocType: Maintenance Schedule Item,Maintenance Schedule Item,Orari Mirëmbajtja Item
 DocType: Sales Order,%  Delivered,% Dorëzuar
-apps/erpnext/erpnext/schools/doctype/fees/fees.js +105,Please set the Email ID for the Student to send the Payment Request,Ju lutemi vendosni ID Email për Studentin për të dërguar Kërkesën e Pagesës
+apps/erpnext/erpnext/education/doctype/fees/fees.js +105,Please set the Email ID for the Student to send the Payment Request,Ju lutemi vendosni ID Email për Studentin për të dërguar Kërkesën e Pagesës
 DocType: Production Order,PRO-,PRO
 DocType: Patient,Medical History,Histori mjekesore
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157,Bank Overdraft Account,Llogaria Overdraft Banka
 DocType: Patient,Patient ID,ID e pacientit
 DocType: Physician Schedule,Schedule Name,Orari Emri
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48,Make Salary Slip,Bëni Kuponi pagave
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +813,Add All Suppliers,Shto të Gjithë Furnizuesit
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +81,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Row # {0}: Shuma e ndarë nuk mund të jetë më e madhe se shuma e papaguar.
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +838,Add All Suppliers,Shto të Gjithë Furnizuesit
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +83,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Row # {0}: Shuma e ndarë nuk mund të jetë më e madhe se shuma e papaguar.
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75,Browse BOM,Shfleto bom
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155,Secured Loans,Kredi të siguruara
 DocType: Purchase Invoice,Edit Posting Date and Time,Edit Posting Data dhe Koha
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +101,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Ju lutemi të vendosur Llogaritë zhvlerësimit lidhur në Kategorinë Aseteve {0} ose kompanisë {1}
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +101,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Ju lutemi të vendosur Llogaritë zhvlerësimit lidhur në Kategorinë Aseteve {0} ose kompanisë {1}
 DocType: Lab Test Groups,Normal Range,Gama normale
 DocType: Academic Term,Academic Year,Vit akademik
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Available Selling,Shitja në dispozicion
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169,Opening Balance Equity,Hapja Bilanci ekuitetit
 DocType: Lead,CRM,CRM
 DocType: Purchase Invoice,N,N
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +24,Reconciliation,pajtim
-apps/erpnext/erpnext/schools/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,mbetur
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,mbetur
 DocType: Appraisal,Appraisal,Vlerësim
 DocType: Purchase Invoice,GST Details,Detajet e GST
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +154,Email sent to supplier {0},Email dërguar për furnizuesit {0}
@@ -3364,22 +3587,23 @@
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19,Date is repeated,Data përsëritet
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27,Authorized Signatory,Nënshkrues i autorizuar
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +215,Leave approver must be one of {0},Dërgo aprovuesi duhet të jetë një nga {0}
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.js +66,Create Fees,Krijo tarifa
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +67,Create Fees,Krijo tarifa
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Gjithsej Kosto Blerje (nëpërmjet Blerje Faturës)
 DocType: Training Event,Start Time,Koha e fillimit
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +377,Select Quantity,Zgjidh Sasia
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +399,Select Quantity,Zgjidh Sasia
 DocType: Customs Tariff Number,Customs Tariff Number,Numri Tarifa doganore
 DocType: Patient Appointment,Patient Appointment,Emërimi i pacientit
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,Miratimi Rolit nuk mund të jetë i njëjtë si rolin rregulli është i zbatueshëm për
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +64,Unsubscribe from this Email Digest,Çabonoheni nga ky Dërgoje Digest
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +803,Get Suppliers By,Merrni Furnizuesit Nga
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +828,Get Suppliers By,Merrni Furnizuesit Nga
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +170,{0} not found for Item {1},{0} nuk u gjet për Item {1}
-apps/erpnext/erpnext/utilities/user_progress.py +176,Go to Courses,Shkoni në Kurse
+apps/erpnext/erpnext/utilities/user_progress.py +194,Go to Courses,Shkoni në Kurse
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,Mesazh dërguar
-apps/erpnext/erpnext/accounts/doctype/account/account.py +101,Account with child nodes cannot be set as ledger,Llogari me nyje të fëmijëve nuk mund të vendosen si librit
+apps/erpnext/erpnext/accounts/doctype/account/account.py +100,Account with child nodes cannot be set as ledger,Llogari me nyje të fëmijëve nuk mund të vendosen si librit
 DocType: C-Form,II,II
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Shkalla në të cilën listë Çmimi monedhës është konvertuar në bazë monedhën klientit
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Shuma neto (Kompania Valuta)
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +229,Total advance amount cannot be greater than total sanctioned amount,Shuma totale e paradhënies nuk mund të jetë më e madhe se shuma totale e sanksionuar
 DocType: Salary Slip,Hour Rate,Ore Rate
 DocType: Stock Settings,Item Naming By,Item Emërtimi By
 apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46,Another Period Closing Entry {0} has been made after {1},Një tjetër Periudha Mbyllja Hyrja {0} është bërë pas {1}
@@ -3395,12 +3619,14 @@
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +155,Source and target warehouse must be different,Burimi dhe depo objektiv duhet të jetë i ndryshëm
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101,Not allowed to update stock transactions older than {0},Nuk lejohet të përtërini transaksioneve të aksioneve të vjetër se {0}
 DocType: Purchase Invoice Item,PR Detail,PR Detail
+DocType: Driving License Category,Class,klasë
 DocType: Sales Order,Fully Billed,Faturuar plotësisht
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101,Shipping rule only applicable for Buying,Rregullimi i transportit është i zbatueshëm vetëm për Blerjen
 DocType: Vital Signs,BMI,BMI
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,Para në dorë
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +136,Delivery warehouse required for stock item {0},Depo ofrimit të nevojshme për pikën e aksioneve {0}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137,Delivery warehouse required for stock item {0},Depo ofrimit të nevojshme për pikën e aksioneve {0}
 DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Pesha bruto e paketës. Zakonisht pesha neto + paketimin pesha materiale. (Për shtyp)
-apps/erpnext/erpnext/schools/doctype/course/course.js +3,Program,program
+apps/erpnext/erpnext/education/doctype/course/course.js +3,Program,program
 DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Përdoruesit me këtë rol janë të lejuara për të ngritur llogaritë ngrirë dhe për të krijuar / modifikuar shënimet e kontabilitetit kundrejt llogarive të ngrira
 DocType: Serial No,Is Cancelled,Është anuluar
 DocType: Student Group,Group Based On,Grupi i bazuar në
@@ -3409,15 +3635,15 @@
 DocType: Healthcare Settings,Laboratory SMS Alerts,Laboratori SMS alarme
 apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20,"Service Item,Type,frequency and expense amount are required","Shërbimi Item, Lloji, frekuenca dhe sasia shpenzimet janë të nevojshme"
 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:","Edhe në qoftë se ka rregulla të shumta çmimeve me prioritet më të lartë, prioritetet e brendshme atëherë në vijim aplikohen:"
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +128,Do you really want to Submit all Salary Slip from {0} to {1},A jeni të vërtetë dëshironi të paraqesë të gjitha kuotat e duhura Rroga nga {0} në {1}
+DocType: Plant Analysis Criteria,Plant Analysis Criteria,Kriteret e analizës së bimëve
 DocType: Cheque Print Template,Cheque Height,Çek Lartësia
 DocType: Supplier,Supplier Details,Detajet Furnizuesi
 DocType: Setup Progress,Setup Progress,Progresi i konfigurimit
 DocType: Expense Claim,Approval Status,Miratimi Statusi
 DocType: Hub Settings,Publish Items to Hub,Botojë artikuj për Hub
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +43,From value must be less than to value in row {0},Nga Vlera duhet të jetë më pak se të vlerës në rresht {0}
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +178,Wire Transfer,Wire Transfer
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +132,Check all,kontrollo të gjitha
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35,From value must be less than to value in row {0},Nga Vlera duhet të jetë më pak se të vlerës në rresht {0}
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182,Wire Transfer,Wire Transfer
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92,Check all,kontrollo të gjitha
 DocType: Vehicle Log,Invoice Ref,faturë Ref
 DocType: Company,Default Income Account,Llogaria e albumit ardhurat
 apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32,Customer Group / Customer,Grupi Customer / Customer
@@ -3426,19 +3652,18 @@
 DocType: Lab Test Template,Change In Item,Ndrysho artikullin
 DocType: Payment Gateway Account,Default Payment Request Message,Default kërkojë pagesën mesazh
 DocType: Item Group,Check this if you want to show in website,Kontrolloni këtë në qoftë se ju doni të tregojnë në faqen e internetit
-apps/erpnext/erpnext/config/accounts.py +142,Banking and Payments,Bankar dhe i Pagesave
+apps/erpnext/erpnext/config/accounts.py +134,Banking and Payments,Bankar dhe i Pagesave
 ,Welcome to ERPNext,Mirë se vini në ERPNext
 apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,Lead për Kuotim
 DocType: Patient,A Negative,Një Negativ
 apps/erpnext/erpnext/templates/includes/product_list.js +45,Nothing more to show.,Asgjë më shumë për të treguar.
 DocType: Lead,From Customer,Nga Klientit
 apps/erpnext/erpnext/demo/setup/setup_data.py +327,Calls,Telefonatat
-apps/erpnext/erpnext/utilities/user_progress.py +122,A Product,Një produkt
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +197,Batches,tufa
-DocType: Project,Total Costing Amount (via Time Logs),Shuma kushton (nëpërmjet Koha Shkrime)
-apps/erpnext/erpnext/schools/doctype/fee_structure/fee_structure.js +34,Make Fee Schedule,Bëni Orarin e Tarifave
+apps/erpnext/erpnext/utilities/user_progress.py +140,A Product,Një produkt
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +207,Batches,tufa
+apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34,Make Fee Schedule,Bëni Orarin e Tarifave
 DocType: Purchase Order Item Supplied,Stock UOM,Stock UOM
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +230,Purchase Order {0} is not submitted,Blerje Rendit {0} nuk është dorëzuar
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233,Purchase Order {0} is not submitted,Blerje Rendit {0} nuk është dorëzuar
 DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Sasia normale e referencës për një të rritur është 16-20 fryma / minutë (RCP 2012)
 DocType: Customs Tariff Number,Tariff Number,Numri Tarifa
 DocType: Production Order Item,Available Qty at WIP Warehouse,Qty në dispozicion në WIP Magazina
@@ -3448,70 +3673,77 @@
 DocType: Notification Control,Quotation Message,Citat Mesazh
 DocType: Employee Loan,Employee Loan Application,Punonjës Loan Application
 DocType: Issue,Opening Date,Hapja Data
-apps/erpnext/erpnext/schools/api.py +80,Attendance has been marked successfully.,Pjesëmarrja është shënuar sukses.
+apps/erpnext/erpnext/education/api.py +80,Attendance has been marked successfully.,Pjesëmarrja është shënuar sukses.
 DocType: Program Enrollment,Public Transport,Transporti publik
+DocType: Soil Texture,Silt Composition (%),Përbërja (%)
 DocType: Journal Entry,Remark,Vërejtje
 DocType: Healthcare Settings,Avoid Confirmation,Shmangni konfirmimin
 DocType: Purchase Receipt Item,Rate and Amount,Shkalla dhe Shuma
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +165,Account Type for {0} must be {1},Lloji i llogarisë për {0} duhet të jetë {1}
 DocType: Healthcare Settings,Default income accounts to be used if not set in Physician to book Consultation charges.,Llogaritë e të ardhurave me vonesë do të përdoren nëse nuk vendosen në mjek për të rezervuar akuzat e konsultimit.
 apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Lë dhe Festa
-DocType: School Settings,Current Academic Term,Term aktual akademik
-DocType: School Settings,Current Academic Term,Term aktual akademik
+DocType: Education Settings,Current Academic Term,Term aktual akademik
+DocType: Education Settings,Current Academic Term,Term aktual akademik
 DocType: Sales Order,Not Billed,Jo faturuar
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +77,Both Warehouse must belong to same Company,Të dyja Magazina duhet t&#39;i përkasë njëjtës kompani
 apps/erpnext/erpnext/public/js/templates/contact_list.html +34,No contacts added yet.,Nuk ka kontakte të shtuar ende.
 DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Kosto zbarkoi Voucher Shuma
 apps/erpnext/erpnext/config/accounts.py +17,Bills raised by Suppliers.,Faturat e ngritura nga furnizuesit.
 DocType: POS Profile,Write Off Account,Shkruani Off Llogari
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +78,Debit Note Amt,Debit Shënim AMT
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +89,Debit Note Amt,Debit Shënim AMT
 apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5,Discount Amount,Shuma Discount
 DocType: Purchase Invoice,Return Against Purchase Invoice,Kthehu kundër Blerje Faturë
 DocType: Item,Warranty Period (in days),Garanci Periudha (në ditë)
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Raporti me Guardian1
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61,Failed to set defaults,Dështoi në përcaktimin e parazgjedhjeve
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Raporti me Guardian1
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +797,Please select BOM against item {0},Ju lutem zgjidhni BOM kundër sendit {0}
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18,Make Invoices,Bëni faturat
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +18,Net Cash from Operations,Paraja neto nga operacionet
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26,Item 4,Pika 4
 DocType: Student Admission,Admission End Date,Pranimi End Date
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30,Sub-contracting,Nënkontraktimi
 DocType: Journal Entry Account,Journal Entry Account,Llogaria Journal Hyrja
-apps/erpnext/erpnext/schools/doctype/academic_year/academic_year.js +3,Student Group,Grupi Student
+apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3,Student Group,Grupi Student
 DocType: Shopping Cart Settings,Quotation Series,Citat 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","Një artikull ekziston me të njëjtin emër ({0}), ju lutemi të ndryshojë emrin e grupit pika ose riemërtoj pika"
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2005,Please select customer,Ju lutemi zgjidhni klientit
+DocType: Soil Analysis Criteria,Soil Analysis Criteria,Kriteret e Analizës së Tokës
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2020,Please select customer,Ju lutemi zgjidhni klientit
 DocType: C-Form,I,unë
 DocType: Company,Asset Depreciation Cost Center,Asset Center Zhvlerësimi Kostoja
 DocType: Sales Order Item,Sales Order Date,Sales Order Data
 DocType: Sales Invoice Item,Delivered Qty,Dorëzuar Qty
 DocType: Production Planning Tool,"If checked, all the children of each production item will be included in the Material Requests.","Nëse kontrollohen, të gjithë fëmijët e çdo zë prodhimi do të përfshihen në Kërkesave materiale."
 DocType: Assessment Plan,Assessment Plan,Plani i vlerësimit
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +90,Customer {0} is created.,Klienti {0} është krijuar.
+apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +93,Customer {0} is created.,Klienti {0} është krijuar.
 DocType: Stock Settings,Limit Percent,Limit Percent
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82, Currently no stock available in any warehouse,Aktualisht nuk ka të aksioneve në dispozicion në ndonjë depo
 ,Payment Period Based On Invoice Date,Periudha e pagesës bazuar në datën Faturë
 DocType: Sample Collection,No. of print,Numri i printimit
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58,Missing Currency Exchange Rates for {0},Missing Currency Exchange Rates për {0}
 DocType: Assessment Plan,Examiner,pedagog
-DocType: Patient Relation,Siblings,Vëllezërit e motrat
+DocType: Student,Siblings,Vëllezërit e motrat
 DocType: Journal Entry,Stock Entry,Stock Hyrja
 DocType: Payment Entry,Payment References,Referencat e pagesës
 DocType: C-Form,C-FORM-,C-pritet të marrin
 DocType: Vehicle,Insurance Details,Details Insurance
 DocType: Account,Payable,Për t&#39;u paguar
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113,Please enter Repayment Periods,Ju lutemi shkruani Periudhat Ripagimi
-apps/erpnext/erpnext/shopping_cart/cart.py +365,Debtors ({0}),Debitorët ({0})
+apps/erpnext/erpnext/shopping_cart/cart.py +376,Debtors ({0}),Debitorët ({0})
 DocType: Pricing Rule,Margin,diferencë
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Klientët e Rinj
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +75,Gross Profit %,Bruto% Fitimi
 DocType: Appraisal Goal,Weightage (%),Weightage (%)
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +489,Change POS Profile,Ndrysho Profilin e POS
 DocType: Bank Reconciliation Detail,Clearance Date,Pastrimi Data
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Raporti i Vlerësimit
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +62,Gross Purchase Amount is mandatory,Gross Shuma Blerje është i detyrueshëm
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Raporti i Vlerësimit
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +62,Gross Purchase Amount is mandatory,Gross Shuma Blerje është i detyrueshëm
 DocType: Lead,Address Desc,Adresuar Përshkrimi
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +101,Party is mandatory,Partia është e detyrueshme
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +102,Party is mandatory,Partia është e detyrueshme
 DocType: Journal Entry,JV-,JV-
+apps/erpnext/erpnext/controllers/accounts_controller.py +687,Rows with duplicate due dates in other rows were found: {list},Rreshtat me datat e dyfishta të gjetjeve në rreshta të tjerë u gjetën: {list}
 DocType: Topic,Topic Name,Topic Emri
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +36,Atleast one of the Selling or Buying must be selected,Atleast një nga shitjen apo blerjen duhet të zgjidhen
-apps/erpnext/erpnext/public/js/setup_wizard.js +33,Select the nature of your business.,Zgjidhni natyrën e biznesit tuaj.
+apps/erpnext/erpnext/public/js/setup_wizard.js +36,Select the nature of your business.,Zgjidhni natyrën e biznesit tuaj.
 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
@@ -3521,19 +3753,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.","I vetëm për rezultatet që kërkojnë vetëm një input të vetëm, rezultati UOM dhe vlera normale <br> Përzierje për rezultate që kërkojnë fusha të shumëfishta të futjes me emrat e ngjarjeve korresponduese, rezultatet UOM dhe vlerat normale <br> Përshkruese për testet të cilat kanë përbërës të shumëfishtë të rezultateve dhe fusha korresponduese të rezultateve. <br> Grupuar për modelet e testimit të cilat janë një grup i modeleve të testeve të tjera. <br> Asnjë rezultat për testime pa rezultate. Gjithashtu, nuk është krijuar asnjë Test Lab. psh. Nën testet për rezultatet e grupuara."
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +73,Row #{0}: Duplicate entry in References {1} {2},Rresht # {0}: Dublikoje hyrja në Referencat {1} {2}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +75,Row #{0}: Duplicate entry in References {1} {2},Rresht # {0}: Dublikoje hyrja në Referencat {1} {2}
 apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,Ku operacionet prodhuese janë kryer.
 DocType: Asset Movement,Source Warehouse,Burimi Magazina
 DocType: Installation Note,Installation Date,Instalimi Data
-apps/erpnext/erpnext/controllers/accounts_controller.py +541,Row #{0}: Asset {1} does not belong to company {2},Row # {0}: Asset {1} nuk i përkasin kompanisë {2}
+apps/erpnext/erpnext/controllers/accounts_controller.py +585,Row #{0}: Asset {1} does not belong to company {2},Row # {0}: Asset {1} nuk i përkasin kompanisë {2}
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206,Sales Invoice {0} created,Fatura Sales {0} krijuar
 DocType: Employee,Confirmation Date,Konfirmimi Data
 DocType: C-Form,Total Invoiced Amount,Shuma totale e faturuar
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +49,Min Qty can not be greater than Max Qty,Min Qty nuk mund të jetë më i madh se Max Qty
+DocType: Soil Texture,Silty Clay,Silty Clay
 DocType: Account,Accumulated Depreciation,Zhvlerësimi i akumuluar
 DocType: Supplier Scorecard Scoring Standing,Standing Name,Emri i Përhershëm
 DocType: Stock Entry,Customer or Supplier Details,Customer ose Furnizuesi Detajet
 DocType: Employee Loan Application,Required by Date,Kërkohet nga Data
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +222,Closing Balance (Dr - Cr),Bilanci mbyllës (Dr - Cr)
 DocType: Lead,Lead Owner,Lead Owner
 DocType: Bin,Requested Quantity,kërkohet Sasia
 DocType: Patient,Marital Status,Statusi martesor
@@ -3543,33 +3777,36 @@
 DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Gross Pay - Zbritja Total - shlyerjen e kredisë
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +26,Current BOM and New BOM can not be same,BOM aktuale dhe të reja bom nuk mund të jetë e njëjtë
 apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +45,Salary Slip ID,Paga Slip ID
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +113,Date Of Retirement must be greater than Date of Joining,Data e daljes në pension duhet të jetë më i madh se data e bashkimit
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +52,There were errors while scheduling course on :,"Ka pasur gabime, ndërsa caktimin kurs për:"
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +118,Date Of Retirement must be greater than Date of Joining,Data e daljes në pension duhet të jetë më i madh se data e bashkimit
+apps/erpnext/erpnext/stock/doctype/item/item.js +68,Multiple Variants,Variante të shumëfishta
 DocType: Sales Invoice,Against Income Account,Kundër llogarisë së të ardhurave
 apps/erpnext/erpnext/controllers/website_list_for_contact.py +117,{0}% Delivered,{0}% Dorëzuar
-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).,Item {0}: Qty Urdhërohet {1} nuk mund të jetë më pak se Qty mënyrë minimale {2} (përcaktuar në pikën).
+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).,Item {0}: Qty Urdhërohet {1} nuk mund të jetë më pak se Qty mënyrë minimale {2} (përcaktuar në pikën).
 DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Mujor Përqindja e shpërndarjes
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +90,Please login as another user.,Ju lutemi identifikohuni si një përdorues tjetër.
 DocType: Territory,Territory Targets,Synimet Territory
+DocType: Soil Analysis,Ca/Mg,Ca / Mg
 DocType: Delivery Note,Transporter Info,Transporter Informacion
-apps/erpnext/erpnext/accounts/utils.py +497,Please set default {0} in Company {1},Ju lutemi të vendosur parazgjedhur {0} në Kompaninë {1}
+apps/erpnext/erpnext/accounts/utils.py +499,Please set default {0} in Company {1},Ju lutemi të vendosur parazgjedhur {0} në Kompaninë {1}
 DocType: Cheque Print Template,Starting position from top edge,pozicion nga buzë të lartë duke filluar
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +31,Same supplier has been entered multiple times,Same furnizuesi është lidhur shumë herë
 apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Fitimi bruto / Humbja
 DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Blerje Rendit Item furnizuar
-apps/erpnext/erpnext/public/js/setup_wizard.js +90,Company Name cannot be Company,Emri i kompanisë nuk mund të jetë i kompanisë
+apps/erpnext/erpnext/public/js/setup_wizard.js +94,Company Name cannot be Company,Emri i kompanisë nuk mund të jetë i kompanisë
 apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,Kryetarët letër për të shtypura templates.
 apps/erpnext/erpnext/config/setup.py +32,Titles for print templates e.g. Proforma Invoice.,Titujt për shtypura templates p.sh. ProFORMA faturë.
 DocType: Program Enrollment,Walking,ecje
 DocType: Student Guardian,Student Guardian,Guardian Student
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +201,Valuation type charges can not marked as Inclusive,Akuzat lloj vlerësimi nuk mund të shënuar si gjithëpërfshirës
+DocType: Member,Member Name,Emri i Anëtarit
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218,Valuation type charges can not marked as Inclusive,Akuzat lloj vlerësimi nuk mund të shënuar si gjithëpërfshirës
 DocType: POS Profile,Update Stock,Update Stock
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,in the subscription,në abonim
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100,Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,UOM ndryshme për sendet do të çojë në të gabuar (Total) vlerën neto Pesha. Sigurohuni që pesha neto e çdo send është në të njëjtën UOM.
+DocType: Membership,Payment Details,Detajet e pagesës
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,Bom Rate
 DocType: Asset,Journal Entry for Scrap,Journal Hyrja për skrap
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83,Please pull items from Delivery Note,Ju lutemi të tërheqë sendet nga i dorëzimit Shënim
-apps/erpnext/erpnext/accounts/utils.py +467,Journal Entries {0} are un-linked,Journal Entries {0} janë të pa-lidhura
+apps/erpnext/erpnext/accounts/utils.py +469,Journal Entries {0} are un-linked,Journal Entries {0} janë të pa-lidhura
 apps/erpnext/erpnext/config/crm.py +92,"Record of all communications of type email, phone, chat, visit, etc.","Rekord të të gjitha komunikimeve të tipit mail, telefon, chat, vizita, etj"
 DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Rezultati i rezultatit të furnitorit
 DocType: Manufacturer,Manufacturers used in Items,Prodhuesit e përdorura në artikujt
@@ -3579,9 +3816,10 @@
 DocType: Buying Settings,Purchase Order Required,Blerje urdhër që nevojitet
 ,Item-wise Sales History,Pika-mençur Historia Sales
 DocType: Expense Claim,Total Sanctioned Amount,Shuma totale e sanksionuar
+DocType: Land Unit,Land Unit,Njësia e Tokës
 ,Purchase Analytics,Analytics Blerje
 DocType: Sales Invoice Item,Delivery Note Item,Ofrimit Shënim Item
-DocType: Expense Claim,Task,Detyrë
+DocType: Asset Maintenance Log,Task,Detyrë
 DocType: Purchase Taxes and Charges,Reference Row #,Referenca Row #
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76,Batch number is mandatory for Item {0},Numri i Batch është i detyrueshëm për Item {0}
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13,This is a root sales person and cannot be edited.,Ky është një person i shitjes rrënjë dhe nuk mund të redaktohen.
@@ -3591,8 +3829,8 @@
 apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},Shkalla: {0}
 DocType: Company,Exchange Gain / Loss Account,Exchange Gain / Humbja e llogarisë
 apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Punonjës dhe Pjesëmarrja
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +78,Purpose must be one of {0},Qëllimi duhet të jetë një nga {0}
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +105,Fill the form and save it,Plotësoni formularin dhe për të shpëtuar atë
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +83,Purpose must be one of {0},Qëllimi duhet të jetë një nga {0}
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +116,Fill the form and save it,Plotësoni formularin dhe për të shpëtuar atë
 DocType: Production Planning Tool,Download a report containing all raw materials with their latest inventory status,Shkarko një raport që përmban të gjitha lëndëve të para me statusin e tyre të fundit inventar
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Forumi Komuniteti
 apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Actual qty in stock,Qty aktuale në magazinë
@@ -3606,7 +3844,7 @@
 DocType: Purchase Order,Get Items from Open Material Requests,Të marrë sendet nga kërkesat Hapur Materiale
 DocType: Lab Test Template,Standard Selling Rate,Standard Shitja Vlerësoni
 DocType: Account,Rate at which this tax is applied,Shkalla në të cilën kjo taksë aplikohet
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +65,Reorder Qty,Reorder Qty
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +75,Reorder Qty,Reorder Qty
 apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28,Current Job Openings,Hapje e tanishme e punës
 DocType: Company,Stock Adjustment Account,Llogaria aksioneve Rregullimit
 apps/erpnext/erpnext/public/js/payment/pos_payment.html +17,Write Off,Shkruani Off
@@ -3617,36 +3855,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.,Në pritje për përditësimin e çmimit të fundit në të gjitha dokumentet e materialeve. Mund të duhen disa minuta.
 apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Emri i llogarisë së re. Shënim: Ju lutem mos krijoni llogari për klientët dhe furnizuesit
 apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Shteti parazgjedhur i mençur Adresa Templates
+DocType: Water Analysis,Appearance,shfaqje
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Buying Price List Rate,Avg. Blerja e çmimit të listës së çmimeve
 DocType: Sales Order Item,Supplier delivers to Customer,Furnizuesi jep Klientit
+apps/erpnext/erpnext/config/non_profit.py +23,Member information.,Informacioni i anëtarit.
 apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Forma / Item / {0}) është nga të aksioneve
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +58,Asset Maintenance,Mirëmbajtja e aseteve
 ,Sales Payment Summary,Përmbledhje e Shitjeve të Pagesave
 DocType: Restaurant,Restaurant,Restorant
-apps/erpnext/erpnext/accounts/party.py +322,Due / Reference Date cannot be after {0},Për shkak / Referenca Data nuk mund të jetë pas {0}
+apps/erpnext/erpnext/accounts/party.py +323,Due / Reference Date cannot be after {0},Për shkak / Referenca Data nuk mund të jetë pas {0}
 apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Importi dhe Eksporti i të dhënave
 DocType: Patient,Account Details,detajet e llogarise
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +76,No students Found,Nuk studentët Found
+DocType: Crop,Materials Required,Materialet e kërkuara
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76,No students Found,Nuk studentët Found
 DocType: Medical Department,Medical Department,Departamenti i Mjekësisë
 DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Kriteret e Shënimit të Rezultatit të Furnizuesit
 apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55,Invoice Posting Date,Fatura Posting Data
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,shes
-DocType: Sales Invoice,Rounded Total,Rrumbullakuar Total
+DocType: Purchase Invoice,Rounded Total,Rrumbullakuar Total
 DocType: Product Bundle,List items that form the package.,Artikuj lista që formojnë paketë.
 apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Alokimi përqindje duhet të jetë e barabartë me 100%
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +567,Please select Posting Date before selecting Party,"Ju lutem, përzgjidhni datën e postimit para se të zgjedhur Partinë"
+DocType: Crop Cycle,Linked Land Unit,Njësia e lidhur tokësore
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584,Please select Posting Date before selecting Party,"Ju lutem, përzgjidhni datën e postimit para se të zgjedhur Partinë"
 DocType: Program Enrollment,School House,School House
 DocType: Serial No,Out of AMC,Nga AMC
-apps/erpnext/erpnext/public/js/utils.js +263,Please select Quotations,"Ju lutem, përzgjidhni Citate"
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +82,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Numri i nënçmime rezervuar nuk mund të jetë më e madhe se Total Numri i nënçmime
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +82,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Numri i nënçmime rezervuar nuk mund të jetë më e madhe se Total Numri i nënçmime
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Bëni Mirëmbajtja vizitë
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +170,Please contact to the user who have Sales Master Manager {0} role,Ju lutem kontaktoni për përdoruesit të cilët kanë Sales Master Menaxher {0} rol
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +198,Please contact to the user who have Sales Master Manager {0} role,Ju lutem kontaktoni për përdoruesit të cilët kanë Sales Master Menaxher {0} rol
 DocType: Company,Default Cash Account,Gabim Llogaria Cash
 apps/erpnext/erpnext/config/accounts.py +62,Company (not Customer or Supplier) master.,Kompani (jo Customer ose Furnizuesi) mjeshtër.
-apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,Kjo është e bazuar në pjesëmarrjen e këtij Student
-apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +178,No Students in,Nuk ka Studentët në
+apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,Kjo është e bazuar në pjesëmarrjen e këtij Student
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +178,No Students in,Nuk ka Studentët në
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +171,Add more items or open full form,Shto artikuj më shumë apo formë të hapur të plotë
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +206,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Shënime ofrimit {0} duhet të anulohet para se anulimi këtë Radhit Sales
-apps/erpnext/erpnext/utilities/user_progress.py +238,Go to Users,Shko te Përdoruesit
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +82,Paid amount + Write Off Amount can not be greater than Grand Total,Shuma e paguar + anullojë Shuma nuk mund të jetë më i madh se Grand Total
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Shënime ofrimit {0} duhet të anulohet para se anulimi këtë Radhit Sales
+apps/erpnext/erpnext/utilities/user_progress.py +256,Go to Users,Shko te Përdoruesit
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85,Paid amount + Write Off Amount can not be greater than Grand Total,Shuma e paguar + anullojë Shuma nuk mund të jetë më i madh se Grand Total
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78,{0} is not a valid Batch Number for Item {1},{0} nuk është një numër i vlefshëm Batch për Item {1}
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +149,Note: There is not enough leave balance for Leave Type {0},Shënim: Nuk ka bilanc mjaft leje për pushim Lloji {0}
 apps/erpnext/erpnext/regional/india/utils.py +15,Invalid GSTIN or Enter NA for Unregistered,GSTIN pavlefshme ose Shkruani NA për paregjistruar
@@ -3664,31 +3907,35 @@
 DocType: Hub Settings,Publish Availability,Publikimi i Disponueshmëria
 DocType: Company,Create Chart Of Accounts Based On,Krijoni planin kontabël në bazë të
 apps/erpnext/erpnext/projects/doctype/task/task.js +91,Cannot convert it to non-group. Child Tasks exist.,Nuk mund të konvertohet në jo-grup. Detyrat e fëmijëve ekzistojnë.
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +107,Date of Birth cannot be greater than today.,Data e lindjes nuk mund të jetë më e madhe se sa sot.
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +112,Date of Birth cannot be greater than today.,Data e lindjes nuk mund të jetë më e madhe se sa sot.
 ,Stock Ageing,Stock plakjen
-apps/erpnext/erpnext/schools/doctype/student/student.py +38,Student {0} exist against student applicant {1},Student {0} ekzistojnë kundër aplikantit studentore {1}
+apps/erpnext/erpnext/education/doctype/student/student.py +38,Student {0} exist against student applicant {1},Student {0} ekzistojnë kundër aplikantit studentore {1}
 DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Rregullimi i Llogaritjeve (Valuta e Kompanisë)
 apps/erpnext/erpnext/projects/doctype/task/task.js +39,Timesheet,pasqyrë e mungesave
-apps/erpnext/erpnext/controllers/accounts_controller.py +233,{0} '{1}' is disabled,{0} &#39;{1}&#39; është me aftësi të kufizuara
+DocType: Volunteer,Afternoon,pasdite
+apps/erpnext/erpnext/controllers/accounts_controller.py +256,{0} '{1}' is disabled,{0} &#39;{1}&#39; është me aftësi të kufizuara
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Bëje si Open
 DocType: Cheque Print Template,Scanned Cheque,skanuar çek
 DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Dërgo email automatike në Kontaktet për transaksionet Dorëzimi.
 DocType: Timesheet,Total Billable Amount,Shuma totale billable
+DocType: Customer,Credit Limit and Payment Terms,Kufizimet e kredisë dhe kushtet e pagesës
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,Pika 3
 apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6,Order Entry,Rendit Hyrja
 DocType: Purchase Order,Customer Contact Email,Customer Contact Email
 DocType: Warranty Claim,Item and Warranty Details,Pika dhe Garanci Details
+DocType: Chapter,Chapter Members,Anëtarët e Kapitullit
 DocType: Sales Team,Contribution (%),Kontributi (%)
-apps/erpnext/erpnext/controllers/accounts_controller.py +75,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Shënim: Pagesa Hyrja nuk do të jetë krijuar që nga &#39;Cash ose Llogarisë Bankare &quot;nuk ishte specifikuar
-apps/erpnext/erpnext/projects/doctype/project/project.py +65,Project {0} already exists,Projekti {0} tashmë ekziston
+apps/erpnext/erpnext/controllers/accounts_controller.py +100,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Shënim: Pagesa Hyrja nuk do të jetë krijuar që nga &#39;Cash ose Llogarisë Bankare &quot;nuk ishte specifikuar
+apps/erpnext/erpnext/projects/doctype/project/project.py +67,Project {0} already exists,Projekti {0} tashmë ekziston
 DocType: Medical Department,Nursing User,Përdorues i Infermierisë
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +227,Responsibilities,Përgjegjësitë
+DocType: Plant Analysis,Plant Analysis Criterias,Kriteret e Analizës së Bimëve
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +237,Responsibilities,Përgjegjësitë
 apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125,Validity period of this quotation has ended.,Periudha e vlefshmërisë së këtij citati ka përfunduar.
 DocType: Expense Claim Account,Expense Claim Account,Llogaria Expense Kërkesa
 DocType: Accounts Settings,Allow Stale Exchange Rates,Lejoni shkëmbimin e stale të këmbimit
 DocType: Sales Person,Sales Person Name,Sales Person Emri
 apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,Ju lutemi shkruani atleast 1 faturën në tryezë
-apps/erpnext/erpnext/utilities/user_progress.py +226,Add Users,Shto Përdoruesit
+apps/erpnext/erpnext/utilities/user_progress.py +244,Add Users,Shto Përdoruesit
 DocType: POS Item Group,Item Group,Grupi i artikullit
 DocType: Item,Safety Stock,Siguria Stock
 DocType: Healthcare Settings,Healthcare Settings,Cilësimet e kujdesit shëndetësor
@@ -3696,74 +3943,78 @@
 DocType: Stock Reconciliation Item,Before reconciliation,Para se të pajtimit
 apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12,To {0},Për {0}
 DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Taksat dhe Tarifat Shtuar (Kompania Valuta)
-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,Row Tatimore pika {0} duhet të keni një llogari te tipit Tatimit ose e ardhur ose shpenzim ose ngarkimit
+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,Row Tatimore pika {0} duhet të keni një llogari te tipit Tatimit ose e ardhur ose shpenzim ose ngarkimit
 DocType: Sales Order,Partly Billed,Faturuar Pjesërisht
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,Item {0} duhet të jetë një artikull Fixed Asset
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,Item {0} duhet të jetë një artikull Fixed Asset
+apps/erpnext/erpnext/stock/doctype/item/item.js +341,Make Variants,Bëni variantet
 DocType: Item,Default BOM,Gabim bom
+DocType: Project,Total Billed Amount (via Sales Invoices),Shuma Totale e Faturuar (përmes Faturat e Shitjes)
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Debit Note Amount,Debit Shënim Shuma
 apps/erpnext/erpnext/setup/doctype/company/company.js +60,Please re-type company name to confirm,Ju lutem ri-lloj emri i kompanisë për të konfirmuar
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +79,Total Outstanding Amt,Outstanding Amt Total
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +90,Total Outstanding Amt,Outstanding Amt Total
 DocType: Journal Entry,Printing Settings,Printime Cilësimet
+DocType: Employee Advance,Advance Account,Llogaria paraprake
 DocType: Sales Invoice,Include Payment (POS),Përfshijnë Pagesa (POS)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292,Total Debit must be equal to Total Credit. The difference is {0},Debiti i përgjithshëm duhet të jetë e barabartë me totalin e kredisë. Dallimi është {0}
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +11,Automotive,Automobilistik
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +290,Total Debit must be equal to Total Credit. The difference is {0},Debiti i përgjithshëm duhet të jetë e barabartë me totalin e kredisë. Dallimi është {0}
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11,Automotive,Automobilistik
 DocType: Vehicle,Insurance Company,Kompania e sigurimeve
 DocType: Asset Category Account,Fixed Asset Account,Llogaria Fixed Asset
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397,Variable,variabël
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +414,Variable,variabël
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,From Delivery Note,Nga dorëzim Shënim
+DocType: Chapter,Members,Anëtarët
 DocType: Student,Student Email Address,Student Email Adresa
 DocType: Item,Hub Warehouse,Magazina Hub
-DocType: Physician Schedule Time Slot,From Time,Nga koha
+DocType: Assessment Plan,From Time,Nga koha
 apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock: ,Në magazinë:
 DocType: Notification Control,Custom Message,Custom Mesazh
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +33,Investment Banking,Investimeve Bankare
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +78,Cash or Bank Account is mandatory for making payment entry,Cash ose Banka Llogaria është e detyrueshme për të bërë hyrjen e pagesës
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Adresa Student
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33,Investment Banking,Investimeve Bankare
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79,Cash or Bank Account is mandatory for making payment entry,Cash ose Banka Llogaria është e detyrueshme për të bërë hyrjen e pagesës
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Adresa Student
 DocType: Purchase Invoice,Price List Exchange Rate,Lista e Çmimeve Exchange Rate
+apps/erpnext/erpnext/accounts/doctype/account/account.py +253,Account Number {0} already used in account {1},Numri i llogarisë {0} që përdoret tashmë në llogarinë {1}
 DocType: POS Profile,POS Profile Name,Emri i Profilit POS
 DocType: Purchase Invoice Item,Rate,Normë
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +100,Intern,Mjek praktikant
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1569,Address Name,adresa Emri
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104,Intern,Mjek praktikant
+DocType: Delivery Stop,Address Name,adresa Emri
 DocType: Stock Entry,From BOM,Nga bom
 DocType: Assessment Code,Assessment Code,Kodi i vlerësimit
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +69,Basic,Themelor
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73,Basic,Themelor
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,Transaksionet e aksioneve para {0} janë të ngrira
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219,Please click on 'Generate Schedule',Ju lutem klikoni në &quot;Generate Listën &#39;
-apps/erpnext/erpnext/config/stock.py +195,"e.g. Kg, Unit, Nos, m","p.sh. Kg, Njësia, Nos, m"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122,Reference No is mandatory if you entered Reference Date,"Referenca Nuk është e detyrueshme, nëse keni hyrë Reference Data"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +120,Reference No is mandatory if you entered Reference Date,"Referenca Nuk është e detyrueshme, nëse keni hyrë Reference Data"
 DocType: Bank Reconciliation Detail,Payment Document,Dokumenti pagesa
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37,Error evaluating the criteria formula,Gabim gjatë vlerësimit të formulës së kritereve
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +110,Date of Joining must be greater than Date of Birth,Data e bashkuar duhet të jetë më i madh se Data e lindjes
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +115,Date of Joining must be greater than Date of Birth,Data e bashkuar duhet të jetë më i madh se Data e lindjes
 DocType: Salary Slip,Salary Structure,Struktura e pagave
 DocType: Account,Bank,Banka
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +9,Airline,Linjë ajrore
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +827,Issue Material,Materiali çështje
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9,Airline,Linjë ajrore
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +852,Issue Material,Materiali çështje
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,An error occured while creating recurring,Ndodhi një gabim gjatë krijimit të përsëritjes
 DocType: Material Request Item,For Warehouse,Për Magazina
 DocType: Employee,Offer Date,Oferta Data
 apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Quotations,Citate
-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.,Ju jeni në offline mode. Ju nuk do të jetë në gjendje për të rifreskoni deri sa të ketë rrjet.
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,Nuk Grupet Student krijuar.
+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.,Ju jeni në offline mode. Ju nuk do të jetë në gjendje për të rifreskoni deri sa të ketë rrjet.
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,Nuk Grupet Student krijuar.
 DocType: Purchase Invoice Item,Serial No,Serial Asnjë
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119,Monthly Repayment Amount cannot be greater than Loan Amount,Shuma mujore e pagesës nuk mund të jetë më e madhe se Shuma e Kredisë
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143,Please enter Maintaince Details first,Ju lutemi shkruani maintaince Detaje parë
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +55,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Rreshti # {0}: Data e pritshme e dorëzimit nuk mund të jetë para datës së porosisë së blerjes
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Rreshti # {0}: Data e pritshme e dorëzimit nuk mund të jetë para datës së porosisë së blerjes
 DocType: Purchase Invoice,Print Language,Print Gjuha
 DocType: Salary Slip,Total Working Hours,Gjithsej Orari i punës
 DocType: Subscription,Next Schedule Date,Data e ardhshme e orarit
 DocType: Stock Entry,Including items for sub assemblies,Duke përfshirë edhe artikuj për nën kuvendet
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1928,Enter value must be positive,Shkruani Vlera duhet të jetë pozitiv
+DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Llogaria e hapjes së përkohshme
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1943,Enter value must be positive,Shkruani Vlera duhet të jetë pozitiv
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +392,All Territories,Të gjitha Territoret
 DocType: Purchase Invoice,Items,Artikuj
-apps/erpnext/erpnext/schools/doctype/program_enrollment/program_enrollment.py +26,Student is already enrolled.,Studenti është regjistruar tashmë.
+apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +28,Student is already enrolled.,Studenti është regjistruar tashmë.
 DocType: Fiscal Year,Year Name,Viti Emri
-DocType: Process Payroll,Process Payroll,Procesi i Pagave
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +240,There are more holidays than working days this month.,Ka më shumë pushimet sesa ditëve pune këtë muaj.
 DocType: Product Bundle Item,Product Bundle Item,Produkt Bundle Item
 DocType: Sales Partner,Sales Partner Name,Emri Sales Partner
-apps/erpnext/erpnext/hooks.py +132,Request for Quotations,Kërkesën për kuotimin
+apps/erpnext/erpnext/hooks.py +136,Request for Quotations,Kërkesën për kuotimin
 DocType: Payment Reconciliation,Maximum Invoice Amount,Shuma maksimale Faturë
-apps/erpnext/erpnext/healthcare/setup.py +209,Haematology,hematologjisë
+apps/erpnext/erpnext/healthcare/setup.py +210,Haematology,hematologjisë
 DocType: Normal Test Items,Normal Test Items,Artikujt e Testimit Normal
 DocType: Student Language,Student Language,Student Gjuha
 apps/erpnext/erpnext/config/selling.py +23,Customers,Klientët
@@ -3773,11 +4024,12 @@
 DocType: Asset,Partially Depreciated,amortizuar pjesërisht
 DocType: Issue,Opening Time,Koha e hapjes
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +92,From and To dates required,Nga dhe në datat e kërkuara
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +46,Securities & Commodity Exchanges,Letrave me Vlerë dhe Shkëmbimeve të Mallrave
-apps/erpnext/erpnext/stock/doctype/item/item.py +675,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Default njësinë e matjes për Varianti &#39;{0}&#39; duhet të jetë i njëjtë si në Template &#39;{1}&#39;
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46,Securities & Commodity Exchanges,Letrave me Vlerë dhe Shkëmbimeve të Mallrave
+apps/erpnext/erpnext/stock/doctype/item/item.py +661,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Default njësinë e matjes për Varianti &#39;{0}&#39; duhet të jetë i njëjtë si në Template &#39;{1}&#39;
 DocType: Shipping Rule,Calculate Based On,Llogaritur bazuar në
 DocType: Delivery Note Item,From Warehouse,Nga Magazina
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +897,No Items with Bill of Materials to Manufacture,Nuk Items me faturën e materialeve të Prodhimi
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59,No employees for the mentioned criteria,Asnjë punonjës për kriteret e përmendura
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +944,No Items with Bill of Materials to Manufacture,Nuk Items me faturën e materialeve të Prodhimi
 DocType: Restaurant,Default Customer,Customer Default
 DocType: Assessment Plan,Supervisor Name,Emri Supervisor
 DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,Mos konfirmoni nëse emërimi është krijuar për të njëjtën ditë
@@ -3787,40 +4039,41 @@
 DocType: Tax Rule,Shipping City,Shipping Qyteti
 DocType: Notification Control,Customize the Notification,Customize Njoftimin
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +19,Cash Flow from Operations,Cash Flow nga operacionet
-DocType: Sales Invoice,Shipping Rule,Rregulla anijeve
+DocType: Purchase Invoice,Shipping Rule,Rregulla anijeve
 DocType: Patient Relation,Spouse,bashkëshort
 DocType: Lab Test Groups,Add Test,Shto Test
 DocType: Manufacturer,Limited to 12 characters,Kufizuar në 12 karaktere
 DocType: Journal Entry,Print Heading,Printo Kreu
+apps/erpnext/erpnext/config/stock.py +146,Delivery Trip service tours to customers.,Shërbimet e udhëtimit të udhëtimit për klientët.
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57,Total cannot be zero,Gjithsej nuk mund të jetë zero
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16,'Days Since Last Order' must be greater than or equal to zero,&quot;Ditët Që Rendit Fundit&quot; duhet të jetë më e madhe se ose e barabartë me zero
-DocType: Process Payroll,Payroll Frequency,Payroll Frekuenca
+DocType: Plant Analysis Criteria,Maximum Permissible Value,Vlera maksimale e lejuar
+DocType: Journal Entry Account,Employee Advance,Advance punonjës
+DocType: Payroll Entry,Payroll Frequency,Payroll Frekuenca
 DocType: Lab Test Template,Sensitivity,ndjeshmëri
-DocType: Asset,Amended From,Ndryshuar Nga
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +58,Raw Material,Raw Material
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +62,Raw Material,Raw Material
 DocType: Leave Application,Follow via Email,Ndiqni nëpërmjet Email
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55,Plants and Machineries,Bimët dhe makineri
 DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Shuma e taksave Pas Shuma ulje
 DocType: Daily Work Summary Settings,Daily Work Summary Settings,Daily Settings Përmbledhje Work
 DocType: Payment Entry,Internal Transfer,Transfer të brendshme
-apps/erpnext/erpnext/accounts/doctype/account/account.py +179,Child account exists for this account. You can not delete this account.,Llogari fëmijë ekziston për këtë llogari. Ju nuk mund të fshini këtë llogari.
+DocType: Asset Maintenance,Maintenance Tasks,Detyrat e Mirmbajtjes
 apps/erpnext/erpnext/setup/doctype/territory/territory.py +19,Either target qty or target amount is mandatory,Ose Qty objektiv ose shuma e synuar është e detyrueshme
-apps/erpnext/erpnext/stock/get_item_details.py +536,No default BOM exists for Item {0},Nuk ekziston parazgjedhur bom për Item {0}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +359,Please select Posting Date first,"Ju lutem, përzgjidhni datën e postimit parë"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +367,Please select Posting Date first,"Ju lutem, përzgjidhni datën e postimit parë"
 apps/erpnext/erpnext/public/js/account_tree_grid.js +210,Opening Date should be before Closing Date,Hapja Data duhet të jetë para datës së mbylljes
 DocType: Leave Control Panel,Carry Forward,Bart
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cost Center with existing transactions can not be converted to ledger,Qendra Kosto me transaksionet ekzistuese nuk mund të konvertohet në Ledger
 DocType: Department,Days for which Holidays are blocked for this department.,Ditë për të cilat Festat janë bllokuar për këtë departament.
+DocType: Crop Cycle,Detected Disease,Zbulohet Sëmundja
 ,Produced,Prodhuar
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +118,Created Salary Slips,Krijuar pagave rrëshqet
 DocType: Item,Item Code for Suppliers,Item Kodi për Furnizuesit
 DocType: Issue,Raised By (Email),Ngritur nga (Email)
 DocType: Training Event,Trainer Name,Emri trajner
 DocType: Mode of Payment,General,I përgjithshëm
 apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,Komunikimi i fundit
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +355,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Nuk mund të zbres kur kategori është për &#39;vlerësimit&#39; ose &#39;Vlerësimit dhe Total &quot;
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +372,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Nuk mund të zbres kur kategori është për &#39;vlerësimit&#39; ose &#39;Vlerësimit dhe Total &quot;
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +234,Serial Nos Required for Serialized Item {0},Serial Nos kërkuar për Item serialized {0}
-apps/erpnext/erpnext/config/accounts.py +152,Match Payments with Invoices,Pagesat ndeshje me faturat
+apps/erpnext/erpnext/config/accounts.py +144,Match Payments with Invoices,Pagesat ndeshje me faturat
 DocType: Journal Entry,Bank Entry,Banka Hyrja
 DocType: Authorization Rule,Applicable To (Designation),Për të zbatueshme (Përcaktimi)
 ,Profitability Analysis,Analiza e profitabilitetit
@@ -3830,17 +4083,19 @@
 apps/erpnext/erpnext/templates/generators/item.html +62,Add to Cart,Futeni në kosh
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,Grupi Nga
 DocType: Guardian,Interests,interesat
-apps/erpnext/erpnext/config/accounts.py +306,Enable / disable currencies.,Enable / disable monedhave.
+apps/erpnext/erpnext/config/accounts.py +298,Enable / disable currencies.,Enable / disable monedhave.
 DocType: Production Planning Tool,Get Material Request,Get materiale Kërkesë
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Postal Expenses,Shpenzimet postare
 apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Gjithsej (Amt)
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +26,Entertainment & Leisure,Entertainment &amp; Leisure
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26,Entertainment & Leisure,Entertainment &amp; Leisure
+,Item Variant Details,Detajet e variantit të artikullit
 DocType: Quality Inspection,Item Serial No,Item Nr Serial
 apps/erpnext/erpnext/utilities/activation.py +135,Create Employee Records,Krijo Records punonjësve
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Present,I pranishëm Total
-apps/erpnext/erpnext/config/accounts.py +113,Accounting Statements,Deklaratat e kontabilitetit
+apps/erpnext/erpnext/config/accounts.py +105,Accounting Statements,Deklaratat e kontabilitetit
 DocType: Drug Prescription,Hour,Orë
 DocType: Restaurant Order Entry,Last Sales Invoice,Fatura e shitjeve të fundit
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +799,Please select Qty against item {0},Ju lutem zgjidhni Qty kundër sendit {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Jo i ri Serial nuk mund të ketë depo. Magazina duhet të përcaktohen nga Bursa e hyrjes ose marrjes Blerje
 DocType: Lead,Lead Type,Lead Type
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133,You are not authorized to approve leaves on Block Dates,Ju nuk jeni i autorizuar të miratojë lë në datat Block
@@ -3852,6 +4107,7 @@
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13,Unknown,I panjohur
 DocType: Shipping Rule,Shipping Rule Conditions,Shipping Rregulla Kushte
 DocType: Purchase Invoice,Export Type,Lloji i eksportit
+DocType: Salary Slip Loan,Salary Slip Loan,Kredia për paga
 DocType: BOM Update Tool,The new BOM after replacement,BOM ri pas zëvendësimit
 ,Point of Sale,Pika e Shitjes
 DocType: Payment Entry,Received Amount,Shuma e marrë
@@ -3859,77 +4115,86 @@
 DocType: GST Settings,GSTIN Email Sent On,GSTIN Email dërguar më
 DocType: Program Enrollment,Pick/Drop by Guardian,Pick / rënie nga Guardian
 DocType: Production Planning Tool,"Create for full quantity, ignoring quantity already on order","Krijo për sasinë e plotë, duke injoruar sasi tashmë në mënyrë"
+DocType: Crop,Planting UOM,Mbjellja e UOM
 DocType: Account,Tax,Tatim
-apps/erpnext/erpnext/schools/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,i pashënuar
+apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,i pashënuar
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1,Opening Invoices Summary,Përmbledhja e hapjes së faturave
+DocType: Education Settings,Education Manager,Menaxher i Arsimit
 DocType: Production Planning Tool,Production Planning Tool,Planifikimi Tool prodhimit
+DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Gjatësia minimale në mes të çdo impianti në fushë për rritje optimale
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +150,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","Batched Item {0} nuk mund të përditësohet duke përdorur Stock pajtimit, në vend që të përdorin Stock Hyrja"
 DocType: Quality Inspection,Report Date,Raporti Data
 DocType: Student,Middle Name,emri i dytë
 DocType: C-Form,Invoices,Faturat
+DocType: Water Analysis,Type of Sample,Lloji i mostrës
 DocType: Batch,Source Document Name,Dokumenti Burimi Emri
 DocType: Job Opening,Job Title,Titulli Job
 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} tregon se {1} nuk do të japë një kuotim, por të gjitha artikujt \ janë cituar. Përditësimi i statusit të kuotës RFQ."
+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}.,Mostrat maksimale - {0} tashmë janë ruajtur për Serinë {1} dhe Pikën {2} në Serinë {3}.
 DocType: Manufacturing Settings,Update BOM Cost Automatically,Përditëso Kostoja e BOM-it automatikisht
 DocType: Lab Test,Test Name,Emri i testit
 apps/erpnext/erpnext/utilities/activation.py +99,Create Users,Krijo Përdoruesit
-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,Në muaj
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +394,Quantity to Manufacture must be greater than 0.,Sasi të Prodhimi duhet të jetë më e madhe se 0.
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +414,Quantity to Manufacture must be greater than 0.,Sasi të Prodhimi duhet të jetë më e madhe se 0.
 apps/erpnext/erpnext/config/maintenance.py +17,Visit report for maintenance call.,Vizitoni raport për thirrjen e mirëmbajtjes.
 DocType: Stock Entry,Update Rate and Availability,Update Vlerësoni dhe Disponueshmëria
 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.,"Përqindja ju keni të drejtë për të marrë ose të japë më shumë kundër sasi të urdhëruar. Për shembull: Nëse ju keni urdhëruar 100 njësi. dhe Allowance juaj është 10%, atëherë ju keni të drejtë për të marrë 110 njësi."
 DocType: POS Customer Group,Customer Group,Grupi Klientit
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +113,New Batch ID (Optional),New ID Batch (Fakultativ)
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +198,Expense account is mandatory for item {0},Llogari shpenzim është i detyrueshëm për pikën {0}
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +120,New Batch ID (Optional),New ID Batch (Fakultativ)
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201,Expense account is mandatory for item {0},Llogari shpenzim është i detyrueshëm për pikën {0}
 DocType: BOM,Website Description,Website Përshkrim
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +42,Net Change in Equity,Ndryshimi neto në ekuitetit
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +196,Newest,Më të Rejat
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +163,Please cancel Purchase Invoice {0} first,Ju lutemi anuloni Blerje Faturën {0} parë
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +163,Please cancel Purchase Invoice {0} first,Ju lutemi anuloni Blerje Faturën {0} parë
 apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43,"Email Address must be unique, already exists for {0}","Adresa Email duhet të jetë unike, tashmë ekziston për {0}"
 DocType: Serial No,AMC Expiry Date,AMC Data e Mbarimit
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +840,Receipt,Faturë
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +865,Receipt,Faturë
 ,Sales Register,Shitjet Regjistrohu
 DocType: Daily Work Summary Settings Company,Send Emails At,Dërgo email Në
 DocType: Quotation,Quotation Lost Reason,Citat Humbur Arsyeja
-apps/erpnext/erpnext/public/js/setup_wizard.js +19,Select your Domain,Zgjidh Domain tuaj
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +367,Transaction reference no {0} dated {1},reference Transaction asnjë {0} datë {1}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +368,Transaction reference no {0} dated {1},reference Transaction asnjë {0} datë {1}
 apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Nuk ka asgjë për të redaktuar.
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +419,Form View,Shiko formularin
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +476,Form View,Shiko formularin
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116,Summary for this month and pending activities,Përmbledhje për këtë muaj dhe aktivitetet në pritje
-apps/erpnext/erpnext/utilities/user_progress.py +227,"Add users to your organization, other than yourself.","Shtojini përdoruesit në organizatën tuaj, përveç vetes."
+apps/erpnext/erpnext/utilities/user_progress.py +245,"Add users to your organization, other than yourself.","Shtojini përdoruesit në organizatën tuaj, përveç vetes."
 DocType: Customer Group,Customer Group Name,Emri Grupi Klientit
 apps/erpnext/erpnext/public/js/pos/pos.html +98,No Customers yet!,Nuk ka Konsumatorët akoma!
 apps/erpnext/erpnext/public/js/financial_statements.js +56,Cash Flow Statement,Pasqyra Cash Flow
 apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23,Loan Amount cannot exceed Maximum Loan Amount of {0},Sasia huaja nuk mund të kalojë sasi maksimale huazimin e {0}
 apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22,License,Liçensë
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +481,Please remove this Invoice {0} from C-Form {1},Ju lutem hiqni këtë Faturë {0} nga C-Form {1}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +485,Please remove this Invoice {0} from C-Form {1},Ju lutem hiqni këtë Faturë {0} nga C-Form {1}
 DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,"Ju lutem, përzgjidhni Mbaj përpara në qoftë se ju të dëshironi që të përfshijë bilancit vitit të kaluar fiskal lë të këtij viti fiskal"
 DocType: GL Entry,Against Voucher Type,Kundër Voucher Type
 DocType: Physician,Phone (R),Telefoni (R)
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +50,Time slots added,Hapat e kohës shtohen
 DocType: Item,Attributes,Atributet
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31,Enable Template,Aktivizo modelin
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +223,Please enter Write Off Account,"Ju lutem, jepini të anullojë Llogari"
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226,Please enter Write Off Account,"Ju lutem, jepini të anullojë Llogari"
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,Rendit fundit Date
 DocType: Patient,B Negative,B Negative
+apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25,Maintenance Status has to be Cancelled or Completed to Submit,Statusi i mirëmbajtjes duhet të anulohet ose të përfundohet për t&#39;u dërguar
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47,Account {0} does not belongs to company {1},Llogaria {0} nuk i takon kompanisë {1}
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +873,Serial Numbers in row {0} does not match with Delivery Note,Numrat serial në rresht {0} nuk përputhet me shpërndarjen Note
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +878,Serial Numbers in row {0} does not match with Delivery Note,Numrat serial në rresht {0} nuk përputhet me shpërndarjen Note
 DocType: Student,Guardian Details,Guardian Details
 DocType: C-Form,C-Form,C-Forma
 apps/erpnext/erpnext/config/hr.py +18,Mark Attendance for multiple employees,Mark Pjesëmarrja për të punësuarit të shumta
+DocType: Agriculture Task,Start Day,Filloni Ditën
 DocType: Vehicle,Chassis No,Shasia No
 DocType: Payment Request,Initiated,Iniciuar
 DocType: Production Order,Planned Start Date,Planifikuar Data e Fillimit
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +592,Please select a BOM,Ju lutem zgjidhni një BOM
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +596,Please select a BOM,Ju lutem zgjidhni një BOM
 DocType: Serial No,Creation Document Type,Krijimi Dokumenti Type
+DocType: Project Task,View Timesheet,Shiko pamjen time
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54,End date must be greater than start date,Data e përfundimit duhet të jetë më e madhe se data e fillimit
 DocType: Leave Type,Is Encash,Është marr me para në dorë
 DocType: Leave Allocation,New Leaves Allocated,Gjethet e reja të alokuar
 apps/erpnext/erpnext/controllers/trends.py +269,Project-wise data is not available for Quotation,Të dhënat Project-i mençur nuk është në dispozicion për Kuotim
-apps/erpnext/erpnext/schools/doctype/student_admission/templates/student_admission.html +30,End on,Mbarojeni
+apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30,End on,Mbarojeni
 DocType: Project,Expected End Date,Pritet Data e Përfundimit
 DocType: Budget Account,Budget Amount,Shuma buxheti
+DocType: Donor,Donor Name,Emri i donatorit
 DocType: Appraisal Template,Appraisal Template Title,Vlerësimi Template Titulli
 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},Nga Data {0} për Employee {1} nuk mund të jetë para Data bashkuar punonjësit {2}
 apps/erpnext/erpnext/utilities/user_progress_utils.py +29,Commercial,Komercial
@@ -3941,32 +4206,34 @@
 DocType: Expense Claim,More Details,Më shumë detaje
 DocType: Supplier Quotation,Supplier Address,Furnizuesi Adresa
 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} Buxheti për Llogarinë {1} kundër {2} {3} është {4}. Ajo do të kalojë nga {5}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +685,Row {0}# Account must be of type 'Fixed Asset',Row {0} # Llogaria duhet të jenë të tipit &quot;Asset fikse &#39;
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +689,Row {0}# Account must be of type 'Fixed Asset',Row {0} # Llogaria duhet të jenë të tipit &quot;Asset fikse &#39;
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,Nga Qty
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,and unchcked Disabled in the,dhe unchcked Disabled në
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +46,Series is mandatory,Seria është i detyrueshëm
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +28,Financial Services,Shërbimet Financiare
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28,Financial Services,Shërbimet Financiare
 DocType: Student Sibling,Student ID,ID Student
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +457,Supplier Email,Email Furnizues
 apps/erpnext/erpnext/config/projects.py +46,Types of activities for Time Logs,Llojet e aktiviteteve për Koha Shkrime
-DocType: Tax Rule,Sales,Shitjet
+DocType: Opening Invoice Creation Tool,Sales,Shitjet
 DocType: Stock Entry Detail,Basic Amount,Shuma bazë
 DocType: Training Event,Exam,Provimi
 DocType: Complaint,Complaint,ankim
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +452,Warehouse required for stock Item {0},Magazina e nevojshme për aksioneve Item {0}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +456,Warehouse required for stock Item {0},Magazina e nevojshme për aksioneve Item {0}
 DocType: Leave Allocation,Unused leaves,Gjethet e papërdorura
 DocType: Patient,Alcohol Past Use,Përdorimi i mëparshëm i alkoolit
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +179,Cr,Cr
+DocType: Fertilizer Content,Fertilizer Content,Përmbajtja e plehut
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +188,Cr,Cr
 DocType: Tax Rule,Billing State,Shteti Faturimi
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +276,Transfer,Transferim
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +891,Fetch exploded BOM (including sub-assemblies),Fetch bom shpërtheu (përfshirë nën-kuvendet)
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +296,Transfer,Transferim
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +916,Fetch exploded BOM (including sub-assemblies),Fetch bom shpërtheu (përfshirë nën-kuvendet)
 DocType: Authorization Rule,Applicable To (Employee),Për të zbatueshme (punonjës)
-apps/erpnext/erpnext/controllers/accounts_controller.py +113,Due Date is mandatory,Për shkak Data është e detyrueshme
+apps/erpnext/erpnext/controllers/accounts_controller.py +135,Due Date is mandatory,Për shkak Data është e detyrueshme
 apps/erpnext/erpnext/controllers/item_variant.py +80,Increment for Attribute {0} cannot be 0,Rritja për Atributit {0} nuk mund të jetë 0
 DocType: Journal Entry,Pay To / Recd From,Për të paguar / Recd Nga
 DocType: Naming Series,Setup Series,Setup Series
 DocType: Payment Reconciliation,To Invoice Date,Në faturën Date
 DocType: Supplier,Contact HTML,Kontakt HTML
+DocType: Disease,Treatment Period,Periudha e Trajtimit
 ,Inactive Customers,Konsumatorët jo aktive
 DocType: Student Admission Program,Maximum Age,Mosha maksimale
 DocType: Landed Cost Voucher,LCV,LCV
@@ -3975,13 +4242,13 @@
 DocType: Stock Entry,Delivery Note No,Ofrimit Shënim Asnjë
 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","Nëse zgjidhet, vetëm Blerje kërkesat materiale për lëndën e parë finale do të përfshihen në Kërkesave materiale. Përndryshe, do të krijohen Kërkesat materiale për artikuj prind"
 DocType: Cheque Print Template,Message to show,Mesazhi për të treguar
-DocType: Company,Retail,Me pakicë
-DocType: Attendance,Absent,Që mungon
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +566,Product Bundle,Bundle produkt
+apps/erpnext/erpnext/public/js/setup_wizard.js +28,Retail,Me pakicë
+DocType: Student Attendance,Absent,Që mungon
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591,Product Bundle,Bundle produkt
 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,Nuk mund të gjej rezultatin duke filluar nga {0}. Duhet të kesh pikët e qendrës që mbulojnë 0 deri në 100
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +212,Row {0}: Invalid reference {1},Row {0}: referencë Invalid {1}
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +206,No submitted Delivery Notes found,Nuk u gjetën shënime dorëzimi dorëzimi
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +210,Row {0}: Invalid reference {1},Row {0}: referencë Invalid {1}
 DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Blerje taksat dhe tatimet Template
-DocType: Upload Attendance,Download Template,Shkarko Template
 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}: Ose debiti ose shuma e kredisë është e nevojshme për {2}
 DocType: GL Entry,Remarks,Vërejtje
@@ -3992,30 +4259,34 @@
 apps/erpnext/erpnext/utilities/activation.py +65,Make Lead,bëni Lead
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112,Print and Stationery,Print dhe Stationery
 DocType: Stock Settings,Show Barcode Field,Trego Barcode Field
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +782,Send Supplier Emails,Dërgo email furnizuesi
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +807,Send Supplier Emails,Dërgo email furnizuesi
 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.","Paga përpunuar tashmë për periudhën ndërmjet {0} dhe {1}, Lini periudha e aplikimit nuk mund të jetë në mes të këtyre datave."
-apps/erpnext/erpnext/config/stock.py +132,Installation record for a Serial No.,Rekord Instalimi për një Nr Serial
 DocType: Guardian Interest,Guardian Interest,Guardian Interesi
-apps/erpnext/erpnext/config/accounts.py +327,Setup default values for POS Invoices,Vendosni vlerat e parazgjedhur për faturat POS
-apps/erpnext/erpnext/config/hr.py +177,Training,stërvitje
+DocType: Volunteer,Availability,disponueshmëri
+apps/erpnext/erpnext/config/accounts.py +319,Setup default values for POS Invoices,Vendosni vlerat e parazgjedhur për faturat POS
+apps/erpnext/erpnext/config/hr.py +182,Training,stërvitje
 DocType: Timesheet,Employee Detail,Detail punonjës
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1 Email ID
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1 Email ID
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68,Next Date's day and Repeat on Day of Month must be equal,Dita datën tjetër dhe përsëritet në ditën e Muajit duhet të jetë e barabartë
 DocType: Lab Prescription,Test Code,Kodi i Testimit
 apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Parametrat për faqen e internetit
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +38,RFQs are not allowed for {0} due to a scorecard standing of {1},Kerkesat e kerkesave nuk lejohen per {0} per shkak te nje standarti te rezultateve te {1}
+DocType: Delivery Stop,Select/Unselect Delivery Notes,Zgjidh / Zgjidh Zgjidh shënimet e dorëzimit
 DocType: Offer Letter,Awaiting Response,Në pritje të përgjigjes
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60,Above,Sipër
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1298,Total Amount {0},Shuma totale {0}
-apps/erpnext/erpnext/controllers/item_variant.py +232,Invalid attribute {0} {1},atribut i pavlefshëm {0} {1}
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1375,Total Amount {0},Shuma totale {0}
+apps/erpnext/erpnext/controllers/item_variant.py +301,Invalid attribute {0} {1},atribut i pavlefshëm {0} {1}
 DocType: Supplier,Mention if non-standard payable account,Përmend në qoftë se llogaria jo-standarde pagueshme
-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',Ju lutemi zgjidhni grupin e vlerësimit të tjera se &quot;të gjitha grupet e vlerësimit &#39;
+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',Ju lutemi zgjidhni grupin e vlerësimit të tjera se &quot;të gjitha grupet e vlerësimit &#39;
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67,Row {0}: Cost center is required for an item {1},Rresht {0}: Qendra kosto është e nevojshme për një artikull {1}
 DocType: Training Event Employee,Optional,fakultativ
 DocType: Salary Slip,Earning & Deduction,Fituar dhe Zbritje
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +36,Optional. This setting will be used to filter in various transactions.,Fakultative. Ky rregullim do të përdoret për të filtruar në transaksionet e ndryshme.
+DocType: Agriculture Analysis Criteria,Water Analysis,Analiza e ujit
+DocType: Chapter,Region,Rajon
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38,Optional. This setting will be used to filter in various transactions.,Fakultative. Ky rregullim do të përdoret për të filtruar në transaksionet e ndryshme.
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +108,Negative Valuation Rate is not allowed,Negativ Rate Vlerësimi nuk është e lejuar
 DocType: Holiday List,Weekly Off,Weekly Off
+apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7,Reload Linked Analysis,Rifresko Analizimin e Lidhur
 DocType: Fiscal Year,"For e.g. 2012, 2012-13","Për shembull 2012, 2012-13"
 apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96,Provisional Profit / Loss (Credit),Fitimi / Humbja e Përkohshme (Credit)
 DocType: Sales Invoice,Return Against Sales Invoice,Kthehu kundër Sales Faturë
@@ -4027,11 +4298,10 @@
 ,Monthly Attendance Sheet,Mujore Sheet Pjesëmarrja
 DocType: Production Order Item,Production Order Item,Prodhimi Order Item
 apps/erpnext/erpnext/healthcare/report/lab_test_report/lab_test_report.py +15,No record found,Nuk ka Record gjetur
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +137,Cost of Scrapped Asset,Kostoja e asetit braktiset
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140,Cost of Scrapped Asset,Kostoja e asetit braktiset
 apps/erpnext/erpnext/controllers/stock_controller.py +236,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Qendra Kosto është e detyrueshme për Item {2}
 DocType: Vehicle,Policy No,Politika No
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +659,Get Items from Product Bundle,Të marrë sendet nga Bundle produktit
-apps/erpnext/erpnext/stock/doctype/item/item.py +663,"As stock exists against an item {0}, you can not enable has variants property","Ndërsa stoku ekziston kundër një artikulli {0}, ju nuk mund të aktivizoni ka variante pronash"
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +684,Get Items from Product Bundle,Të marrë sendet nga Bundle produktit
 DocType: Asset,Straight Line,Vijë e drejtë
 DocType: Project User,Project User,User Project
 apps/erpnext/erpnext/stock/doctype/batch/batch.js +64,Split,ndarje
@@ -4043,6 +4313,8 @@
 apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Data e fundit Komunikimi
 DocType: Sales Team,Contact No.,Kontakt Nr
 DocType: Bank Reconciliation,Payment Entries,Entries pagesës
+DocType: Land Unit,Land Unit Details,Detajet e Njësisë së Tokës
+DocType: Land Unit,Latitude,gjerësi
 DocType: Production Order,Scrap Warehouse,Scrap Magazina
 DocType: Production Order,Check if material transfer entry is not required,Kontrolloni nëse hyrja transferimi material nuk është e nevojshme
 DocType: Program Enrollment Tool,Get Students From,Get Studentët nga
@@ -4055,77 +4327,83 @@
 DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Shitjet Taksat dhe Tarifat Stampa
 apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68,Total (Credit),Total (Credit)
 DocType: Repayment Schedule,Payment Date,Data e pagesës
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +107,New Batch Qty,New Batch Qty
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +10,Apparel & Accessories,Veshmbathje &amp; Aksesorë
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +114,New Batch Qty,New Batch Qty
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10,Apparel & Accessories,Veshmbathje &amp; Aksesorë
 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.,Nuk mund të zgjidhej funksioni i rezultateve të peshuara. Sigurohuni që formula është e vlefshme.
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67,Number of Order,Numri i Rendit
 DocType: Item Group,HTML / Banner that will show on the top of product list.,HTML / Banner që do të tregojnë në krye të listës së produktit.
 DocType: Shipping Rule,Specify conditions to calculate shipping amount,Specifikoni kushtet për të llogaritur shumën e anijeve
+DocType: Program Enrollment,Institute's Bus,Autobus i Institutit
 DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Roli i lejohet të Accounts ngrirë dhe Edit ngrira gjitha
 DocType: Supplier Scorecard Scoring Variable,Path,Rrugë
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28,Cannot convert Cost Center to ledger as it has child nodes,Nuk mund të konvertohet Qendra Kosto të librit si ajo ka nyje fëmijë
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +56,Opening Value,Vlera e hapjes
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +66,Opening Value,Vlera e hapjes
 DocType: Salary Detail,Formula,formulë
 apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47,Serial #,Serial #
 DocType: Lab Test Template,Lab Test Template,Modeli i testimit të laboratorit
+DocType: Purchase Invoice Item,Total Weight,Pesha Totale
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94,Commission on Sales,Komisioni për Shitje
 DocType: Offer Letter Term,Value / Description,Vlera / Përshkrim
-apps/erpnext/erpnext/controllers/accounts_controller.py +565,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Row # {0}: Asset {1} nuk mund të paraqitet, ajo është tashmë {2}"
+apps/erpnext/erpnext/controllers/accounts_controller.py +609,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Row # {0}: Asset {1} nuk mund të paraqitet, ajo është tashmë {2}"
 DocType: Tax Rule,Billing Country,Faturimi Vendi
 DocType: Purchase Order Item,Expected Delivery Date,Pritet Data e dorëzimit
 DocType: Restaurant Order Entry,Restaurant Order Entry,Regjistrimi i Restorantit
 apps/erpnext/erpnext/accounts/general_ledger.py +132,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debi dhe Kredi jo të barabartë për {0} # {1}. Dallimi është {2}.
+DocType: Asset Maintenance Task,Assign To Name,Cakto për emrin
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98,Entertainment Expenses,Shpenzimet Argëtim
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +48,Make Material Request,Bëni materiale Kërkesë
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +63,Make Material Request,Bëni materiale Kërkesë
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20,Open Item {0},Hapur Artikull {0}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +214,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Shitjet Faturë {0} duhet të anulohet para anulimit këtë Radhit Sales
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Shitjet Faturë {0} duhet të anulohet para anulimit këtë Radhit Sales
 DocType: Consultation,Age,Moshë
 DocType: Sales Invoice Timesheet,Billing Amount,Shuma Faturimi
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Sasia e pavlefshme specifikuar për pika {0}. Sasia duhet të jetë më i madh se 0.
+DocType: Company,Default Employee Advance Account,Llogaria paraprake e punonjësve
 apps/erpnext/erpnext/config/hr.py +60,Applications for leave.,Aplikimet për leje.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +177,Account with existing transaction can not be deleted,Llogaria me transaksion ekzistues nuk mund të fshihet
+apps/erpnext/erpnext/accounts/doctype/account/account.py +166,Account with existing transaction can not be deleted,Llogaria me transaksion ekzistues nuk mund të fshihet
 DocType: Vehicle,Last Carbon Check,Last Kontrolloni Carbon
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102,Legal Expenses,Shpenzimet ligjore
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +130,Please select quantity on row ,Ju lutemi zgjidhni sasinë në rresht
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140,Please select quantity on row ,Ju lutemi zgjidhni sasinë në rresht
+apps/erpnext/erpnext/config/accounts.py +277,Make Opening Sales and Purchase Invoices,Bëni hapjen e shitjeve dhe blerjeve të faturave
 DocType: Purchase Invoice,Posting Time,Posting Koha
 DocType: Timesheet,% Amount Billed,% Shuma faturuar
 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;Koha për Emërim&quot; nuk është caktuar për Dr {0}. Shtojeni atë në Master Master.
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118,Telephone Expenses,Shpenzimet telefonike
 DocType: Sales Partner,Logo,Logo
 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.,Kontrolloni këtë në qoftë se ju doni për të detyruar përdoruesit për të zgjedhur një seri përpara se të kryeni. Nuk do të ketë parazgjedhur në qoftë se ju kontrolloni këtë.
-apps/erpnext/erpnext/stock/get_item_details.py +135,No Item with Serial No {0},Nuk ka artikull me Serial Nr {0}
+apps/erpnext/erpnext/stock/get_item_details.py +129,No Item with Serial No {0},Nuk ka artikull me Serial Nr {0}
 DocType: Email Digest,Open Notifications,Njoftimet Hapur
 DocType: Payment Entry,Difference Amount (Company Currency),Dallimi Shuma (Company Valuta)
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79,Direct Expenses,Shpenzimet direkte
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in Education &gt; Education Settings,Ju lutemi vendosni Sistemin e Emërimit të Instruktorit në Arsim&gt; Cilësimet e Arsimit
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Të ardhurat New Customer
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119,Travel Expenses,Shpenzimet e udhëtimit
 DocType: Maintenance Visit,Breakdown,Avari
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50,Add custom field Subscription in the doctype {0},Shto fushën me parapagesë në doktorin {0}
-apps/erpnext/erpnext/controllers/accounts_controller.py +677,Account: {0} with currency: {1} can not be selected,Llogaria: {0} me monedhën: {1} nuk mund të zgjidhen
+apps/erpnext/erpnext/controllers/accounts_controller.py +789,Account: {0} with currency: {1} can not be selected,Llogaria: {0} me monedhën: {1} nuk mund të zgjidhen
+DocType: Purchase Receipt Item,Sample Quantity,Sasia e mostrës
 DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.","Përditësimi i çmimit BOM automatikisht nëpërmjet Planifikuesit, bazuar në normën e fundit të vlerësimit / normën e çmimeve / normën e fundit të blerjes së lëndëve të para."
 DocType: Bank Reconciliation Detail,Cheque Date,Çek Data
-apps/erpnext/erpnext/accounts/doctype/account/account.py +54,Account {0}: Parent account {1} does not belong to company: {2},Llogaria {0}: llogari Parent {1} nuk i përkasin kompanisë: {2}
+apps/erpnext/erpnext/accounts/doctype/account/account.py +50,Account {0}: Parent account {1} does not belong to company: {2},Llogaria {0}: llogari Parent {1} nuk i përkasin kompanisë: {2}
 DocType: Program Enrollment Tool,Student Applicants,Aplikantët Student
 apps/erpnext/erpnext/setup/doctype/company/company.js +77,Successfully deleted all transactions related to this company!,Sukses të fshihen të gjitha transaksionet që lidhen me këtë kompani!
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +21,As on Date,Si në Data
 DocType: Appraisal,HR,HR
 DocType: Program Enrollment,Enrollment Date,regjistrimi Date
 DocType: Healthcare Settings,Out Patient SMS Alerts,Nga paralajmërimet e pacientit me SMS
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +96,Probation,Provë
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100,Probation,Provë
 apps/erpnext/erpnext/config/hr.py +115,Salary Components,Komponentet e pagave
 DocType: Program Enrollment Tool,New Academic Year,New Year akademik
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +762,Return / Credit Note,Kthimi / Credit Note
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +809,Return / Credit Note,Kthimi / Credit Note
 DocType: Stock Settings,Auto insert Price List rate if missing,Auto insert Shkalla Lista e Çmimeve nëse mungon
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +23,Total Paid Amount,Gjithsej shuma e paguar
 DocType: Production Order Item,Transferred Qty,Transferuar Qty
 apps/erpnext/erpnext/config/learn.py +11,Navigating,Vozitja
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +184,Planning,Planifikim
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188,Planning,Planifikim
 DocType: Material Request,Issued,Lëshuar
-apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +14,Student Activity,Aktiviteti Student
-DocType: Project,Total Billing Amount (via Time Logs),Shuma totale Faturimi (nëpërmjet Koha Shkrime)
+apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14,Student Activity,Aktiviteti Student
 apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80,Supplier Id,Furnizuesi Id
 DocType: Payment Request,Payment Gateway Details,Pagesa Gateway Details
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +264,Quantity should be greater than 0,Sasia duhet të jetë më e madhe se 0
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +267,Quantity should be greater than 0,Sasia duhet të jetë më e madhe se 0
 DocType: Journal Entry,Cash Entry,Hyrja Cash
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17,Child nodes can be only created under 'Group' type nodes,nyjet e fëmijëve mund të krijohen vetëm me nyje të tipit &#39;Grupit&#39;
 DocType: Leave Application,Half Day Date,Half Day Date
@@ -4134,22 +4412,25 @@
 apps/erpnext/erpnext/config/hr.py +65,"Type of leaves like casual, sick etc.","Lloji i lë si rastësor, të sëmurë etj"
 DocType: Email Digest,Send regular summary reports via Email.,Dërgo raporte të rregullta përmbledhje nëpërmjet Email.
 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},Ju lutemi të vendosur llogarinë e paracaktuar në Expense kërkesën Lloji {0}
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +305,Please set default account in Expense Claim Type {0},Ju lutemi të vendosur llogarinë e paracaktuar në Expense kërkesën Lloji {0}
 DocType: Assessment Result,Student Name,Emri i studentit
 DocType: Brand,Item Manager,Item Menaxher
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Payroll Payable,Payroll pagueshme
 DocType: Buying Settings,Default Supplier Type,Gabim Furnizuesi Type
+DocType: Plant Analysis,Collection Datetime,Data e mbledhjes
 DocType: Production Order,Total Operating Cost,Gjithsej Kosto Operative
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171,Note: Item {0} entered multiple times,Shënim: Item {0} hyrë herë të shumta
 apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Të gjitha kontaktet.
-apps/erpnext/erpnext/public/js/setup_wizard.js +67,Company Abbreviation,Shkurtesa kompani
+apps/erpnext/erpnext/public/js/setup_wizard.js +71,Company Abbreviation,Shkurtesa kompani
 apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +57,User {0} does not exist,Përdoruesi {0} nuk ekziston
+DocType: Payment Term,Day(s) after invoice date,Ditë (a) pas datës së faturës
+DocType: Payment Schedule,Payment Schedule,Orari i pagesës
 DocType: Subscription,SUB-,nën-
 DocType: Item Attribute Value,Abbreviation,Shkurtim
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +182,Payment Entry already exists,Pagesa Hyrja tashmë ekziston
 apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,Jo Authroized që nga {0} tejkalon kufijtë
 apps/erpnext/erpnext/config/hr.py +110,Salary template master.,Mjeshtër paga template.
-apps/erpnext/erpnext/healthcare/setup.py +240,Pathology,patologji
+apps/erpnext/erpnext/healthcare/setup.py +241,Pathology,patologji
 DocType: Restaurant Order Entry,Restaurant Table,Tavolina e restorantit
 DocType: Leave Type,Max Days Leave Allowed,Max Ditët Pushimi Lejohet
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63,Set Tax Rule for shopping cart,Set Rregulla Taksa për shopping cart
@@ -4162,67 +4443,71 @@
 apps/erpnext/erpnext/config/selling.py +13,Quotes to Leads or Customers.,Kuotat për kryeson apo klientët.
 DocType: Stock Settings,Role Allowed to edit frozen stock,Roli i lejuar për të redaktuar aksioneve të ngrirë
 ,Territory Target Variance Item Group-Wise,Territori i synuar Varianca Item Grupi i urti
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +139,All Customer Groups,Të gjitha grupet e konsumatorëve
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143,All Customer Groups,Të gjitha grupet e konsumatorëve
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114,Accumulated Monthly,akumuluar mujore
-apps/erpnext/erpnext/controllers/accounts_controller.py +638,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} është i detyrueshëm. Ndoshta rekord Currency Exchange nuk është krijuar për {1} të {2}.
+apps/erpnext/erpnext/controllers/accounts_controller.py +750,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} është i detyrueshëm. Ndoshta rekord Currency Exchange nuk është krijuar për {1} të {2}.
 apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +41,Tax Template is mandatory.,Template tatimi është i detyrueshëm.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +48,Account {0}: Parent account {1} does not exist,Llogaria {0}: llogari Parent {1} nuk ekziston
+apps/erpnext/erpnext/accounts/doctype/account/account.py +44,Account {0}: Parent account {1} does not exist,Llogaria {0}: llogari Parent {1} nuk ekziston
 DocType: Purchase Invoice Item,Price List Rate (Company Currency),Lista e Çmimeve Rate (Kompania Valuta)
 DocType: Products Settings,Products Settings,Produkte Settings
+,Item Price Stock,Çmimi i Artikullit
 DocType: Lab Prescription,Test Created,Krijuar test
 DocType: Healthcare Settings,Custom Signature in Print,Nënshkrimi me porosi në shtyp
 DocType: Account,Temporary,I përkohshëm
 DocType: Program,Courses,kurse
 DocType: Monthly Distribution Percentage,Percentage Allocation,Alokimi Përqindja
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +124,Secretary,Sekretar
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128,Secretary,Sekretar
 DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Nëse disable, &quot;me fjalë&quot; fushë nuk do të jetë i dukshëm në çdo transaksion"
 DocType: Serial No,Distinct unit of an Item,Njësi të dallueshme nga një artikull
 DocType: Supplier Scorecard Criteria,Criteria Name,Emri i kritereve
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1213,Please set Company,Ju lutemi të vendosur Company
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1289,Please set Company,Ju lutemi të vendosur Company
 DocType: Pricing Rule,Buying,Blerje
+apps/erpnext/erpnext/config/agriculture.py +24,Diseases & Fertilizers,Sëmundjet dhe plehrat
 DocType: HR Settings,Employee Records to be created by,Të dhënat e punonjësve që do të krijohet nga
 DocType: Patient,AB Negative,AB Negative
 DocType: Sample Collection,SMPL-,SMPL-
 DocType: POS Profile,Apply Discount On,Aplikoni zbritje në
+DocType: Member,Membership Type,Lloji i Anëtarësimit
 ,Reqd By Date,Reqd By Date
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140,Creditors,Kreditorët
 DocType: Assessment Plan,Assessment Name,Emri i vlerësimit
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +96,Row # {0}: Serial No is mandatory,Row # {0}: Asnjë Serial është i detyrueshëm
 DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Item Tatimore urti Detail
-apps/erpnext/erpnext/public/js/setup_wizard.js +67,Institute Abbreviation,Shkurtesa Institute
+apps/erpnext/erpnext/public/js/setup_wizard.js +71,Institute Abbreviation,Shkurtesa Institute
 ,Item-wise Price List Rate,Pika-mençur Lista e Çmimeve Rate
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +941,Supplier Quotation,Furnizuesi Citat
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +966,Supplier Quotation,Furnizuesi Citat
 DocType: Quotation,In Words will be visible once you save the Quotation.,Me fjalë do të jetë i dukshëm një herë ju ruani Kuotim.
 apps/erpnext/erpnext/utilities/transaction_base.py +153,Quantity ({0}) cannot be a fraction in row {1},Sasi ({0}) nuk mund të jetë një pjesë në rradhë {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},Barkodi {0} përdorur tashmë në pikën {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +473,Barcode {0} already used in Item {1},Barkodi {0} përdorur tashmë në pikën {1}
 apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,Rregullat për të shtuar shpenzimet e transportit detar.
 DocType: Item,Opening Stock,hapja Stock
 apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Konsumatorit është e nevojshme
 DocType: Lab Test,Result Date,Data e Rezultatit
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20,{0} is mandatory for Return,{0} është e detyrueshme për Kthim
 DocType: Purchase Order,To Receive,Për të marrë
-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,Pronar i aseteve
 DocType: Employee,Personal Email,Personale Email
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57,Total Variance,Ndryshimi Total
 DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Nëse aktivizuar, sistemi do të shpallë shënimet e kontabilitetit për inventarizimin automatikisht."
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +15,Brokerage,Brokerimi
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15,Brokerage,Brokerimi
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +232,Attendance for employee {0} is already marked for this day,Pjesëmarrja për {0} punonjësi është shënuar tashmë për këtë ditë
 DocType: Production Order Operation,"in Minutes
 Updated via 'Time Log'",në minuta Përditësuar nëpërmjet &#39;Koha Identifikohu &quot;
 DocType: Customer,From Lead,Nga Lead
 apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,Urdhërat lëshuar për prodhim.
 apps/erpnext/erpnext/public/js/account_tree_grid.js +66,Select Fiscal Year...,Zgjidh Vitin Fiskal ...
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +557,POS Profile required to make POS Entry,POS Profilin nevojshme për të bërë POS Hyrja
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +561,POS Profile required to make POS Entry,POS Profilin nevojshme për të bërë POS Hyrja
 DocType: Program Enrollment Tool,Enroll Students,regjistrohen Studentët
 DocType: Lab Test,Approved Date,Data e Aprovuar
 apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Shitja Standard
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +138,Atleast one warehouse is mandatory,Atleast një depo është e detyrueshme
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +143,Atleast one warehouse is mandatory,Atleast një depo është e detyrueshme
 DocType: Serial No,Out of Warranty,Nga Garanci
 DocType: BOM Update Tool,Replace,Zëvendësoj
 apps/erpnext/erpnext/templates/includes/product_list.js +42,No products found.,Nuk ka produkte gjet.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360,{0} against Sales Invoice {1},{0} kundër Shitjeve Faturës {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +358,{0} against Sales Invoice {1},{0} kundër Shitjeve Faturës {1}
 DocType: Antibiotic,Laboratory User,Përdoruesi i Laboratorit
 DocType: Sales Invoice,SINV-,SINV-
 DocType: Request for Quotation Item,Project Name,Emri i Projektit
@@ -4232,43 +4517,47 @@
 DocType: Stock Ledger Entry,Stock Value Difference,Vlera e aksioneve Diferenca
 apps/erpnext/erpnext/config/learn.py +234,Human Resource,Burimeve Njerëzore
 DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Pajtimi Pagesa Pagesa
+DocType: Disease,Treatment Task,Detyra e Trajtimit
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38,Tax Assets,Pasuritë tatimore
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +626,Production Order has been {0},Prodhimi Order ka qenë {0}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +630,Production Order has been {0},Prodhimi Order ka qenë {0}
 DocType: BOM Item,BOM No,Bom Asnjë
 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,Journal Hyrja {0} nuk ka llogari {1} ose tashmë krahasohen me kupon tjetër
+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,Journal Hyrja {0} nuk ka llogari {1} ose tashmë krahasohen me kupon tjetër
 DocType: Item,Moving Average,Moving Mesatare
 DocType: BOM Update Tool,The BOM which will be replaced,BOM i cili do të zëvendësohet
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46,Electronic Equipments,Pajisje elektronike
+DocType: Asset,Maintenance Required,Kërkohet Mirëmbajtja
 DocType: Account,Debit,Debi
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49,Leaves must be allocated in multiples of 0.5,Lë duhet të ndahen në shumëfisha e 0.5
 DocType: Production Order,Operation Cost,Operacioni Kosto
 apps/erpnext/erpnext/config/hr.py +29,Upload attendance from a .csv file,Ngarko pjesëmarrjen nga një skedar CSV
-apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +39,Outstanding Amt,Amt Outstanding
+apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45,Outstanding Amt,Amt Outstanding
 DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Caqet e përcaktuara Item Grupi-mençur për këtë person të shitjes.
 DocType: Stock Settings,Freeze Stocks Older Than [Days],Stoqet Freeze vjetër se [Ditët]
-apps/erpnext/erpnext/controllers/accounts_controller.py +535,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Row # {0}: Asset është e detyrueshme për të aseteve fikse blerje / shitje
+apps/erpnext/erpnext/controllers/accounts_controller.py +579,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Row # {0}: Asset është e detyrueshme për të aseteve fikse blerje / shitje
+DocType: Asset Maintenance Team,Maintenance Team Name,Emri i ekipit të mirëmbajtjes
 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.","Nëse dy ose më shumë Rregullat e Çmimeve janë gjetur në bazë të kushteve të mësipërme, Prioritet është aplikuar. Prioritet është një numër mes 0 deri ne 20, ndërsa vlera e parazgjedhur është zero (bosh). Numri më i lartë do të thotë se do të marrë përparësi nëse ka rregulla të shumta çmimeve me kushte të njëjta."
 apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,Viti Fiskal: {0} nuk ekziston
 DocType: Currency Exchange,To Currency,Për të Valuta
 DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Lejo përdoruesit e mëposhtme të miratojë Dërgo Aplikacione për ditë bllok.
-apps/erpnext/erpnext/config/hr.py +132,Types of Expense Claim.,Llojet e shpenzimeve kërkesës.
-apps/erpnext/erpnext/controllers/selling_controller.py +176,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Shitjen e normës për elementit {0} është më e ulët se saj {1}. Shitja e normës duhet të jetë atleast {2}
+apps/erpnext/erpnext/config/hr.py +137,Types of Expense Claim.,Llojet e shpenzimeve kërkesës.
+apps/erpnext/erpnext/controllers/selling_controller.py +144,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Shitjen e normës për elementit {0} është më e ulët se saj {1}. Shitja e normës duhet të jetë atleast {2}
 DocType: Item,Taxes,Tatimet
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +324,Paid and Not Delivered,Paguar dhe nuk dorëzohet
+DocType: Purchase Invoice Item,Weight Per Unit,Pesha për njësi
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344,Paid and Not Delivered,Paguar dhe nuk dorëzohet
 DocType: Project,Default Cost Center,Qendra Kosto e albumit
 DocType: Bank Guarantee,End Date,End Date
 apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,Transaksionet e aksioneve
 DocType: Budget,Budget Accounts,Llogaritë e buxhetit
 DocType: Employee,Internal Work History,Historia e brendshme
 DocType: Depreciation Schedule,Accumulated Depreciation Amount,Akumuluar Shuma Zhvlerësimi
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +42,Private Equity,Ekuiteti privat
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42,Private Equity,Ekuiteti privat
 DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Vleresimi i rezultateve te furnitorit
 DocType: Employee Loan,Fully Disbursed,lëvrohet plotësisht
 DocType: Maintenance Visit,Customer Feedback,Feedback Customer
 DocType: Account,Expense,Shpenzim
-apps/erpnext/erpnext/schools/doctype/assessment_result/assessment_result.js +36,Score cannot be greater than Maximum Score,Rezultati nuk mund të jetë më e madhe se rezultatin maksimal
-apps/erpnext/erpnext/utilities/user_progress.py +108,Customers and Suppliers,Konsumatorët dhe Furnizuesit
+apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +36,Score cannot be greater than Maximum Score,Rezultati nuk mund të jetë më e madhe se rezultatin maksimal
+apps/erpnext/erpnext/utilities/user_progress.py +126,Customers and Suppliers,Konsumatorët dhe Furnizuesit
 DocType: Item Attribute,From Range,Nga Varg
 DocType: BOM,Set rate of sub-assembly item based on BOM,Cakto shkallën e artikullit të nën-montimit bazuar në BOM
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98,Syntax error in formula or condition: {0},gabim sintakse në formulën ose kushte: {0}
@@ -4277,6 +4566,7 @@
 DocType: Appraisal,APRSL,APRSL
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +109,Submit this Production Order for further processing.,Submit Kjo mënyrë e prodhimit për përpunim të mëtejshëm.
 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.","Për të nuk zbatohet Rregulla e Çmimeve në një transaksion të caktuar, të gjitha rregullat e aplikueshme çmimeve duhet të jetë me aftësi të kufizuara."
+DocType: Payment Term,Day(s) after the end of the invoice month,Ditë (a) pas përfundimit të muajit të faturës
 DocType: Assessment Group,Parent Assessment Group,Parent Group Vlerësimit
 apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27,Jobs,Jobs
 ,Sales Order Trends,Sales Rendit Trendet
@@ -4285,21 +4575,23 @@
 ,Employee Information,Informacione punonjës
 DocType: Stock Entry Detail,Additional Cost,Kosto shtesë
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +39,"Can not filter based on Voucher No, if grouped by Voucher","Nuk mund të filtruar në bazë të Voucher Jo, qoftë të grupuara nga Bonon"
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +891,Make Supplier Quotation,Bëjnë Furnizuesi Kuotim
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +916,Make Supplier Quotation,Bëjnë Furnizuesi Kuotim
 DocType: Quality Inspection,Incoming,Hyrje
-apps/erpnext/erpnext/schools/doctype/assessment_result/assessment_result.py +47,Assessment Result record {0} already exists.,Regjistrimi i rezultatit të rezultatit {0} tashmë ekziston.
+apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +47,Assessment Result record {0} already exists.,Regjistrimi i rezultatit të rezultatit {0} tashmë ekziston.
 DocType: BOM,Materials Required (Exploded),Materialet e nevojshme (Shpërtheu)
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60,Please set Company filter blank if Group By is 'Company',Ju lutemi të vendosur Company filtër bosh nëse Group By është &#39;Company&#39;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66,Posting Date cannot be future date,Posting Data nuk mund të jetë data e ardhmja
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +101,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: serial {1} nuk përputhet me {2} {3}
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,for generating the recurring,për gjenerimin e përsëritjes
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +82,Casual Leave,Lini Rastesishme
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86,Casual Leave,Lini Rastesishme
 apps/erpnext/erpnext/config/healthcare.py +138,Lab Test UOM.,Lab Test UOM.
+DocType: Agriculture Task,End Day,Dita e Fundit
 DocType: Batch,Batch ID,ID Batch
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380,Note: {0},Shënim: {0}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +378,Note: {0},Shënim: {0}
 ,Delivery Note Trends,Trendet ofrimit Shënim
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112,This Week's Summary,Përmbledhja e kësaj jave
 apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +20,In Stock Qty,Në modelet Qty
+DocType: Delivery Trip,Calculate Estimated Arrival Times,Llogarit kohët e arritura të mbërritjes
 apps/erpnext/erpnext/accounts/general_ledger.py +111,Account: {0} can only be updated via Stock Transactions,Llogaria: {0} mund të përditësuar vetëm përmes aksionare transaksionet
 DocType: Student Group Creation Tool,Get Courses,Get Kurse
 DocType: GL Entry,Party,Parti
@@ -4308,59 +4600,68 @@
 DocType: Sales Order,Delivery Date,Ofrimit Data
 DocType: Opportunity,Opportunity Date,Mundësi Data
 DocType: Purchase Receipt,Return Against Purchase Receipt,Kthehu përkundrejt marrjes Blerje
+DocType: Water Analysis,Person Responsible,Personi përgjegjës
 DocType: Request for Quotation Item,Request for Quotation Item,Kërkesë për Kuotim Item
 DocType: Purchase Order,To Bill,Për Bill
 DocType: Material Request,% Ordered,% Urdhërohet
-DocType: School Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.","Për Grupin bazuar Course Studentëve, kursi do të miratohet për çdo student nga kurset e regjistruar në programin e regjistrimit."
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +99,Piecework,Punë me copë
+DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.","Për Grupin bazuar Course Studentëve, kursi do të miratohet për çdo student nga kurset e regjistruar në programin e regjistrimit."
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103,Piecework,Punë me copë
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71,Avg. Buying Rate,Avg. Blerja Rate
 DocType: Task,Actual Time (in Hours),Koha aktuale (në orë)
 DocType: Employee,History In Company,Historia Në kompanisë
 apps/erpnext/erpnext/config/learn.py +107,Newsletters,Buletinet
 DocType: Drug Prescription,Description/Strength,Përshkrimi / Forca
 DocType: Stock Ledger Entry,Stock Ledger Entry,Stock Ledger Hyrja
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +82,Same item has been entered multiple times,Same artikull është futur disa herë
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83,Same item has been entered multiple times,Same artikull është futur disa herë
 DocType: Department,Leave Block List,Lini Blloko Lista
-DocType: Sales Invoice,Tax ID,ID e taksave
+DocType: Purchase Invoice,Tax ID,ID e taksave
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192,Item {0} is not setup for Serial Nos. Column must be blank,Item {0} nuk është setup për Serial Nr. Kolona duhet të jetë bosh
 DocType: Accounts Settings,Accounts Settings,Llogaritë Settings
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +38,Approve,miratoj
-apps/erpnext/erpnext/schools/doctype/assessment_result_tool/assessment_result_tool.js +149,No Result to submit,Asnjë rezultat për të paraqitur
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11,Approve,miratoj
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +51,"Malformatted address for {0}, please fix to continue.","Adresa pa format malformues për {0}, fillo të vazhdosh."
+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","Numri i llogarisë së re, do të përfshihet në emrin e llogarisë si një prefiks"
+DocType: Maintenance Team Member,Team Member,Anëtar i ekipit
+apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151,No Result to submit,Asnjë rezultat për të paraqitur
 DocType: Customer,Sales Partner and Commission,Sales Partner dhe Komisioni
 DocType: Employee Loan,Rate of Interest (%) / Year,Norma e interesit (%) / Viti
 ,Project Quantity,Sasia Project
 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'","Total {0} për të gjitha sendet është zero, mund të jetë që ju duhet të ndryshojë &quot;Shpërndani akuzat Bazuar On &#39;"
 DocType: Opportunity,To Discuss,Për të diskutuar
-apps/erpnext/erpnext/stock/stock_ledger.py +368,{0} units of {1} needed in {2} to complete this transaction.,{0} njësitë e {1} nevojshme në {2} për të përfunduar këtë transaksion.
+apps/erpnext/erpnext/stock/stock_ledger.py +375,{0} units of {1} needed in {2} to complete this transaction.,{0} njësitë e {1} nevojshme në {2} për të përfunduar këtë transaksion.
 DocType: Loan Type,Rate of Interest (%) Yearly,Norma e interesit (%) vjetore
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71,Temporary Accounts,Llogaritë e përkohshme
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +203,Black,E zezë
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207,Black,E zezë
 DocType: BOM Explosion Item,BOM Explosion Item,Bom Shpërthimi i artikullit
 DocType: Account,Auditor,Revizor
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +132,{0} items produced,{0} artikuj prodhuara
 apps/erpnext/erpnext/utilities/user_progress.py +55,Learn More,Mëso më shumë
 DocType: Cheque Print Template,Distance from top edge,Largësia nga buzë të lartë
-apps/erpnext/erpnext/stock/get_item_details.py +317,Price List {0} is disabled or does not exist,Lista e Çmimeve {0} është me aftësi të kufizuara ose nuk ekziston
+apps/erpnext/erpnext/stock/get_item_details.py +360,Price List {0} is disabled or does not exist,Lista e Çmimeve {0} është me aftësi të kufizuara ose nuk ekziston
 DocType: Purchase Invoice,Return,Kthimi
 DocType: Production Order Operation,Production Order Operation,Prodhimit Rendit Operacioni
 DocType: Pricing Rule,Disable,Disable
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +161,Mode of payment is required to make a payment,Mënyra e pagesës është e nevojshme për të bërë një pagesë
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +186,Mode of payment is required to make a payment,Mënyra e pagesës është e nevojshme për të bërë një pagesë
 DocType: Project Task,Pending Review,Në pritje Rishikimi
+apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14,"Edit in full page for more options like assets, serial nos, batches etc.","Modifiko në faqen e plotë për më shumë opsione si asetet, numrat serial, batch etj."
 apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10,Appointments and Consultations,Emërimet dhe konsultimet
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +41,{0} - {1} is not enrolled in the Batch {2},{0} - {1} nuk është i regjistruar në grumbull {2}
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +113,"Asset {0} cannot be scrapped, as it is already {1}","Asset {0} nuk mund të braktiset, pasi ajo është tashmë {1}"
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41,{0} - {1} is not enrolled in the Batch {2},{0} - {1} nuk është i regjistruar në grumbull {2}
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113,"Asset {0} cannot be scrapped, as it is already {1}","Asset {0} nuk mund të braktiset, pasi ajo është tashmë {1}"
 DocType: Task,Total Expense Claim (via Expense Claim),Gjithsej Kërkesa shpenzimeve (nëpërmjet shpenzimeve Kërkesës)
 apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177,Mark Absent,Mark Mungon
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40,Failed to setup company,Dështoi në konfigurimin e kompanisë
+DocType: Asset Repair,Asset Repair,Riparimi i aseteve
 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}: Valuta e BOM # {1} duhet të jetë e barabartë me monedhën e zgjedhur {2}
 DocType: Journal Entry Account,Exchange Rate,Exchange Rate
 DocType: Patient,Additional information regarding the patient,Informacione shtesë lidhur me pacientin
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +575,Sales Order {0} is not submitted,Sales Order {0} nuk është dorëzuar
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +579,Sales Order {0} is not submitted,Sales Order {0} nuk është dorëzuar
 DocType: Homepage,Tag Line,tag Line
 DocType: Fee Component,Fee Component,Komponenti Fee
-apps/erpnext/erpnext/config/hr.py +199,Fleet Management,Menaxhimi Fleet
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +939,Add items from,Shto artikuj nga
+apps/erpnext/erpnext/config/hr.py +204,Fleet Management,Menaxhimi Fleet
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +964,Add items from,Shto artikuj nga
+apps/erpnext/erpnext/config/agriculture.py +7,Crops & Lands,Bimët dhe tokat
 DocType: Cheque Print Template,Regular,i rregullt
-apps/erpnext/erpnext/schools/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Weightage i përgjithshëm i të gjitha kriteret e vlerësimit duhet të jetë 100%
+DocType: Fertilizer,Density (if liquid),Dendësia (nëse është e lëngshme)
+apps/erpnext/erpnext/education/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Weightage i përgjithshëm i të gjitha kriteret e vlerësimit duhet të jetë 100%
 DocType: Purchase Order Item,Last Purchase Rate,Rate fundit Blerje
 DocType: Account,Asset,Pasuri
 DocType: Project Task,Task ID,Detyra ID
@@ -4370,29 +4671,33 @@
 DocType: Training Event,Contact Number,Numri i kontaktit
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0} does not exist,Magazina {0} nuk ekziston
 DocType: Monthly Distribution,Monthly Distribution Percentages,Përqindjet mujore Shpërndarjes
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +37,The selected item cannot have Batch,Elementi i përzgjedhur nuk mund të ketë Serisë
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +38,The selected item cannot have Batch,Elementi i përzgjedhur nuk mund të ketë Serisë
 DocType: Delivery Note,% of materials delivered against this Delivery Note,% E materialeve dorëzuar kundër këtij notën shpërndarëse
-DocType: Training Event,Has Certificate,Ka certifikatë
+DocType: Asset Maintenance Log,Has Certificate,Ka certifikatë
 DocType: Project,Customer Details,Detajet e klientit
+DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,Kontrolloni nëse Aseti kërkon mirëmbajtje parandaluese ose kalibrim
 DocType: Employee,Reports to,Raportet për
 ,Unpaid Expense Claim,Papaguar shpenzimeve Kërkesa
 DocType: Payment Entry,Paid Amount,Paid Shuma
-apps/erpnext/erpnext/utilities/user_progress.py +137,Explore Sales Cycle,Eksploro Cikullin e Shitjes
+apps/erpnext/erpnext/utilities/user_progress.py +155,Explore Sales Cycle,Eksploro Cikullin e Shitjes
 DocType: Assessment Plan,Supervisor,mbikëqyrës
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +73,Online,online
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +70,Online,online
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +867,Retention Stock Entry,Regjistrimi i aksioneve mbajtëse
 ,Available Stock for Packing Items,Stock dispozicion për Items Paketimi
 DocType: Item Variant,Item Variant,Item Variant
 DocType: Assessment Result Tool,Assessment Result Tool,Vlerësimi Rezultati Tool
 DocType: BOM Scrap Item,BOM Scrap Item,BOM Scrap Item
-apps/erpnext/erpnext/accounts/page/pos/pos.js +871,Submitted orders can not be deleted,urdhërat e dorëzuara nuk mund të fshihet
-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'","Bilanci i llogarisë tashmë në Debitimit, ju nuk jeni i lejuar për të vendosur &quot;Bilanci Must Be &#39;si&#39; Credit&quot;"
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +114,Quality Management,Menaxhimit të Cilësisë
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +41,Item {0} has been disabled,{0} artikull ka qenë me aftësi të kufizuara
+apps/erpnext/erpnext/accounts/page/pos/pos.js +886,Submitted orders can not be deleted,urdhërat e dorëzuara nuk mund të fshihet
+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'","Bilanci i llogarisë tashmë në Debitimit, ju nuk jeni i lejuar për të vendosur &quot;Bilanci Must Be &#39;si&#39; Credit&quot;"
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118,Quality Management,Menaxhimit të Cilësisë
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +41,Item {0} has been disabled,{0} artikull ka qenë me aftësi të kufizuara
+DocType: Project,Total Billable Amount (via Timesheets),Shuma totale e faturimit (përmes Timesheets)
+DocType: Agriculture Task,Previous Business Day,Dita e mëparshme e punës
 DocType: Employee Loan,Repay Fixed Amount per Period,Paguaj shuma fikse për një periudhë
 apps/erpnext/erpnext/buying/utils.py +47,Please enter quantity for Item {0},Ju lutemi shkruani sasine e artikullit {0}
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +78,Credit Note Amt,Credit Note Amt
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +89,Credit Note Amt,Credit Note Amt
 DocType: Employee External Work History,Employee External Work History,Punonjës historia e jashtme
-DocType: Tax Rule,Purchase,Blerje
+DocType: Opening Invoice Creation Tool,Purchase,Blerje
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,Bilanci Qty
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20,Goals cannot be empty,Qëllimet nuk mund të jetë bosh
 DocType: Item Group,Parent Item Group,Grupi prind Item
@@ -4400,23 +4705,25 @@
 apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{0} për {1}
 DocType: Healthcare Settings,Valid number of days,Numri i ditëve të vlefshme
 apps/erpnext/erpnext/setup/doctype/company/company.js +35,Cost Centers,Qendrat e kostos
+DocType: Land Unit,Linked Plant Analysis,Analizë e bimëve të lidhur
 DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,Shkalla në të cilën furnizuesit e valutës është e konvertuar në monedhën bazë kompanisë
 apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},Row # {0}: konfliktet timings me radhë {1}
 DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Lejo Zero Vlerësimit Vlerësoni
 DocType: Training Event Employee,Invited,Të ftuar
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +177,Multiple active Salary Structures found for employee {0} for the given dates,Multiple Strukturat aktive pagave gjetur për punonjës {0} për të dhënë data
-apps/erpnext/erpnext/config/accounts.py +316,Setup Gateway accounts.,Setup Llogaritë Gateway.
+apps/erpnext/erpnext/config/accounts.py +308,Setup Gateway accounts.,Setup Llogaritë Gateway.
 DocType: Employee,Employment Type,Lloji Punësimi
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42,Fixed Assets,Mjetet themelore
 DocType: Payment Entry,Set Exchange Gain / Loss,Set Exchange Gain / Humbje
 ,GST Purchase Register,GST Blerje Regjistrohu
 ,Cash Flow,Cash Flow
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +92,Application period cannot be across two alocation records,Periudha e aplikimit nuk mund të jetë në dy regjistrave alokimin
+apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25,Combined invoice portion must equal 100%,Pjesa e kombinuar e faturës duhet të jetë e barabartë me 100%
 DocType: Item Group,Default Expense Account,Llogaria e albumit shpenzimeve
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,Student Email ID
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,Student Email ID
 DocType: Employee,Notice (days),Njoftim (ditë)
 DocType: Tax Rule,Sales Tax Template,Template Sales Tax
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2448,Select items to save the invoice,Zgjidhni artikuj për të shpëtuar faturën
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2467,Select items to save the invoice,Zgjidhni artikuj për të shpëtuar faturën
 DocType: Employee,Encashment Date,Arkëtim Data
 DocType: Training Event,Internet,internet
 DocType: Special Test Template,Special Test Template,Modeli i Testimit Special
@@ -4426,6 +4733,7 @@
 DocType: Academic Term,Term Start Date,Term Data e fillimit
 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},Ju lutem gjeni bashkangjitur {0} # {1}
+apps/erpnext/erpnext/controllers/accounts_controller.py +701,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Shuma totale e pagesës në orarin e pagesës duhet të jetë e barabartë me grandin / totalin e rrumbullakët
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,Balanca Deklarata Banka sipas Librit Kryesor
 DocType: Job Applicant,Applicant Name,Emri i aplikantit
 DocType: Authorization Rule,Customer / Item Name,Customer / Item Emri
@@ -4439,6 +4747,7 @@
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42,Serial No is mandatory for Item {0},Asnjë Serial është i detyrueshëm për Item {0}
 DocType: Item Variant Attribute,Attribute,Atribut
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43,Please specify from/to range,Ju lutemi specifikoni nga / në varg
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28,Opening {0} Invoice created,Hapja e {0} Faturave të krijuara
 DocType: Serial No,Under AMC,Sipas AMC
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55,Item valuation rate is recalculated considering landed cost voucher amount,Shkalla e vlerësimit Item rillogaritet duke marrë parasysh ul sasinë kuponave kosto
 apps/erpnext/erpnext/config/selling.py +153,Default settings for selling transactions.,Default settings për shitjen e transaksioneve.
@@ -4450,53 +4759,57 @@
 apps/erpnext/erpnext/config/support.py +22,Warranty,garanci
 DocType: Purchase Invoice,Debit Note Issued,Debit Note Hedhur në qarkullim
 DocType: Production Order,Warehouses,Depot
-apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} aktiv nuk mund të transferohet
-apps/erpnext/erpnext/stock/doctype/item/item.js +66,This Item is a Variant of {0} (Template).,Ky Artikull është një variant i {0} (Shabllon).
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} aktiv nuk mund të transferohet
+apps/erpnext/erpnext/stock/doctype/item/item.js +80,This Item is a Variant of {0} (Template).,Ky Artikull është një variant i {0} (Shabllon).
 DocType: Workstation,per hour,në orë
 apps/erpnext/erpnext/config/buying.py +7,Purchasing,blerje
 DocType: Announcement,Announcement,njoftim
-DocType: School Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","Për Grupin Batch bazuar Studentëve, grupi i Studentëve do të miratohet për çdo student nga Regjistrimi Programit."
+DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","Për Grupin Batch bazuar Studentëve, grupi i Studentëve do të miratohet për çdo student nga Regjistrimi Programit."
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +51,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Depo nuk mund të fshihet si ekziston hyrja aksioneve librit për këtë depo.
-DocType: Company,Distribution,Shpërndarje
+apps/erpnext/erpnext/public/js/setup_wizard.js +25,Distribution,Shpërndarje
+DocType: Expense Claim Advance,Expense Claim Advance,Kërkesa e Shpenzimit të Shpenzimeve
 DocType: Lab Test,Report Preference,Preferencë e raportit
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +129,Project Manager,Menaxher i Projektit
+apps/erpnext/erpnext/config/non_profit.py +43,Volunteer information.,Informacione vullnetare.
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133,Project Manager,Menaxher i Projektit
 ,Quoted Item Comparison,Cituar Item Krahasimi
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34,Overlap in scoring between {0} and {1},Mbivendosja në pikët midis {0} dhe {1}
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +110,Dispatch,Dërgim
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114,Dispatch,Dërgim
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +73,Max discount allowed for item: {0} is {1}%,Max zbritje lejohet për artikull: {0} është {1}%
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +173,Net Asset value as on,Vlera neto e aseteve si në
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176,Net Asset value as on,Vlera neto e aseteve si në
+DocType: Crop,Produce,prodhoj
 DocType: Account,Receivable,Arkëtueshme
-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}: Nuk lejohet të ndryshojë Furnizuesit si Urdhër Blerje tashmë ekziston
+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}: Nuk lejohet të ndryshojë Furnizuesit si Urdhër Blerje tashmë ekziston
 DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,Roli që i lejohet të paraqesë transaksionet që tejkalojnë limitet e kreditit përcaktuara.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +929,Select Items to Manufacture,Zgjidhni Items të Prodhimi
-apps/erpnext/erpnext/accounts/page/pos/pos.js +939,"Master data syncing, it might take some time","Master dhënat syncing, ajo mund të marrë disa kohë"
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +978,Select Items to Manufacture,Zgjidhni Items të Prodhimi
+DocType: Delivery Stop,Delivery Stop,Dorëzimi i ndalimit
+apps/erpnext/erpnext/accounts/page/pos/pos.js +954,"Master data syncing, it might take some time","Master dhënat syncing, ajo mund të marrë disa kohë"
 DocType: Item,Material Issue,Materiali Issue
 DocType: Employee Education,Qualification,Kualifikim
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +40,View Salary Slips,Shihni pagat e pagave
 DocType: Item Price,Item Price,Item Çmimi
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +48,Soap & Detergent,Sapun dhe detergjent
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48,Soap & Detergent,Sapun dhe detergjent
 DocType: BOM,Show Items,Shfaq Items
-apps/erpnext/erpnext/schools/doctype/course_schedule/course_schedule.py +30,From Time cannot be greater than To Time.,Nga koha nuk mund të jetë më i madh se në kohë.
-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.,Nga koha nuk mund të jetë më i madh se në kohë.
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +74,Do you want to notify all the customers by email?,A doni të njoftoni të gjithë klientët me email?
+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,Urdhërohet
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51,Resume,Vazhdoj
-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,"Nëse aktivizohet atëherë sistemi nuk do të azhurnojë fushat e varianteve nga shablloni, por do të kopjojë të dhënat e fushave të përmendura më poshtë duke bërë variant të ri"
 DocType: Salary Detail,Component,komponent
 DocType: Assessment Criteria,Assessment Criteria Group,Kriteret e vlerësimit Group
 DocType: Healthcare Settings,Patient Name By,Emri i pacientit nga
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +72,Opening Accumulated Depreciation must be less than equal to {0},Hapja amortizimi i akumuluar duhet të jetë më pak se e barabartë me {0}
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +72,Opening Accumulated Depreciation must be less than equal to {0},Hapja amortizimi i akumuluar duhet të jetë më pak se e barabartë me {0}
 DocType: Warehouse,Warehouse Name,Magazina Emri
 DocType: Naming Series,Select Transaction,Përzgjedhjen e transaksioneve
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,Ju lutemi shkruani Miratimi Roli ose Miratimi përdoruesin
 DocType: Journal Entry,Write Off Entry,Shkruani Off Hyrja
 DocType: BOM,Rate Of Materials Based On,Shkalla e materialeve në bazë të
-DocType: Item Variant Settings,Do not Update Variants,Mos Update Variante
 apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Analtyics Mbështetje
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +142,Uncheck all,Uncheck gjitha
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102,Uncheck all,Uncheck gjitha
 DocType: POS Profile,Terms and Conditions,Termat dhe Kushtet
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49,To Date should be within the Fiscal Year. Assuming To Date = {0},Deri më sot duhet të jetë brenda vitit fiskal. Duke supozuar në datën = {0}
 DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Këtu ju mund të mbajë lartësia, pesha, alergji, shqetësimet mjekësore etj"
 DocType: Leave Block List,Applies to Company,Zbatohet për Kompaninë
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +202,Cannot cancel because submitted Stock Entry {0} exists,"Nuk mund të anulojë, sepse paraqitet Stock Hyrja {0} ekziston"
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +222,Cannot cancel because submitted Stock Entry {0} exists,"Nuk mund të anulojë, sepse paraqitet Stock Hyrja {0} ekziston"
 DocType: Employee Loan,Disbursement Date,disbursimi Date
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80,'Recipients' not specified,&#39;Përfituesit&#39; nuk janë të specifikuara
 DocType: BOM Update Tool,Update latest price in all BOMs,Përditësoni çmimin e fundit në të gjitha BOM-et
@@ -4505,43 +4818,52 @@
 DocType: Purchase Invoice,In Words,Me fjalë të
 apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15,{0} must be submitted,{0} duhet të dorëzohet
 DocType: POS Profile,Item Groups,Grupet artikull
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +217,Today is {0}'s birthday!,Sot është {0} &#39;s ditëlindjen!
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +221,Today is {0}'s birthday!,Sot është {0} &#39;s ditëlindjen!
 DocType: Production Planning Tool,Material Request For Warehouse,Kërkesë material Për Magazina
 DocType: Sales Order Item,For Production,Për Prodhimit
 DocType: Payment Request,payment_url,payment_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,Ju lutemi të shtoni një llogari të Hapjes së Përkohshme në Kartën e Llogarive
+DocType: Customer,Customer Primary Contact,Kontakti Primar i Klientit
 DocType: Project Task,View Task,Shiko Task
 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,Pjesa e faturës
 ,Asset Depreciations and Balances,Nënçmime aseteve dhe Bilancet
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +356,Amount {0} {1} transferred from {2} to {3},Shuma {0} {1} transferuar nga {2} të {3}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +357,Amount {0} {1} transferred from {2} to {3},Shuma {0} {1} transferuar nga {2} të {3}
 DocType: Sales Invoice,Get Advances Received,Get Përparimet marra
 DocType: Email Digest,Add/Remove Recipients,Add / Remove Recipients
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +461,Transaction not allowed against stopped Production Order {0},Transaksioni nuk lejohet kundër Prodhimit ndalur Rendit {0}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +486,Transaction not allowed against stopped Production Order {0},Transaksioni nuk lejohet kundër Prodhimit ndalur Rendit {0}
 apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","Për të vendosur këtë vit fiskal si default, klikoni mbi &#39;Bëje si Default&#39;"
-apps/erpnext/erpnext/projects/doctype/project/project.py +205,Join,bashkohem
+apps/erpnext/erpnext/projects/doctype/project/project.py +216,Join,bashkohem
 apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +20,Shortage Qty,Mungesa Qty
-apps/erpnext/erpnext/stock/doctype/item/item.py +699,Item variant {0} exists with same attributes,Item variant {0} ekziston me atributet e njëjta
+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.,Nuk mund të ndryshojë pronat e variantit pas transakcionit të stoqeve. Ju do të keni për të bërë një artikull të ri për ta bërë këtë.
+apps/erpnext/erpnext/stock/doctype/item/item.py +685,Item variant {0} exists with same attributes,Item variant {0} ekziston me atributet e njëjta
 DocType: Employee Loan,Repay from Salary,Paguajë nga paga
 DocType: Leave Application,LAP/,LAP /
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +347,Requesting payment against {0} {1} for amount {2},Kerkuar pagesën kundër {0} {1} për sasi {2}
 DocType: Salary Slip,Salary Slip,Shqip paga
 DocType: Lead,Lost Quotation,Lost Citat
-apps/erpnext/erpnext/utilities/user_progress.py +200,Student Batches,Grupet e Studentëve
+apps/erpnext/erpnext/utilities/user_progress.py +218,Student Batches,Grupet e Studentëve
 DocType: Pricing Rule,Margin Rate or Amount,Margin Vlerësoni ose Shuma
 apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48,'To Date' is required,&quot;Deri më sot&quot; është e nevojshme
 DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Generate paketim rrëshqet për paketat që do të dërgohen. Përdoret për të njoftuar numrin paketë, paketë përmbajtjen dhe peshën e saj."
 DocType: Sales Invoice Item,Sales Order Item,Sales Rendit Item
 DocType: Salary Slip,Payment Days,Ditët e pagesës
+DocType: Stock Settings,Convert Item Description to Clean HTML,Convert Item Description për të pastruar HTML
 DocType: Patient,Dormant,në gjumë
+DocType: Salary Slip,Total Interest Amount,Shuma totale e interesit
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +125,Warehouses with child nodes cannot be converted to ledger,Depot me nyjet e fëmijëve nuk mund të konvertohet në Ledger
 DocType: BOM,Manage cost of operations,Menaxhuar koston e operacioneve
 DocType: Accounts Settings,Stale Days,Ditët Stale
 DocType: Notification Control,"When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.","Kur ndonjë nga transaksionet e kontrolluara janë &quot;Dërguar&quot;, një email pop-up u hap automatikisht për të dërguar një email tek të lidhur &quot;Kontakt&quot; në këtë transaksion, me transaksionin si një shtojcë. Ky përdorues mund ose nuk mund të dërgoni email."
 apps/erpnext/erpnext/config/setup.py +14,Global Settings,Cilësimet globale
+DocType: Crop,Row Spacing UOM,Rreshtimi i rreshtit UOM
 DocType: Assessment Result Detail,Assessment Result Detail,Vlerësimi Rezultati Detail
 DocType: Employee Education,Employee Education,Arsimimi punonjës
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +48,Duplicate item group found in the item group table,Grupi Duplicate artikull gjenden në tabelën e grupit artikull
-apps/erpnext/erpnext/public/js/controllers/transaction.js +965,It is needed to fetch Item Details.,Është e nevojshme për të shkoj të marr dhëna të artikullit.
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53,Duplicate item group found in the item group table,Grupi Duplicate artikull gjenden në tabelën e grupit artikull
+DocType: Land Unit,Parent Land Unit,Njësia e tokës parësore
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1045,It is needed to fetch Item Details.,Është e nevojshme për të shkoj të marr dhëna të artikullit.
+DocType: Fertilizer,Fertilizer Name,Emri i plehut
 DocType: Salary Slip,Net Pay,Pay Net
 DocType: Account,Account,Llogari
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217,Serial No {0} has already been received,Serial Asnjë {0} tashmë është marrë
@@ -4549,40 +4871,45 @@
 DocType: Expense Claim,Vehicle Log,Vehicle Identifikohu
 DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),Prania e etheve (temp&gt; 38.5 ° C / 101.3 ° F ose temperatura e qëndrueshme&gt; 38 ° C / 100.4 ° F)
 DocType: Customer,Sales Team Details,Detajet shitjet e ekipit
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1326,Delete permanently?,Fshini përgjithmonë?
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1341,Delete permanently?,Fshini përgjithmonë?
 DocType: Expense Claim,Total Claimed Amount,Shuma totale Pohoi
 apps/erpnext/erpnext/config/crm.py +17,Potential opportunities for selling.,Mundësi potenciale për të shitur.
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +228,Invalid {0},Invalid {0}
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +86,Sick Leave,Pushimi mjekësor
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90,Sick Leave,Pushimi mjekësor
 DocType: Email Digest,Email Digest,Email Digest
 DocType: Delivery Note,Billing Address Name,Faturimi Adresa Emri
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +22,Department Stores,Dyqane
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22,Department Stores,Dyqane
 ,Item Delivery Date,Data e dorëzimit të artikullit
 DocType: Warehouse,PIN,GJILPËRË
-apps/erpnext/erpnext/setup/setup_wizard/sample_data.py +110,Setup your School in ERPNext,Setup shkolla juaj në ERPNext
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +125,Error '{0}' occured. Arguments {1}.,Gabim &#39;{0}&#39; ndodhi. Argumente {1}.
 DocType: Sales Invoice,Base Change Amount (Company Currency),Base Ndryshimi Shuma (Company Valuta)
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304,No accounting entries for the following warehouses,Nuk ka hyrje të kontabilitetit për magazinat e mëposhtme
 apps/erpnext/erpnext/projects/doctype/project/project.js +111,Save the document first.,Ruaj dokumentin e parë.
+apps/erpnext/erpnext/shopping_cart/cart.py +71,Only {0} in stock for item {1},Vetëm {0} në magazinë për artikullin {1}
 DocType: Account,Chargeable,I dënueshëm
 DocType: Company,Change Abbreviation,Ndryshimi Shkurtesa
 DocType: Expense Claim Detail,Expense Date,Shpenzim Data
 DocType: Item,Max Discount (%),Max Discount (%)
+apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30,Credit Days cannot be a negative number,Ditët e kredisë nuk mund të jenë një numër negativ
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Shuma Rendit Fundit
+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} Retain Sample është i bazuar në grumbull, ju lutemi kontrolloni Keni Jo Serinë për të mbajtur mostrën e sendit"
 DocType: Task,Is Milestone,A Milestone
-DocType: Daily Work Summary,Email Sent To,Email Sent To
+DocType: Delivery Stop,Email Sent To,Email Sent To
 DocType: Budget,Warn,Paralajmëroj
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +81,Are you sure you want to unregister?,Je i sigurt që dëshiron të çregjistrosh?
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Çdo vërejtje të tjera, përpjekje të përmendet se duhet të shkoni në të dhënat."
-DocType: BOM,Manufacturing User,Prodhim i përdoruesit
+DocType: Asset Maintenance,Manufacturing User,Prodhim i përdoruesit
 DocType: Purchase Invoice,Raw Materials Supplied,Lëndëve të para furnizuar
 DocType: C-Form,Series,Seri
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +270,Currency of the price list {0} must be {1} or {2},Valuta e listës së çmimeve {0} duhet të jetë {1} ose {2}
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +273,Currency of the price list {0} must be {1} or {2},Valuta e listës së çmimeve {0} duhet të jetë {1} ose {2}
 DocType: Appraisal,Appraisal Template,Vlerësimi Template
+DocType: Soil Texture,Ternary Plot,Komplot tresh
 DocType: Item Group,Item Classification,Klasifikimi i artikullit
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +127,Business Development Manager,Zhvillimin e Biznesit Manager
+DocType: Driver,License Number,Numri i licencës
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131,Business Development Manager,Zhvillimin e Biznesit Manager
 DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Mirëmbajtja Vizitoni Qëllimi
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19,Invoice Patient Registration,Regjistrimi i Faturës së Pacientëve
-DocType: Drug Prescription,Period,Periudhë
+DocType: Crop,Period,Periudhë
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +18,General Ledger,Përgjithshëm Ledger
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33,Employee {0} on Leave on {1},I punësuar {0} për të lënë në {1}
 apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Shiko kryeson
@@ -4590,9 +4917,9 @@
 DocType: Item Attribute Value,Attribute Value,Atribut Vlera
 ,Itemwise Recommended Reorder Level,Itemwise Recommended reorder Niveli
 DocType: Salary Detail,Salary Detail,Paga Detail
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1017,Please select {0} first,"Ju lutem, përzgjidhni {0} parë"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1043,Please select {0} first,"Ju lutem, përzgjidhni {0} parë"
 DocType: Appointment Type,Physician,mjek
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +804,Batch {0} of Item {1} has expired.,Batch {0} i artikullit {1} ka skaduar.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +833,Batch {0} of Item {1} has expired.,Batch {0} i artikullit {1} ka skaduar.
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11,Consultations,konsultimet
 DocType: Sales Invoice,Commission,Komision
 apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Sheet Koha për prodhimin.
@@ -4603,7 +4930,7 @@
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +93,Warehouse not found in the system,Magazina nuk gjendet ne sistem
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115,This Month's Summary,Përmbledhje këtij muaji
 DocType: Quality Inspection Reading,Quality Inspection Reading,Inspektimi Leximi Cilësia
-apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +24,`Freeze Stocks Older Than` should be smaller than %d days.,`Ngrij Stoqet me te vjetra se` duhet të jetë më e vogël se% d ditë.
+apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25,`Freeze Stocks Older Than` should be smaller than %d days.,`Ngrij Stoqet me te vjetra se` duhet të jetë më e vogël se% d ditë.
 DocType: Tax Rule,Purchase Tax Template,Blerje Template Tatimore
 apps/erpnext/erpnext/utilities/user_progress.py +45,Set a sales goal you'd like to achieve for your company.,Vendosni një qëllim të shitjes që dëshironi të arrini për kompaninë tuaj.
 ,Project wise Stock Tracking,Projekti Ndjekja mençur Stock
@@ -4611,42 +4938,50 @@
 apps/erpnext/erpnext/config/healthcare.py +40,Laboratory,laborator
 DocType: Stock Entry Detail,Actual Qty (at source/target),Sasia aktuale (në burim / objektiv)
 DocType: Item Customer Detail,Ref Code,Kodi ref
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +66,Customer Group is Required in POS Profile,Grupi i Konsumatorëve kërkohet në Profilin e POS
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +71,Customer Group is Required in POS Profile,Grupi i Konsumatorëve kërkohet në Profilin e POS
 apps/erpnext/erpnext/config/hr.py +12,Employee records.,Të dhënat punonjës.
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +92,Please set Next Depreciation Date,Ju lutemi të vendosur Date Amortizimi tjetër
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +92,Please set Next Depreciation Date,Ju lutemi të vendosur Date Amortizimi tjetër
 DocType: HR Settings,Payroll Settings,Listën e pagave Cilësimet
-apps/erpnext/erpnext/config/accounts.py +154,Match non-linked Invoices and Payments.,Përputhje për Faturat jo-lidhura dhe pagesat.
+apps/erpnext/erpnext/config/accounts.py +146,Match non-linked Invoices and Payments.,Përputhje për Faturat jo-lidhura dhe pagesat.
 DocType: POS Settings,POS Settings,POS Settings
 apps/erpnext/erpnext/templates/pages/cart.html +16,Place Order,Vendi Renditja
 DocType: Email Digest,New Purchase Orders,Blerje porositë e reja
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24,Root cannot have a parent cost center,Rrënjë nuk mund të ketë një qendër me kosto prind
 apps/erpnext/erpnext/public/js/stock_analytics.js +57,Select Brand...,Zgjidh Markë ...
+apps/erpnext/erpnext/public/js/setup_wizard.js +32,Non Profit (beta),Jo fitim (beta)
 apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18,Training Events/Results,Ngjarjet / rezultateve të trajnimit
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +149,Accumulated Depreciation as on,Amortizimin e akumuluar si në
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152,Accumulated Depreciation as on,Amortizimin e akumuluar si në
 DocType: Sales Invoice,C-Form Applicable,C-Formulari i zbatueshëm
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +399,Operation Time must be greater than 0 for Operation {0},Operacioni Koha duhet të jetë më e madhe se 0 për Operacionin {0}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +419,Operation Time must be greater than 0 for Operation {0},Operacioni Koha duhet të jetë më e madhe se 0 për Operacionin {0}
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +106,Warehouse is mandatory,Magazina është e detyrueshme
 DocType: Supplier,Address and Contacts,Adresa dhe Kontakte
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67,Failed to create website,Dështoi në krijimin e faqes së internetit
+DocType: Soil Analysis,Mg/K,Mg / K
 DocType: UOM Conversion Detail,UOM Conversion Detail,UOM Konvertimi Detail
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +922,Retention Stock Entry already created or Sample Quantity not provided,Regjistrimi i aksioneve të mbajtjes tashmë të krijuar ose Sasia e mostrës nuk është dhënë
 DocType: Program,Program Abbreviation,Shkurtesa program
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +387,Production Order cannot be raised against a Item Template,Rendit prodhimi nuk mund të ngrihet kundër një Template Item
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +407,Production Order cannot be raised against a Item Template,Rendit prodhimi nuk mund të ngrihet kundër një Template Item
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52,Charges are updated in Purchase Receipt against each item,Akuzat janë përditësuar në pranimin Blerje kundër çdo send
 DocType: Warranty Claim,Resolved By,Zgjidhen nga
 DocType: Bank Guarantee,Start Date,Data e Fillimit
 apps/erpnext/erpnext/config/hr.py +75,Allocate leaves for a period.,Alokimi i lë për një periudhë.
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Cheques and Deposits incorrectly cleared,Çeqet dhe Depozitat pastruar gabimisht
-apps/erpnext/erpnext/accounts/doctype/account/account.py +50,Account {0}: You can not assign itself as parent account,Llogaria {0}: Ju nuk mund të caktojë veten si llogari prind
+apps/erpnext/erpnext/accounts/doctype/account/account.py +46,Account {0}: You can not assign itself as parent account,Llogaria {0}: Ju nuk mund të caktojë veten si llogari prind
 DocType: Purchase Invoice Item,Price List Rate,Lista e Çmimeve Rate
 apps/erpnext/erpnext/utilities/activation.py +72,Create customer quotes,Krijo kuotat konsumatorëve
 DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",Trego &quot;Në magazinë&quot; ose &quot;Jo në magazinë&quot; në bazë të aksioneve në dispozicion në këtë depo.
 apps/erpnext/erpnext/config/manufacturing.py +38,Bill of Materials (BOM),Bill e materialeve (BOM)
 DocType: Item,Average time taken by the supplier to deliver,Koha mesatare e marra nga furnizuesi për të ofruar
 DocType: Sample Collection,Collected By,Mbledhur nga
-apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.js +22,Assessment Result,Rezultati i vlerësimit
+apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +22,Assessment Result,Rezultati i vlerësimit
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,Orë
 DocType: Project,Expected Start Date,Pritet Data e Fillimit
+apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant Details Report,Raportet e variantit
 DocType: Setup Progress Action,Setup Progress Action,Aksioni i progresit të instalimit
+apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +18,Buying Price List,Lista e Çmimeve të Blerjes
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49,Remove item if charges is not applicable to that item,Hiq pika në qoftë se akuza nuk është i zbatueshëm për këtë artikull
+apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21,Please select Maintenance Status as Completed or remove Completion Date,Ju lutem zgjidhni Statusin e Mirëmbajtjes si Komplet ose hiqni Datën e Përfundimit
+DocType: Supplier,Default Payment Terms Template,Modeli i parazgjedhur i pagesave
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34,Transaction currency must be same as Payment Gateway currency,Monedha transaksion duhet të jetë i njëjtë si pagesë Gateway valutë
 DocType: Payment Entry,Receive,Merre
 apps/erpnext/erpnext/templates/pages/rfq.html +75,Quotations: ,Citate:
@@ -4656,20 +4991,20 @@
 DocType: Workstation,Operating Costs,Shpenzimet Operative
 DocType: Budget,Action if Accumulated Monthly Budget Exceeded,Veprimi në qoftë akumuluar tejkaluar buxhetin mujor
 DocType: Subscription,Submit on creation,Submit në krijimin
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +469,Currency for {0} must be {1},Monedhë për {0} duhet të jetë {1}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +470,Currency for {0} must be {1},Monedhë për {0} duhet të jetë {1}
 DocType: Asset,Disposal Date,Shkatërrimi Date
 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.","Email do të dërgohet të gjithë të punësuarve aktive e shoqërisë në orë të caktuar, në qoftë se ata nuk kanë pushim. Përmbledhje e përgjigjeve do të dërgohet në mesnatë."
 DocType: Employee Leave Approver,Employee Leave Approver,Punonjës Pushimi aprovuesi
-apps/erpnext/erpnext/stock/doctype/item/item.py +508,Row {0}: An Reorder entry already exists for this warehouse {1},Row {0}: Një hyrje Reorder tashmë ekziston për këtë depo {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +485,Row {0}: An Reorder entry already exists for this warehouse {1},Row {0}: Një hyrje Reorder tashmë ekziston për këtë depo {1}
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99,"Cannot declare as lost, because Quotation has been made.","Nuk mund të deklarojë si të humbur, sepse Kuotim i është bërë."
 apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16,Training Feedback,Feedback Training
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +458,Production Order {0} must be submitted,Prodhimi Rendit {0} duhet të dorëzohet
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +483,Production Order {0} must be submitted,Prodhimi Rendit {0} duhet të dorëzohet
 DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Kriteret e Scorecard Furnizuesit
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149,Please select Start Date and End Date for Item {0},"Ju lutem, përzgjidhni Data e Fillimit Data e Përfundimit Kohëzgjatja për Item {0}"
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +55,Course is mandatory in row {0},Kursi është i detyrueshëm në rresht {0}
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55,Course is mandatory in row {0},Kursi është i detyrueshëm në rresht {0}
 apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16,To date cannot be before from date,Deri më sot nuk mund të jetë e para nga data e
 DocType: Supplier Quotation Item,Prevdoc DocType,Prevdoc DOCTYPE
-apps/erpnext/erpnext/stock/doctype/item/item.js +272,Add / Edit Prices,Add / Edit Çmimet
+apps/erpnext/erpnext/stock/doctype/item/item.js +268,Add / Edit Prices,Add / Edit Çmimet
 DocType: Batch,Parent Batch,Batch Parent
 DocType: Cheque Print Template,Cheque Print Template,Çek Print Template
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36,Chart of Cost Centers,Grafiku i Qendrave te Kostos
@@ -4678,7 +5013,6 @@
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +655,My Orders,Urdhërat e mia
 DocType: Price List,Price List Name,Lista e Çmimeve Emri
 apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +32,Daily Work Summary for {0},Daily Përmbledhje Puna për {0}
-DocType: Employee Loan,Totals,Totalet
 DocType: BOM,Manufacturing,Prodhim
 ,Ordered Items To Be Delivered,Items urdhëroi që do të dërgohen
 DocType: Account,Income,Të ardhura
@@ -4688,129 +5022,142 @@
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +266,Sales Invoice {0} has already been submitted,Shitjet Faturë {0} tashmë është dorëzuar
 DocType: Supplier Scorecard Scoring Criteria,Score,rezultat
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,Viti Fiskal {0} nuk ekziston
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Completion Date,Data e përfundimit
+DocType: Asset Maintenance Log,Completion Date,Data e përfundimit
 DocType: Purchase Invoice Item,Amount (Company Currency),Shuma (Kompania Valuta)
+DocType: Crop,Agriculture User,Përdoruesi i Bujqësisë
 apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38,Valid till date cannot be before transaction date,E vlefshme deri në datën nuk mund të jetë para datës së transaksionit
-apps/erpnext/erpnext/stock/stock_ledger.py +372,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} njësitë e {1} nevojshme në {2} në {3} {4} për {5} për të përfunduar këtë transaksion.
+apps/erpnext/erpnext/stock/stock_ledger.py +379,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} njësitë e {1} nevojshme në {2} në {3} {4} për {5} për të përfunduar këtë transaksion.
 DocType: Fee Schedule,Student Category,Student Category
 DocType: Announcement,Student,student
-apps/erpnext/erpnext/config/hr.py +233,Organization unit (department) master.,Njësia Organizata (departamenti) mjeshtër.
-apps/erpnext/erpnext/utilities/user_progress.py +218,Go to Rooms,Shkoni në Dhoma
+apps/erpnext/erpnext/config/hr.py +238,Organization unit (department) master.,Njësia Organizata (departamenti) mjeshtër.
+DocType: Shipping Rule,Shipping Rule Type,Lloji Rregullave të Transportit
+apps/erpnext/erpnext/utilities/user_progress.py +236,Go to Rooms,Shkoni në Dhoma
 apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,Ju lutem shkruani mesazhin para se të dërgonte
 DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,Duplicate Furnizuesi
 DocType: Email Digest,Pending Quotations,Në pritje Citate
-apps/erpnext/erpnext/config/accounts.py +326,Point-of-Sale Profile,Point-of-Sale Profilin
+apps/erpnext/erpnext/config/accounts.py +318,Point-of-Sale Profile,Point-of-Sale Profilin
 apps/erpnext/erpnext/config/healthcare.py +153,Lab Test Configurations.,Konfigurimet e testit të laboratorit.
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156,Unsecured Loans,Kredi pasiguruar
 DocType: Cost Center,Cost Center Name,Kosto Emri Qendra
-DocType: Employee,B+,B +
+DocType: Student,B+,B +
 DocType: HR Settings,Max working hours against Timesheet,Max orarit të punës kundër pasqyrë e mungesave
 DocType: Maintenance Schedule Detail,Scheduled Date,Data e planifikuar
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +77,Total Paid Amt,Totale e paguar Amt
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +88,Total Paid Amt,Totale e paguar Amt
 DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Mesazhet më të mëdha se 160 karaktere do të ndahet në mesazhe të shumta
 DocType: Purchase Receipt Item,Received and Accepted,Marrë dhe pranuar
 DocType: Hub Settings,Company and Seller Profile,Profili i Kompanisë dhe Shitësit
 ,GST Itemised Sales Register,GST e detajuar Sales Regjistrohu
+DocType: Soil Texture,Silt Loam,Pjellë e zhytur
 ,Serial No Service Contract Expiry,Serial Asnjë Shërbimit Kontratë Expiry
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299,You cannot credit and debit same account at the same time,Ju nuk mund të kreditit dhe debitit njëjtën llogari në të njëjtën kohë
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +297,You cannot credit and debit same account at the same time,Ju nuk mund të kreditit dhe debitit njëjtën llogari në të njëjtën kohë
 DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Shkalla e rritjes së të rriturve është diku midis 50 dhe 80 rrahje në minutë.
 DocType: Naming Series,Help HTML,Ndihmë HTML
 DocType: Student Group Creation Tool,Student Group Creation Tool,Student Group Krijimi Tool
 DocType: Item,Variant Based On,Variant i bazuar në
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53,Total weightage assigned should be 100%. It is {0},Weightage Gjithsej caktuar duhet të jetë 100%. Kjo është {0}
-apps/erpnext/erpnext/utilities/user_progress.py +88,Your Suppliers,Furnizuesit tuaj
+apps/erpnext/erpnext/utilities/user_progress.py +106,Your Suppliers,Furnizuesit tuaj
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,Please correct the,Ju lutem korrigjoni
 apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80,Cannot set as Lost as Sales Order is made.,Nuk mund të vendosur si Humbur si Sales Order është bërë.
 DocType: Request for Quotation Item,Supplier Part No,Furnizuesi Part No
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +365,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Nuk mund të zbres kur kategori është për &#39;vlerësimin&#39; ose &#39;Vaulation dhe Total &quot;
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +363,Received From,Marrë nga
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +382,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Nuk mund të zbres kur kategori është për &#39;vlerësimin&#39; ose &#39;Vaulation dhe Total &quot;
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +364,Received From,Marrë nga
 DocType: Lead,Converted,Konvertuar
 DocType: Item,Has Serial No,Nuk ka Serial
 DocType: Employee,Date of Issue,Data e lëshimit
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +24,{0}: From {0} for {1},{0}: Nga {0} për {1}
-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}","Sipas Settings Blerja nëse blerja Reciept Required == &#39;PO&#39;, pastaj për krijimin Blerje Faturën, përdoruesi duhet të krijoni Marrjes blerjen e parë për pikën {0}"
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +166,Row #{0}: Set Supplier for item {1},Row # {0}: Furnizuesi Set për pika {1}
+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}","Sipas Settings Blerja nëse blerja Reciept Required == &#39;PO&#39;, pastaj për krijimin Blerje Faturën, përdoruesi duhet të krijoni Marrjes blerjen e parë për pikën {0}"
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167,Row #{0}: Set Supplier for item {1},Row # {0}: Furnizuesi Set për pika {1}
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121,Row {0}: Hours value must be greater than zero.,Row {0}: Hours Vlera duhet të jetë më e madhe se zero.
-apps/erpnext/erpnext/stock/doctype/item/item.py +183,Website Image {0} attached to Item {1} cannot be found,Faqja Image {0} bashkangjitur në pikën {1} nuk mund të gjendet
+apps/erpnext/erpnext/stock/doctype/item/item.py +185,Website Image {0} attached to Item {1} cannot be found,Faqja Image {0} bashkangjitur në pikën {1} nuk mund të gjendet
 DocType: Issue,Content Type,Përmbajtja Type
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +17,Computer,Kompjuter
+DocType: Asset,Assets,asetet
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17,Computer,Kompjuter
 DocType: Item,List this Item in multiple groups on the website.,Lista këtë artikull në grupe të shumta në faqen e internetit.
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +82,Please set default customer group and territory in Selling Settings,Ju lutemi vendosni grupin e parazgjedhur të konsumatorëve dhe territorin në Cilësimet e shitjes
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323,Please check Multi Currency option to allow accounts with other currency,Ju lutem kontrolloni opsionin Multi Valuta për të lejuar llogaritë me valutë tjetër
+DocType: Payment Term,Due Date Based On,Datë e bazuar në bazë
+apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +85,Please set default customer group and territory in Selling Settings,Ju lutemi vendosni grupin e parazgjedhur të konsumatorëve dhe territorin në Cilësimet e shitjes
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +203,{0} {1} does not exist,{0} {1} nuk ekziston
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +321,Please check Multi Currency option to allow accounts with other currency,Ju lutem kontrolloni opsionin Multi Valuta për të lejuar llogaritë me valutë tjetër
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +85,Item: {0} does not exist in the system,Item: {0} nuk ekziston në sistemin
-apps/erpnext/erpnext/accounts/doctype/account/account.py +109,You are not authorized to set Frozen value,Ju nuk jeni i autorizuar për të vendosur vlerën e ngrira
+apps/erpnext/erpnext/accounts/doctype/account/account.py +108,You are not authorized to set Frozen value,Ju nuk jeni i autorizuar për të vendosur vlerën e ngrira
 DocType: Payment Reconciliation,Get Unreconciled Entries,Get Unreconciled Entries
 DocType: Payment Reconciliation,From Invoice Date,Nga Faturë Data
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.py +28,You don't have permission to submit,Ju nuk keni leje për të dorëzuar
-apps/erpnext/erpnext/accounts/party.py +268,Billing currency must be equal to either default comapany's currency or party account currency,monedhë faturimit duhet të jetë e barabartë me monedhën ose llogarinë pala e secilës parazgjedhur comapany e monedhës
 DocType: Healthcare Settings,Laboratory Settings,Cilësimet laboratorike
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +71,Leave Encashment,Lini arkëtim
-apps/erpnext/erpnext/public/js/setup_wizard.js +111,What does it do?,Çfarë do të bëni?
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +75,To Warehouse,Për Magazina
-apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +26,All Student Admissions,Të gjitha Pranimet e studentëve
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75,Leave Encashment,Lini arkëtim
+apps/erpnext/erpnext/public/js/setup_wizard.js +114,What does it do?,Çfarë do të bëni?
+DocType: Crop,Byproducts,derivateve të tjerë
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +76,To Warehouse,Për Magazina
+apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26,All Student Admissions,Të gjitha Pranimet e studentëve
 ,Average Commission Rate,Mesatare Rate Komisioni
-apps/erpnext/erpnext/stock/doctype/item/item.py +418,'Has Serial No' can not be 'Yes' for non-stock item,&#39;Nuk ka Serial&#39; nuk mund të jetë &#39;Po&#39; për jo-aksioneve artikull
+apps/erpnext/erpnext/stock/doctype/item/item.py +434,'Has Serial No' can not be 'Yes' for non-stock item,&#39;Nuk ka Serial&#39; nuk mund të jetë &#39;Po&#39; për jo-aksioneve artikull
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +62,Select Status,Zgjidh statusin
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41,Attendance can not be marked for future dates,Pjesëmarrja nuk mund të shënohet për datat e ardhshme
 DocType: Pricing Rule,Pricing Rule Help,Rregulla e Çmimeve Ndihmë
 DocType: School House,House Name,Emri House
 DocType: Fee Schedule,Total Amount per Student,Shuma totale për student
 DocType: Purchase Taxes and Charges,Account Head,Shef llogari
-apps/erpnext/erpnext/config/stock.py +173,Update additional costs to calculate landed cost of items,Update shpenzimet shtesë për të llogaritur koston ul të artikujve
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +149,Electrical,Elektrik
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153,Electrical,Elektrik
 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,Shto pjesën tjetër të organizatës suaj si përdoruesit e juaj. Ju gjithashtu mund të shtoni ftojë konsumatorët për portalin tuaj duke shtuar ato nga Kontaktet
 DocType: Stock Entry,Total Value Difference (Out - In),Gjithsej Diferenca Vlera (Out - In)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348,Row {0}: Exchange Rate is mandatory,Row {0}: Exchange Rate është i detyrueshëm
+DocType: Grant Application,Requested Amount,Shuma e Kërkuar
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +346,Row {0}: Exchange Rate is mandatory,Row {0}: Exchange Rate është i detyrueshëm
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27,User ID not set for Employee {0},Përdoruesi ID nuk është caktuar për punonjësit {0}
 DocType: Vehicle,Vehicle Value,Vlera automjeteve
+DocType: Crop Cycle,Detected Diseases,Sëmundjet e zbuluara
 DocType: Stock Entry,Default Source Warehouse,Gabim Burimi Magazina
 DocType: Item,Customer Code,Kodi Klientit
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +216,Birthday Reminder for {0},Vërejtje ditëlindjen për {0}
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +220,Birthday Reminder for {0},Vërejtje ditëlindjen për {0}
+DocType: Asset Maintenance Task,Last Completion Date,Data e përfundimit të fundit
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72,Days Since Last Order,Ditët Që Rendit Fundit
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +355,Debit To account must be a Balance Sheet account,Debi Për shkak duhet të jetë një llogari Bilanci i Gjendjes
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +359,Debit To account must be a Balance Sheet account,Debi Për shkak duhet të jetë një llogari Bilanci i Gjendjes
 DocType: Buying Settings,Naming Series,Emërtimi Series
 DocType: Leave Block List,Leave Block List Name,Dërgo Block Lista Emri
 apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14,Insurance Start date should be less than Insurance End date,date Insurance Fillimi duhet të jetë më pak se data Insurance Fund
-apps/erpnext/erpnext/schools/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in School &gt; School Settings,Ju lutemi vendosni Sistemin e Emërimit të Instruktorit në Shkolla&gt; Cilësimet e Shkollave
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,Pasuritë e aksioneve
 DocType: Timesheet,Production Detail,Detail e prodhimit
 DocType: Restaurant,Active Menu,Meny aktiv
 DocType: Target Detail,Target Qty,Target Qty
 DocType: Shopping Cart Settings,Checkout Settings,Cilësimet Checkout
-DocType: Attendance,Present,I pranishëm
+DocType: Student Attendance,Present,I pranishëm
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37,Delivery Note {0} must not be submitted,Ofrimit Shënim {0} nuk duhet të dorëzohet
 DocType: Notification Control,Sales Invoice Message,Mesazh Shitjet Faturë
 apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,Closing Account {0} must be of type Liability / Equity,Llogarisë {0} Mbyllja duhet të jetë e tipit me Përgjegjësi / ekuitetit
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +325,Salary Slip of employee {0} already created for time sheet {1},Paga Slip nga punonjësi {0} krijuar tashmë për fletë kohë {1}
 DocType: Vehicle Log,Odometer,rrugëmatës
 DocType: Sales Order Item,Ordered Qty,Urdhërohet Qty
-apps/erpnext/erpnext/stock/doctype/item/item.py +727,Item {0} is disabled,Item {0} është me aftësi të kufizuara
+apps/erpnext/erpnext/stock/doctype/item/item.py +713,Item {0} is disabled,Item {0} është me aftësi të kufizuara
 DocType: Stock Settings,Stock Frozen Upto,Stock ngrira Upto
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +904,BOM does not contain any stock item,BOM nuk përmban ndonjë artikull aksioneve
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +929,BOM does not contain any stock item,BOM nuk përmban ndonjë artikull aksioneve
+DocType: Chapter,Chapter Head,Kreu i Kapitullit
+DocType: Payment Term,Month(s) after the end of the invoice month,Muaj (a) pas përfundimit të muajit të faturës
 apps/erpnext/erpnext/config/projects.py +19,Project activity / task.,Aktiviteti i projekt / detyra.
 DocType: Vehicle Log,Refuelling Details,Details Rimbushja
 apps/erpnext/erpnext/config/hr.py +104,Generate Salary Slips,Generate paga rrëshqet
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +44,"Buying must be checked, if Applicable For is selected as {0}","Blerja duhet të kontrollohet, nëse është e aplikueshme për të është zgjedhur si {0}"
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,Discount duhet të jetë më pak se 100
+DocType: Shipping Rule,Restrict to Countries,Kufizo vendet
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +171,Select Delivery Notes,Zgjidh shënimet e dorëzimit
 DocType: Purchase Invoice,Write Off Amount (Company Currency),Shkruaj Off Shuma (Kompania Valuta)
 DocType: Sales Invoice Timesheet,Billing Hours,faturimit Hours
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +500,Default BOM for {0} not found,BOM Default për {0} nuk u gjet
-apps/erpnext/erpnext/stock/doctype/item/item.py +498,Row #{0}: Please set reorder quantity,Row # {0}: Ju lutemi të vendosur sasinë Reorder
+DocType: Project,Total Sales Amount (via Sales Order),Shuma totale e shitjeve (me anë të shitjes)
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +528,Default BOM for {0} not found,BOM Default për {0} nuk u gjet
+apps/erpnext/erpnext/stock/doctype/item/item.py +489,Row #{0}: Please set reorder quantity,Row # {0}: Ju lutemi të vendosur sasinë Reorder
 apps/erpnext/erpnext/public/js/pos/pos.html +20,Tap items to add them here,Prekni për të shtuar artikuj tyre këtu
 DocType: Fees,Program Enrollment,program Regjistrimi
 DocType: Landed Cost Voucher,Landed Cost Voucher,Zbarkoi Voucher Kosto
 apps/erpnext/erpnext/public/js/queries.js +39,Please set {0},Ju lutemi të vendosur {0}
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} është nxënës joaktiv
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} është nxënës joaktiv
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} është nxënës joaktiv
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} është nxënës joaktiv
 DocType: Employee,Health Details,Detajet Shëndeti
 DocType: Offer Letter,Offer Letter Terms,Oferta Kushtet Letër
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,To create a Payment Request reference document is required,Për të krijuar një kërkesë për pagesë dokument reference është e nevojshme
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,To create a Payment Request reference document is required,Për të krijuar një kërkesë për pagesë dokument reference është e nevojshme
+DocType: Soil Texture,Sandy Clay,Sandy Balta
+DocType: Grant Application,Assessment  Manager,Menaxheri i Vlerësimit
 DocType: Payment Entry,Allocate Payment Amount,Alokimi Shuma e pagesës
 DocType: Employee External Work History,Salary,Rrogë
 DocType: Serial No,Delivery Document Type,Ofrimit Dokumenti Type
-DocType: Process Payroll,Submit all salary slips for the above selected criteria,Paraqit të gjitha rrëshqet pagave për kriteret e përzgjedhura më sipër
 DocType: Sales Order,Partly Delivered,Dorëzuar Pjesërisht
+DocType: Item Variant Settings,Do not update variants on save,Mos update variante për të shpëtuar
 DocType: Email Digest,Receivables,Arkëtueshme
 DocType: Lead Source,Lead Source,Burimi Lead
 DocType: Customer,Additional information regarding the customer.,Informacion shtesë në lidhje me konsumatorin.
@@ -4821,24 +5168,27 @@
 DocType: Maintenance Visit,Maintenance Date,Mirëmbajtja Data
 DocType: Purchase Invoice Item,Rejected Serial No,Refuzuar Nuk Serial
 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,Viti data e fillimit ose data fundi mbivendosje me {0}. Për të shmangur ju lutem kompaninë vendosur
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +94,Please mention the Lead Name in Lead {0},Ju lutemi të përmendni Emrin Lead në Lead {0}
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +108,Please mention the Lead Name in Lead {0},Ju lutemi të përmendni Emrin Lead në Lead {0}
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156,Start date should be less than end date for Item {0},Data e fillimit duhet të jetë më pak se data përfundimtare e artikullit {0}
 DocType: Item,"Example: ABCD.#####
 If series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.","Shembull:. ABCD ##### Nëse seri është vendosur dhe nuk Serial nuk është përmendur në transaksione, numri atëherë automatike serial do të krijohet në bazë të kësaj serie. Nëse ju gjithmonë doni të në mënyrë eksplicite përmend Serial Nos për këtë artikull. lënë bosh këtë."
 DocType: Upload Attendance,Upload Attendance,Ngarko Pjesëmarrja
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +319,BOM and Manufacturing Quantity are required,BOM dhe Prodhim Sasi janë të nevojshme
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +535,BOM and Manufacturing Quantity are required,BOM dhe Prodhim Sasi janë të nevojshme
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,Gama plakjen 2
 DocType: SG Creation Tool Course,Max Strength,Max Forca
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +28,Installing presets,Instalimi i paravendosjeve
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +67,No Delivery Note selected for Customer {},Nuk ka Shënim për Dorëzim të zgjedhur për Klientin {}
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +22,BOM replaced,Bom zëvendësohet
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +992,Select Items based on Delivery Date,Zgjedhni artikujt bazuar në Datën e Dorëzimit
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1041,Select Items based on Delivery Date,Zgjedhni artikujt bazuar në Datën e Dorëzimit
+DocType: Grant Application,Has any past Grant Record,Ka ndonjë të kaluar Grant Record
 ,Sales Analytics,Sales Analytics
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +119,Available {0},Në dispozicion {0}
 ,Prospects Engaged But Not Converted,Perspektivat angazhuar Por Jo konvertuar
 ,Prospects Engaged But Not Converted,Perspektivat angazhuar Por Jo konvertuar
 DocType: Manufacturing Settings,Manufacturing Settings,Prodhim Cilësimet
 apps/erpnext/erpnext/config/setup.py +56,Setting up Email,Ngritja me e-mail
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,Guardian1 Mobile No
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +103,Please enter default currency in Company Master,Ju lutem shkruani monedhën parazgjedhje në kompaninë Master
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,Guardian1 Mobile No
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106,Please enter default currency in Company Master,Ju lutem shkruani monedhën parazgjedhje në kompaninë Master
 DocType: Stock Entry Detail,Stock Entry Detail,Stock Hyrja Detail
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +109,Daily Reminders,Harroni të Përditshëm
 DocType: Products Settings,Home Page is Products,Faqja Kryesore është Produkte
@@ -4847,17 +5197,17 @@
 apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25,New Account Name,New Emri i llogarisë
 DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Kosto të lëndëve të para furnizuar
 DocType: Selling Settings,Settings for Selling Module,Cilësimet për shitjen Module
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +111,Customer Service,Shërbimi ndaj klientit
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115,Customer Service,Shërbimi ndaj klientit
 DocType: BOM,Thumbnail,Thumbnail
 DocType: Item Customer Detail,Item Customer Detail,Item Detail Klientit
 apps/erpnext/erpnext/config/hr.py +50,Offer candidate a Job.,Oferta kandidat a Job.
 DocType: Notification Control,Prompt for Email on Submission of,Prompt për Dërgoje në dorëzimin e
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88,Total allocated leaves are more than days in the period,Gjithsej gjethet e ndara janë më shumë se ditë në periudhën
+DocType: Land Unit,Linked Soil Analysis,Analizë e Lidhjeve të Tokës
 DocType: Pricing Rule,Percentage,përqindje
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70,Item {0} must be a stock Item,Item {0} duhet të jetë një gjendje Item
 DocType: Manufacturing Settings,Default Work In Progress Warehouse,Default Puna Në Magazina Progresit
-apps/erpnext/erpnext/config/accounts.py +296,Default settings for accounting transactions.,Default settings për transaksionet e kontabilitetit.
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +23,Please setup Employee Naming System in Human Resource &gt; HR Settings,Ju lutem vendosni Sistemin e Emërimit të Punonjësve në Burimet Njerëzore&gt; Cilësimet e HR
+apps/erpnext/erpnext/config/accounts.py +288,Default settings for accounting transactions.,Default settings për transaksionet e kontabilitetit.
 DocType: Maintenance Visit,MV,MV
 DocType: Restaurant,Default Tax Template,Modeli Tatimor i Parazgjedhur
 DocType: Fees,Student Details,Detajet e Studentit
@@ -4871,11 +5221,11 @@
 DocType: Sales Order,Printing Details,Shtypi Detajet
 DocType: Task,Closing Date,Data e mbylljes
 DocType: Sales Order Item,Produced Quantity,Sasia e prodhuar
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +122,Engineer,Inxhinier
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126,Engineer,Inxhinier
 DocType: Journal Entry,Total Amount Currency,Total Shuma Valuta
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Kuvendet Kërko Nën
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +168,Item Code required at Row No {0},Kodi i artikullit kërkohet në radhë nr {0}
-apps/erpnext/erpnext/utilities/user_progress.py +133,Go to Items,Shko te artikujt
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171,Item Code required at Row No {0},Kodi i artikullit kërkohet në radhë nr {0}
+apps/erpnext/erpnext/utilities/user_progress.py +151,Go to Items,Shko te artikujt
 DocType: Sales Partner,Partner Type,Lloji Partner
 DocType: Purchase Taxes and Charges,Actual,Aktual
 DocType: Restaurant Menu,Restaurant Manager,Menaxheri i Restorantit
@@ -4892,36 +5242,38 @@
 DocType: Item Reorder,Re-Order Level,Re-Rendit nivel
 DocType: Production Planning Tool,Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,Shkruani artikuj dhe Qty planifikuar për të cilën ju doni të rritur urdhërat e prodhimit ose shkarkoni materiale të papërpunuara për analizë.
 apps/erpnext/erpnext/projects/doctype/project/project.js +64,Gantt Chart,Gantt Chart
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +95,Part-time,Me kohë të pjesshme
+DocType: Crop Cycle,Cycle Type,Lloji i ciklit
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99,Part-time,Me kohë të pjesshme
 DocType: Employee,Applicable Holiday List,Zbatueshme Lista Holiday
 DocType: Employee,Cheque,Çek
 DocType: Training Event,Employee Emails,E-mail punonjësish
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +59,Series Updated,Seria Përditësuar
-apps/erpnext/erpnext/accounts/doctype/account/account.py +162,Report Type is mandatory,Raporti Lloji është i detyrueshëm
+apps/erpnext/erpnext/accounts/doctype/account/account.py +161,Report Type is mandatory,Raporti Lloji është i detyrueshëm
 DocType: Item,Serial Number Series,Serial Number Series
 apps/erpnext/erpnext/buying/utils.py +68,Warehouse is mandatory for stock Item {0} in row {1},Depoja është e detyrueshme për aksioneve Item {0} në rresht {1}
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +45,Retail & Wholesale,Shitje me pakicë dhe shumicë
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45,Retail & Wholesale,Shitje me pakicë dhe shumicë
 DocType: Issue,First Responded On,Së pari u përgjigj më
 DocType: Website Item Group,Cross Listing of Item in multiple groups,Kryqi Listimi i artikullit në grupe të shumta
 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},Viti Fiskal Data e Fillimit dhe Viti Fiskal Fundi Data e janë vendosur tashmë në vitin fiskal {0}
 apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,Clearance Date updated,Pastrimi Date updated
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +131,Split Batch,Batch Split
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +131,Split Batch,Batch Split
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +138,Split Batch,Batch Split
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +138,Split Batch,Batch Split
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +131,Successfully Reconciled,Harmonizuar me sukses
 DocType: Request for Quotation Supplier,Download PDF,Shkarko PDF
 DocType: Production Order,Planned End Date,Planifikuar Data e Përfundimit
-apps/erpnext/erpnext/controllers/buying_controller.py +423,Please enter Schedule Date,Ju lutemi shkruani datën e orarit
-apps/erpnext/erpnext/config/stock.py +189,Where items are stored.,Ku sendet janë ruajtur.
+apps/erpnext/erpnext/controllers/buying_controller.py +424,Please enter Schedule Date,Ju lutemi shkruani datën e orarit
+apps/erpnext/erpnext/config/non_profit.py +63,Donor Type information.,Informacioni mbi tipin e donatorit.
 DocType: Request for Quotation,Supplier Detail,furnizuesi Detail
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100,Error in formula or condition: {0},Error ne formulen ose gjendje: {0}
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +16,Invoiced Amount,Shuma e faturuar
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47,Criteria weights must add up to 100%,Peshat e kriterit duhet të shtojnë deri në 100%
-DocType: Attendance,Attendance,Pjesëmarrje
+apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7,Attendance,Pjesëmarrje
 apps/erpnext/erpnext/public/js/pos/pos.html +104,Stock Items,Stock Items
 DocType: BOM,Materials,Materiale
 DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Nëse nuk kontrollohet, lista do të duhet të shtohet për çdo Departamentit ku ajo duhet të zbatohet."
-apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Burimi dhe Target Warehouse nuk mund të jetë e njëjtë
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +535,Posting date and posting time is mandatory,Postimi datën dhe postimi kohë është i detyrueshëm
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +103,Creating {0},Krijimi i {0}
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Burimi dhe Target Warehouse nuk mund të jetë e njëjtë
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +561,Posting date and posting time is mandatory,Postimi datën dhe postimi kohë është i detyrueshëm
 apps/erpnext/erpnext/config/buying.py +76,Tax template for buying transactions.,Template taksave për blerjen e transaksioneve.
 ,Item Prices,Çmimet pika
 DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,Me fjalë do të jetë i dukshëm një herë ju ruani qëllim blerjen.
@@ -4931,39 +5283,42 @@
 apps/erpnext/erpnext/config/selling.py +67,Price List master.,Lista e Çmimeve mjeshtër.
 DocType: Task,Review Date,Data shqyrtim
 DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Seria për Shënimin e Zhvlerësimit të Aseteve (Hyrja e Gazetës)
+DocType: Membership,Member Since,Anëtar që prej
 DocType: Purchase Invoice,Advance Payments,Pagesat e paradhënies
 DocType: Purchase Taxes and Charges,On Net Total,On Net Total
 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},Vlera për atribut {0} duhet të jetë brenda intervalit {1} të {2} në increments e {3} për Item {4}
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +161,Target warehouse in row {0} must be same as Production Order,Magazinë synuar në radhë {0} duhet të jetë i njëjtë si Rendit Prodhimi
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +166,Target warehouse in row {0} must be same as Production Order,Magazinë synuar në radhë {0} duhet të jetë i njëjtë si Rendit Prodhimi
 DocType: Restaurant Reservation,Waitlisted,e konfirmuar
-apps/erpnext/erpnext/accounts/doctype/account/account.py +127,Currency can not be changed after making entries using some other currency,"Valuta nuk mund të ndryshohet, pasi duke e bërë shënimet duke përdorur disa valutë tjetër"
+apps/erpnext/erpnext/accounts/doctype/account/account.py +126,Currency can not be changed after making entries using some other currency,"Valuta nuk mund të ndryshohet, pasi duke e bërë shënimet duke përdorur disa valutë tjetër"
+DocType: Shipping Rule,Fixed,fiks
 DocType: Vehicle Service,Clutch Plate,Plate Clutch
 DocType: Company,Round Off Account,Rrumbullakët Off Llogari
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93,Administrative Expenses,Shpenzimet administrative
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +18,Consulting,Këshillues
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18,Consulting,Këshillues
 DocType: Customer Group,Parent Customer Group,Grupi prind Klientit
 DocType: Journal Entry,Subscription,abonim
 DocType: Purchase Invoice,Contact Email,Kontakti Email
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Krijimi i tarifës në pritje
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Krijimi i tarifës në pritje
 DocType: Appraisal Goal,Score Earned,Vota fituara
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +229,Notice Period,Periudha Njoftim
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239,Notice Period,Periudha Njoftim
 DocType: Asset Category,Asset Category Name,Asset Category Emri
 apps/erpnext/erpnext/setup/doctype/territory/territory.js +13,This is a root territory and cannot be edited.,Kjo është një territor rrënjë dhe nuk mund të redaktohen.
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5,New Sales Person Name,Emri i ri Sales Person
 DocType: Packing Slip,Gross Weight UOM,Bruto Pesha UOM
+DocType: Asset Maintenance Task,Preventive Maintenance,Mirëmbajtje parandaluese
 DocType: Delivery Note Item,Against Sales Invoice,Kundër Sales Faturës
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +141,Please enter serial numbers for serialized item ,Ju lutem shkruani numrat serik për artikull serialized
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +151,Please enter serial numbers for serialized item ,Ju lutem shkruani numrat serik për artikull serialized
 DocType: Bin,Reserved Qty for Production,Rezervuar Qty për Prodhimin
 DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,Dërgo pakontrolluar në qoftë se ju nuk doni të marrin në konsideratë duke bërë grumbull grupet kurs të bazuar.
 DocType: Asset,Frequency of Depreciation (Months),Frekuenca e Zhvlerësimit (Muaj)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +493,Credit Account,Llogaria e Kredisë
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +501,Credit Account,Llogaria e Kredisë
 DocType: Landed Cost Item,Landed Cost Item,Kosto zbarkoi Item
 apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57,Show zero values,Trego zero vlerat
 DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Sasia e sendit të marra pas prodhimit / ripaketimin nga sasi të caktuara të lëndëve të para
 DocType: Lab Test,Test Group,Grupi i Testimeve
 DocType: Payment Reconciliation,Receivable / Payable Account,Arkëtueshme / pagueshme Llogaria
 DocType: Delivery Note Item,Against Sales Order Item,Kundër Sales Rendit Item
-apps/erpnext/erpnext/stock/doctype/item/item.py +694,Please specify Attribute Value for attribute {0},Ju lutem specifikoni atribut Vlera për atribut {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +680,Please specify Attribute Value for attribute {0},Ju lutem specifikoni atribut Vlera për atribut {0}
 DocType: Item,Default Warehouse,Gabim Magazina
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45,Budget cannot be assigned against Group Account {0},Buxheti nuk mund të caktohet kundër Llogaria Grupit {0}
 DocType: Healthcare Settings,Patient Registration,Regjistrimi i pacientit
@@ -4975,24 +5330,28 @@
 DocType: Appraisal,Total Score (Out of 5),Rezultati i përgjithshëm (nga 5)
 DocType: Fee Structure,FS.,FS.
 DocType: Student Attendance Tool,Batch,Grumbull
+DocType: Donor,Donor Type,Lloji i donatorit
 apps/erpnext/erpnext/stock/doctype/item/item.js +27,Balance,Ekuilibër
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66,Please select the Company,Ju lutemi zgjidhni Kompaninë
 DocType: Room,Seating Capacity,Seating Kapaciteti
 DocType: Issue,ISS-,ISS-
 DocType: Lab Test Groups,Lab Test Groups,Grupet e Testimit Lab
 DocType: Project,Total Expense Claim (via Expense Claims),Gjithsej Kërkesa shpenzimeve (nëpërmjet kërkesave shpenzime)
 DocType: GST Settings,GST Summary,GST Përmbledhje
 DocType: Assessment Result,Total Score,Total Score
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +116,Please set the Default Cost Center in {0} company,Vendosni Qendrën e Kostos së Parazgjedhur në {0} kompani
 DocType: Journal Entry,Debit Note,Debiti Shënim
 DocType: Stock Entry,As per Stock UOM,Sipas Stock UOM
 apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,Jo Skaduar
 DocType: Student Log,Achievement,arritje
 DocType: Batch,Source Document Type,Burimi Lloji i dokumentit
 DocType: Batch,Source Document Type,Burimi Lloji i dokumentit
+apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24,Following course schedules were created,Pas orarit të kurseve u krijuan
 DocType: Journal Entry,Total Debit,Debiti i përgjithshëm
 DocType: Manufacturing Settings,Default Finished Goods Warehouse,Default përfunduara Mallra Magazina
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +77,Sales Person,Sales Person
-apps/erpnext/erpnext/config/accounts.py +241,Budget and Cost Center,Buxheti dhe Qendra Kosto
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +60,Multiple default mode of payment is not allowed,Mënyra e parazgjedhur e pagesës nuk lejohet
+apps/erpnext/erpnext/config/accounts.py +233,Budget and Cost Center,Buxheti dhe Qendra Kosto
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65,Multiple default mode of payment is not allowed,Mënyra e parazgjedhur e pagesës nuk lejohet
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,for the,për
 ,Appointment Analytics,Analiza e emërimeve
 DocType: Vehicle Service,Half Yearly,Gjysma vjetore
@@ -5001,18 +5360,19 @@
 DocType: Healthcare Settings,Consultations in valid days,Konsultimet në ditë të vlefshme
 DocType: Assessment Plan Criteria,Maximum Score,Maximum Score
 apps/erpnext/erpnext/config/setup.py +83,Create rules to restrict transactions based on values.,Krijo rregulla për të kufizuar transaksionet në bazë të vlerave.
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,Grupi Roll No
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Krijimi i taksës dështoi
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,Grupi Roll No
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Krijimi i taksës dështoi
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Lini bosh në qoftë se ju bëni studentëve grupet në vit
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Nëse kontrolluar, Gjithsej nr. i ditëve të punës do të përfshijë pushimet, dhe kjo do të zvogëlojë vlerën e pagave Per Day"
 DocType: Purchase Invoice,Total Advance,Advance Total
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27,Change Template Code,Ndrysho kodin e modelit
-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.,"Term End Date nuk mund të jetë më herët se data e fillimit Term. Ju lutem, Korrigjo datat dhe provoni përsëri."
+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.,"Term End Date nuk mund të jetë më herët se data e fillimit Term. Ju lutem, Korrigjo datat dhe provoni përsëri."
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,quot Count
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,quot Count
 ,BOM Stock Report,BOM Stock Raporti
 DocType: Stock Reconciliation Item,Quantity Difference,sasia Diferenca
-apps/erpnext/erpnext/config/hr.py +315,Processing Payroll,Përpunimi Pagave
+DocType: Employee Advance,EA-,EA-
+apps/erpnext/erpnext/config/hr.py +320,Processing Payroll,Përpunimi Pagave
 DocType: Opportunity Item,Basic Rate,Norma bazë
 DocType: GL Entry,Credit Amount,Shuma e kreditit
 DocType: Cheque Print Template,Signatory Position,Pozita nënshkruese
@@ -5020,7 +5380,7 @@
 DocType: Timesheet,Total Billable Hours,Gjithsej orëve billable
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4,Payment Receipt Note,Pagesa Pranimi Shënim
 apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,This is based on transactions against this Customer. See timeline below for details,Kjo është e bazuar në transaksionet kundër këtij Klientit. Shih afat kohor më poshtë për detaje
-DocType: Supplier,Credit Days Based On,Ditët e kredisë së bazuar në
+DocType: Company,Credit Days Based On,Ditët e kredisë së bazuar në
 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}: Shuma e alokuar {1} duhet të jetë më pak se ose e barabartë me shumën e pagesës Hyrja {2}
 ,Course wise Assessment Report,Raporti i Vlerësimit kurs i mençur
 DocType: Tax Rule,Tax Rule,Rregulla Tatimore
@@ -5028,66 +5388,73 @@
 DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Planifikoni kohë shkrimet jashtë orarit Workstation punës.
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +92,Dr {0} does not have a Physician Schedule. Add it in Physician master,Dr {0} nuk ka një orar të mjekut. Shtoni në Master
 apps/erpnext/erpnext/public/js/pos/pos.html +87,Customers in Queue,Konsumatorët në radhë
+DocType: Driver,Issuing Date,Data e lëshimit
 DocType: Student,Nationality,kombësi
 ,Items To Be Requested,Items të kërkohet
 DocType: Company,Company Info,Company Info
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1359,Select or add new customer,Zgjidhni ose shtoni klient të ri
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +154,Cost center is required to book an expense claim,Qendra Kosto është e nevojshme për të librit një kërkesë shpenzimeve
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1374,Select or add new customer,Zgjidhni ose shtoni klient të ri
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +179,Cost center is required to book an expense claim,Qendra Kosto është e nevojshme për të librit një kërkesë shpenzimeve
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Aplikimi i mjeteve (aktiveve)
 apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6,This is based on the attendance of this Employee,Kjo është e bazuar në pjesëmarrjen e këtij punonjësi
-apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Pjesëmarrja e Markut
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +487,Debit Account,Llogaria Debiti
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Pjesëmarrja e Markut
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +495,Debit Account,Llogaria Debiti
 DocType: Fiscal Year,Year Start Date,Viti Data e Fillimit
 DocType: Attendance,Employee Name,Emri punonjës
 DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Produkti i Renditjes
-DocType: Sales Invoice,Rounded Total (Company Currency),Harmonishëm Total (Kompania Valuta)
-apps/erpnext/erpnext/accounts/doctype/account/account.py +99,Cannot covert to Group because Account Type is selected.,Nuk mund të fshehta të grupit për shkak Tipi Llogarisë është zgjedhur.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +240,{0} {1} has been modified. Please refresh.,{0} {1} është modifikuar. Ju lutem refresh.
+DocType: Purchase Invoice,Rounded Total (Company Currency),Harmonishëm Total (Kompania Valuta)
+apps/erpnext/erpnext/accounts/doctype/account/account.py +98,Cannot covert to Group because Account Type is selected.,Nuk mund të fshehta të grupit për shkak Tipi Llogarisë është zgjedhur.
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260,{0} {1} has been modified. Please refresh.,{0} {1} është modifikuar. Ju lutem refresh.
 DocType: Leave Block List,Stop users from making Leave Applications on following days.,Stop përdoruesit nga bërja Dërgo Aplikacione në ditët në vijim.
+DocType: Asset Maintenance Team,Maintenance Team Members,Anëtarët e ekipit të mirëmbajtjes
 apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63,Purchase Amount,Shuma Blerje
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +259,Supplier Quotation {0} created,Furnizuesi Citat {0} krijuar
 apps/erpnext/erpnext/accounts/report/financial_statements.py +97,End Year cannot be before Start Year,Fundi Viti nuk mund të jetë para se të fillojë Vitit
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +222,Employee Benefits,Përfitimet e Punonjësve
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232,Employee Benefits,Përfitimet e Punonjësve
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +255,Packed quantity must equal quantity for Item {0} in row {1},Sasia e mbushur duhet të barabartë sasi për Item {0} në rresht {1}
 DocType: Production Order,Manufactured Qty,Prodhuar Qty
 apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64,Invoice Created,Fatura u krijua
+DocType: Asset,Out of Order,Jashtë përdorimit
 DocType: Purchase Receipt Item,Accepted Quantity,Sasi të pranuar
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +238,Please set a default Holiday List for Employee {0} or Company {1},Ju lutemi të vendosur një default Holiday Lista për punonjësit {0} ose Company {1}
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +242,Please set a default Holiday List for Employee {0} or Company {1},Ju lutemi të vendosur një default Holiday Lista për punonjësit {0} ose Company {1}
 apps/erpnext/erpnext/accounts/party.py +31,{0}: {1} does not exists,{0}: {1} nuk ekziston
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +75,Select Batch Numbers,Zgjidh Batch Numbers
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76,Select Batch Numbers,Zgjidh Batch Numbers
 apps/erpnext/erpnext/config/accounts.py +12,Bills raised to Customers.,Faturat e ngritura për të Konsumatorëve.
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,Projekti 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},Row Asnjë {0}: Shuma nuk mund të jetë më e madhe se pritje Shuma kundër shpenzimeve sipas Pretendimit {1}. Në pritje Shuma është {2}
-DocType: Maintenance Schedule,Schedule,Orar
+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},Row Asnjë {0}: Shuma nuk mund të jetë më e madhe se pritje Shuma kundër shpenzimeve sipas Pretendimit {1}. Në pritje Shuma është {2}
+DocType: Assessment Plan,Schedule,Orar
 DocType: Account,Parent Account,Llogaria prind
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +253,Available,Në dispozicion
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266,Available,Në dispozicion
 DocType: Quality Inspection Reading,Reading 3,Leximi 3
 ,Hub,Qendër
 DocType: GL Entry,Voucher Type,Voucher Type
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1691,Price List not found or disabled,Lista e Çmimeve nuk u gjet ose me aftësi të kufizuara
-DocType: Lab Test,Approved,I miratuar
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1706,Price List not found or disabled,Lista e Çmimeve nuk u gjet ose me aftësi të kufizuara
+DocType: Student Applicant,Approved,I miratuar
 DocType: Pricing Rule,Price,Çmim
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +266,Employee relieved on {0} must be set as 'Left',Punonjës lirohet për {0} duhet të jetë vendosur si &#39;majtë&#39;
 DocType: Hub Settings,Last Sync On,Sinjali i fundit në
 DocType: Guardian,Guardian,kujdestar
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,Appraisal {0} created for Employee {1} in the given date range,Vlerësimi {0} krijuar për punonjësit {1} në datën e caktuar varg
-DocType: Employee,Education,Arsim
+DocType: Academic Term,Education,Arsim
 apps/erpnext/erpnext/public/js/pos/pos.html +78,Del,del
 DocType: Selling Settings,Campaign Naming By,Emërtimi Fushata By
 DocType: Employee,Current Address Is,Adresa e tanishme është
 apps/erpnext/erpnext/utilities/user_progress.py +48,Monthly Sales Target (,Synimi i shitjeve mujore (
 apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9,modified,modifikuar
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +41,"Optional. Sets company's default currency, if not specified.","Fakultative. Vë monedhë default kompanisë, nëse nuk është specifikuar."
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43,"Optional. Sets company's default currency, if not specified.","Fakultative. Vë monedhë default kompanisë, nëse nuk është specifikuar."
 DocType: Sales Invoice,Customer GSTIN,GSTIN Customer
+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 ,"Lista e sëmundjeve të zbuluara në terren. Kur zgjidhet, do të shtojë automatikisht një listë të detyrave për t&#39;u marrë me sëmundjen"
+DocType: Asset Repair,Repair Status,Gjendja e Riparimit
 apps/erpnext/erpnext/config/accounts.py +67,Accounting journal entries.,Rregjistrimet në ditar të kontabilitetit.
 DocType: Delivery Note Item,Available Qty at From Warehouse,Qty në dispozicion në nga depo
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +295,Please select Employee Record first.,"Ju lutem, përzgjidhni Record punonjës parë."
 DocType: POS Profile,Account for Change Amount,Llogaria për Ndryshim Shuma
-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}: Partia / Llogaria nuk përputhet me {1} / {2} në {3} {4}
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Course Code: ,Kodi i kursit:
+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}: Partia / Llogaria nuk përputhet me {1} / {2} në {3} {4}
+DocType: Maintenance Team Member,Maintenance Team Member,Anëtar i ekipit të mirëmbajtjes
+DocType: Agriculture Analysis Criteria,Soil Analysis,Analiza e tokës
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Course Code: ,Kodi i kursit:
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +238,Please enter Expense Account,Ju lutemi shkruani Llogari kurriz
 DocType: Account,Stock,Stock
-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","Row # {0}: Reference Lloji i dokumentit duhet të jetë një e Rendit Blerje, Blerje Faturë ose Journal Entry"
+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","Row # {0}: Reference Lloji i dokumentit duhet të jetë një e Rendit Blerje, Blerje Faturë ose Journal Entry"
 DocType: Employee,Current Address,Adresa e tanishme
 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","Nëse pika është një variant i një tjetër çështje pastaj përshkrimin, imazhi, çmimi, taksat, etj do të vendoset nga template përveç nëse specifikohet shprehimisht"
 DocType: Serial No,Purchase / Manufacture Details,Blerje / Detajet Prodhimi
@@ -5098,54 +5465,53 @@
 DocType: Sales Invoice Item,Discount and Margin,Discount dhe Margin
 DocType: Lab Test,Prescription,recetë
 DocType: Production Planning Tool,Pull sales orders (pending to deliver) based on the above criteria,"Shitjes tërheq urdhëron (në pritje për të ofruar), bazuar në kriteret e mësipërme"
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +90,Not Available,Not Available
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +98,Not Available,Not Available
 DocType: Pricing Rule,Min Qty,Min Qty
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36,Disable Template,Çaktivizo modelin
-DocType: Asset Movement,Transaction Date,Transaksioni Data
+DocType: GL Entry,Transaction Date,Transaksioni Data
 DocType: Production Plan Item,Planned Qty,Planifikuar Qty
 apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Tatimi Total
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +177,For Quantity (Manufactured Qty) is mandatory,Për sasinë (Prodhuar Qty) është i detyrueshëm
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +182,For Quantity (Manufactured Qty) is mandatory,Për sasinë (Prodhuar Qty) është i detyrueshëm
 DocType: Stock Entry,Default Target Warehouse,Gabim Magazina Target
 DocType: Purchase Invoice,Net Total (Company Currency),Net Total (Kompania Valuta)
-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.,"Viti End Date nuk mund të jetë më herët se data e fillimit Year. Ju lutem, Korrigjo datat dhe provoni përsëri."
-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}: Partia Lloji dhe Partia është i zbatueshëm vetëm kundër arkëtueshme / pagueshme llogari
+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.,"Viti End Date nuk mund të jetë më herët se data e fillimit Year. Ju lutem, Korrigjo datat dhe provoni përsëri."
 DocType: Notification Control,Purchase Receipt Message,Blerje Pranimi Mesazh
 DocType: BOM,Scrap Items,Items skrap
 DocType: Production Order,Actual Start Date,Aktuale Data e Fillimit
 DocType: Sales Order,% of materials delivered against this Sales Order,% E materialeve dorëzuar kundër këtij Rendit Shitje
-apps/erpnext/erpnext/config/stock.py +12,Record item movement.,Lëvizja rekord pika.
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +57,Set default mode of payment,Vendosni mënyrën e paracaktuar të pagesës
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62,Set default mode of payment,Vendosni mënyrën e paracaktuar të pagesës
+DocType: Grant Application,Withdrawn,I tërhequr
 DocType: Hub Settings,Hub Settings,Hub Cilësimet
 DocType: Project,Gross Margin %,Marzhi bruto%
 DocType: BOM,With Operations,Me Operacioneve
-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}.,"Regjistrimet kontabël tashmë janë bërë në monedhën {0} për kompaninë {1}. Ju lutem, përzgjidhni një llogari arkëtueshëm ose të pagueshëm me monedhën {0}."
+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}.,"Regjistrimet kontabël tashmë janë bërë në monedhën {0} për kompaninë {1}. Ju lutem, përzgjidhni një llogari arkëtueshëm ose të pagueshëm me monedhën {0}."
 DocType: Asset,Is Existing Asset,Është Asetin ekzistuese
 DocType: Salary Detail,Statistical Component,Komponenti statistikore
 DocType: Salary Detail,Statistical Component,Komponenti statistikore
 DocType: Warranty Claim,If different than customer address,Nëse është e ndryshme se sa adresën e konsumatorëve
 DocType: Purchase Invoice,Without Payment of Tax,Pa pagesën e tatimit
 DocType: BOM Operation,BOM Operation,Bom Operacioni
+apps/erpnext/erpnext/config/stock.py +141,Fulfilment,përmbushje
 DocType: Purchase Taxes and Charges,On Previous Row Amount,Në Shuma Previous Row
-DocType: Student,Home Address,Adresa e shtepise
 DocType: Item,Has Expiry Date,Ka Data e Skadimit
-apps/erpnext/erpnext/config/stock.py +111,Item Variant Settings.,Cilësimet e variantit të artikullit.
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +249,Transfer Asset,Asset Transfer
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +269,Transfer Asset,Asset Transfer
 DocType: POS Profile,POS Profile,POS Profilin
 DocType: Training Event,Event Name,Event Emri
 DocType: Physician,Phone (Office),Telefoni (Zyra)
-apps/erpnext/erpnext/hooks.py +147,Admission,pranim
-apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +29,Admissions for {0},Regjistrimet për {0}
-apps/erpnext/erpnext/config/accounts.py +265,"Seasonality for setting budgets, targets etc.","Sezonalitetit për vendosjen buxhetet, objektivat etj"
+apps/erpnext/erpnext/hooks.py +151,Admission,pranim
+apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29,Admissions for {0},Regjistrimet për {0}
+apps/erpnext/erpnext/config/accounts.py +257,"Seasonality for setting budgets, targets etc.","Sezonalitetit për vendosjen buxhetet, objektivat etj"
 DocType: Supplier Scorecard Scoring Variable,Variable Name,Emri i ndryshueshëm
-apps/erpnext/erpnext/stock/get_item_details.py +147,"Item {0} is a template, please select one of its variants","Item {0} është një template, ju lutem zgjidhni një nga variantet e saj"
+apps/erpnext/erpnext/stock/get_item_details.py +142,"Item {0} is a template, please select one of its variants","Item {0} është një template, ju lutem zgjidhni një nga variantet e saj"
 DocType: Asset,Asset Category,Asset Category
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31,Net pay cannot be negative,Paguajnë neto nuk mund të jetë negative
 DocType: Assessment Plan,Room,dhomë
 DocType: Purchase Order,Advance Paid,Advance Paid
 DocType: Item,Item Tax,Tatimi i artikullit
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +843,Material to Supplier,Materiale për Furnizuesin
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +384,Excise Invoice,Akciza Faturë
-apps/erpnext/erpnext/schools/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Pragun {0}% shfaqet më shumë se një herë
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +868,Material to Supplier,Materiale për Furnizuesin
+DocType: Soil Texture,Loamy Sand,Rërë e pangopur
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +594,Excise Invoice,Akciza Faturë
+apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Pragun {0}% shfaqet më shumë se një herë
 DocType: Expense Claim,Employees Email Id,Punonjësit Email Id
 DocType: Employee Attendance Tool,Marked Attendance,Pjesëmarrja e shënuar
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138,Current Liabilities,Detyrimet e tanishme
@@ -5153,16 +5519,17 @@
 DocType: Patient,A Positive,Një pozitive
 DocType: Program,Program Name,program Emri
 DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Konsideroni tatimit apo detyrimit për
+DocType: Driver,Driving License Category,Kategoria e licencës së vozitjes
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,Aktuale Qty është e detyrueshme
-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} aktualisht ka një {1} Scorecard të Furnizuesit, dhe Urdhërat e Blerjes për këtë furnizues duhet të lëshohen me kujdes."
+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} aktualisht ka një {1} Scorecard të Furnizuesit, dhe Urdhërat e Blerjes për këtë furnizues duhet të lëshohen me kujdes."
+DocType: Asset Maintenance Team,Asset Maintenance Team,Ekipi i Mirëmbajtjes së Aseteve
 DocType: Employee Loan,Loan Type,Lloji Loan
 DocType: Scheduling Tool,Scheduling Tool,caktimin Tool
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +176,Credit Card,Credit Card
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180,Credit Card,Credit Card
 DocType: BOM,Item to be manufactured or repacked,Pika për të prodhuar apo ripaketohen
-apps/erpnext/erpnext/config/stock.py +184,Default settings for stock transactions.,Default settings për transaksionet e aksioneve.
 DocType: Employee Education,Major/Optional Subjects,/ Subjektet e mëdha fakultative
 DocType: Sales Invoice Item,Drop Ship,Drop Ship
-DocType: Hub Settings,Suspended,pezulluar
+DocType: Driver,Suspended,pezulluar
 DocType: Training Event,Attendees,pjesëmarrësit
 DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Këtu ju mund të mbajë të dhënat e familjes si emrin dhe profesionin e prindërve, bashkëshortit dhe fëmijëve"
 DocType: Academic Term,Term End Date,Term End Date
@@ -5171,13 +5538,13 @@
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23,From Currency and To Currency cannot be same,Nga Valuta dhe me monedhën nuk mund të jetë e njëjtë
 DocType: Stock Entry,Repack,Ripaketoi
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,Ju duhet të ruani formën para se të vazhdoni
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +96,Please select the Company first,Ju lutem zgjidhni fillimisht Kompaninë
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113,Please select the Company first,Ju lutem zgjidhni fillimisht Kompaninë
 DocType: Item Attribute,Numeric Values,Vlerat numerike
-apps/erpnext/erpnext/public/js/setup_wizard.js +52,Attach Logo,Bashkangjit Logo
+apps/erpnext/erpnext/public/js/setup_wizard.js +56,Attach Logo,Bashkangjit Logo
 apps/erpnext/erpnext/stock/doctype/batch/batch.js +43,Stock Levels,Nivelet e aksioneve
 DocType: Customer,Commission Rate,Rate Komisioni
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187,Created {0} scorecards for {1} between: ,Krijuar {0} tabelat e rezultateve për {1} midis:
-apps/erpnext/erpnext/stock/doctype/item/item.js +346,Make Variant,Bëni Variant
+apps/erpnext/erpnext/stock/doctype/item/item.js +472,Make Variant,Bëni Variant
 apps/erpnext/erpnext/config/hr.py +87,Block leave applications by department.,Aplikacionet pushimit bllok nga departamenti.
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +144,"Payment Type must be one of Receive, Pay and Internal Transfer","Pagesa Lloji duhet të jetë një nga Merre, të paguajë dhe Transfer të Brendshme"
 apps/erpnext/erpnext/config/selling.py +179,Analytics,analitikë
@@ -5185,7 +5552,8 @@
 DocType: Vehicle,Model,Model
 DocType: Production Order,Actual Operating Cost,Aktuale Kosto Operative
 DocType: Payment Entry,Cheque/Reference No,Çek / Reference No
-apps/erpnext/erpnext/accounts/doctype/account/account.py +84,Root cannot be edited.,Rrënjë nuk mund të redaktohen.
+DocType: Soil Texture,Clay Loam,Clay Loam
+apps/erpnext/erpnext/accounts/doctype/account/account.py +83,Root cannot be edited.,Rrënjë nuk mund të redaktohen.
 DocType: Item,Units of Measure,Njësitë e masës
 DocType: Manufacturing Settings,Allow Production on Holidays,Lejo Prodhimi në pushime
 DocType: Sales Order,Customer's Purchase Order Date,Konsumatorit Rendit Blerje Data
@@ -5198,39 +5566,37 @@
 DocType: Company,Existing Company,Company ekzistuese
 DocType: Healthcare Settings,Result Emailed,Rezultati u dërgua me email
 apps/erpnext/erpnext/controllers/buying_controller.py +84,"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Tax Category ka ndryshuar për të &quot;Total&quot;, sepse të gjitha sendet janë artikuj jo-aksioneve"
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Kodi i artikullit&gt; Grupi i artikullit&gt; Markë
 apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103,Please select a csv file,"Ju lutem, përzgjidhni një skedar CSV"
 DocType: Student Leave Application,Mark as Present,Mark si pranishëm
 DocType: Supplier Scorecard,Indicator Color,Treguesi Ngjyra
 DocType: Purchase Order,To Receive and Bill,Për të marrë dhe Bill
 apps/erpnext/erpnext/templates/pages/home.html +14,Featured Products,Produkte Featured
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +132,Designer,Projektues
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136,Designer,Projektues
 apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Termat dhe Kushtet Template
 DocType: Serial No,Delivery Details,Detajet e ofrimit të
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +487,Cost Center is required in row {0} in Taxes table for type {1},Qendra Kosto është e nevojshme në rresht {0} në Tatimet tryezë për llojin {1}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +491,Cost Center is required in row {0} in Taxes table for type {1},Qendra Kosto është e nevojshme në rresht {0} në Tatimet tryezë për llojin {1}
 DocType: Program,Program Code,Kodi program
 DocType: Terms and Conditions,Terms and Conditions Help,Termat dhe Kushtet Ndihmë
 ,Item-wise Purchase Register,Pika-mençur Blerje Regjistrohu
-DocType: Batch,Expiry Date,Data e Mbarimit
+DocType: Driver,Expiry Date,Data e Mbarimit
 DocType: Healthcare Settings,Employee name and designation in print,Emri i punonjësit dhe emërtimi në shtyp
 ,accounts-browser,Llogaritë-browser
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +351,Please select Category first,Ju lutemi zgjidhni kategorinë e parë
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368,Please select Category first,Ju lutemi zgjidhni kategorinë e parë
 apps/erpnext/erpnext/config/projects.py +13,Project master.,Mjeshtër projekt.
 apps/erpnext/erpnext/controllers/status_updater.py +209,"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.","Për të lejuar mbi-faturimit ose mbi-urdhërimin, të rinovuar &quot;Allowance&quot; në Stock Settings ose Item."
 DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,A nuk tregojnë ndonjë simbol si $ etj ardhshëm të valutave.
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +459, (Half Day),(Gjysme Dite)
-DocType: Supplier,Credit Days,Ditët e kreditit
+DocType: Payment Term,Credit Days,Ditët e kreditit
 apps/erpnext/erpnext/utilities/activation.py +128,Make Student Batch,Bëni Serisë Student
 DocType: Fee Schedule,FRQ.,FRQ.
 DocType: Leave Type,Is Carry Forward,Është Mbaj Forward
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +815,Get Items from BOM,Të marrë sendet nga bom
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +840,Get Items from BOM,Të marrë sendet nga bom
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,Lead ditësh
-apps/erpnext/erpnext/controllers/accounts_controller.py +556,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Row # {0}: Posting Data duhet të jetë i njëjtë si data e blerjes {1} e aseteve {2}
+apps/erpnext/erpnext/controllers/accounts_controller.py +600,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Row # {0}: Posting Data duhet të jetë i njëjtë si data e blerjes {1} e aseteve {2}
 DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,Kontrolloni këtë nëse studenti banon në Hostel e Institutit.
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125,Please enter Sales Orders in the above table,Ju lutem shkruani urdhëron Sales në tabelën e mësipërme
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +182,Not Submitted Salary Slips,Jo Dërguar pagave rrëshqet
 ,Stock Summary,Stock Përmbledhje
-apps/erpnext/erpnext/config/accounts.py +280,Transfer an asset from one warehouse to another,Transferimi një aktiv nga një magazinë në tjetrën
+apps/erpnext/erpnext/config/assets.py +50,Transfer an asset from one warehouse to another,Transferimi një aktiv nga një magazinë në tjetrën
 DocType: Vehicle,Petrol,benzinë
 apps/erpnext/erpnext/config/learn.py +217,Bill of Materials,Bill e materialeve
 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}: Partia Lloji dhe Partia është e nevojshme për arkëtueshme / pagueshme llogari {1}
@@ -5240,9 +5606,9 @@
 DocType: Employee Loan Application,Rate of Interest,Norma e interesit
 DocType: Expense Claim Detail,Sanctioned Amount,Shuma e sanksionuar
 DocType: GL Entry,Is Opening,Është Hapja
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196,Row {0}: Debit entry can not be linked with a {1},Row {0}: debiti hyrja nuk mund të jetë i lidhur me një {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +194,Row {0}: Debit entry can not be linked with a {1},Row {0}: debiti hyrja nuk mund të jetë i lidhur me një {1}
 DocType: Journal Entry,Subscription Section,Seksioni i abonimit
-apps/erpnext/erpnext/accounts/doctype/account/account.py +193,Account {0} does not exist,Llogaria {0} nuk ekziston
+apps/erpnext/erpnext/accounts/doctype/account/account.py +179,Account {0} does not exist,Llogaria {0} nuk ekziston
 DocType: Training Event,Training Program,Programi i Trajnimit
 DocType: Account,Cash,Para
 DocType: Employee,Short biography for website and other publications.,Biografia e shkurtër për faqen e internetit dhe botime të tjera.
