diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 0000000..c145291
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,47 @@
+---
+name: Bug report
+about: Report a bug encountered while using ERPNext
+labels: bug
+---
+
+<!--
+Welcome to ERPNext issue tracker! Before creating an issue, please heed the following:
+
+1. This tracker should only be used to report bugs and request features / enhancements to ERPNext
+    - For questions and general support, checkout the manual https://erpnext.com/docs/user/manual/en or use https://discuss.erpnext.com
+    - For documentation issues, refer to https://github.com/frappe/erpnext_com
+2. Use the search function before creating a new issue. Duplicates will be closed and directed to
+   the original discussion.
+3. When making a bug report, make sure you provide all required information. The easier it is for
+   maintainers to reproduce, the faster it'll be fixed.
+4. If you think you know what the reason for the bug is, share it with us. Maybe put in a PR 😉
+-->
+
+## Description of the issue
+
+## Context information (for bug reports)
+
+**Output of `bench version`**
+```
+(paste here)
+```
+
+## Steps to reproduce the issue
+
+1.
+2.
+3.
+
+### Observed result
+
+### Expected result
+
+### Stacktrace / full error message
+
+```
+(paste here)
+```
+
+## Additional information
+
+OS version / distribution, `ERPNext` install method, etc.
diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md
new file mode 100644
index 0000000..6cdad35
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,28 @@
+---
+name: Feature request
+about: Suggest an idea to improve ERPNext
+labels: feature-request
+---
+
+<!--
+Welcome to ERPNext issue tracker! Before creating an issue, please heed the following:
+
+1. This tracker should only be used to report bugs and request features / enhancements to ERPNext
+    - For questions and general support, checkout the manual https://erpnext.com/docs/user/manual/en or use https://discuss.erpnext.com
+    - For documentation issues, refer to https://github.com/frappe/erpnext_com
+2. Use the search function before creating a new issue. Duplicates will be closed and directed to
+   the original discussion.
+3. When making a feature request, make sure to be as verbose as possible. The better you convey your message, the     greater the drive to make it happen.
+-->
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.
diff --git a/.github/ISSUE_TEMPLATE/question-about-using-erpnext.md b/.github/ISSUE_TEMPLATE/question-about-using-erpnext.md
new file mode 100644
index 0000000..455c20e
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/question-about-using-erpnext.md
@@ -0,0 +1,17 @@
+---
+name: Question about using ERPNext
+about: This is not the appropriate channel
+labels: invalid
+---
+
+Please post on our forums:
+
+for questions about using `ERPNext`: https://discuss.erpnext.com
+
+for questions about using the `Frappe Framework`: https://discuss.frappe.io
+
+for questions about using `bench`, probably the best place to start is the [bench repo](https://github.com/frappe/bench)
+
+For documentation issues, use the [ERPNext Documentation](https://erpnext.com/docs/) or [Frappe Framework Documentation](https://frappe.io/docs/user/en) or the [developer cheetsheet](https://github.com/frappe/frappe/wiki/Developer-Cheatsheet)
+
+> **Posts that are not bug reports or feature requests will not be addressed on this issue tracker.**
\ No newline at end of file
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index c0e186d..091cf47 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -1,2 +1,33 @@
-Please read the pull request checklist to make sure your changes are merged: https://github.com/frappe/erpnext/wiki/Pull-Request-Checklist
+<!--
 
+Some key notes before you open a PR:
+
+ 1. Select which branch should this PR be merged in?
+ 2. PR name follows [convention](http://karma-runner.github.io/4.0/dev/git-commit-msg.html)
+ 3. All tests pass locally, UI and Unit tests
+ 4. All business logic and validations must be on the server-side
+ 5. Update necessary Documentation
+ 6. Put `closes #XXXX` in your comment to auto-close the issue that your PR fixes
+
+
+Also, if you're new here
+
+- Documentation Guidelines => https://github.com/frappe/erpnext/wiki/Updating-Documentation
+
+- Contribution Guide => https://github.com/frappe/erpnext/blob/develop/.github/CONTRIBUTING.md
+
+- Pull Request Checklist => https://github.com/frappe/erpnext/wiki/Pull-Request-Checklist
+
+-->
+
+> Please provide enough information so that others can review your pull request:
+
+<!-- You can skip this if you're fixing a typo or updating existing documentation -->
+
+> Explain the **details** for making this change. What existing problem does the pull request solve?
+
+<!-- Example: When "Adding a function to do X", explain why it is necessary to have a way to do X. -->
+
+> Screenshots/GIFs
+
+<!-- Add images/recordings to better visualize the change: expected/current behviour -->
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 0000000..46ed437
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,7 @@
+# Security Policy
+
+The ERPNext team and community take security issues seriously. To report a security issue, fill out the form at [https://erpnext.com/security/report](https://erpnext.com/security/report).
+
+You can help us make ERPNext and all it's users more secure by following the [Reporting guidelines](https://erpnext.com/security).
+
+We appreciate your efforts to responsibly disclose your findings. We'll endeavor to respond quickly, and will keep you updated throughout the process.
\ No newline at end of file
diff --git a/erpnext/accounts/doctype/journal_entry/journal_entry.js b/erpnext/accounts/doctype/journal_entry/journal_entry.js
index 5d88bfa..11d847d 100644
--- a/erpnext/accounts/doctype/journal_entry/journal_entry.js
+++ b/erpnext/accounts/doctype/journal_entry/journal_entry.js
@@ -608,15 +608,9 @@
 	},
 
 	account_query: function(frm) {
-		var inter_company = 0;
-		if (frm.doc.voucher_type == "Inter Company Journal Entry") {
-			inter_company = 1;
-		}
-
 		var filters = {
 			company: frm.doc.company,
-			is_group: 0,
-			inter_company_account: inter_company
+			is_group: 0
 		};
 		if(!frm.doc.multi_currency) {
 			$.extend(filters, {
diff --git a/erpnext/accounts/doctype/share_transfer/share_transfer.js b/erpnext/accounts/doctype/share_transfer/share_transfer.js
index 446ae68..364ca6f 100644
--- a/erpnext/accounts/doctype/share_transfer/share_transfer.js
+++ b/erpnext/accounts/doctype/share_transfer/share_transfer.js
@@ -16,7 +16,7 @@
 				};
 			};
 		});
-		if (frm.doc.docstatus == 1) {
+		if (frm.doc.docstatus == 1 && frm.doc.equity_or_liability_account && frm.doc.asset_account) {
 			frm.add_custom_button(__('Create Journal Entry'), function () {
 				erpnext.share_transfer.make_jv(frm);
 			});
diff --git a/erpnext/accounts/party.py b/erpnext/accounts/party.py
index 20f8737..59936d5 100644
--- a/erpnext/accounts/party.py
+++ b/erpnext/accounts/party.py
@@ -12,7 +12,7 @@
 from frappe.contacts.doctype.address.address import (get_address_display,
 	get_default_address, get_company_address)
 from frappe.contacts.doctype.contact.contact import get_contact_details, get_default_contact
-from erpnext.exceptions import PartyFrozen, InvalidAccountCurrency
+from erpnext.exceptions import PartyFrozen, PartyDisabled, InvalidAccountCurrency
 from erpnext.accounts.utils import get_fiscal_year
 from erpnext import get_company_currency
 
@@ -446,7 +446,9 @@
 	if party_type and party_name:
 		if party_type in ("Customer", "Supplier"):
 			party = frappe.get_cached_value(party_type, party_name, ["is_frozen", "disabled"], as_dict=True)
-			if party.get("is_frozen"):
+			if party.disabled:
+				frappe.throw(_("{0} {1} is disabled").format(party_type, party_name), PartyDisabled)
+			elif party.get("is_frozen"):
 				frozen_accounts_modifier = frappe.db.get_single_value( 'Accounts Settings', 'frozen_accounts_modifier')
 				if not frozen_accounts_modifier in frappe.get_roles():
 					frappe.throw(_("{0} {1} is frozen").format(party_type, party_name), PartyFrozen)
diff --git a/erpnext/accounts/print_format/sales_invoice_return/sales_invoice_return.html b/erpnext/accounts/print_format/sales_invoice_return/sales_invoice_return.html
index 2c01519..1d758e8 100644
--- a/erpnext/accounts/print_format/sales_invoice_return/sales_invoice_return.html
+++ b/erpnext/accounts/print_format/sales_invoice_return/sales_invoice_return.html
@@ -9,7 +9,7 @@
 	</div>
 	<div class="col-xs-{{ "3" if df.fieldtype=="Check" else "7" }} value">
 		{% if doc.get(df.fieldname) != None -%}
-			{{ frappe.utils.fmt_money((doc[df.fieldname])|int|abs, currency=doc.currency) }}
+			{{ frappe.utils.fmt_money((doc[df.fieldname])|abs, currency=doc.currency) }}
 		{% endif %}
 	</div>
 </div>
@@ -26,7 +26,7 @@
 					<div class="col-xs-5 {%- if doc.align_labels_right %} text-right{%- endif -%}">
 						<label>{{ charge.get_formatted("description") }}</label></div>
 					<div class="col-xs-7 text-right">
-						{{ frappe.utils.fmt_money((charge.tax_amount)|int|abs, currency=doc.currency) }}
+						{{ frappe.utils.fmt_money((charge.tax_amount)|abs, currency=doc.currency) }}
 					</div>
 				</div>
 				{%- endif -%}
@@ -65,8 +65,10 @@
 						{% for tdf in visible_columns %}
 						{% if not d.flags.compact_item_print or tdf.fieldname in doc.get(df.fieldname)[0].flags.compact_item_fields %}
 							<td class="{{ get_align_class(tdf) }}" {{ fieldmeta(df) }}>
-								{% if tdf.fieldtype == 'Currency' %}
-									<div class="value">{{ frappe.utils.fmt_money((d[tdf.fieldname])|int|abs, currency=doc.currency) }}</div></td>
+								{% if tdf.fieldname == 'qty' %}
+									<div class="value">{{ (d[tdf.fieldname])|abs }}</div></td>
+								{% elif tdf.fieldtype == 'Currency' %}
+									<div class="value">{{ frappe.utils.fmt_money((d[tdf.fieldname])|abs, currency=doc.currency) }}</div></td>
 								{% else %}
 									<div class="value">{{ print_value(tdf, d, doc, visible_columns) }}</div></td>
 								{% endif %}
@@ -117,7 +119,7 @@
 						{{ render_currency(df, doc) }}
 					{% elif df.fieldtype =='Table' %}
 						{{ render_table(df, doc)}}
-					{% elif doc[df.fieldname] %}
+					{% elif doc[df.fieldname] and df.fieldname != 'total_qty' %}
 						{{ render_field(df, doc) }}
 					{% endif %}
            		 {% endfor %}
diff --git a/erpnext/assets/doctype/asset/asset.py b/erpnext/assets/doctype/asset/asset.py
index 306fb14..6e2bbc1 100644
--- a/erpnext/assets/doctype/asset/asset.py
+++ b/erpnext/assets/doctype/asset/asset.py
@@ -20,12 +20,7 @@
 		self.validate_asset_values()
 		self.validate_item()
 		self.set_missing_values()
-		if self.calculate_depreciation:
-			self.set_depreciation_rate()
-			self.make_depreciation_schedule()
-			self.set_accumulated_depreciation()
-		else:
-			self.finance_books = []
+		self.prepare_depreciation_data()
 		if self.get("schedules"):
 			self.validate_expected_value_after_useful_life()
 
@@ -45,6 +40,17 @@
 		delete_gl_entries(voucher_type='Asset', voucher_no=self.name)
 		self.db_set('booked_fixed_asset', 0)
 
+	def prepare_depreciation_data(self):
+		if self.calculate_depreciation:
+			self.value_after_depreciation = 0
+			self.set_depreciation_rate()
+			self.make_depreciation_schedule()
+			self.set_accumulated_depreciation()
+		else:
+			self.finance_books = []
+			self.value_after_depreciation = (flt(self.gross_purchase_amount) -
+				flt(self.opening_accumulated_depreciation))
+
 	def validate_item(self):
 		item = frappe.get_cached_value("Item", self.item_code,
 			["is_fixed_asset", "is_stock_item", "disabled"], as_dict=1)
diff --git a/erpnext/assets/doctype/asset/depreciation.py b/erpnext/assets/doctype/asset/depreciation.py
index e911e80..2d23f77 100644
--- a/erpnext/assets/doctype/asset/depreciation.py
+++ b/erpnext/assets/doctype/asset/depreciation.py
@@ -188,7 +188,8 @@
 				idx = d.idx
 				break
 
-	value_after_depreciation = asset.finance_books[idx - 1].value_after_depreciation
+	value_after_depreciation = (asset.finance_books[idx - 1].value_after_depreciation
+		if asset.calculate_depreciation else asset.value_after_depreciation)
 	accumulated_depr_amount = flt(asset.gross_purchase_amount) - flt(value_after_depreciation)
 
 	gl_entries = [
diff --git a/erpnext/assets/report/fixed_asset_register/fixed_asset_register.json b/erpnext/assets/report/fixed_asset_register/fixed_asset_register.json
index ae2aa54..b40243c 100644
--- a/erpnext/assets/report/fixed_asset_register/fixed_asset_register.json
+++ b/erpnext/assets/report/fixed_asset_register/fixed_asset_register.json
@@ -1,13 +1,13 @@
 {
  "add_total_row": 0,
  "creation": "2019-09-23 16:35:02.836134",
- "disable_prepared_report": 0,
+ "disable_prepared_report": 1,
  "disabled": 0,
  "docstatus": 0,
  "doctype": "Report",
  "idx": 0,
  "is_standard": "Yes",
- "modified": "2019-09-23 16:35:02.836134",
+ "modified": "2019-10-22 13:00:31.539726",
  "modified_by": "Administrator",
  "module": "Assets",
  "name": "Fixed Asset Register",
diff --git a/erpnext/assets/report/fixed_asset_register/fixed_asset_register.py b/erpnext/assets/report/fixed_asset_register/fixed_asset_register.py
index 2c9e48a..f395499 100644
--- a/erpnext/assets/report/fixed_asset_register/fixed_asset_register.py
+++ b/erpnext/assets/report/fixed_asset_register/fixed_asset_register.py
@@ -4,6 +4,7 @@
 from __future__ import unicode_literals
 import frappe
 from frappe import _
+from frappe.utils import cstr
 
 def execute(filters=None):
 	filters = frappe._dict(filters or {})
@@ -149,12 +150,12 @@
 		FROM `tabAsset Finance Book`
 		WHERE
 			parentfield='finance_books'
-			AND finance_book=%s''', (finance_book)))
+			AND ifnull(finance_book, '')=%s''', cstr(finance_book)))
 
 def get_purchase_receipt_supplier_map():
 	return frappe._dict(frappe.db.sql(''' Select
 		pr.name, pr.supplier
-		FROM `tabPurchase Receipt` pr, `tabPurchase Receipt Item` pri 
+		FROM `tabPurchase Receipt` pr, `tabPurchase Receipt Item` pri
 		WHERE
 			pri.parent = pr.name
 			AND pri.is_fixed_asset=1
@@ -164,7 +165,7 @@
 def get_purchase_invoice_supplier_map():
 	return frappe._dict(frappe.db.sql(''' Select
 		pi.name, pi.supplier
-		FROM `tabPurchase Invoice` pi, `tabPurchase Invoice Item` pii 
+		FROM `tabPurchase Invoice` pi, `tabPurchase Invoice Item` pii
 		WHERE
 			pii.parent = pi.name
 			AND pii.is_fixed_asset=1
diff --git a/erpnext/buying/doctype/purchase_order/test_purchase_order.py b/erpnext/buying/doctype/purchase_order/test_purchase_order.py
index ff0b65b..4506db6 100644
--- a/erpnext/buying/doctype/purchase_order/test_purchase_order.py
+++ b/erpnext/buying/doctype/purchase_order/test_purchase_order.py
@@ -589,6 +589,23 @@
 		frappe.db.set_value("Accounts Settings", "Accounts Settings",
 			"unlink_advance_payment_on_cancelation_of_order", 0)
 
+	def test_schedule_date(self):
+		po = create_purchase_order(do_not_submit=True)
+		po.schedule_date = None
+		po.append("items", {
+			"item_code": "_Test Item",
+			"qty": 1,
+			"rate": 100,
+			"schedule_date": add_days(nowdate(), 5)
+		})
+		po.save()
+		self.assertEqual(po.schedule_date, add_days(nowdate(), 1))
+
+		po.items[0].schedule_date = add_days(nowdate(), 2)
+		po.save()
+		self.assertEqual(po.schedule_date, add_days(nowdate(), 2))
+
+
 def make_pr_against_po(po, received_qty=0):
 	pr = make_purchase_receipt(po)
 	pr.get("items")[0].qty = received_qty or 5
diff --git a/erpnext/buying/doctype/supplier/test_supplier.py b/erpnext/buying/doctype/supplier/test_supplier.py
index 227a3df..a377ec9 100644
--- a/erpnext/buying/doctype/supplier/test_supplier.py
+++ b/erpnext/buying/doctype/supplier/test_supplier.py
@@ -5,6 +5,7 @@
 
 import frappe, unittest
 from erpnext.accounts.party import get_due_date
+from erpnext.exceptions import PartyDisabled
 from frappe.test_runner import make_test_records
 
 test_dependencies = ['Payment Term', 'Payment Terms Template']
@@ -70,7 +71,7 @@
 
         po = create_purchase_order(do_not_save=True)
 
-        self.assertRaises(frappe.ValidationError, po.save)
+        self.assertRaises(PartyDisabled, po.save)
 
         frappe.db.set_value("Supplier", "_Test Supplier", "disabled", 0)
 
diff --git a/erpnext/controllers/accounts_controller.py b/erpnext/controllers/accounts_controller.py
index 1d4a25e..320a618 100644
--- a/erpnext/controllers/accounts_controller.py
+++ b/erpnext/controllers/accounts_controller.py
@@ -1228,6 +1228,8 @@
 	parent.flags.ignore_validate_update_after_submit = True
 	parent.set_qty_as_per_stock_uom()
 	parent.calculate_taxes_and_totals()
+	if parent_doctype == "Sales Order":
+		parent.set_gross_profit()
 	frappe.get_doc('Authorization Control').validate_approving_authority(parent.doctype,
 		parent.company, parent.base_grand_total)
 
diff --git a/erpnext/controllers/buying_controller.py b/erpnext/controllers/buying_controller.py
index 9d37df0..0dde898 100644
--- a/erpnext/controllers/buying_controller.py
+++ b/erpnext/controllers/buying_controller.py
@@ -695,8 +695,10 @@
 	def validate_schedule_date(self):
 		if not self.get("items"):
 			return
-		if not self.schedule_date:
-			self.schedule_date = min([d.schedule_date for d in self.get("items")])
+
+		earliest_schedule_date = min([d.schedule_date for d in self.get("items")])
+		if earliest_schedule_date:
+			self.schedule_date = earliest_schedule_date
 
 		if self.schedule_date:
 			for d in self.get('items'):
diff --git a/erpnext/crm/doctype/lead/lead.py b/erpnext/crm/doctype/lead/lead.py
index c9216ee..1dae4b9 100644
--- a/erpnext/crm/doctype/lead/lead.py
+++ b/erpnext/crm/doctype/lead/lead.py
@@ -146,14 +146,7 @@
 @frappe.whitelist()
 def make_opportunity(source_name, target_doc=None):
 	def set_missing_values(source, target):
-		address = frappe.get_all('Dynamic Link', {
-			'link_doctype': source.doctype,
-			'link_name': source.name,
-			'parenttype': 'Address',
-		}, ['parent'], limit=1)
-
-		if address:
-			target.customer_address = address[0].parent
+		_set_missing_values(source, target)
 
 	target_doc = get_mapped_doc("Lead", source_name,
 		{"Lead": {
@@ -173,13 +166,17 @@
 
 @frappe.whitelist()
 def make_quotation(source_name, target_doc=None):
+	def set_missing_values(source, target):
+		_set_missing_values(source, target)
+
 	target_doc = get_mapped_doc("Lead", source_name,
 		{"Lead": {
 			"doctype": "Quotation",
 			"field_map": {
 				"name": "party_name"
 			}
-		}}, target_doc)
+		}}, target_doc, set_missing_values)
+
 	target_doc.quotation_to = "Lead"
 	target_doc.run_method("set_missing_values")
 	target_doc.run_method("set_other_charges")
@@ -187,6 +184,25 @@
 
 	return target_doc
 
+def _set_missing_values(source, target):
+	address = frappe.get_all('Dynamic Link', {
+			'link_doctype': source.doctype,
+			'link_name': source.name,
+			'parenttype': 'Address',
+		}, ['parent'], limit=1)
+
+	contact = frappe.get_all('Dynamic Link', {
+			'link_doctype': source.doctype,
+			'link_name': source.name,
+			'parenttype': 'Contact',
+		}, ['parent'], limit=1)
+
+	if address:
+		target.customer_address = address[0].parent
+
+	if contact:
+		target.contact_person = contact[0].parent
+
 @frappe.whitelist()
 def get_lead_details(lead, posting_date=None, company=None):
 	if not lead: return {}
diff --git a/erpnext/crm/doctype/opportunity/opportunity.js b/erpnext/crm/doctype/opportunity/opportunity.js
index 6e4d3ed..c9b0433 100644
--- a/erpnext/crm/doctype/opportunity/opportunity.js
+++ b/erpnext/crm/doctype/opportunity/opportunity.js
@@ -100,10 +100,6 @@
 				});
 			}
 		}
-
-		if (frm.doc.opportunity_from && frm.doc.party_name && !frm.doc.contact_person) {
-			frm.trigger("party_name");
-		}
 	},
 
 	set_contact_link: function(frm) {
@@ -171,7 +167,7 @@
 		if (me.frm.doc.opportunity_from == "Lead") {
 			me.frm.set_query('party_name', erpnext.queries['lead']);
 		}
-		else if (me.frm.doc.opportunity_from == "Cuatomer") {
+		else if (me.frm.doc.opportunity_from == "Customer") {
 			me.frm.set_query('party_name', erpnext.queries['customer']);
 		}
 	},
diff --git a/erpnext/erpnext_integrations/connectors/shopify_connection.py b/erpnext/erpnext_integrations/connectors/shopify_connection.py
index bd98037..3be08a2 100644
--- a/erpnext/erpnext_integrations/connectors/shopify_connection.py
+++ b/erpnext/erpnext_integrations/connectors/shopify_connection.py
@@ -29,7 +29,8 @@
 			validate_item(order, shopify_settings)
 			create_order(order, shopify_settings)
 		except Exception as e:
-			make_shopify_log(status="Error", message=e.message, exception=False)
+			make_shopify_log(status="Error", exception=e)
+
 		else:
 			make_shopify_log(status="Success")
 
@@ -42,9 +43,9 @@
 		sales_order = get_sales_order(cstr(order['id']))
 		if sales_order:
 			create_sales_invoice(order, shopify_settings, sales_order)
-		make_shopify_log(status="Success")
-	except Exception:
-		make_shopify_log(status="Error", exception=True)
+			make_shopify_log(status="Success")
+	except Exception as e:
+		make_shopify_log(status="Error", exception=e, rollback=True)
 
 def prepare_delivery_note(order, request_id=None):
 	frappe.set_user('Administrator')
@@ -56,8 +57,8 @@
 		if sales_order:
 			create_delivery_note(order, shopify_settings, sales_order)
 		make_shopify_log(status="Success")
-	except Exception:
-		make_shopify_log(status="Error", exception=True)
+	except Exception as e:
+		make_shopify_log(status="Error", exception=e, rollback=True)
 
 def get_sales_order(shopify_order_id):
 	sales_order = frappe.db.get_value("Sales Order", filters={"shopify_order_id": shopify_order_id})
@@ -97,7 +98,7 @@
 			message = 'Following items are exists in order but relevant record not found in Product master'
 			message += "\n" + ", ".join(product_not_exists)
 
-			make_shopify_log(status="Error", message=message, exception=True)
+			make_shopify_log(status="Error", exception=e, rollback=True)
 
 			return ''
 
diff --git a/erpnext/erpnext_integrations/doctype/shopify_log/shopify_log.py b/erpnext/erpnext_integrations/doctype/shopify_log/shopify_log.py
index 0c821e0..7d3f572 100644
--- a/erpnext/erpnext_integrations/doctype/shopify_log/shopify_log.py
+++ b/erpnext/erpnext_integrations/doctype/shopify_log/shopify_log.py
@@ -12,23 +12,38 @@
 	pass
 
 
-def make_shopify_log(status="Queued", message=None, exception=False):
+def make_shopify_log(status="Queued", exception=None, rollback=False):
 	# if name not provided by log calling method then fetch existing queued state log
+	make_new = False
+
 	if not frappe.flags.request_id:
-		return
+		make_new = True
 
-	log = frappe.get_doc("Shopify Log", frappe.flags.request_id)
-
-	if exception:
+	if rollback:
 		frappe.db.rollback()
-		log = frappe.get_doc({"doctype":"Shopify Log"}).insert(ignore_permissions=True)
 
-	log.message = message if message else ''
+	if make_new:
+		log = frappe.get_doc({"doctype":"Shopify Log"}).insert(ignore_permissions=True)
+	else:
+		log = log = frappe.get_doc("Shopify Log", frappe.flags.request_id)
+
+	log.message = get_message(exception)
 	log.traceback = frappe.get_traceback()
 	log.status = status
 	log.save(ignore_permissions=True)
 	frappe.db.commit()
 
+def get_message(exception):
+	message = None
+
+	if hasattr(exception, 'message'):
+		message = exception.message
+	elif hasattr(exception, '__str__'):
+		message = e.__str__()
+	else:
+		message = "Something went wrong while syncing"
+	return message
+
 def dump_request_data(data, event="create/order"):
 	event_mapper = {
 		"orders/create": get_webhook_address(connector_name='shopify_connection', method="sync_sales_order", exclude_uri=True),
@@ -43,11 +58,11 @@
 	}).insert(ignore_permissions=True)
 
 	frappe.db.commit()
-	frappe.enqueue(method=event_mapper[event], queue='short', timeout=300, is_async=True, 
+	frappe.enqueue(method=event_mapper[event], queue='short', timeout=300, is_async=True,
 		**{"order": data, "request_id": log.name})
 
 @frappe.whitelist()
 def resync(method, name, request_data):
 	frappe.db.set_value("Shopify Log", name, "status", "Queued", update_modified=False)
-	frappe.enqueue(method=method, queue='short', timeout=300, is_async=True, 
+	frappe.enqueue(method=method, queue='short', timeout=300, is_async=True,
 		**{"order": json.loads(request_data), "request_id": name})
diff --git a/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py b/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py
index e2f6d49..a4332b1 100644
--- a/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py
+++ b/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py
@@ -30,13 +30,9 @@
 		# url = get_shopify_url('admin/webhooks.json', self)
 		created_webhooks = [d.method for d in self.webhooks]
 		url = get_shopify_url('admin/api/2019-04/webhooks.json', self)
-		print('url', url)
 		for method in webhooks:
-			print('method', method)
 			session = get_request_session()
-			print('session', session)
 			try:
-				print(get_header(self))
 				d = session.post(url, data=json.dumps({
 					"webhook": {
 						"topic": method,
@@ -44,7 +40,6 @@
 						"format": "json"
 						}
 					}), headers=get_header(self))
-				print('d', d.json())
 				d.raise_for_status()
 				self.update_webhook_table(method, d.json())
 			except Exception as e:
@@ -67,7 +62,6 @@
 			self.remove(d)
 
 	def update_webhook_table(self, method, res):
-		print('update')
 		self.append("webhooks", {
 			"webhook_id": res['webhook']['id'],
 			"method": method
@@ -75,7 +69,6 @@
 
 def get_shopify_url(path, settings):
 	if settings.app_type == "Private":
-		print(settings.api_key, settings.get_password('password'), settings.shopify_url, path)
 		return 'https://{}:{}@{}/{}'.format(settings.api_key, settings.get_password('password'), settings.shopify_url, path)
 	else:
 		return 'https://{}/{}'.format(settings.shopify_url, path)
diff --git a/erpnext/exceptions.py b/erpnext/exceptions.py
index fb3a5cb..d92af5d 100644
--- a/erpnext/exceptions.py
+++ b/erpnext/exceptions.py
@@ -5,3 +5,4 @@
 class PartyFrozen(frappe.ValidationError): pass
 class InvalidAccountCurrency(frappe.ValidationError): pass
 class InvalidCurrency(frappe.ValidationError): pass
+class PartyDisabled(frappe.ValidationError):pass
diff --git a/erpnext/healthcare/page/patient_history/patient_history.js b/erpnext/healthcare/page/patient_history/patient_history.js
index b335ada..fe5b7bc 100644
--- a/erpnext/healthcare/page/patient_history/patient_history.js
+++ b/erpnext/healthcare/page/patient_history/patient_history.js
@@ -234,7 +234,7 @@
 				<a class='btn btn-default btn-xs btn-show-chart' data-show-chart-id='temperature' \
 				data-pts='°C or °F' data-title='Temperature'>Temperature</a>\
 				<a class='btn btn-default btn-xs btn-show-chart' data-show-chart-id='bmi' \
-				data-pts='bmi' data-title='BMI'>BMI</a></div>";
+				data-pts='' data-title='BMI'>BMI</a></div>";
 				me.page.main.find(".show_chart_btns").html(show_chart_btns_html);
 				var data = r.message;
 				let labels = [], datasets = [];
@@ -283,7 +283,7 @@
 
 					title: title,
 					type: 'axis-mixed', // 'axis-mixed', 'bar', 'line', 'pie', 'percentage'
-					height: 150,
+					height: 200,
 					colors: ['purple', '#ffa3ef', 'light-blue'],
 
 					tooltipOptions: {
diff --git a/erpnext/hr/doctype/leave_application/leave_application.py b/erpnext/hr/doctype/leave_application/leave_application.py
index 737f602..97de40f 100755
--- a/erpnext/hr/doctype/leave_application/leave_application.py
+++ b/erpnext/hr/doctype/leave_application/leave_application.py
@@ -404,8 +404,11 @@
 	if cint(half_day) == 1:
 		if from_date == to_date:
 			number_of_days = 0.5
-		else:
+		elif half_day_date and half_day_date <= to_date:
 			number_of_days = date_diff(to_date, from_date) + .5
+		else:
+			number_of_days = date_diff(to_date, from_date) + 1
+
 	else:
 		number_of_days = date_diff(to_date, from_date) + 1
 
@@ -549,8 +552,16 @@
 			if leave_entry.to_date > getdate(to_date):
 				leave_entry.to_date = to_date
 
+			half_day = 0
+			half_day_date = None
+			# fetch half day date for leaves with half days
+			if leave_entry.leaves % 1:
+				half_day = 1
+				half_day_date = frappe.db.get_value('Leave Application',
+					{'name': leave_entry.transaction_name}, ['half_day_date'])
+
 			leave_days += get_number_of_leave_days(employee, leave_type,
-				leave_entry.from_date, leave_entry.to_date) * -1
+				leave_entry.from_date, leave_entry.to_date, half_day, half_day_date) * -1
 
 	return leave_days
 
@@ -562,7 +573,7 @@
 def get_leave_entries(employee, leave_type, from_date, to_date):
 	''' Returns leave entries between from_date and to_date '''
 	return frappe.db.sql("""
-		select employee, leave_type, from_date, to_date, leaves, transaction_type, is_carry_forward
+		select employee, leave_type, from_date, to_date, leaves, transaction_type, is_carry_forward, transaction_name
 		from `tabLeave Ledger Entry`
 		where employee=%(employee)s and leave_type=%(leave_type)s
 			and docstatus=1
diff --git a/erpnext/manufacturing/doctype/bom/bom.js b/erpnext/manufacturing/doctype/bom/bom.js
index 9248ac0..b9591d6 100644
--- a/erpnext/manufacturing/doctype/bom/bom.js
+++ b/erpnext/manufacturing/doctype/bom/bom.js
@@ -117,7 +117,7 @@
 			args: {
 				update_parent: true,
 				from_child_bom:false,
-				save: false
+				save: frm.doc.docstatus === 1 ? true : false
 			},
 			callback: function(r) {
 				refresh_field("items");
diff --git a/erpnext/manufacturing/doctype/bom/bom.py b/erpnext/manufacturing/doctype/bom/bom.py
index eb01b8c..225ae29 100644
--- a/erpnext/manufacturing/doctype/bom/bom.py
+++ b/erpnext/manufacturing/doctype/bom/bom.py
@@ -35,7 +35,8 @@
 			# name can be BOM/ITEM/001, BOM/ITEM/001-1, BOM-ITEM-001, BOM-ITEM-001-1
 
 			# split by item
-			names = [name.split(self.item)[-1][1:] for name in names]
+			names = [name.split(self.item, 1) for name in names]
+			names = [d[-1][1:] for d in filter(lambda x: len(x) > 1 and x[-1], names)]
 
 			# split by (-) if cancelled
 			names = [cint(name.split('-')[-1]) for name in names]
diff --git a/erpnext/selling/doctype/customer/test_customer.py b/erpnext/selling/doctype/customer/test_customer.py
index 42c7d99..87fdaa3 100644
--- a/erpnext/selling/doctype/customer/test_customer.py
+++ b/erpnext/selling/doctype/customer/test_customer.py
@@ -8,7 +8,7 @@
 
 from erpnext.accounts.party import get_due_date
 from frappe.test_runner import make_test_records
-from erpnext.exceptions import PartyFrozen
+from erpnext.exceptions import PartyFrozen, PartyDisabled
 from frappe.utils import flt
 from erpnext.selling.doctype.customer.customer import get_credit_limit, get_customer_outstanding
 from erpnext.tests.utils import create_test_contact_and_address
@@ -178,7 +178,7 @@
 
 		so = make_sales_order(do_not_save=True)
 
-		self.assertRaises(frappe.ValidationError, so.save)
+		self.assertRaises(PartyDisabled, so.save)
 
 		frappe.db.set_value("Customer", "_Test Customer", "disabled", 0)
 
diff --git a/erpnext/selling/doctype/quotation/quotation.js b/erpnext/selling/doctype/quotation/quotation.js
index fb5336b..12f3260 100644
--- a/erpnext/selling/doctype/quotation/quotation.js
+++ b/erpnext/selling/doctype/quotation/quotation.js
@@ -23,9 +23,6 @@
 	refresh: function(frm) {
 		frm.trigger("set_label");
 		frm.trigger("set_dynamic_field_label");
-		if (frm.doc.quotation_to && frm.doc.party_name && !frm.doc.contact_person) {
-			frm.trigger("party_name");
-		}
 	},
 
 	quotation_to: function(frm) {
diff --git a/erpnext/selling/doctype/sales_order/sales_order.json b/erpnext/selling/doctype/sales_order/sales_order.json
index 78e7b4a..ccc48e1 100644
--- a/erpnext/selling/doctype/sales_order/sales_order.json
+++ b/erpnext/selling/doctype/sales_order/sales_order.json
@@ -682,10 +682,10 @@
    "label": "Additional Discount and Coupon Code"
   },
   {
-    "fieldname": "coupon_code",
-    "fieldtype": "Link",
-    "label": "Coupon Code",
-    "options": "Coupon Code"
+   "fieldname": "coupon_code",
+   "fieldtype": "Link",
+   "label": "Coupon Code",
+   "options": "Coupon Code"
   },
   {
    "default": "Grand Total",
@@ -1185,6 +1185,7 @@
    "default": "0",
    "fieldname": "skip_delivery_note",
    "fieldtype": "Check",
+   "hidden": 1,
    "label": "Skip Delivery Note",
    "print_hide": 1
   }
@@ -1192,7 +1193,7 @@
  "icon": "fa fa-file-text",
  "idx": 105,
  "is_submittable": 1,
- "modified": "2019-10-14 08:46:07.540565",
+ "modified": "2019-10-22 14:26:42.767189",
  "modified_by": "Administrator",
  "module": "Selling",
  "name": "Sales Order",
@@ -1269,4 +1270,4 @@
  "title_field": "title",
  "track_changes": 1,
  "track_seen": 1
-}
+}
\ No newline at end of file
diff --git a/erpnext/setup/setup_wizard/operations/install_fixtures.py b/erpnext/setup/setup_wizard/operations/install_fixtures.py
index 66598f4..ebd7b50 100644
--- a/erpnext/setup/setup_wizard/operations/install_fixtures.py
+++ b/erpnext/setup/setup_wizard/operations/install_fixtures.py
@@ -65,7 +65,7 @@
 		{'doctype': 'Leave Type', 'leave_type_name': _('Casual Leave'), 'name': _('Casual Leave'),
 			'allow_encashment': 1, 'is_carry_forward': 1, 'max_continuous_days_allowed': '3', 'include_holiday': 1},
 		{'doctype': 'Leave Type', 'leave_type_name': _('Compensatory Off'), 'name': _('Compensatory Off'),
-			'allow_encashment': 0, 'is_carry_forward': 0, 'include_holiday': 1},
+			'allow_encashment': 0, 'is_carry_forward': 0, 'include_holiday': 1, 'is_compensatory':1 },
 		{'doctype': 'Leave Type', 'leave_type_name': _('Sick Leave'), 'name': _('Sick Leave'),
 			'allow_encashment': 0, 'is_carry_forward': 0, 'include_holiday': 1},
 		{'doctype': 'Leave Type', 'leave_type_name': _('Privilege Leave'), 'name': _('Privilege Leave'),
diff --git a/erpnext/stock/doctype/stock_entry/stock_entry.py b/erpnext/stock/doctype/stock_entry/stock_entry.py
index 758fb37..7fa7d3b 100644
--- a/erpnext/stock/doctype/stock_entry/stock_entry.py
+++ b/erpnext/stock/doctype/stock_entry/stock_entry.py
@@ -329,8 +329,8 @@
 			if total_completed_qty > flt(completed_qty):
 				job_card = frappe.db.get_value('Job Card', {'operation_id': d.name}, 'name')
 				if not job_card:
-					frappe.throw(_("Work Order {0}: job card not found for the operation {1}")
-						.format(self.work_order, job_card))
+					frappe.throw(_("Work Order {0}: Job Card not found for the operation {1}")
+						.format(self.work_order, d.operation))
 
 				work_order_link = frappe.utils.get_link_to_form('Work Order', self.work_order)
 				job_card_link = frappe.utils.get_link_to_form('Job Card', job_card)
diff --git a/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py b/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py
index c5cf6c4..9a97210 100644
--- a/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py
+++ b/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py
@@ -24,7 +24,7 @@
 
 	data = []
 	for item in items:
-		total_outgoing = consumed_item_map.get(item.name, 0) + delivered_item_map.get(item.name,0)
+		total_outgoing = flt(consumed_item_map.get(item.name, 0)) + flt(delivered_item_map.get(item.name,0))
 		avg_daily_outgoing = flt(total_outgoing / diff, float_preceision)
 		reorder_level = (avg_daily_outgoing * flt(item.lead_time_days)) + flt(item.safety_stock)
 
@@ -55,18 +55,20 @@
 
 
 def get_consumed_items(condition):
-	cn_items = frappe.db.sql("""select se_item.item_code,
-			sum(se_item.transfer_qty) as 'consume_qty'
-		from `tabStock Entry` se, `tabStock Entry Detail` se_item
-		where se.name = se_item.parent and se.docstatus = 1
-		and (ifnull(se_item.t_warehouse, '') = '' or se.purpose = 'Send to Subcontractor') %s
-		group by se_item.item_code""" % (condition), as_dict=1)
+	consumed_items = frappe.db.sql("""
+		select item_code, abs(sum(actual_qty)) as consumed_qty
+		from `tabStock Ledger Entry`
+		where actual_qty < 0
+			and voucher_type not in ('Delivery Note', 'Sales Invoice')
+			%s
+		group by item_code
+	""" % condition, as_dict=1)
 
-	cn_items_map = {}
-	for item in cn_items:
-		cn_items_map.setdefault(item.item_code, item.consume_qty)
+	consumed_items_map = {}
+	for item in consumed_items:
+		consumed_items_map.setdefault(item.item_code, item.consumed_qty)
 
-	return cn_items_map
+	return consumed_items_map
 
 def get_delivered_items(condition):
 	dn_items = frappe.db.sql("""select dn_item.item_code, sum(dn_item.stock_qty) as dn_qty
diff --git a/erpnext/stock/report/stock_balance/stock_balance.py b/erpnext/stock/report/stock_balance/stock_balance.py
index e5ae70c..68b8b50 100644
--- a/erpnext/stock/report/stock_balance/stock_balance.py
+++ b/erpnext/stock/report/stock_balance/stock_balance.py
@@ -39,6 +39,9 @@
 
 	data = []
 	conversion_factors = {}
+
+	_func = lambda x: x[1]
+
 	for (company, item, warehouse) in sorted(iwb_map):
 		if item_map.get(item):
 			qty_dict = iwb_map[(company, item, warehouse)]
@@ -70,7 +73,9 @@
 					'latest_age': 0
 				}
 				if fifo_queue:
-					fifo_queue = sorted(fifo_queue, key=lambda fifo_data: fifo_data[1])
+					fifo_queue = sorted(filter(_func, fifo_queue), key=_func)
+					if not fifo_queue: continue
+
 					stock_ageing_data['average_age'] = get_average_age(fifo_queue, to_date)
 					stock_ageing_data['earliest_age'] = date_diff(to_date, fifo_queue[0][1])
 					stock_ageing_data['latest_age'] = date_diff(to_date, fifo_queue[-1][1])
diff --git a/erpnext/stock/report/total_stock_summary/total_stock_summary.py b/erpnext/stock/report/total_stock_summary/total_stock_summary.py
index 41e2f86..ed52393 100644
--- a/erpnext/stock/report/total_stock_summary/total_stock_summary.py
+++ b/erpnext/stock/report/total_stock_summary/total_stock_summary.py
@@ -30,7 +30,7 @@
 
 	if filters.get("group_by") == "Warehouse":
 		if filters.get("company"):
-			conditions += " AND warehouse.company = '%s'" % frappe.db.escape(filters.get("company"), percent=False)
+			conditions += " AND warehouse.company = %s" % frappe.db.escape(filters.get("company"), percent=False)
 
 		conditions += " GROUP BY ledger.warehouse, item.item_code"
 		columns += "'' as company, ledger.warehouse"
diff --git a/erpnext/templates/includes/cart/cart_address.html b/erpnext/templates/includes/cart/cart_address.html
index e857ce1..fe53f34 100644
--- a/erpnext/templates/includes/cart/cart_address.html
+++ b/erpnext/templates/includes/cart/cart_address.html
@@ -104,7 +104,7 @@
 				{
 					label: __('Country'),
 					fieldname: 'country',
-					fieldtype: 'Data',
+					fieldtype: 'Link',
 					reqd: 1
 				},
 			],
diff --git a/erpnext/translations/af.csv b/erpnext/translations/af.csv
index 88f8d6f..f74448e 100644
--- a/erpnext/translations/af.csv
+++ b/erpnext/translations/af.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Kliëntkontak
 DocType: Shift Type,Enable Auto Attendance,Aktiveer outo-bywoning
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Voer asseblief Warehouse en Date in
 DocType: Lost Reason Detail,Opportunity Lost Reason,Geleentheid Verlore Rede
 DocType: Patient Appointment,Check availability,Gaan beskikbaarheid
 DocType: Retention Bonus,Bonus Payment Date,Bonus Betalingsdatum
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Voltooide werkorders
 DocType: Support Settings,Forum Posts,Forum Posts
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Die taak is aangewys as &#39;n agtergrondtaak. In die geval dat daar probleme met die verwerking van die agtergrond is, sal die stelsel &#39;n opmerking byvoeg oor die fout op hierdie voorraadversoening en dan weer terug na die konsepstadium."
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Jammer, die geldigheid van die koeponkode het nie begin nie"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Belasbare Bedrag
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Jy is nie gemagtig om inskrywings by te voeg of op te dateer voor {0}
 DocType: Leave Policy,Leave Policy Details,Verlaat beleidsbesonderhede
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,verbruikbare
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,graad
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Itemkode&gt; Itemgroep&gt; Merk
 DocType: Restaurant Table,No of Seats,Aantal plekke
 DocType: Sales Invoice,Overdue and Discounted,Agterstallig en verdiskonteer
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Bel ontkoppel
@@ -506,6 +509,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Lyn spasiëring vir hoeveelheid in woorde
 DocType: Vehicle,Additional Details,Bykomende besonderhede
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Geen beskrywing gegee nie
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Haal voorwerpe uit die pakhuis
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Versoek om aankoop.
 DocType: POS Closing Voucher Details,Collected Amount,Versamel bedrag
 DocType: Lab Test,Submitted Date,Datum gestuur
@@ -613,6 +617,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Leer
 ,Trial Balance (Simple),Proefbalans (eenvoudig)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Aktiveer Uitgestelde Uitgawe
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Toegepaste koeponkode
 DocType: Asset,Next Depreciation Date,Volgende Depresiasie Datum
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Aktiwiteitskoste per werknemer
 DocType: Accounts Settings,Settings for Accounts,Instellings vir rekeninge
@@ -848,8 +853,6 @@
 DocType: BOM,Work Order,Werks bestelling
 DocType: Sales Invoice,Total Qty,Totale hoeveelheid
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 E-pos ID
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Skrap die werknemer <a href=""#Form/Employee/{0}"">{0}</a> \ om hierdie dokument te kanselleer"
 DocType: Item,Show in Website (Variant),Wys in Webwerf (Variant)
 DocType: Employee,Health Concerns,Gesondheid Kommer
 DocType: Payroll Entry,Select Payroll Period,Kies Payroll Periode
@@ -1013,6 +1016,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Belastingverhoudingsrekening
 DocType: Pricing Rule,Sales Partner,Verkoopsvennoot
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Alle verskaffer scorecards.
+DocType: Coupon Code,To be used to get discount,Word gebruik om afslag te kry
 DocType: Buying Settings,Purchase Receipt Required,Aankoop Ontvangs Benodig
 DocType: Sales Invoice,Rail,spoor
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Werklike koste
@@ -1063,6 +1067,7 @@
 DocType: Production Plan,Production Plan,Produksieplan
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Openingsfaktuurskeppingsinstrument
 DocType: Salary Component,Round to the Nearest Integer,Rond tot die naaste heelgetal
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,"Laat toe dat items wat nie op voorraad is nie, in die mandjie gevoeg word"
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Verkope terug
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Stel aantal in Transaksies gebaseer op Serial No Input
 ,Total Stock Summary,Totale voorraadopsomming
@@ -1192,6 +1197,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Basissuurkoers (Maatskappy Geld)
 ,Qty To Be Billed,Aantal wat gefaktureer moet word
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Afgelope bedrag
+DocType: Coupon Code,Gift Card,Geskenkbewys
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Gereserveerde hoeveelheid vir produksie: hoeveelheid grondstowwe om vervaardigingsitems te maak.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Aflossingsdatum
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Hierdie banktransaksie is reeds volledig versoen
@@ -1279,6 +1285,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Skep tydstaat
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Rekening {0} is verskeie kere ingevoer
 DocType: Account,Expenses Included In Valuation,Uitgawes Ingesluit in Waardasie
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Koop fakture
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,U kan net hernu indien u lidmaatskap binne 30 dae verstryk
 DocType: Shopping Cart Settings,Show Stock Availability,Toon voorraad beskikbaarheid
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Stel {0} in batekategorie {1} of maatskappy {2}
@@ -1818,6 +1825,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Invoer van items en UOM&#39;s
 DocType: Repayment Schedule,Balance Loan Amount,Saldo Lening Bedrag
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Bygevoeg aan besonderhede
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Jammer, koeponkode is uitgeput"
 DocType: Communication Medium,Catch All,Vang almal
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Skedule Kursus
 DocType: Budget,Applicable on Material Request,Van toepassing op materiaal versoek
@@ -1985,6 +1993,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Ongeldige kenmerk
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} moet ingedien word
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,E-posveldtogte
+DocType: Sales Partner,To Track inbound purchase,Om inkomende aankope op te spoor
 DocType: Buying Settings,Default Supplier Group,Verstekverskaffergroep
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Hoeveelheid moet minder as of gelyk wees aan {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},"Die maksimum bedrag wat in aanmerking kom vir die komponent {0}, oorskry {1}"
@@ -2140,8 +2149,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Doen voorraadinskrywing
 DocType: Hotel Room Reservation,Hotel Reservation User,Hotel besprekingsgebruiker
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Stel status in
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Stel nommeringreekse op vir bywoning via Setup&gt; Numbering Series
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Kies asseblief voorvoegsel eerste
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Stel Naming Series in vir {0} via Setup&gt; Settings&gt; Naming Series
 DocType: Contract,Fulfilment Deadline,Vervaldatum
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Naby jou
 DocType: Student,O-,O-
@@ -2265,6 +2274,7 @@
 DocType: Quality Meeting Table,Under Review,Onder oorsig
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Kon nie inteken nie
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Bate {0} geskep
+DocType: Coupon Code,Promotional,promosie
 DocType: Special Test Items,Special Test Items,Spesiale toetsitems
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Jy moet &#39;n gebruiker wees met Stelselbestuurder- en Itembestuurderrolle om op Marketplace te registreer.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Sleutelverslae
@@ -2302,6 +2312,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc Type
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Totale toegewysde persentasie vir verkope span moet 100 wees
 DocType: Subscription Plan,Billing Interval Count,Rekeninginterval telling
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Skrap die werknemer <a href=""#Form/Employee/{0}"">{0}</a> \ om hierdie dokument te kanselleer"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Aanstellings en pasiente
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Waarde ontbreek
 DocType: Employee,Department and Grade,Departement en Graad
@@ -2404,6 +2416,7 @@
 DocType: Project,Start and End Dates,Begin en einddatums
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Kontrak Template Vervaardiging Terme
 ,Delivered Items To Be Billed,Aflewerings Items wat gefaktureer moet word
+DocType: Coupon Code,Maximum Use,Maksimum gebruik
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Oop BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Pakhuis kan nie vir reeksnommer verander word nie.
 DocType: Authorization Rule,Average Discount,Gemiddelde afslag
@@ -2565,6 +2578,7 @@
 DocType: Item,Inventory,Voorraad
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Laai af as Json
 DocType: Item,Sales Details,Verkoopsbesonderhede
+DocType: Coupon Code,Used,gebruik
 DocType: Opportunity,With Items,Met Items
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Die veldtog &#39;{0}&#39; bestaan reeds vir die {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Onderhoudspan
@@ -2694,7 +2708,7 @@
 						Serial No cannot be ensured",Geen aktiewe BOM gevind vir item {0} nie. Aflewering met \ Serienommer kan nie verseker word nie
 DocType: Sales Partner,Sales Partner Target,Verkoopsvennoteiken
 DocType: Loan Type,Maximum Loan Amount,Maksimum leningsbedrag
-DocType: Pricing Rule,Pricing Rule,Prysreël
+DocType: Coupon Code,Pricing Rule,Prysreël
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplikaatrolnommer vir student {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Materiaal Versoek om aankoop bestelling
 DocType: Company,Default Selling Terms,Standaard verkoopvoorwaardes
@@ -2773,6 +2787,7 @@
 DocType: Payment Schedule,Payment Amount,Betalingsbedrag
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Halfdag Datum moet tussen werk van datum en werk einddatum wees
 DocType: Healthcare Settings,Healthcare Service Items,Gesondheidsorg Diens Items
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Ongeldige strepieskode. Daar is geen item verbonde aan hierdie strepieskode nie.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Verbruik Bedrag
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Netto verandering in kontant
 DocType: Assessment Plan,Grading Scale,Graderingskaal
@@ -2892,7 +2907,6 @@
 DocType: Share Transfer,Asset Account,Bate rekening
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Nuwe vrystellingdatum sal in die toekoms wees
 DocType: Purchase Invoice,End date of current invoice's period,Einddatum van huidige faktuur se tydperk
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Stel asseblief &#39;n naamstelsel vir werknemers in vir mensehulpbronne&gt; HR-instellings
 DocType: Lab Test,Technician Name,Tegnikus Naam
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3002,6 +3016,7 @@
 DocType: Products Settings,Hide Variants,Versteek variante
 DocType: Lead,Next Contact By,Volgende kontak deur
 DocType: Compensatory Leave Request,Compensatory Leave Request,Vergoedingsverlofversoek
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Kan nie meer as {2} oor item {0} in ry {1} oorkoop nie. Om oorfakturering toe te laat, stel asseblief toelae in rekeninginstellings"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Hoeveelheid benodig vir item {0} in ry {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},"Pakhuis {0} kan nie uitgevee word nie, aangesien die hoeveelheid vir item {1} bestaan"
 DocType: Blanket Order,Order Type,Bestelling Tipe
@@ -3171,7 +3186,6 @@
 DocType: Student,Student Mobile Number,Student Mobiele Nommer
 DocType: Item,Has Variants,Het Varianten
 DocType: Employee Benefit Claim,Claim Benefit For,Eisvoordeel vir
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Kan nie oorbetaal vir Item {0} in ry {1} meer as {2}. Om oor-faktuur toe te laat, stel asseblief in Voorraadinstellings"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Update Response
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Jy het reeds items gekies van {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Naam van die Maandelikse Verspreiding
@@ -3461,6 +3475,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Spesifiseer asseblief geldeenheid in die Maatskappy
 DocType: Workstation,Wages per hour,Lone per uur
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Stel {0} op
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Kliënt&gt; Kliëntegroep&gt; Gebied
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Voorraadbalans in Batch {0} word negatief {1} vir Item {2} by Warehouse {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Volgende Materiële Versoeke is outomaties opgestel op grond van die item se herbestellingsvlak
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Rekening {0} is ongeldig. Rekeninggeldeenheid moet {1} wees
@@ -3790,6 +3805,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Dien Salarisstrokie in
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,On Hold
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,&#39;N Kwessie moet ten minste een korrekte opsie hê
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Koop bestellings
 DocType: Account,Inter Company Account,Intermaatskappyrekening
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Invoer in grootmaat
 DocType: Sales Partner,Address & Contacts,Adres &amp; Kontakte
@@ -3800,6 +3816,7 @@
 DocType: POS Profile,[Select],[Kies]
 DocType: Staffing Plan Detail,Number Of Positions,Aantal posisies
 DocType: Vital Signs,Blood Pressure (diastolic),Bloeddruk (diastoliese)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Kies die kliënt.
 DocType: SMS Log,Sent To,Gestuur na
 DocType: Agriculture Task,Holiday Management,Vakansiebestuur
 DocType: Payment Request,Make Sales Invoice,Maak verkoopfaktuur
@@ -4009,7 +4026,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} is nie ingedien nie
 DocType: Subscription,Trialling,uitte
 DocType: Sales Invoice Item,Deferred Revenue,Uitgestelde Inkomste
-DocType: Bank Account,GL Account,GL-rekening
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Kontantrekening sal gebruik word vir die skep van verkope faktuur
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Vrystelling Subkategorie
 DocType: Member,Membership Expiry Date,Lidmaatskap Vervaldatum
@@ -4413,13 +4429,13 @@
 DocType: C-Form Invoice Detail,Territory,gebied
 DocType: Pricing Rule,Apply Rule On Item Code,Pas Reël op Itemkode toe
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Noem asseblief geen besoeke benodig nie
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Voorraadbalansverslag
 DocType: Stock Settings,Default Valuation Method,Verstekwaardasiemetode
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,fooi
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Toon kumulatiewe bedrag
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Werk aan die gang. Dit kan &#39;n rukkie neem.
 DocType: Production Plan Item,Produced Qty,Geproduceerde hoeveelheid
 DocType: Vehicle Log,Fuel Qty,Brandstof Aantal
-DocType: Stock Entry,Target Warehouse Name,Teiken pakhuis naam
 DocType: Work Order Operation,Planned Start Time,Beplande aanvangstyd
 DocType: Course,Assessment,assessering
 DocType: Payment Entry Reference,Allocated,toegeken
@@ -4485,10 +4501,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","Standaard bepalings en voorwaardes wat by verkope en aankope gevoeg kan word. Voorbeelde: 1. Geldigheid van die aanbod. 1. Betalingsvoorwaardes (Vooraf, Op Krediet, Voorskotte, ens.). 1. Wat is ekstra (of betaalbaar deur die kliënt). 1. Veiligheid / gebruik waarskuwing. 1. Waarborg indien enige. 1. Retourbeleid. 1. Voorwaardes van verskeping, indien van toepassing. 1. Maniere om geskille, skadeloosstelling, aanspreeklikheid, ens. Aan te spreek. 1. Adres en kontak van u maatskappy."
 DocType: Homepage Section,Section Based On,Afdeling gebaseer op
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Toon Pas koeponkode toe
 DocType: Issue,Issue Type,Uitgawe Tipe
 DocType: Attendance,Leave Type,Verlaat tipe
 DocType: Purchase Invoice,Supplier Invoice Details,Verskaffer se faktuurbesonderhede
 DocType: Agriculture Task,Ignore holidays,Ignoreer vakansiedae
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Voeg / wysig koeponvoorwaardes
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Uitgawe / Verskil rekening ({0}) moet &#39;n &#39;Wins of Verlies&#39; rekening wees
 DocType: Stock Entry Detail,Stock Entry Child,Voorraadinskrywingskind
 DocType: Project,Copied From,Gekopieer vanaf
@@ -4663,6 +4681,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Assesseringsplan Kriteria
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,transaksies
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Voorkom Aankooporders
+DocType: Coupon Code,Coupon Name,Koeponnaam
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,vatbaar
 DocType: Email Campaign,Scheduled,geskeduleer
 DocType: Shift Type,Working Hours Calculation Based On,Berekening van werksure gebaseer op
@@ -4679,7 +4698,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Skep variante
 DocType: Vehicle,Diesel,diesel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Pryslys Geldeenheid nie gekies nie
+DocType: Quick Stock Balance,Available Quantity,Beskikbare hoeveelheid
 DocType: Purchase Invoice,Availed ITC Cess,Benut ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Stel asb. Die opvoeder-benamingstelsel op in onderwys&gt; Onderwysinstellings
 ,Student Monthly Attendance Sheet,Student Maandelikse Bywoningsblad
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Stuurreël is slegs van toepassing op Verkoop
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Waardevermindering-ry {0}: Volgende waarderingsdatum kan nie voor die aankoopdatum wees nie
@@ -4746,8 +4767,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Ry {0}: Voorskot teen kliënt moet krediet wees
 DocType: Quality Meeting,Quality Meeting,Kwaliteit vergadering
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Nie-Groep tot Groep
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Stel Naming Series in vir {0} via Setup&gt; Settings&gt; Naming Series
 DocType: Employee,ERPNext User,ERPNext gebruiker
+DocType: Coupon Code,Coupon Description,Koeponbeskrywing
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Joernaal is verpligtend in ry {0}
 DocType: Company,Default Buying Terms,Standaard koopvoorwaardes
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Aankoopontvangste Item verskaf
@@ -4910,6 +4931,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Teen dokumentbesonderhede No
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Skrapping is nie toegelaat vir land {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Party Tipe is verpligtend
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Pas koeponkode toe
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",Vir werkskaart {0} kan u slegs die &#39;Materiaaloordrag vir Vervaardiging&#39; tipe inskrywing doen
 DocType: Quality Inspection,Outgoing,uitgaande
 DocType: Customer Feedback Table,Customer Feedback Table,Kliënteterugvoer-tabel
@@ -5059,7 +5081,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,By die indiening van bestellings
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Voeg alle verskaffers by
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Ry # {0}: Toegewysde bedrag kan nie groter wees as die uitstaande bedrag nie.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Kliënt&gt; Klantegroep&gt; Gebied
 DocType: Tally Migration,Parties,partye
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Blaai deur BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Beveiligde Lenings
@@ -5091,7 +5112,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Moenie toelaat dat alternatiewe item vir die item {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Datum word herhaal
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Gemagtigde ondertekenaar
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Stel asb. Die opvoeder-benamingstelsel op in onderwys&gt; Onderwysinstellings
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Netto ITC beskikbaar (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Skep Fooie
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Totale Aankoopprys (via Aankoopfaktuur)
@@ -5116,6 +5136,7 @@
 DocType: Quiz Result,Wrong,Verkeerde
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Koers waarteen Pryslys-geldeenheid omgeskakel word na die kliënt se basiese geldeenheid
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Netto Bedrag (Maatskappy Geld)
+DocType: Sales Partner,Referral Code,Verwysingskode
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Totale voorskotbedrag kan nie groter wees as die totale sanksiebedrag nie
 DocType: Salary Slip,Hour Rate,Uurtarief
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Aktiveer outomatiese herbestelling
@@ -5244,6 +5265,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Toon Voorraad Hoeveelheid
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Netto kontant uit bedrywighede
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Ry # {0}: Status moet {1} wees vir faktuurafslag {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM-omskakelingsfaktor ({0} -&gt; {1}) nie gevind vir item: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Item 4
 DocType: Student Admission,Admission End Date,Toelating Einddatum
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Sub-kontraktering
@@ -5266,6 +5288,7 @@
 DocType: Travel Request,Fully Sponsored,Volledig Sponsored
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Reverse Journal Entry
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Skep werkkaart
+DocType: Quotation,Referral Sales Partner,Verwysingsvennoot
 DocType: Quality Procedure Process,Process Description,Prosesbeskrywing
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Kliënt {0} is geskep.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Tans is geen voorraad beskikbaar in enige pakhuis nie
@@ -5400,6 +5423,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM-koers
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Lees opgelaaide lêer
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel",Gestopte werkbestelling kan nie gekanselleer word nie. Staak dit eers om te kanselleer
+DocType: Coupon Code,Coupon Code,Koeponkode
 DocType: Asset,Journal Entry for Scrap,Tydskrifinskrywing vir afval
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Trek asseblief items van afleweringsnotas
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Ry {0}: kies die werkstasie teen die operasie {1}
@@ -5482,6 +5506,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;Datum&#39; is verpligtend
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Verwysingsdatum kan nie na {0} wees nie.
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Data Invoer en Uitvoer
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Jammer, die geldigheid van die koepon het verval"
 DocType: Bank Account,Account Details,Rekeningbesonderhede
 DocType: Crop,Materials Required,Materiaal benodig
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Geen studente gevind
@@ -5519,6 +5544,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Gaan na gebruikers
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Betaalde bedrag + Skryf af Die bedrag kan nie groter as Grand Total wees nie
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} is nie &#39;n geldige lotnommer vir item {1} nie
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Voer asseblief &#39;n geldige koeponkode in !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Nota: Daar is nie genoeg verlofbalans vir Verlof-tipe {0}
 DocType: Task,Task Description,Taakbeskrywing
 DocType: Training Event,Seminar,seminaar
@@ -5782,6 +5808,7 @@
 ,TDS Payable Monthly,TDS betaalbaar maandeliks
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Wag vir die vervanging van die BOM. Dit kan &#39;n paar minute neem.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Kan nie aftrek wanneer die kategorie vir &#39;Waardasie&#39; of &#39;Waardasie en Totaal&#39; is nie.
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Stel asseblief &#39;n naamstelsel vir werknemers in vir menslike hulpbronne&gt; HR-instellings
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Totale betalings
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serial Nos Required for Serialized Item {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Pas betalings met fakture
@@ -5871,6 +5898,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Kry grondstowwe vir produksie
 DocType: Job Opening,Job Title,Werkstitel
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Toekomstige betaling ref
+DocType: Quotation,Additional Discount and Coupon Code,Bykomende afslag- en koeponkode
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} dui aan dat {1} nie &#39;n kwotasie sal verskaf nie, maar al die items \ is aangehaal. Opdateer die RFQ kwotasie status."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maksimum steekproewe - {0} is reeds behou vir bondel {1} en item {2} in bondel {3}.
@@ -6098,7 +6126,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Instellings vir webwerf tuisblad
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} is aan die houer tot {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ&#39;s word nie toegelaat vir {0} as gevolg van &#39;n telkaart wat staan van {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Maak aankoopfaktuur
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Gebruikte Blare
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Gebruikte koepon is {1}. Toegestane hoeveelheid is uitgeput
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Wil u die materiaalversoek indien?
 DocType: Job Offer,Awaiting Response,In afwagting van antwoord
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6112,6 +6142,7 @@
 DocType: Training Event Employee,Optional,opsioneel
 DocType: Salary Slip,Earning & Deduction,Verdien en aftrekking
 DocType: Agriculture Analysis Criteria,Water Analysis,Wateranalise
+DocType: Sales Order,Skip Delivery Note,Slaan afleweringsnota oor
 DocType: Price List,Price Not UOM Dependent,Prys nie UOM afhanklik nie
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} variante geskep.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Daar is reeds &#39;n standaarddiensooreenkoms.
@@ -6216,6 +6247,7 @@
 DocType: Vehicle,Last Carbon Check,Laaste Carbon Check
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Regskoste
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Kies asseblief die hoeveelheid op ry
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Werksbestelling {0}: werkkaart word nie vir die operasie gevind nie {1}
 DocType: Purchase Invoice,Posting Time,Posietyd
 DocType: Timesheet,% Amount Billed,% Bedrag gefaktureer
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Telefoon uitgawes
@@ -6318,7 +6350,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Belasting en heffings bygevoeg
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Waardevermindering-ry {0}: Volgende waarderingsdatum kan nie voor die datum beskikbaar wees vir gebruik nie
 ,Sales Funnel,Verkope trechter
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Itemkode&gt; Itemgroep&gt; Merk
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Afkorting is verpligtend
 DocType: Project,Task Progress,Taak vordering
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,wa
@@ -6413,6 +6444,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS-profiel wat nodig is om POS-inskrywing te maak
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Loyaliteitspunte sal bereken word uit die bestede gedoen (via die Verkoopfaktuur), gebaseer op die genoemde invorderingsfaktor."
 DocType: Program Enrollment Tool,Enroll Students,Teken studente in
+DocType: Pricing Rule,Coupon Code Based,Gebaseerde koeponkode
 DocType: Company,HRA Settings,HRA-instellings
 DocType: Homepage,Hero Section,Heldeseksie
 DocType: Employee Transfer,Transfer Date,Oordragdatum
@@ -6528,6 +6560,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Stel asseblief die Maatskappyfilter leeg as Groep By &#39;Maatskappy&#39; is.
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Posdatum kan nie toekomstige datum wees nie
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Ry # {0}: reeksnommer {1} stem nie ooreen met {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Stel nommeringreekse op vir bywoning via Setup&gt; Numbering Series
 DocType: Stock Entry,Target Warehouse Address,Teiken pakhuis adres
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Toevallige verlof
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,Die tyd voor die aanvangstyd van die skof waartydens werknemers-inklok in aanmerking kom vir die bywoning.
@@ -6562,7 +6595,6 @@
 DocType: Employee Grade,Employee Grade,Werknemersgraad
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,stukwerk
 DocType: GSTR 3B Report,June,Junie
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Verskaffer&gt; Verskaffer tipe
 DocType: Share Balance,From No,Van No
 DocType: Shift Type,Early Exit Grace Period,Genade tydperk vir vroeë uitgang
 DocType: Task,Actual Time (in Hours),Werklike tyd (in ure)
@@ -6845,7 +6877,6 @@
 DocType: Warehouse,Warehouse Name,Pakhuisnaam
 DocType: Naming Series,Select Transaction,Kies transaksie
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Voer asseblief &#39;n goedgekeurde rol of goedgekeurde gebruiker in
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM-omskakelingsfaktor ({0} -&gt; {1}) nie vir item gevind nie: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Diensvlakooreenkoms met entiteitstipe {0} en entiteit {1} bestaan reeds.
 DocType: Journal Entry,Write Off Entry,Skryf Uit Inskrywing
 DocType: BOM,Rate Of Materials Based On,Mate van materiaal gebaseer op
@@ -6983,6 +7014,7 @@
 DocType: Budget,Warn,waarsku
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Alle items is reeds vir hierdie werkorder oorgedra.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Enige ander opmerkings, noemenswaardige poging wat in die rekords moet plaasvind."
+DocType: Bank Account,Company Account,Maatskappyrekening
 DocType: Asset Maintenance,Manufacturing User,Vervaardigingsgebruiker
 DocType: Purchase Invoice,Raw Materials Supplied,Grondstowwe voorsien
 DocType: Subscription Plan,Payment Plan,Betalingsplan
@@ -7024,6 +7056,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) kan nie groter wees as die beplande hoeveelheid ({2}) in werkorder {3}
 DocType: Certification Application,Name of Applicant,Naam van applikant
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Tydskrif vir vervaardiging.
+DocType: Quick Stock Balance,Quick Stock Balance,Vinnige voorraadbalans
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Subtotaal
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Kan nie Variant eiendomme verander na voorraad transaksie. Jy sal &#39;n nuwe item moet maak om dit te doen.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA Mandaat
@@ -7350,6 +7383,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},Stel asseblief {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} is onaktiewe student
 DocType: Employee,Health Details,Gesondheids besonderhede
+DocType: Coupon Code,Coupon Type,Soort koepon
 DocType: Leave Encashment,Encashable days,Ontvankbare dae
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,"Om &#39;n Betalingsversoek te maak, is verwysingsdokument nodig"
 DocType: Soil Texture,Sandy Clay,Sandy Clay
@@ -7632,6 +7666,7 @@
 DocType: Hotel Room Package,Amenities,geriewe
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Haal betalingsvoorwaardes outomaties aan
 DocType: QuickBooks Migrator,Undeposited Funds Account,Onvoorsiene Fondsrekening
+DocType: Coupon Code,Uses,gebruike
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Veelvuldige verstekmodus van betaling is nie toegelaat nie
 DocType: Sales Invoice,Loyalty Points Redemption,Lojaliteit punte Redemption
 ,Appointment Analytics,Aanstelling Analytics
@@ -7648,6 +7683,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Totale begroting
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Los leeg as jy studente groepe per jaar maak
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Indien gekontroleer, Totale nommer. van werksdae sal vakansiedae insluit, en dit sal die waarde van salaris per dag verminder"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Kon nie domein byvoeg nie
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Om die ontvangs / aflewering toe te laat, moet u &quot;Toelaag vir oorontvangs / aflewering&quot; in Voorraadinstellings of die item opdateer."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Programme wat die huidige sleutel gebruik, sal nie toegang hê nie, is jy seker?"
 DocType: Subscription Settings,Prorate,Prorate
@@ -7660,6 +7696,7 @@
 ,BOM Stock Report,BOM Voorraad Verslag
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","As daar geen toegewysde tydgleuf is nie, word kommunikasie deur hierdie groep hanteer"
 DocType: Stock Reconciliation Item,Quantity Difference,Hoeveelheidsverskil
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Verskaffer&gt; Verskaffer tipe
 DocType: Opportunity Item,Basic Rate,Basiese tarief
 DocType: GL Entry,Credit Amount,Kredietbedrag
 ,Electronic Invoice Register,Elektroniese faktuurregister
@@ -7913,6 +7950,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Belasting en heffings afgetrek (Maatskappy Geld)
 DocType: Item Group,General Settings,Algemene instellings
 DocType: Article,Article,Artikel
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Voer asseblief koeponkode in !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Van Geld en Geld kan nie dieselfde wees nie
 DocType: Taxable Salary Slab,Percent Deduction,Persent aftrekking
 DocType: GL Entry,To Rename,Om te hernoem
diff --git a/erpnext/translations/am.csv b/erpnext/translations/am.csv
index 8277608..6b2e47b 100644
--- a/erpnext/translations/am.csv
+++ b/erpnext/translations/am.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,ማት-ዱብ-ያዮያን.-
 DocType: Purchase Order,Customer Contact,የደንበኛ ያግኙን
 DocType: Shift Type,Enable Auto Attendance,በራስ መገኘትን ያንቁ።
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,እባክዎ ወደ መጋዘን እና ቀን ያስገቡ
 DocType: Lost Reason Detail,Opportunity Lost Reason,ዕድል የጠፋበት ምክንያት።
 DocType: Patient Appointment,Check availability,ተገኝነትን ያረጋግጡ
 DocType: Retention Bonus,Bonus Payment Date,የጉርሻ ክፍያ ቀን
@@ -265,6 +266,7 @@
 ,Completed Work Orders,የስራ ትዕዛዞችን አጠናቅቋል
 DocType: Support Settings,Forum Posts,ፎረም ልጥፎች
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage",ተግባሩ እንደ ዳራ ሥራ ተሸልሟል ፡፡ በጀርባ ሂደት ላይ ማናቸውም ችግር ቢኖር ስርዓቱ በዚህ የአክሲዮን ማቋቋሚያ ዕርቅ ላይ ስሕተት ይጨምርና ወደ ረቂቁ ደረጃ ይመለሳል ፡፡
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started",ይቅርታ ፣ የኩፖን ኮድ ትክክለኛነት አልተጀመረም
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,ግብር የሚከፈልበት መጠን
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},ከእናንተ በፊት ግቤቶችን ማከል ወይም ዝማኔ ስልጣን አይደለም {0}
 DocType: Leave Policy,Leave Policy Details,የፖሊሲ ዝርዝሮችን ይተው
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Consumable
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,ደረጃ
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,የንጥል ኮድ&gt; የንጥል ቡድን&gt; የምርት ስም
 DocType: Restaurant Table,No of Seats,የመቀመጫዎች ቁጥር
 DocType: Sales Invoice,Overdue and Discounted,ጊዜው ያለፈበት እና የተቀነሰ።
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,ጥሪ ተቋር .ል።
@@ -505,6 +508,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,ቃላት ውስጥ መጠን ለማግኘት የመስመር ክፍተት
 DocType: Vehicle,Additional Details,ተጨማሪ ዝርዝሮች
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,የተሰጠው መግለጫ የለም
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,ከመጋዘን ቤት ዕቃዎች
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,ግዢ ይጠይቁ.
 DocType: POS Closing Voucher Details,Collected Amount,የተከማቹ መጠን
 DocType: Lab Test,Submitted Date,የተረከበት ቀን
@@ -612,6 +616,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,ይወቁ
 ,Trial Balance (Simple),የሙከራ ሂሳብ (ቀላል)
 DocType: Purchase Invoice Item,Enable Deferred Expense,የሚገመተው ወጪን ያንቁ
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,የተተገበረ የኩፖን ኮድ
 DocType: Asset,Next Depreciation Date,ቀጣይ የእርጅና ቀን
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,የተቀጣሪ በአንድ እንቅስቃሴ ወጪ
 DocType: Accounts Settings,Settings for Accounts,መለያዎች ቅንብሮች
@@ -846,8 +851,6 @@
 DocType: BOM,Work Order,የሥራ ትዕዛዝ
 DocType: Sales Invoice,Total Qty,ጠቅላላ ብዛት
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 ኢሜይል መታወቂያ
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","ይህንን ሰነድ ለመሰረዝ እባክዎ ሰራተኛውን <a href=""#Form/Employee/{0}"">{0}</a> \ ያጥፉ።"
 DocType: Item,Show in Website (Variant),የድር ጣቢያ ውስጥ አሳይ (ተለዋጭ)
 DocType: Employee,Health Concerns,የጤና ሰጋት
 DocType: Payroll Entry,Select Payroll Period,የደመወዝ ክፍያ ክፍለ ይምረጡ
@@ -1011,6 +1014,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,የግብር መያዣ ሂሳብ
 DocType: Pricing Rule,Sales Partner,የሽያጭ አጋር
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,ሁሉም የአቅራቢ መለኪያ ካርዶች.
+DocType: Coupon Code,To be used to get discount,ቅናሽ ለማግኘት ጥቅም ላይ እንዲውል
 DocType: Buying Settings,Purchase Receipt Required,የግዢ ደረሰኝ ያስፈልጋል
 DocType: Sales Invoice,Rail,ባቡር
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,ትክክለኛ ወጪ።
@@ -1061,6 +1065,7 @@
 DocType: Production Plan,Production Plan,የምርት ዕቅድ
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,የጋብቻ ክፍያ መጠየቂያ መሳሪያ መፍጠሩ
 DocType: Salary Component,Round to the Nearest Integer,ወደ ቅርብ integer Integer።
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,በክምችት ውስጥ የሌሉ ዕቃዎች ወደ ጋሪ እንዲጨምሩ ይፍቀዱ
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,የሽያጭ ተመለስ
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,በ Serial No Entput ላይ በመመርኮዝ ስንት ግምት ያዘጋጁ
 ,Total Stock Summary,ጠቅላላ የአክሲዮን ማጠቃለያ
@@ -1190,6 +1195,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),የመሠረት ሰዓት ተመን (የኩባንያ የምንዛሬ)
 ,Qty To Be Billed,እንዲከፍሉ
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,ደርሷል መጠን
+DocType: Coupon Code,Gift Card,ስጦታ ካርድ
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,ለምርቶቹ የተቀመጡ ጫፎች-ለማኑፋክቸሪንግ ዕቃዎች የሚውሉ ጥሬ ዕቃዎች ብዛት።
 DocType: Loyalty Point Entry Redemption,Redemption Date,የመቤዠት ቀን
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,ይህ የባንክ ግብይት ቀድሞውኑ ሙሉ በሙሉ ታረቀ።
@@ -1277,6 +1283,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,የጊዜ ሰሌዳ ይፍጠሩ።
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,መለያ {0} በርካታ ጊዜ ገብቷል ታይቷል
 DocType: Account,Expenses Included In Valuation,ወጪዎች ግምቱ ውስጥ ተካቷል
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,የክፍያ መጠየቂያ ደረሰኞችን ይግዙ
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,አባልነትዎ በ 30 ቀናት ውስጥ የሚያልቅ ከሆነ ብቻ መታደስ የሚችሉት
 DocType: Shopping Cart Settings,Show Stock Availability,የኤክስቴንሽን አቅርቦት አሳይ
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},{0} ን በንብረት ምድብ {1} ወይም ኩባንያ {2} ውስጥ ያዘጋጁ
@@ -1816,6 +1823,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,እቃዎችን እና UOM ን ማስመጣት ፡፡
 DocType: Repayment Schedule,Balance Loan Amount,ቀሪ የብድር መጠን
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,ወደ ዝርዝር ታክሏል
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted",ይቅርታ ፣ የኩፖን ኮድ ደክሟል
 DocType: Communication Medium,Catch All,ሁሉንም ይያዙ።
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,መርሐግብር ኮርስ
 DocType: Budget,Applicable on Material Request,በወሳኝ ጥያቄ ላይ ተፈጻሚነት ይኖረዋል
@@ -1983,6 +1991,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,ልክ ያልሆነ መገለጫ ባህሪ
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} መቅረብ አለበት
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,የኢሜል ዘመቻዎች ፡፡
+DocType: Sales Partner,To Track inbound purchase,ወደ ውስጥ ገቢ ግ Trackን ለመከታተል
 DocType: Buying Settings,Default Supplier Group,ነባሪ የአቅራቢ ቡድን
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},ብዛት ይልቅ ያነሰ ወይም እኩል መሆን አለበት {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},ለክፍለ አካል ከሚፈቀደው ከፍተኛ መጠን {0} ይበልጣል {1}
@@ -2138,7 +2147,6 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,የአክሲዮን ግባን ያድርጉ ፡፡
 DocType: Hotel Room Reservation,Hotel Reservation User,የሆቴል መያዣ ተጠቃሚ
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,ሁኔታን ያዘጋጁ።
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,እባክዎን ለተማሪ ተገኝተው በማዋቀር&gt; በቁጥር ተከታታይ በኩል ያዘጋጁ።
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,መጀመሪያ ቅድመ ቅጥያ ይምረጡ
 DocType: Contract,Fulfilment Deadline,የማረጋገጫ ጊዜ ገደብ
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,በአጠገብህ
@@ -2263,6 +2271,7 @@
 DocType: Quality Meeting Table,Under Review,በ ግምገማ ላይ
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,ለመግባት ተስኗል
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,ንብረት {0} ተፈጥሯል
+DocType: Coupon Code,Promotional,ማስተዋወቂያ
 DocType: Special Test Items,Special Test Items,ልዩ የፈተና ንጥሎች
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,በገበያ ቦታ ላይ ለመመዝገብ የስርዓት አቀናባሪ እና የንጥል አስተዳዳሪ ሚናዎች ተጠቃሚ መሆን አለብዎት.
 apps/erpnext/erpnext/config/buying.py,Key Reports,ቁልፍ ሪፖርቶች ፡፡
@@ -2300,6 +2309,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,የሰነድ ዓይነት
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,የሽያጭ ቡድን ጠቅላላ የተመደበ መቶኛ 100 መሆን አለበት
 DocType: Subscription Plan,Billing Interval Count,የማስከፈያ የጊዜ ክፍተት ቆጠራ
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","ይህንን ሰነድ ለመሰረዝ እባክዎ ሰራተኛውን <a href=""#Form/Employee/{0}"">{0}</a> \ ያጥፉ"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,ቀጠሮዎች እና የታካሚ መጋጠሚያዎች
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,እሴት ይጎድላል
 DocType: Employee,Department and Grade,መምሪያ እና ደረጃ
@@ -2402,6 +2413,7 @@
 DocType: Project,Start and End Dates,ይጀምሩ እና ቀኖች የማይኖርበት
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,የውጤት ቅጽ ቅንጅቶች ውሎች
 ,Delivered Items To Be Billed,የደረሱ ንጥሎች እንዲከፍሉ ለማድረግ
+DocType: Coupon Code,Maximum Use,ከፍተኛ አጠቃቀም
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},ክፍት BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,መጋዘን መለያ ቁጥር ሊቀየር አይችልም
 DocType: Authorization Rule,Average Discount,አማካይ ቅናሽ
@@ -2563,6 +2575,7 @@
 DocType: Item,Inventory,ንብረት ቆጠራ
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,እንደ ጆንሰን አውርድ ፡፡
 DocType: Item,Sales Details,የሽያጭ ዝርዝሮች
+DocType: Coupon Code,Used,ያገለገሉ
 DocType: Opportunity,With Items,ንጥሎች ጋር
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',ዘመቻው &#39;{0}&#39; ቀድሞውኑ ለ {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,የጥገና ቡድን
@@ -2692,7 +2705,7 @@
 						Serial No cannot be ensured",ለንጥል {0} ምንም ገባሪ ቦም አልተገኘም. በ \ Serial No መላክ አይረጋግጥም
 DocType: Sales Partner,Sales Partner Target,የሽያጭ ባልደረባ ዒላማ
 DocType: Loan Type,Maximum Loan Amount,ከፍተኛ የብድር መጠን
-DocType: Pricing Rule,Pricing Rule,የዋጋ አሰጣጥ ደንብ
+DocType: Coupon Code,Pricing Rule,የዋጋ አሰጣጥ ደንብ
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},ተማሪ የተባዙ ጥቅል ቁጥር {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,ትዕዛዝ ግዢ ቁሳዊ ጥያቄ
 DocType: Company,Default Selling Terms,ነባሪ የመሸጫ ውሎች።
@@ -2771,6 +2784,7 @@
 DocType: Payment Schedule,Payment Amount,የክፍያ መጠን
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,የግማሽ ቀን ቀን ከሥራ ቀን እና የስራ መጨረሻ ቀን መሃል መካከል መሆን አለበት
 DocType: Healthcare Settings,Healthcare Service Items,የጤና እንክብካቤ አገልግሎት እቃዎች
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,ልክ ያልሆነ የአሞሌ ኮድ ከዚህ ባርኮድ ጋር የተገናኘ ንጥል የለም።
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,ፍጆታ መጠን
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,በጥሬ ገንዘብ ውስጥ የተጣራ ለውጥ
 DocType: Assessment Plan,Grading Scale,አሰጣጥ በስምምነት
@@ -2890,7 +2904,6 @@
 DocType: Share Transfer,Asset Account,የንብረት መለያ
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,አዲስ የተለቀቀበት ቀን ለወደፊቱ መሆን አለበት።
 DocType: Purchase Invoice,End date of current invoice's period,የአሁኑ መጠየቂያ ያለው ክፍለ ጊዜ መጨረሻ ቀን
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,በሰብአዊ ሀብት&gt; የሰው ሠራሽ ቅንብሮች ውስጥ የሰራተኛ መለያ ስም መስሪያ ስርዓት ያዋቅሩ ፡፡
 DocType: Lab Test,Technician Name,የቴክኒክ ስም
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3000,6 +3013,7 @@
 DocType: Products Settings,Hide Variants,ልዩነቶችን ደብቅ።
 DocType: Lead,Next Contact By,በ ቀጣይ እውቂያ
 DocType: Compensatory Leave Request,Compensatory Leave Request,የማካካሻ ፍቃድ ጥያቄ
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings",በንጥል {0} በተከታታይ {1} ከ {2} በላይ መብለጥ አይቻልም። ከመጠን በላይ ክፍያ መጠየቅን ለመፍቀድ እባክዎ በመለያዎች ቅንብሮች ውስጥ አበል ያዘጋጁ
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},ረድፍ ውስጥ ንጥል {0} ያስፈልጋል ብዛት {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},የብዛት ንጥል የለም እንደ መጋዘን {0} ሊሰረዝ አይችልም {1}
 DocType: Blanket Order,Order Type,ትዕዛዝ አይነት
@@ -3169,7 +3183,6 @@
 DocType: Student,Student Mobile Number,የተማሪ የተንቀሳቃሽ ስልክ ቁጥር
 DocType: Item,Has Variants,ተለዋጮች አለው
 DocType: Employee Benefit Claim,Claim Benefit For,የድጐማ ማመልከት ለ
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","{0} በ {1} ከ {2} በላይ በአለው ነገር ላይ ማለፍ አይቻልም. ከመጠን በላይ-ወጪ የሚጠይቁትን, እባክዎ በማከማቻ ቅንጅቶች ውስጥ ያስቀምጡ"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,ምላሽ ስጥ
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},ከዚህ ቀደም ከ ንጥሎች ተመርጠዋል ሊሆን {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,ወደ ወርሃዊ ስርጭት ስም
@@ -3458,6 +3471,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,ኩባንያ ውስጥ ምንዛሬ ይግለጹ
 DocType: Workstation,Wages per hour,በሰዓት የደመወዝ
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},አዋቅር {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,ደንበኛ&gt; የደንበኞች ቡድን&gt; ክልል
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},ባች ውስጥ የአክሲዮን ቀሪ {0} ይሆናል አሉታዊ {1} መጋዘን ላይ ንጥል {2} ለ {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,ቁሳዊ ጥያቄዎች የሚከተሉት ንጥል ዳግም-ትዕዛዝ ደረጃ ላይ ተመስርቶ በራስ-ሰር ከፍ ተደርጓል
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},መለያ {0} ልክ ያልሆነ ነው. መለያ ምንዛሬ መሆን አለበት {1}
@@ -3787,6 +3801,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,የቀጣሪ አስገባ
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,በተጠንቀቅ
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,ማከለያ ቢያንስ አንድ ትክክለኛ አማራጮች ሊኖሩት ይገባል።
+apps/erpnext/erpnext/hooks.py,Purchase Orders,የግ Or ትዕዛዞች
 DocType: Account,Inter Company Account,የቡድን ኩባንያ ሂሳብ
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,የጅምላ ውስጥ አስመጣ
 DocType: Sales Partner,Address & Contacts,አድራሻ እና እውቂያዎች
@@ -3797,6 +3812,7 @@
 DocType: POS Profile,[Select],[ምረጥ]
 DocType: Staffing Plan Detail,Number Of Positions,የፖስታ ቁጥር
 DocType: Vital Signs,Blood Pressure (diastolic),የደም ግፊት (ዳቲኮል)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,እባክዎ ደንበኛውን ይምረጡ።
 DocType: SMS Log,Sent To,ወደ ተልኳል
 DocType: Agriculture Task,Holiday Management,የበዓል አያያዝ
 DocType: Payment Request,Make Sales Invoice,የሽያጭ ደረሰኝ አድርግ
@@ -4006,7 +4022,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} ማቅረብ አይደለም
 DocType: Subscription,Trialling,ፈዛዛ
 DocType: Sales Invoice Item,Deferred Revenue,የተዘገበው ገቢ
-DocType: Bank Account,GL Account,GL መለያ።
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,የገንዘብ መለያ ለሽያጭ ደረሰኝ ፍጆታ ያገለግላል
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,የተፈለገው ንዑስ ምድብ
 DocType: Member,Membership Expiry Date,የአባልነት ጊዜ ማብቂያ ቀን
@@ -4408,13 +4423,13 @@
 DocType: C-Form Invoice Detail,Territory,ግዛት
 DocType: Pricing Rule,Apply Rule On Item Code,በንጥል ኮድ ላይ ይተግብሩ።
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,የሚያስፈልግ ጉብኝቶች ምንም መጥቀስ እባክዎ
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,የአክሲዮን ቀሪ ሂሳብ ሪፖርት
 DocType: Stock Settings,Default Valuation Method,ነባሪ ዋጋ ትመና ዘዴው
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,ክፍያ
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,የተደመረው መጠን አሳይ
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,በሂደት ላይ ያለ ዝማኔ. የተወሰነ ጊዜ ሊወስድ ይችላል.
 DocType: Production Plan Item,Produced Qty,ያመረተ
 DocType: Vehicle Log,Fuel Qty,የነዳጅ ብዛት
-DocType: Stock Entry,Target Warehouse Name,የዒላማ መሸጫ ስም
 DocType: Work Order Operation,Planned Start Time,የታቀደ መጀመሪያ ጊዜ
 DocType: Course,Assessment,ግምገማ
 DocType: Payment Entry Reference,Allocated,የተመደበ
@@ -4480,10 +4495,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","መደበኛ ውሎች እና ሽያጭ እና ግዢዎች ሊታከሉ የሚችሉ ሁኔታዎች. ምሳሌዎች: ቅናሽ 1. ስለሚቆይበት. 1. የክፍያ ውል (ምንጭ ላይ የቅድሚያ ውስጥ, ክፍል አስቀድመህ ወዘተ). 1. ተጨማሪ (ወይም የደንበኛ የሚከፈል) ምንድን ነው. 1. ደህንነት / የአጠቃቀም ማስጠንቀቂያ. 1. ዋስትና ካለ. 1. መመሪያ ያወጣል. መላኪያ 1. ውል, የሚመለከተው ከሆነ. ክርክሮችን ለመፍታት, ጥቅማጥቅም, ተጠያቂነት 1. መንገዶች, ወዘተ 1. አድራሻ እና የእርስዎ ኩባንያ ያግኙን."
 DocType: Homepage Section,Section Based On,ክፍል ላይ የተመሠረተ።
+DocType: Shopping Cart Settings,Show Apply Coupon Code,ተግብር ኩፖን ኮድ አሳይ
 DocType: Issue,Issue Type,የችግር አይነት
 DocType: Attendance,Leave Type,ፈቃድ አይነት
 DocType: Purchase Invoice,Supplier Invoice Details,አቅራቢ የደረሰኝ ዝርዝሮች
 DocType: Agriculture Task,Ignore holidays,በዓላትን ችላ ይበሉ
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,የኩፖን ሁኔታዎችን ያክሉ / ያርትዑ
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,ወጪ / መማሩ መለያ ({0}) አንድ &#39;ትርፍ ወይም ኪሳራ&#39; መለያ መሆን አለበት
 DocType: Stock Entry Detail,Stock Entry Child,የአክሲዮን ግቤት ልጅ።
 DocType: Project,Copied From,ከ ተገልብጧል
@@ -4658,6 +4675,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,ግምገማ ዕቅድ መስፈርት
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,ግብይቶች
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,የግዢ ትዕዛዞችን ይከላከሉ
+DocType: Coupon Code,Coupon Name,የኩፖን ስም
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,በቀላሉ ሊታወቅ የሚችል
 DocType: Email Campaign,Scheduled,የተያዘለት
 DocType: Shift Type,Working Hours Calculation Based On,የስራ ሰዓቶች ስሌት ላይ የተመሠረተ።
@@ -4674,7 +4692,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,ተለዋጮችን ይፍጠሩ።
 DocType: Vehicle,Diesel,በናፍጣ
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,የዋጋ ዝርዝር ምንዛሬ አልተመረጠም
+DocType: Quick Stock Balance,Available Quantity,የሚገኝ ብዛት
 DocType: Purchase Invoice,Availed ITC Cess,በ ITC Cess ማግኘት
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,እባክዎ በትምህርቱ&gt; የትምህርት ቅንብሮች ውስጥ አስተማሪን የማኔጅመንት ስርዓት ያዋቅሩ
 ,Student Monthly Attendance Sheet,የተማሪ ወርሃዊ ክትትል ሉህ
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,የማጓጓዣ ደንብ ለሽያጭ ብቻ ነው የሚመለከተው
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,የአከፋፈል ቅደም ተከተራ {0}: የቀጣዩ ቀን ቅነሳ ቀን ከግዢ ቀን በፊት ሊሆን አይችልም
@@ -4742,6 +4762,7 @@
 DocType: Quality Meeting,Quality Meeting,ጥራት ያለው ስብሰባ።
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,ወደ ቡድን ያልሆነ ቡድን
 DocType: Employee,ERPNext User,ERPNext User
+DocType: Coupon Code,Coupon Description,የኩፖን መግለጫ
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},ባች ረድፍ ላይ ግዴታ ነው {0}
 DocType: Company,Default Buying Terms,ነባሪ የግying ውል።
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,የግዢ ደረሰኝ ንጥል አቅርቦት
@@ -4904,6 +4925,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,የሰነድ ዝርዝር ላይ የለም
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},ስረዛ ለአገር {0} አይፈቀድም
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,የድግስ አይነት ግዴታ ነው
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,የኩፖን ኮድ ይተግብሩ
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",ለስራ ካርድ {0} ፣ እርስዎ የ ‹ቁሳቁስ ሽግግር ለአምራች› ዓይነት የአክሲዮን ግቤት ብቻ ማድረግ ይችላሉ ፡፡
 DocType: Quality Inspection,Outgoing,የወጪ
 DocType: Customer Feedback Table,Customer Feedback Table,የደንበኛ ግብረ መልስ ሰንጠረዥ
@@ -5053,7 +5075,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,የግcha ትዕዛዝ ማቅረቢያ ላይ።
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,ሁሉንም አቅራቢዎች አክል
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,የረድፍ # {0}: የተመደበ መጠን የላቀ መጠን የበለጠ ሊሆን አይችልም.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,የደንበኛ&gt; የደንበኛ ቡድን&gt; ክልል።
 DocType: Tally Migration,Parties,ፓርቲዎች ፡፡
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,አስስ BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,ደህንነቱ የተጠበቀ ብድሮች
@@ -5085,7 +5106,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},ለንጥል የተለየ አማራጭ ለማዘጋጀት አይፈቀድም {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,ቀን ተደግሟል
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,የተፈቀደላቸው የፈራሚ
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,እባክዎ በትምህርቱ&gt; የትምህርት ቅንብሮች ውስጥ አስተማሪ ስም ማጎሪያ ስርዓት ያዋቅሩ።
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),የተጣራ ITC ይገኛል (ሀ) - (ለ)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,ክፍያዎች ይፍጠሩ
 DocType: Project,Total Purchase Cost (via Purchase Invoice),ጠቅላላ የግዢ ዋጋ (የግዢ ደረሰኝ በኩል)
@@ -5110,6 +5130,7 @@
 DocType: Quiz Result,Wrong,ስህተት።
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,ፍጥነት ዋጋ ዝርዝር ምንዛሬ ላይ የደንበኛ መሰረት ከሆነው ምንዛሬ በመለወጥ ላይ ነው
 DocType: Purchase Invoice Item,Net Amount (Company Currency),የተጣራ መጠን (የኩባንያ የምንዛሬ)
+DocType: Sales Partner,Referral Code,ሪፈራል ኮድ
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,የጠቅላላ የቅድመ ክፍያ መጠን ከማዕቀዛት ጠቅላላ መጠን በላይ ሊሆን አይችልም
 DocType: Salary Slip,Hour Rate,ሰዓቲቱም ተመን
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,ራስ-ማዘመኛን ያንቁ።
@@ -5238,6 +5259,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,የአክሲዮን ብዛት አሳይ
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,ክወናዎች ከ የተጣራ ገንዘብ
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},ረድፍ # {0}: ሁኔታ ለገንዘብ መጠየቂያ ቅናሽ {2} ሁኔታ {1} መሆን አለበት
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM የልወጣ ሁኔታ ({0} -&gt; {1}) ለእንጥል አልተገኘም {{2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,ንጥል 4
 DocType: Student Admission,Admission End Date,የመግቢያ መጨረሻ ቀን
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,ንዑስ-የኮንትራት
@@ -5260,6 +5282,7 @@
 DocType: Travel Request,Fully Sponsored,ሙሉ በሙሉ የተደገፈ
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,የተራዘመ የጆርናሉ ምዝገባ
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,የሥራ ካርድ ይፍጠሩ ፡፡
+DocType: Quotation,Referral Sales Partner,ሪፈራል የሽያጭ አጋር
 DocType: Quality Procedure Process,Process Description,የሂደት መግለጫ
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,ደንበኛ {0} ተፈጥሯል.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,በአሁኑ ጊዜ በማንኛውም መጋዘን ውስጥ ምንም አክሲዮስ የለም
@@ -5393,6 +5416,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM ተመን
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,የተጫነ ፋይል በማንበብ ላይ።
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","የተቋረጠው የሥራ ትዕዛዝ ሊተው አይችልም, መተው መጀመሪያ ይጥፉ"
+DocType: Coupon Code,Coupon Code,የኩፖን ኮድ
 DocType: Asset,Journal Entry for Scrap,ቁራጭ ለ ጆርናል የሚመዘገብ መረጃ
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,የመላኪያ ማስታወሻ የመጡ ንጥሎችን ለመንቀል እባክዎ
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},ረድፍ {0}: ከግዜው ላይ {1}
@@ -5475,6 +5499,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;ቀን&#39; ያስፈልጋል።
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},ምክንያት / ማጣቀሻ ቀን በኋላ መሆን አይችልም {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,የውሂብ ያስመጡ እና ወደ ውጪ ላክ
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired",ይቅርታ ፣ የኩፖን ኮድ ትክክለኛነት ጊዜው አልፎበታል
 DocType: Bank Account,Account Details,የመለያ ዝርዝሮች
 DocType: Crop,Materials Required,አስፈላጊ ነገሮች
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,ምንም ተማሪዎች አልተገኙም
@@ -5512,6 +5537,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,ወደ ተጠቃሚዎች ሂድ
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,የሚከፈልበት መጠን መጠን ግራንድ ጠቅላላ በላይ ሊሆን አይችልም ጠፍቷል ጻፍ; +
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} ንጥል ትክክለኛ ባች ቁጥር አይደለም {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,እባክዎ ትክክለኛ የኩፖን ኮድ ያስገቡ !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},ማስታወሻ: አይተውህም ዓይነት በቂ ፈቃድ ቀሪ የለም {0}
 DocType: Task,Task Description,የተግባር መግለጫ።
 DocType: Training Event,Seminar,ሴሚናሩ
@@ -5775,6 +5801,7 @@
 ,TDS Payable Monthly,TDS የሚከፈል ወርሃዊ
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,ቦም (BOM) ለመተመን ተሰልፏል. ጥቂት ደቂቃዎችን ሊወስድ ይችላል.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',በምድብ «ግምቱ &#39;ወይም&#39; ግምቱ እና ጠቅላላ &#39;ነው ጊዜ ቀነሰ አይቻልም
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,በሰብአዊ ሀብት&gt; የሰው ሠራሽ ቅንጅቶች ውስጥ የሰራተኛ መለያ ስም መስጫ ስርዓትን ያዋቅሩ
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,ጠቅላላ ክፍያዎች።
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serialized ንጥል ሲሪያል ቁጥሮች ያስፈልጋል {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,ደረሰኞች ጋር አዛምድ ክፍያዎች
@@ -5864,6 +5891,7 @@
 DocType: Production Plan,Get Raw Materials For Production,ለማምረት ጥሬ ዕቃዎችን ያግኙ
 DocType: Job Opening,Job Title,የስራ መደቡ መጠሪያ
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,የወደፊት ክፍያ Ref
+DocType: Quotation,Additional Discount and Coupon Code,ተጨማሪ ቅናሽ እና የኩፖን ኮድ
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} እንደሚያሳየው {1} የጥቅስ ነገርን አያቀርብም, ነገር ግን ሁሉም ንጥሎች \ ተወስደዋል. የ RFQ መጠይቅ ሁኔታን በማዘመን ላይ."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,ከፍተኛ ቁጥር ያላቸው - {0} አስቀድመው በቡድን {1} እና በንጥል {2} በቡድን {3} ውስጥ ተይዘው ተቀምጠዋል.
@@ -6091,7 +6119,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,ድር መነሻ ገጽ ቅንብሮች
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} ያቆመበት እስከ {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},በ {0} ነጥብ የምርጫ ካርድ ደረጃ ምክንያት በ {0} አይፈቀድም RFQs አይፈቀዱም.
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,የክፍያ መጠየቂያ ደረሰኝ ይግዙ
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,ጥቅም ላይ የዋሉ ቅጠሎች
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} ያገለገሉ ኩፖኖች {1} ናቸው። የተፈቀደው ብዛት ደክሟል
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,የቁሳዊ ጥያቄውን ማስገባት ይፈልጋሉ?
 DocType: Job Offer,Awaiting Response,ምላሽ በመጠባበቅ ላይ
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-yYYYY.-
@@ -6105,6 +6135,7 @@
 DocType: Training Event Employee,Optional,አማራጭ
 DocType: Salary Slip,Earning & Deduction,ገቢ እና ተቀናሽ
 DocType: Agriculture Analysis Criteria,Water Analysis,የውሃ ትንተና
+DocType: Sales Order,Skip Delivery Note,ማቅረቢያ ማስታወሻ ዝለል
 DocType: Price List,Price Not UOM Dependent,ዋጋ UOM ጥገኛ አይደለም።
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} ፈጣሪዎች ተፈጥረዋል.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,ነባሪ የአገልግሎት ደረጃ ስምምነት ቀድሞውኑ አለ።
@@ -6209,6 +6240,7 @@
 DocType: Vehicle,Last Carbon Check,የመጨረሻው ካርቦን ፈትሽ
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,የህግ ወጪዎች
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,ረድፍ ላይ ብዛት ይምረጡ
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},የሥራ ትእዛዝ {0}: - የሥራው ካርድ ለኦፕሬሽኑ አልተገኘም {1}
 DocType: Purchase Invoice,Posting Time,መለጠፍ ሰዓት
 DocType: Timesheet,% Amount Billed,% መጠን የሚከፈል
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,የስልክ ወጪ
@@ -6311,7 +6343,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,ግብሮች እና ክፍያዎች ታክሏል
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,የአከፋፈል ቅደም ተከተልን {0}: የሚቀጥለው የአለሜሽን ቀን ከክፍያ ጋር ለመገናኘት የሚውል ቀን ከመሆኑ በፊት ሊሆን አይችልም
 ,Sales Funnel,የሽያጭ ማጥለያ
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,የንጥል ኮድ&gt; የንጥል ቡድን&gt; የምርት ስም።
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,ምህጻረ ቃል የግዴታ ነው
 DocType: Project,Task Progress,ተግባር ሂደት
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,ጋሪ
@@ -6406,6 +6437,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS መገለጫ POS የሚመዘገብ ለማድረግ ያስፈልጋል
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",የታማኝነት ስብስብ ነጥቦች ከተጠቀሰው ጊዜ (በሽያጭ ደረሰኝ በኩል) ተወስዶ የተሰራውን መሰረት በማድረግ ነው.
 DocType: Program Enrollment Tool,Enroll Students,ተማሪዎች ይመዝገቡ
+DocType: Pricing Rule,Coupon Code Based,የኩፖን ኮድ የተመሠረተ
 DocType: Company,HRA Settings,HRA ቅንብሮች
 DocType: Homepage,Hero Section,ጀግና ክፍል ፡፡
 DocType: Employee Transfer,Transfer Date,የማስተላለፍ ቀን
@@ -6521,6 +6553,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',የቡድን በ «ኩባንያ &#39;ከሆነ ኩባንያ ባዶ ማጣሪያ ያዘጋጁ እባክዎ
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,መለጠፍ ቀን ወደፊት ቀን ሊሆን አይችልም
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},የረድፍ # {0}: መለያ አይ {1} ጋር አይዛመድም {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,እባክዎን ለተማሪ ተገኝተው በማዋቀር&gt; በቁጥር ተከታታይ በኩል ያዘጋጁ
 DocType: Stock Entry,Target Warehouse Address,የዒላማ መሸጫ ቤት አድራሻ
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,ተራ ፈቃድ
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,የሰራተኛ ተመዝግቦ መግቢያ ለመገኘት የታሰበበት ከለውጥያው ጊዜ በፊት ያለው ሰዓት
@@ -6555,7 +6588,6 @@
 DocType: Employee Grade,Employee Grade,የሰራተኛ ደረጃ
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,ጭማቂዎች
 DocType: GSTR 3B Report,June,ሰኔ
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,አቅራቢ&gt; የአቅራቢ ዓይነት።
 DocType: Share Balance,From No,ከ
 DocType: Shift Type,Early Exit Grace Period,ቀደምት የመልቀቂያ ጊዜ።
 DocType: Task,Actual Time (in Hours),(ሰዓቶች ውስጥ) ትክክለኛ ሰዓት
@@ -6840,7 +6872,6 @@
 DocType: Warehouse,Warehouse Name,የመጋዘን ስም
 DocType: Naming Series,Select Transaction,ይምረጡ የግብይት
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,ሚና በማፅደቅ ወይም የተጠቃሚ በማፅደቅ ያስገቡ
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM የልወጣ ሁኔታ ({0} -&gt; {1}) ለእንጥል አልተገኘም {{2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,የአገልግሎት ደረጃ ስምምነት ከድርጅት ዓይነት {0} እና ህጋዊ አካል {1} ቀድሞውኑ አለ።
 DocType: Journal Entry,Write Off Entry,Entry ጠፍቷል ይጻፉ
 DocType: BOM,Rate Of Materials Based On,ደረጃ ይስጡ እቃዎች ላይ የተመረኮዘ ላይ
@@ -6978,6 +7009,7 @@
 DocType: Budget,Warn,አስጠንቅቅ
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,ሁሉም ነገሮች ለዚህ የሥራ ትዕዛዝ ተላልፈዋል.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","ሌሎች ማንኛውም አስተያየት, መዝገቦች ውስጥ መሄድ ዘንድ ትኩረት የሚስብ ጥረት."
+DocType: Bank Account,Company Account,የኩባንያ መለያ
 DocType: Asset Maintenance,Manufacturing User,ማኑፋክቸሪንግ ተጠቃሚ
 DocType: Purchase Invoice,Raw Materials Supplied,ጥሬ እቃዎች አቅርቦት
 DocType: Subscription Plan,Payment Plan,የክፍያ ዕቅድ
@@ -7018,6 +7050,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},በስርዓት ቅደም ተከተል ውስጥ {0} ({1}) ሊሠራ ከታቀደ ብዛት ({2}) መብለጥ የለበትም {3}
 DocType: Certification Application,Name of Applicant,የአመልካች ስም
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,የአምራች ሰዓት ሉህ.
+DocType: Quick Stock Balance,Quick Stock Balance,ፈጣን የአክሲዮን ሚዛን
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,ድምር
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,ከምርት ግብይት በኋላ ተለዋዋጭ ባህሪያትን መለወጥ አይቻልም. ይህን ለማድረግ አዲስ ንጥል ማዘጋጀት ይኖርብዎታል.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,የ GoCardless SEPA ኃላፊ
@@ -7344,6 +7377,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},ማዘጋጀት እባክዎ {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} የቦዘነ ተማሪ ነው
 DocType: Employee,Health Details,የጤና ዝርዝሮች
+DocType: Coupon Code,Coupon Type,የኩፖን አይነት
 DocType: Leave Encashment,Encashable days,የሚጣሩ ቀናት
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,"የማጣቀሻ ሰነድ ያስፈልጋል ክፍያ ጥያቄ ለመፍጠር,"
 DocType: Soil Texture,Sandy Clay,ሳንዲ ሸክላ
@@ -7626,6 +7660,7 @@
 DocType: Hotel Room Package,Amenities,ምግቦች
 DocType: Accounts Settings,Automatically Fetch Payment Terms,የክፍያ ውሎችን በራስ-ሰር ያውጡ።
 DocType: QuickBooks Migrator,Undeposited Funds Account,ተመላሽ ያልተደረገ የገንዘብ ሒሳብ
+DocType: Coupon Code,Uses,ይጠቀማል
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,ባለብዙ ነባሪ የክፍያ ስልት አይፈቀድም
 DocType: Sales Invoice,Loyalty Points Redemption,የታማኝነት መክፈል ዋጋዎች
 ,Appointment Analytics,የቀጠሮ ትንታኔ
@@ -7642,6 +7677,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,ጠቅላላ በጀት
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,እርስዎ በዓመት ተማሪዎች ቡድኖች ለማድረግ ከሆነ ባዶ ይተዉት
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","ከተመረጠ, ጠቅላላ የለም. የስራ ቀናት በዓላት ያካትታል; ይህም ደመወዝ በእያንዳንዱ ቀን ዋጋ እንዲቀንስ ያደርጋል"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,ጎራ ማከል አልተሳካም
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.",ከደረሰኝ / ማድረስ በላይ ለመፍቀድ በአክሲዮን ቅንጅቶች ወይም በእቃው ውስጥ “ከደረሰኝ / ማቅረቢያ አበል” በላይ አዘምን።
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","የአሁኑን ቁልፍ የሚጠቀሙ መተግበሪያዎች መዳረስ አይችሉም, እርግጠኛ ነዎት?"
 DocType: Subscription Settings,Prorate,Prorate
@@ -7654,6 +7690,7 @@
 ,BOM Stock Report,BOM ስቶክ ሪፖርት
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group",የተመደበው የጊዜ ሰሌዳ ከሌለ ታዲያ በዚህ ቡድን ግንኙነቶች ይከናወናል ፡፡
 DocType: Stock Reconciliation Item,Quantity Difference,የብዛት ለውጥ አምጥተዋል
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,አቅራቢ&gt; የአቅራቢ ዓይነት
 DocType: Opportunity Item,Basic Rate,መሰረታዊ ደረጃ
 DocType: GL Entry,Credit Amount,የብድር መጠን
 ,Electronic Invoice Register,የኤሌክትሮኒክ የክፍያ መጠየቂያ ምዝገባ
@@ -7907,6 +7944,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),ግብሮች እና ክፍያዎች ተቀናሽ (የኩባንያ የምንዛሬ)
 DocType: Item Group,General Settings,ጠቅላላ ቅንብሮች
 DocType: Article,Article,አንቀጽ
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,እባክዎ የኩፖን ኮድ ያስገቡ !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,ገንዘብና ጀምሮ እና ምንዛሬ ወደ አንድ ዓይነት ሊሆኑ አይችሉም
 DocType: Taxable Salary Slab,Percent Deduction,መቶኛ ማስተካከያ
 DocType: GL Entry,To Rename,እንደገና ለመሰየም።
diff --git a/erpnext/translations/ar.csv b/erpnext/translations/ar.csv
index 60c5b51..05ccdbf 100644
--- a/erpnext/translations/ar.csv
+++ b/erpnext/translations/ar.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,معلومات اتصال العميل
 DocType: Shift Type,Enable Auto Attendance,تمكين الحضور التلقائي
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,الرجاء إدخال المستودع والتاريخ
 DocType: Lost Reason Detail,Opportunity Lost Reason,فرصة ضائعة السبب
 DocType: Patient Appointment,Check availability,التحقق من الصلاحية
 DocType: Retention Bonus,Bonus Payment Date,تاريخ دفع المكافأة
@@ -265,6 +266,7 @@
 ,Completed Work Orders,أوامر العمل المكتملة
 DocType: Support Settings,Forum Posts,مشاركات المنتدى
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage",وقد تم إرساء المهمة كعمل خلفية. في حالة وجود أي مشكلة في المعالجة في الخلفية ، سيقوم النظام بإضافة تعليق حول الخطأ في تسوية المخزون هذا والعودة إلى مرحلة المسودة
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started",عذرًا ، لم تبدأ صلاحية رمز القسيمة
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,المبلغ الخاضع للضريبة
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},غير مصرح لك لإضافة أو تحديث الإدخالات قبل {0}
 DocType: Leave Policy,Leave Policy Details,اترك تفاصيل السياسة
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,المواد المستهلكة
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,درجة
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,كود الصنف&gt; مجموعة الصنف&gt; العلامة التجارية
 DocType: Restaurant Table,No of Seats,عدد المقاعد
 DocType: Sales Invoice,Overdue and Discounted,المتأخرة و مخفضة
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,تم قطع الاتصال
@@ -506,6 +509,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,سطر فارغ للمبلغ بالحروف
 DocType: Vehicle,Additional Details,تفاصيل اضافية
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,لم يتم اعطاء وصف
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,جلب العناصر من المستودع
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,طلب للشراء.
 DocType: POS Closing Voucher Details,Collected Amount,المبلغ المجمع
 DocType: Lab Test,Submitted Date,تاريخ التقديم / التسجيل
@@ -613,6 +617,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,تعلم
 ,Trial Balance (Simple),ميزان المراجعة (بسيط)
 DocType: Purchase Invoice Item,Enable Deferred Expense,تمكين المصروفات المؤجلة
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,رمز القسيمة المطبق
 DocType: Asset,Next Depreciation Date,تاريخ االاستهالك التالي
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,تكلفة النشاط لكل موظف
 DocType: Accounts Settings,Settings for Accounts,إعدادات الحسابات
@@ -848,8 +853,6 @@
 DocType: BOM,Work Order,أمر العمل
 DocType: Sales Invoice,Total Qty,إجمالي الكمية
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 معرف البريد الإلكتروني
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","يرجى حذف الموظف <a href=""#Form/Employee/{0}"">{0}</a> \ لإلغاء هذا المستند"
 DocType: Item,Show in Website (Variant),مشاهدة في موقع (البديل)
 DocType: Employee,Health Concerns,شؤون صحية
 DocType: Payroll Entry,Select Payroll Period,تحديد فترة دفع الرواتب
@@ -1013,6 +1016,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,حساب حجب الضرائب
 DocType: Pricing Rule,Sales Partner,شريك المبيعات
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,جميع نتائج الموردين
+DocType: Coupon Code,To be used to get discount,ليتم استخدامها للحصول على الخصم
 DocType: Buying Settings,Purchase Receipt Required,إيصال استلام المشتريات مطلوب
 DocType: Sales Invoice,Rail,سكة حديدية
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,التكلفة الفعلية
@@ -1063,6 +1067,7 @@
 DocType: Production Plan,Production Plan,خطة الإنتاج
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,أداة إنشاء فاتورة افتتاحية
 DocType: Salary Component,Round to the Nearest Integer,جولة إلى أقرب عدد صحيح
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,السماح بإضافة العناصر غير الموجودة في المخزن إلى السلة
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,مبيعات المعاده
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,تعيين الكمية في المعاملات استناداً إلى Serial No Input
 ,Total Stock Summary,ملخص إجمالي المخزون
@@ -1192,6 +1197,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),سعر الساعة الأساسي (عملة الشركة)
 ,Qty To Be Billed,الكمية المطلوب دفعها
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,القيمة التي تم تسليمها
+DocType: Coupon Code,Gift Card,كرت هدية
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,الكمية المخصصة للإنتاج: كمية المواد الخام لتصنيع المواد.
 DocType: Loyalty Point Entry Redemption,Redemption Date,تاريخ الاسترداد
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,تمت تسوية هذه الصفقة المصرفية بالفعل بالكامل
@@ -1279,6 +1285,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,إنشاء الجدول الزمني
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,تم إدخال الحساب {0} عدة مرات
 DocType: Account,Expenses Included In Valuation,المصروفات متضمنة في تقييم السعر
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,فواتير الشراء
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,يمكنك تجديد عضويتك اذا انتهت عضويتك خلال 30 يوما
 DocType: Shopping Cart Settings,Show Stock Availability,عرض توافر المخزون
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},تعيين {0} في فئة الأصول {1} أو الشركة {2}
@@ -1837,6 +1844,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,استيراد العناصر و UOMs
 DocType: Repayment Schedule,Balance Loan Amount,رصيد مبلغ القرض
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,تم اضافته الى التفاصيل
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted",عذرا ، رمز الكوبون مستنفد
 DocType: Communication Medium,Catch All,قبض على الكل
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,دورة الجدول الزمني
 DocType: Budget,Applicable on Material Request,ينطبق على طلب المواد
@@ -2004,6 +2012,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,خاصية غير صالحة
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} يجب أن يتم تقديمه
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,حملات البريد الإلكتروني
+DocType: Sales Partner,To Track inbound purchase,لتتبع الشراء الوارد
 DocType: Buying Settings,Default Supplier Group,مجموعة الموردين الافتراضية
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},يجب أن تكون الكمية أقل من أو تساوي {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},أقصى مبلغ مؤهل للعنصر {0} يتجاوز {1}
@@ -2159,8 +2168,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,جعل دخول الأسهم
 DocType: Hotel Room Reservation,Hotel Reservation User,فندق حجز المستخدم
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,تعيين الحالة
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,يرجى إعداد سلسلة الترقيم للحضور عبر الإعداد&gt; سلسلة الترقيم
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,الرجاء اختيار البادئة اولا
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,يرجى تعيين سلسلة التسمية لـ {0} عبر الإعداد&gt; الإعدادات&gt; سلسلة التسمية
 DocType: Contract,Fulfilment Deadline,الموعد النهائي للوفاء
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,بالقرب منك
 DocType: Student,O-,O-
@@ -2284,6 +2293,7 @@
 DocType: Quality Meeting Table,Under Review,تحت المراجعة
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,فشل في تسجيل الدخول
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,تم إنشاء الأصل {0}
+DocType: Coupon Code,Promotional,الترويجية
 DocType: Special Test Items,Special Test Items,عناصر الاختبار الخاصة
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,يجب أن تكون مستخدمًا بأدوار مدير النظام و مدير الصنف للتسجيل في Marketplace.
 apps/erpnext/erpnext/config/buying.py,Key Reports,التقارير الرئيسية
@@ -2321,6 +2331,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,نوع الوثيقة
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,مجموع النسبة المئوية المخصصة ل فريق المبيعات يجب أن يكون 100
 DocType: Subscription Plan,Billing Interval Count,عدد الفواتير الفوترة
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","يرجى حذف الموظف <a href=""#Form/Employee/{0}"">{0}</a> \ لإلغاء هذا المستند"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,المواعيد ومواجهات المرضى
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,القيمة مفقودة
 DocType: Employee,Department and Grade,قسم والصف
@@ -2423,6 +2435,7 @@
 DocType: Project,Start and End Dates,تواريخ البدء والانتهاء
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,شروط استيفاء قالب العقد
 ,Delivered Items To Be Billed,مواد سلمت و لم يتم اصدار فواتيرها
+DocType: Coupon Code,Maximum Use,الاستخدام الأقصى
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},فتح قائمة المواد {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,لا يمكن تغيير الرقم التسلسلي لل مستودع
 DocType: Authorization Rule,Average Discount,متوسط الخصم
@@ -2585,6 +2598,7 @@
 DocType: Item,Inventory,جرد
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,تنزيل باسم Json
 DocType: Item,Sales Details,تفاصيل المبيعات
+DocType: Coupon Code,Used,مستخدم
 DocType: Opportunity,With Items,مع الأصناف
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',الحملة &#39;{0}&#39; موجودة بالفعل لـ {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,فريق الصيانة
@@ -2714,7 +2728,7 @@
 						Serial No cannot be ensured",لم يتم العثور على BOM نشط للعنصر {0}. التسليم عن طريق \ Serial لا يمكن ضمانه
 DocType: Sales Partner,Sales Partner Target,المبلغ المطلوب للمندوب
 DocType: Loan Type,Maximum Loan Amount,أعلى قيمة للقرض
-DocType: Pricing Rule,Pricing Rule,قاعدة التسعير
+DocType: Coupon Code,Pricing Rule,قاعدة التسعير
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},رقم لفة مكرر للطالب {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Material Request to Purchase Order
 DocType: Company,Default Selling Terms,شروط البيع الافتراضية
@@ -2793,6 +2807,7 @@
 DocType: Payment Schedule,Payment Amount,دفع مبلغ
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,يجب أن يكون تاريخ نصف يوم بين العمل من التاريخ وتاريخ انتهاء العمل
 DocType: Healthcare Settings,Healthcare Service Items,عناصر خدمة الرعاية الصحية
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,الباركود غير صالح. لا يوجد عنصر مرفق بهذا الرمز الشريطي.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,القيمة المستهلكة
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,صافي التغير في النقد
 DocType: Assessment Plan,Grading Scale,مقياس الدرجات
@@ -2912,7 +2927,6 @@
 DocType: Share Transfer,Asset Account,حساب الأصول
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,يجب أن يكون تاريخ الإصدار الجديد في المستقبل
 DocType: Purchase Invoice,End date of current invoice's period,تاريخ نهاية فترة الفاتورة الحالية
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,يرجى إعداد نظام تسمية الموظفين في الموارد البشرية&gt; إعدادات الموارد البشرية
 DocType: Lab Test,Technician Name,اسم فني
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3024,6 +3038,7 @@
 DocType: Products Settings,Hide Variants,إخفاء المتغيرات
 DocType: Lead,Next Contact By,جهة الاتصال التالية بواسطة
 DocType: Compensatory Leave Request,Compensatory Leave Request,طلب الإجازة التعويضية
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings",لا يمكن زيادة حجم العنصر {0} في الصف {1} أكثر من {2}. للسماح بالإفراط في الفوترة ، يرجى تعيين بدل في إعدادات الحسابات
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},الكمية المطلوبة للبند {0} في الصف {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},مستودع {0} لا يمكن حذف كما توجد كمية القطعة ل {1}
 DocType: Blanket Order,Order Type,نوع الطلب
@@ -3193,7 +3208,6 @@
 DocType: Student,Student Mobile Number,طالب عدد موبايل
 DocType: Item,Has Variants,يحتوي على متغيرات
 DocType: Employee Benefit Claim,Claim Benefit For,فائدة للمطالبة
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings",لا يمكن المبالغة في البند {0} في الصف {1} أكثر من {2}. للسماح بالإفراط في الفوترة، يرجى تعيينه في إعدادات الأسهم
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,تحديث الرد
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},لقد حددت العناصر من {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,اسم التوزيع الشهري
@@ -3483,6 +3497,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,يرجى تحديد العملة للشركة
 DocType: Workstation,Wages per hour,الأجور في الساعة
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},تكوين {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,العملاء&gt; مجموعة العملاء&gt; الإقليم
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},توازن الأسهم في الدفعة {0} ستصبح سلبية {1} القطعة ل{2} في {3} مستودع
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,تم رفع طلبات المواد التالية تلقائيا بناء على مستوى اعادة الطلب للبنود
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},الحساب {0} غير صحيح. يجب أن تكون عملة الحساب {1}
@@ -3812,6 +3827,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,الموافقة كشف الرواتب
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,في الانتظار
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,يجب أن يحتوي qustion على خيارات صحيحة واحدة على الأقل
+apps/erpnext/erpnext/hooks.py,Purchase Orders,طلبات الشراء
 DocType: Account,Inter Company Account,حساب الشركة المشترك
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,استيراد بكميات كبيرة
 DocType: Sales Partner,Address & Contacts,معلومات الاتصال والعنوان
@@ -3822,6 +3838,7 @@
 DocType: POS Profile,[Select],[اختر ]
 DocType: Staffing Plan Detail,Number Of Positions,عدد المناصب
 DocType: Vital Signs,Blood Pressure (diastolic),ضغط الدم (الانبساطي)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,يرجى اختيار العميل.
 DocType: SMS Log,Sent To,يرسل الى
 DocType: Agriculture Task,Holiday Management,إدارة العطلات
 DocType: Payment Request,Make Sales Invoice,انشاء فاتورة المبيعات
@@ -4031,7 +4048,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} لم يتم تقديمه
 DocType: Subscription,Trialling,تجربته
 DocType: Sales Invoice Item,Deferred Revenue,الإيرادات المؤجلة
-DocType: Bank Account,GL Account,حساب غوغل
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,سيستخدم الحساب النقدي لإنشاء فاتورة المبيعات
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,الإعفاء الفئة الفرعية
 DocType: Member,Membership Expiry Date,تاريخ انتهاء العضوية
@@ -4455,13 +4471,13 @@
 DocType: C-Form Invoice Detail,Territory,إقليم
 DocType: Pricing Rule,Apply Rule On Item Code,تطبيق القاعدة على رمز البند
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,يرجى ذكر عدد الزيارات المطلوبة
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,تقرير رصيد المخزون
 DocType: Stock Settings,Default Valuation Method,أسلوب التقييم الافتراضي
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,رسوم
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,إظهار المبلغ التراكمي
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,التحديث قيد التقدم. قد يستغرق بعض الوقت.
 DocType: Production Plan Item,Produced Qty,الكمية المنتجة
 DocType: Vehicle Log,Fuel Qty,كمية الوقود
-DocType: Stock Entry,Target Warehouse Name,اسم المستودع المستهدف
 DocType: Work Order Operation,Planned Start Time,المخططة بداية
 DocType: Course,Assessment,تقييم
 DocType: Payment Entry Reference,Allocated,تخصيص
@@ -4539,10 +4555,12 @@
  1. سبل معالجة النزاعات، التعويض، والمسؤولية، الخ 
  1. معالجة والاتصال من الشركة الخاصة بك."
 DocType: Homepage Section,Section Based On,قسم بناء على
+DocType: Shopping Cart Settings,Show Apply Coupon Code,إظهار تطبيق رمز القسيمة
 DocType: Issue,Issue Type,نوع القضية
 DocType: Attendance,Leave Type,نوع الاجازة
 DocType: Purchase Invoice,Supplier Invoice Details,المورد تفاصيل الفاتورة
 DocType: Agriculture Task,Ignore holidays,تجاهل العطلات
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,إضافة / تحرير شروط القسيمة
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,حساب نفقات / قروق ({0}) يجب ان يكون حساب ارباح و خسائر
 DocType: Stock Entry Detail,Stock Entry Child,الأسهم دخول الطفل
 DocType: Project,Copied From,تم نسخها من
@@ -4717,6 +4735,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,معايير خطة التقييم
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,المعاملات
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,منع أوامر الشراء
+DocType: Coupon Code,Coupon Name,اسم القسيمة
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,سريع التأثر
 DocType: Email Campaign,Scheduled,من المقرر
 DocType: Shift Type,Working Hours Calculation Based On,ساعات العمل حساب على أساس
@@ -4733,7 +4752,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,إنشاء المتغيرات
 DocType: Vehicle,Diesel,ديزل
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,قائمة أسعار العملات غير محددة
+DocType: Quick Stock Balance,Available Quantity,الكمية المتوفرة
 DocType: Purchase Invoice,Availed ITC Cess,استفاد من إيتس سيس
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,يرجى إعداد نظام تسمية المدرب في التعليم&gt; إعدادات التعليم
 ,Student Monthly Attendance Sheet,طالب ورقة الحضور الشهري
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,الشحن القاعدة المعمول بها فقط للبيع
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,صف الإهلاك {0}: لا يمكن أن يكون تاريخ الاستهلاك قبل تاريخ الشراء
@@ -4800,8 +4821,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,الصف {0}:  الدفعة المقدمة مقابل الزبائن يجب أن تكون دائن
 DocType: Quality Meeting,Quality Meeting,اجتماع الجودة
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,من تصنيف (غير المجموعة) إلى تصنيف ( المجموعة)
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,يرجى تعيين سلسلة التسمية لـ {0} عبر الإعداد&gt; الإعدادات&gt; سلسلة التسمية
 DocType: Employee,ERPNext User,ERPNext المستخدم
+DocType: Coupon Code,Coupon Description,وصف القسيمة
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},الدفعة إلزامية على التوالي {0}
 DocType: Company,Default Buying Terms,شروط الشراء الافتراضية
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,شراء السلعة استلام الموردة
@@ -4964,6 +4985,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,مقابل المستند التفصيلى رقم
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},الحذف غير مسموح به في البلد {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,نوع الطرف المعني إلزامي
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,تطبيق رمز القسيمة
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",بالنسبة لبطاقة المهمة {0} ، يمكنك فقط إدخال إدخال نوع الأسهم &quot;نقل المواد للصناعة&quot;
 DocType: Quality Inspection,Outgoing,المنتهية ولايته
 DocType: Customer Feedback Table,Customer Feedback Table,جدول ملاحظات العملاء
@@ -5113,7 +5135,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,عند تقديم طلب الشراء
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,إضافة جميع الموردين
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,الصف # {0}: المبلغ المخصص لا يمكن أن يكون أكبر من المبلغ المستحق.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,العملاء&gt; مجموعة العملاء&gt; الإقليم
 DocType: Tally Migration,Parties,حفلات
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,تصفح قائمة المواد
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,القروض المضمونة
@@ -5145,7 +5166,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},لا تسمح بتعيين عنصر بديل للعنصر {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,التاريخ مكرر
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,المخول بالتوقيع
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,يرجى إعداد نظام تسمية المدرب في التعليم&gt; إعدادات التعليم
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),صافي ITC المتوفر (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,إنشاء رسوم
 DocType: Project,Total Purchase Cost (via Purchase Invoice),مجموع تكلفة الشراء (عن طريق شراء الفاتورة)
@@ -5170,6 +5190,7 @@
 DocType: Quiz Result,Wrong,خطأ
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,المعدل الذي يتم تحويل سعر العملة العملة الأساسية القائمة لالعملاء
 DocType: Purchase Invoice Item,Net Amount (Company Currency),صافي المبلغ  ( بعملة الشركة )
+DocType: Sales Partner,Referral Code,كود الإحالة
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,لا يمكن أن يكون إجمالي المبلغ المدفوع أكبر من المبلغ الإجمالي المعتمد
 DocType: Salary Slip,Hour Rate,سعرالساعة
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,تمكين إعادة الطلب التلقائي
@@ -5298,6 +5319,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,عرض كمية المخزون
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,صافي النقد من العمليات
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},الصف # {0}: يجب أن تكون الحالة {1} بالنسبة لخصم الفاتورة {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},معامل تحويل UOM ({0} -&gt; {1}) غير موجود للعنصر: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,صنف رقم 4
 DocType: Student Admission,Admission End Date,تاريخ انتهاء القبول
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,التعاقد من الباطن
@@ -5320,6 +5342,7 @@
 DocType: Travel Request,Fully Sponsored,برعاية كاملة
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,عكس دخول المجلة
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,إنشاء بطاقة العمل
+DocType: Quotation,Referral Sales Partner,شريك مبيعات الإحالة
 DocType: Quality Procedure Process,Process Description,وصف العملية
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,تم إنشاء العميل {0}.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,حاليا لا يوجد مخزون متاح في أي مستودع
@@ -5454,6 +5477,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,سعر قائمة المواد
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,قراءة ملف تم الرفع
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel",لا يمكن إلغاء طلب العمل المتوقف ، قم بإلغاء إيقافه أولاً للإلغاء
+DocType: Coupon Code,Coupon Code,رمز الكوبون
 DocType: Asset,Journal Entry for Scrap,قيد دفتر يومية للتخريد
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,يرجى سحب البنوود من اشعار التسليم
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},الصف {0}: حدد محطة العمل مقابل العملية {1}
@@ -5536,6 +5560,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&quot;التاريخ&quot; مطلوب
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},تاريخ الاستحقاق أو المرجع لا يمكن أن يكون بعد {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,استيراد وتصدير البيانات
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired",عفوًا ، انتهت صلاحية صلاحية رمز القسيمة
 DocType: Bank Account,Account Details,تفاصيل الحساب
 DocType: Crop,Materials Required,المواد المطلوبة
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,لم يتم العثور على أي طلاب
@@ -5573,6 +5598,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,انتقل إلى المستخدمين
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,المبلغ المدفوع + شطب المبلغ لا يمكن أن يكون أكبر من المجموع الكلي
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} ليس رقم الدفعة صالحة للصنف {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,الرجاء إدخال رمز القسيمة صالح!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},ملاحظة: لا يوجد رصيد إجازات كافي لنوع الإجازة {0}
 DocType: Task,Task Description,وصف المهمة
 DocType: Training Event,Seminar,ندوة
@@ -5836,6 +5862,7 @@
 ,TDS Payable Monthly,TDS مستحق الدفع شهريًا
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,في قائمة الانتظار لاستبدال BOM. قد يستغرق بضع دقائق.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"لا يمكن الخصم عندما تكون الفئة ""التقييم"" أو ""التقييم والإجمالي"""
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,يرجى إعداد نظام تسمية الموظفين في الموارد البشرية&gt; إعدادات الموارد البشرية
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,مجموع المدفوعات
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},مسلسل نص مطلوب لل مسلسل البند {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,مطابقة المدفوعات مع الفواتير
@@ -5925,6 +5952,7 @@
 DocType: Production Plan,Get Raw Materials For Production,الحصول على المواد الخام للإنتاج
 DocType: Job Opening,Job Title,المسمى الوظيفي
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,الدفع في المستقبل المرجع
+DocType: Quotation,Additional Discount and Coupon Code,خصم إضافي ورمز القسيمة
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.",{0} يشير إلى أن {1} لن يقدم اقتباس، ولكن يتم نقل جميع العناصر \ تم نقلها. تحديث حالة اقتباس الأسعار.
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,الحد الأقصى للعينات - {0} تم الاحتفاظ به مسبقا للدفعة {1} و العنصر {2} في الدفعة {3}.
@@ -6152,7 +6180,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,إعدادات موقعه الإلكتروني
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} معلق حتى {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},لا يسمح ب رفق ل {0} بسبب وضع بطاقة الأداء ل {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,جعل فاتورة شراء
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,مغادرات مستخدمة
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} القسيمة المستخدمة هي {1}. الكمية المسموح بها مستنفدة
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,هل ترغب في تقديم طلب المواد
 DocType: Job Offer,Awaiting Response,انتظار الرد
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6166,6 +6196,7 @@
 DocType: Training Event Employee,Optional,اختياري
 DocType: Salary Slip,Earning & Deduction,الكسب و الخصم
 DocType: Agriculture Analysis Criteria,Water Analysis,تحليل المياه
+DocType: Sales Order,Skip Delivery Note,تخطي ملاحظة التسليم
 DocType: Price List,Price Not UOM Dependent,السعر لا يعتمد على UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,تم إنشاء المتغيرات {0}.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,اتفاقية مستوى الخدمة الافتراضية موجودة بالفعل.
@@ -6270,6 +6301,7 @@
 DocType: Vehicle,Last Carbon Check,آخر تحقق للكربون
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,نفقات قانونية
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,يرجى تحديد الكمية على الصف
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},أمر العمل {0}: لم يتم العثور على بطاقة المهمة للعملية {1}
 DocType: Purchase Invoice,Posting Time,نشر التوقيت
 DocType: Timesheet,% Amount Billed,المبلغ٪ صفت
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,نفقات الهاتف
@@ -6372,7 +6404,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,أضيفت الضرائب والرسوم
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,صف الإهلاك {0}: لا يمكن أن يكون تاريخ الاستهلاك التالي قبل تاريخ المتاح للاستخدام
 ,Sales Funnel,قمع المبيعات
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,كود الصنف&gt; مجموعة الصنف&gt; العلامة التجارية
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,الاسم المختصر إلزامي
 DocType: Project,Task Progress,تقدم المهمة
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,عربة
@@ -6468,6 +6499,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,ملف نقطة البيع مطلوب للقيام بإدخال خاص بنقطة البيع
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",سيتم احتساب نقاط الولاء من المبالغ التي تم صرفها (عبر فاتورة المبيعات) ، بناءً على عامل الجمع المذكور.
 DocType: Program Enrollment Tool,Enroll Students,تسجيل الطلاب
+DocType: Pricing Rule,Coupon Code Based,كود الكوبون
 DocType: Company,HRA Settings,إعدادات HRA
 DocType: Homepage,Hero Section,قسم البطل
 DocType: Employee Transfer,Transfer Date,تاريخ التحويل
@@ -6583,6 +6615,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',الرجاء تعيين فلتر الشركة فارغا إذا كانت المجموعة بي هي &#39;كومباني&#39;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,تاريخ النشر لا يمكن أن يكون تاريخ مستقبلي
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},الصف # {0}: الرقم التسلسلي {1} لا يتطابق مع {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,يرجى إعداد سلسلة الترقيم للحضور عبر الإعداد&gt; سلسلة الترقيم
 DocType: Stock Entry,Target Warehouse Address,عنوان المستودع المستهدف
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,أجازة عادية
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,الوقت الذي يسبق وقت بدء التحول الذي يتم خلاله فحص تسجيل الموظف للحضور.
@@ -6617,7 +6650,6 @@
 DocType: Employee Grade,Employee Grade,درجة الموظف
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,الأجرة المدفوعة لكمية العمل المنجز
 DocType: GSTR 3B Report,June,يونيو
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,مورد&gt; نوع المورد
 DocType: Share Balance,From No,من رقم
 DocType: Shift Type,Early Exit Grace Period,الخروج المبكر فترة سماح
 DocType: Task,Actual Time (in Hours),الوقت الفعلي (بالساعات)
@@ -6904,7 +6936,6 @@
 DocType: Warehouse,Warehouse Name,اسم المستودع
 DocType: Naming Series,Select Transaction,حدد المعاملات
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,الرجاء إدخال صلاحية المخول بالتصديق أو المستخدم المخول بالتصديق
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},معامل تحويل UOM ({0} -&gt; {1}) غير موجود للعنصر: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,اتفاقية مستوى الخدمة مع نوع الكيان {0} والكيان {1} موجودة بالفعل.
 DocType: Journal Entry,Write Off Entry,شطب الدخول
 DocType: BOM,Rate Of Materials Based On,سعرالمواد استنادا على
@@ -7043,6 +7074,7 @@
 DocType: Budget,Warn,تحذير
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,جميع الإصناف تم نقلها لأمر العمل
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.",أي ملاحظات أخرى، وجهود جديرة بالذكر يجب أن تدون في السجلات.
+DocType: Bank Account,Company Account,حساب الشركة
 DocType: Asset Maintenance,Manufacturing User,مستخدم التصنيع
 DocType: Purchase Invoice,Raw Materials Supplied,المواد الخام الموردة
 DocType: Subscription Plan,Payment Plan,خطة الدفع
@@ -7084,6 +7116,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) لا يمكن أن يكون أكبر من الكمية المخطط لها ({2}) في أمر العمل {3}
 DocType: Certification Application,Name of Applicant,اسم صاحب الطلب
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,ورقة الوقت للتصنيع.
+DocType: Quick Stock Balance,Quick Stock Balance,رصيد سريع الأسهم
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,حاصل الجمع
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,لا يمكن تغيير خصائص المتغير بعد معاملة المخزون. سيكون عليك عمل عنصر جديد للقيام بذلك.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA التكليف
@@ -7410,6 +7443,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},الرجاء تعيين {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} طالب غير نشط
 DocType: Employee,Health Details,تفاصيل الحالة الصحية
+DocType: Coupon Code,Coupon Type,نوع الكوبون
 DocType: Leave Encashment,Encashable days,أيام قابلة للتهيئة
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,لإنشاء مستند مرجع طلب الدفع مطلوب
 DocType: Soil Texture,Sandy Clay,الصلصال الرملي
@@ -7693,6 +7727,7 @@
 DocType: Hotel Room Package,Amenities,وسائل الراحة
 DocType: Accounts Settings,Automatically Fetch Payment Terms,جلب شروط الدفع تلقائيًا
 DocType: QuickBooks Migrator,Undeposited Funds Account,حساب الأموال غير المدعومة
+DocType: Coupon Code,Uses,الاستخدامات
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,لا يسمح بوضع الدفع الافتراضي المتعدد
 DocType: Sales Invoice,Loyalty Points Redemption,نقاط الولاء الفداء
 ,Appointment Analytics,تحليلات الموعد
@@ -7709,6 +7744,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,الميزانية الإجمالية
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,اتركه فارغا إذا جعلت مجموعات الطلاب في السنة
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day",إذا تم، المشاركات لا. من أيام عمل وسوف تشمل أيام العطل، وهذا سوف يقلل من قيمة الراتب لكل يوم
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,فشل في اضافة النطاق
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.",للسماح بوصول الاستلام / التسليم ، قم بتحديث &quot;الإفراط في الاستلام / بدل التسليم&quot; في إعدادات المخزون أو العنصر.
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?",التطبيقات التي تستخدم المفتاح الحالي لن تتمكن من الدخول ، هل انت متأكد ؟
 DocType: Subscription Settings,Prorate,بنسبة كذا
@@ -7721,6 +7757,7 @@
 ,BOM Stock Report,تقرير الأسهم BOM
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group",إذا لم يكن هناك مهلة زمنية محددة ، فسيتم التعامل مع الاتصالات من قبل هذه المجموعة
 DocType: Stock Reconciliation Item,Quantity Difference,الكمية الفرق
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,مورد&gt; نوع المورد
 DocType: Opportunity Item,Basic Rate,قيم الأساسية
 DocType: GL Entry,Credit Amount,مبلغ دائن
 ,Electronic Invoice Register,تسجيل الفاتورة الإلكترونية
@@ -7974,6 +8011,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),الضرائب والرسوم مقطوعة (عملة الشركة)
 DocType: Item Group,General Settings,الإعدادات العامة
 DocType: Article,Article,مقالة - سلعة
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,الرجاء إدخال رمز القسيمة !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,(من عملة) و (إلى عملة) لا يمكن أن تكون نفسها
 DocType: Taxable Salary Slab,Percent Deduction,خصم في المئة
 DocType: GL Entry,To Rename,لإعادة تسمية
diff --git a/erpnext/translations/bg.csv b/erpnext/translations/bg.csv
index ab0fb60..9da1eb3 100644
--- a/erpnext/translations/bg.csv
+++ b/erpnext/translations/bg.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,МАТ-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Клиент - Контакти
 DocType: Shift Type,Enable Auto Attendance,Активиране на автоматично посещение
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,"Моля, въведете Склад и Дата"
 DocType: Lost Reason Detail,Opportunity Lost Reason,Възможност Изгубена причина
 DocType: Patient Appointment,Check availability,Провери наличността
 DocType: Retention Bonus,Bonus Payment Date,Бонус Дата на плащане
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Завършени работни поръчки
 DocType: Support Settings,Forum Posts,Форум Публикации
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Задачата е включена като основна задача. В случай, че има някакъв проблем при обработката във фонов режим, системата ще добави коментар за грешката в това Съгласуване на запасите и ще се върне към етапа на чернова."
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started",За съжаление валидността на кода на купона не е започнала
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Облагаема сума
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Вие не можете да добавяте или актуализация записи преди {0}
 DocType: Leave Policy,Leave Policy Details,Оставете подробности за правилата
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Консумативи
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,Клас
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Код на артикула&gt; Група артикули&gt; Марка
 DocType: Restaurant Table,No of Seats,Брой на седалките
 DocType: Sales Invoice,Overdue and Discounted,Просрочени и намалени
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Обаждането е прекъснато
@@ -506,6 +509,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Разстоянието между редовете за сумата с думи
 DocType: Vehicle,Additional Details,допълнителни детайли
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Не е зададено описание
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Извличане на артикули от склад
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Заявка за покупка.
 DocType: POS Closing Voucher Details,Collected Amount,Събрана сума
 DocType: Lab Test,Submitted Date,Изпратена дата
@@ -613,6 +617,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Уча
 ,Trial Balance (Simple),Пробен баланс (прост)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Активиране на отложения разход
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Приложен купонов код
 DocType: Asset,Next Depreciation Date,Следваща дата на амортизация
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Разходите за дейността според Служител
 DocType: Accounts Settings,Settings for Accounts,Настройки за сметки
@@ -848,8 +853,6 @@
 DocType: BOM,Work Order,Работна поръчка
 DocType: Sales Invoice,Total Qty,Общо Количество
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Идентификационен номер на
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Моля, изтрийте Служителя <a href=""#Form/Employee/{0}"">{0}</a> \, за да отмените този документ"
 DocType: Item,Show in Website (Variant),Покажи в уебсайта (вариант)
 DocType: Employee,Health Concerns,Здравни проблеми
 DocType: Payroll Entry,Select Payroll Period,Изберете ТРЗ Период
@@ -1013,6 +1016,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Сметка за удържане на данъци
 DocType: Pricing Rule,Sales Partner,Търговски партньор
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Всички оценъчни карти на доставчици.
+DocType: Coupon Code,To be used to get discount,Да се използва за получаване на отстъпка
 DocType: Buying Settings,Purchase Receipt Required,Покупка Квитанция Задължително
 DocType: Sales Invoice,Rail,релса
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Реална цена
@@ -1063,6 +1067,7 @@
 DocType: Production Plan,Production Plan,План за производство
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Отваряне на инструмента за създаване на фактури
 DocType: Salary Component,Round to the Nearest Integer,Завъртете до най-близкия цяло число
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,"Позволете артикулите, които не са на склад, да бъдат добавени в количката"
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Продажби - Връщане
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Задайте количество в транзакции въз основа на сериен № вход
 ,Total Stock Summary,Общо обобщение на наличностите
@@ -1192,6 +1197,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Базова цена на час (Валута на компанията)
 ,Qty To Be Billed,"Количество, за да бъдете таксувани"
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Доставени Сума
+DocType: Coupon Code,Gift Card,Карта за подарък
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,"Количество, запазено за производство: количество суровини за производство на производствени артикули."
 DocType: Loyalty Point Entry Redemption,Redemption Date,Дата на обратно изкупуване
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Тази банкова транзакция вече е напълно съгласувана
@@ -1279,6 +1285,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Създайте график
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Сметка {0} е била въведена на няколко пъти
 DocType: Account,Expenses Included In Valuation,"Разходи, включени в остойностяване"
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Фактури за покупка
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Можете да го подновите само ако вашето членство изтече в рамките на 30 дни
 DocType: Shopping Cart Settings,Show Stock Availability,Показване на наличностите в наличност
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Задайте {0} в категория активи {1} или фирма {2}
@@ -1818,6 +1825,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Импортиране на елементи и UOMs
 DocType: Repayment Schedule,Balance Loan Amount,Баланс на заема
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Добавени към подробности
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted",За съжаление кодът на талона е изчерпан
 DocType: Communication Medium,Catch All,Хванете всички
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,График на курса
 DocType: Budget,Applicable on Material Request,Приложимо за материално искане
@@ -1985,6 +1993,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Невалиден атрибут
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} трябва да бъде изпратено
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Кампании по имейл
+DocType: Sales Partner,To Track inbound purchase,За проследяване на входяща покупка
 DocType: Buying Settings,Default Supplier Group,Група доставчици по подразбиране
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Количеството трябва да бъде по-малко или равно на {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Максималната допустима сума за компонента {0} надвишава {1}
@@ -2140,8 +2149,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Направете запис на акции
 DocType: Hotel Room Reservation,Hotel Reservation User,Потребителски резервационен хотел
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Задаване на състояние
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,"Моля, настройте сериите за номериране на посещаемостта чрез Настройка&gt; Серия за номериране"
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Моля изберете префикс първо
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,"Моля, задайте Именуване на серия за {0} чрез Настройка&gt; Настройки&gt; Наименуване на серия"
 DocType: Contract,Fulfilment Deadline,Краен срок за изпълнение
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Близо до вас
 DocType: Student,O-,О-
@@ -2265,6 +2274,7 @@
 DocType: Quality Meeting Table,Under Review,В процес на преразглеждане
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Неуспешно влизане
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Актив {0} е създаден
+DocType: Coupon Code,Promotional,Промоционални
 DocType: Special Test Items,Special Test Items,Специални тестови елементи
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,"Трябва да сте потребител с роля на системния мениджър и мениджър на елементи, за да се регистрирате на Marketplace."
 apps/erpnext/erpnext/config/buying.py,Key Reports,Основни доклади
@@ -2302,6 +2312,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc Type
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Общо разпределят процентно за екип по продажбите трябва да бъде 100
 DocType: Subscription Plan,Billing Interval Count,Графичен интервал на фактуриране
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Моля, изтрийте Служителя <a href=""#Form/Employee/{0}"">{0}</a> \, за да отмените този документ"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Срещи и срещи с пациентите
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Стойността липсва
 DocType: Employee,Department and Grade,Департамент и степен
@@ -2404,6 +2416,7 @@
 DocType: Project,Start and End Dates,Начална и крайна дата
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Условия за изпълнение на Общите условия на договора
 ,Delivered Items To Be Billed,"Доставени изделия, които да се фактурират"
+DocType: Coupon Code,Maximum Use,Максимална употреба
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Open BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Складът не може да се променя за Serial No.
 DocType: Authorization Rule,Average Discount,Средна отстъпка
@@ -2565,6 +2578,7 @@
 DocType: Item,Inventory,Инвентаризация
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Изтеглете като Json
 DocType: Item,Sales Details,Продажби Детайли
+DocType: Coupon Code,Used,Използва се
 DocType: Opportunity,With Items,С артикули
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Кампанията &#39;{0}&#39; вече съществува за {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Екип за поддръжка
@@ -2694,7 +2708,7 @@
 						Serial No cannot be ensured",За актив {0} не е намерен активен ценови списък. Доставката чрез \ сериен номер не може да бъде осигурена
 DocType: Sales Partner,Sales Partner Target,Търговски партньор - Цел
 DocType: Loan Type,Maximum Loan Amount,Максимален Размер на заема
-DocType: Pricing Rule,Pricing Rule,Ценообразуване Правило
+DocType: Coupon Code,Pricing Rule,Ценообразуване Правило
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Дублиран номер на ролката за ученик {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Заявка за материал към поръчка за покупка
 DocType: Company,Default Selling Terms,Условия за продажба по подразбиране
@@ -2773,6 +2787,7 @@
 DocType: Payment Schedule,Payment Amount,Сума За Плащане
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Полудневният ден трябва да е между Работата от датата и датата на приключване на работата
 DocType: Healthcare Settings,Healthcare Service Items,Елементи на здравната служба
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Невалиден баркод. Към този баркод няма прикрепен артикул.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Консумирана Сума
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Нетна промяна в паричната наличност
 DocType: Assessment Plan,Grading Scale,Оценъчна скала
@@ -2892,7 +2907,6 @@
 DocType: Share Transfer,Asset Account,Активна сметка
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Нова дата на издаване трябва да бъде в бъдеще
 DocType: Purchase Invoice,End date of current invoice's period,Крайна дата на периода на текущата фактура за
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Моля, настройте системата за именуване на служители в Човешки ресурси&gt; Настройки за човешки ресурси"
 DocType: Lab Test,Technician Name,Име на техник
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3003,6 +3017,7 @@
 DocType: Products Settings,Hide Variants,Скриване на варианти
 DocType: Lead,Next Contact By,Следваща Контакт с
 DocType: Compensatory Leave Request,Compensatory Leave Request,Искане за компенсаторно напускане
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Не може да се таксува за елемент {0} в ред {1} повече от {2}. За да разрешите надплащането, моля, задайте квота в Настройки на акаунти"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},"Количество, необходимо за елемент {0} на ред {1}"
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},"Склад {0} не може да се изтрие, тъй като съществува количество за артикул {1}"
 DocType: Blanket Order,Order Type,Тип поръчка
@@ -3172,7 +3187,6 @@
 DocType: Student,Student Mobile Number,Student мобилен номер
 DocType: Item,Has Variants,Има варианти
 DocType: Employee Benefit Claim,Claim Benefit For,Възползвайте се от обезщетението за
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Не може да надхвърля стойността {0} на ред {1} повече от {2}. За да позволите прекалено таксуване, моля, задайте настройките за запас"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Актуализиране на отговора
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Вие вече сте избрали елементи от {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Име на месец Дистрибуцията
@@ -3462,6 +3476,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,"Моля, посочете валута във фирмата"
 DocType: Workstation,Wages per hour,Заплати на час
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Конфигурирайте {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Клиент&gt; Клиентска група&gt; Територия
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Склад за баланс в Batch {0} ще стане отрицателна {1} за позиция {2} в склада {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,След Материал Исканията са повдигнати автоматично въз основа на нивото на повторна поръчка Точка на
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Сметка {0} е невалидна. Валутата на сметката трябва да е {1}
@@ -3791,6 +3806,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Знаете Заплата Slip
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,На изчакване
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,А ргенирането трябва да има поне една правилна опция
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Поръчки за покупка
 DocType: Account,Inter Company Account,Вътрешна фирмена сметка
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Масов импорт
 DocType: Sales Partner,Address & Contacts,Адрес и контакти
@@ -3801,6 +3817,7 @@
 DocType: POS Profile,[Select],[Избор]
 DocType: Staffing Plan Detail,Number Of Positions,Брой позиции
 DocType: Vital Signs,Blood Pressure (diastolic),Кръвно налягане (диастолично)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,"Моля, изберете клиента."
 DocType: SMS Log,Sent To,Изпратени На
 DocType: Agriculture Task,Holiday Management,Управление на ваканциите
 DocType: Payment Request,Make Sales Invoice,Направи фактурата за продажба
@@ -4010,7 +4027,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} не е изпратена
 DocType: Subscription,Trialling,изпробване
 DocType: Sales Invoice Item,Deferred Revenue,Отсрочени приходи
-DocType: Bank Account,GL Account,GL акаунт
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Парична сметка ще се използва за създаване на фактура за продажба
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Освобождаване от подкатегорията
 DocType: Member,Membership Expiry Date,Дата на изтичане на членството
@@ -4414,13 +4430,13 @@
 DocType: C-Form Invoice Detail,Territory,Територия
 DocType: Pricing Rule,Apply Rule On Item Code,Приложете правило за кода на артикула
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,"Моля, не споменете на посещенията, изисквани"
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Доклад за баланса на акциите
 DocType: Stock Settings,Default Valuation Method,Метод на оценка по подразбиране
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Такса
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Показване на кумулативната сума
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Актуализираното актуализиране. Може да отнеме известно време.
 DocType: Production Plan Item,Produced Qty,Произведен брой
 DocType: Vehicle Log,Fuel Qty,Количество на горивото
-DocType: Stock Entry,Target Warehouse Name,Име на целевия склад
 DocType: Work Order Operation,Planned Start Time,Планиран начален час
 DocType: Course,Assessment,Оценяване
 DocType: Payment Entry Reference,Allocated,Разпределен
@@ -4486,10 +4502,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","Стандартни условия, които могат да бъдат добавени към Продажби и покупки. Примери: 1. Валидност на офертата. 1. Условия на плащане (авансово, на кредит, част аванс и т.н.). 1. Какво е допълнително (или платими от клиента). Предупреждение / използване 1. безопасност. 1. Гаранция ако има такива. 1. Връща политика. 1. Условия за корабоплаването, ако е приложимо. 1. начини за разрешаване на спорове, обезщетение, отговорност и др 1. Адрес и контакти на вашата компания."
 DocType: Homepage Section,Section Based On,Раздел Въз основа на
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Показване на прилагане на кода на купона
 DocType: Issue,Issue Type,Тип на издаване
 DocType: Attendance,Leave Type,Тип отсъствие
 DocType: Purchase Invoice,Supplier Invoice Details,Доставчик Данни за фактурата
 DocType: Agriculture Task,Ignore holidays,Пренебрегвайте празниците
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Добавяне / редактиране на условия за талони
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Expense / Разлика сметка ({0}) трябва да бъде партида на &quot;печалбата или загубата&quot;
 DocType: Stock Entry Detail,Stock Entry Child,Дете за влизане в акции
 DocType: Project,Copied From,Копирано от
@@ -4664,6 +4682,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,План за оценка Критерии
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Сделки
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Предотвратяване на поръчки за покупка
+DocType: Coupon Code,Coupon Name,Име на талон
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Податлив
 DocType: Email Campaign,Scheduled,Планиран
 DocType: Shift Type,Working Hours Calculation Based On,Изчисляване на работното време въз основа на
@@ -4680,7 +4699,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Създаване на варианти
 DocType: Vehicle,Diesel,дизел
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Не е избрана валута на ценоразписа
+DocType: Quick Stock Balance,Available Quantity,Налично количество
 DocType: Purchase Invoice,Availed ITC Cess,Наблюдаваше ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,"Моля, настройте системата за именуване на инструктори в Образование&gt; Настройки за образование"
 ,Student Monthly Attendance Sheet,Student Месечен Присъствие Sheet
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,"Правило за доставка, приложимо само за продажбата"
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Амортизационен ред {0}: Следващата дата на амортизация не може да бъде преди датата на закупуване
@@ -4747,8 +4768,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Row {0}: Advance срещу Клиентът трябва да бъде кредити
 DocType: Quality Meeting,Quality Meeting,Качествена среща
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-група на група
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,"Моля, задайте Именуване на серия за {0} чрез Настройка&gt; Настройки&gt; Наименуване на серия"
 DocType: Employee,ERPNext User,ERPПреводен потребител
+DocType: Coupon Code,Coupon Description,Описание на талона
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Партида е задължителна на ред {0}
 DocType: Company,Default Buying Terms,Условия за покупка по подразбиране
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Покупка Квитанция приложените аксесоари
@@ -4911,6 +4932,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Against Document Detail No
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Изтриването не е разрешено за държава {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Тип Компания е задължително
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Приложете купонния код
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",За работна карта {0} можете да направите само запис на запасите от типа „Прехвърляне на материали за производство“
 DocType: Quality Inspection,Outgoing,Изходящ
 DocType: Customer Feedback Table,Customer Feedback Table,Таблица за обратна връзка на клиентите
@@ -5060,7 +5082,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,При подаване на поръчка
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Добавете всички доставчици
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Ред # {0}: Разпределената сума не може да бъде по-голяма от остатъка.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Клиент&gt; Клиентска група&gt; Територия
 DocType: Tally Migration,Parties,страни
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Разгледай BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Обезпечени кредити
@@ -5092,7 +5113,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Не позволявайте да зададете алтернативен елемент за елемента {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Датата се повтаря
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Оторизиран подпис
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,"Моля, настройте системата за именуване на инструктори в Образование&gt; Настройки за образование"
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Наличен нетен ITC (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Създаване на такси
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Общата покупна цена на придобиване (чрез покупка на фактура)
@@ -5117,6 +5137,7 @@
 DocType: Quiz Result,Wrong,погрешно
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Скоростта, с която Ценоразпис валута се превръща в основна валута на клиента"
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Нетната сума (фирмена валута)
+DocType: Sales Partner,Referral Code,Референтен код
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Общият размер на авансовото плащане не може да бъде по-голям от общия размер на санкцията
 DocType: Salary Slip,Hour Rate,Цена на час
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Активиране на автоматичната повторна поръчка
@@ -5245,6 +5266,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Показване на наличностите
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Нетни парични средства от Текуща дейност
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Ред № {0}: Състоянието трябва да бъде {1} за отстъпка от фактури {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Коефициент на конверсия на UOM ({0} -&gt; {1}) не е намерен за артикул: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Позиция 4
 DocType: Student Admission,Admission End Date,Прием - Крайна дата
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Подизпълнители
@@ -5267,6 +5289,7 @@
 DocType: Travel Request,Fully Sponsored,Напълно спонсориран
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Вписване на обратния дневник
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Създайте Job Card
+DocType: Quotation,Referral Sales Partner,Референтен партньор за продажби
 DocType: Quality Procedure Process,Process Description,Описание на процеса
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Клиент {0} е създаден.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Понастоящем няма налични запаси в нито един склад
@@ -5401,6 +5424,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM Курс
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Четене на качен файл
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Спиралата поръчка за работа не може да бъде отменена, първо я отменете, за да я отмените"
+DocType: Coupon Code,Coupon Code,Код на талона
 DocType: Asset,Journal Entry for Scrap,Вестник Влизане за скрап
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,"Моля, дръпнете елементи от Delivery Note"
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Ред {0}: изберете работната станция срещу операцията {1}
@@ -5483,6 +5507,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,Изисква се „Дата“
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Поради / Референтен дата не може да бъде след {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Внос и експорт на данни
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired",За съжаление валидността на кода на купона е изтекла
 DocType: Bank Account,Account Details,Детайли на сметка
 DocType: Crop,Materials Required,Необходими материали
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Няма намерени студенти
@@ -5520,6 +5545,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Отидете на Потребители
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Платената сума + отписана сума не може да бъде по-голяма от обща сума
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} не е валиден Партиден номер за Артикул {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,"Моля, въведете валиден код на купона !!"
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Забележка: Няма достатъчно отпуск баланс за отпуск Тип {0}
 DocType: Task,Task Description,Описание на задачата
 DocType: Training Event,Seminar,семинар
@@ -5783,6 +5809,7 @@
 ,TDS Payable Monthly,Такса за плащане по месеци
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Зареден за замяна на BOM. Това може да отнеме няколко минути.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Не може да се приспадне при категория е за &quot;оценка&quot; или &quot;Оценка и Total&quot;
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Моля, настройте системата за именуване на служители в Човешки ресурси&gt; Настройки за човешки ресурси"
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Общи плащания
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},"Серийни номера, изисквано за серийни номера, т {0}"
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Краен Плащания с фактури
@@ -5872,6 +5899,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Вземи суровини за производство
 DocType: Job Opening,Job Title,Длъжност
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Бъдещо плащане Реф
+DocType: Quotation,Additional Discount and Coupon Code,Допълнителен код за отстъпка и купон
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} показва, че {1} няма да предостави котировка, но са цитирани всички елементи \. Актуализиране на състоянието на котировката на RFQ."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Максималните проби - {0} вече са запазени за партида {1} и елемент {2} в партида {3}.
@@ -6099,7 +6127,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Настройки за уебсайт страница
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} е задържан до {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},Не са разрешени RFQ за {0} поради наличието на {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Направи фактурата за покупка
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Използвани листа
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Използваните талони са {1}. Позволеното количество се изчерпва
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Искате ли да изпратите материалната заявка
 DocType: Job Offer,Awaiting Response,Очаква отговор
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6113,6 +6143,7 @@
 DocType: Training Event Employee,Optional,по избор
 DocType: Salary Slip,Earning & Deduction,Приходи & Удръжки
 DocType: Agriculture Analysis Criteria,Water Analysis,Воден анализ
+DocType: Sales Order,Skip Delivery Note,Пропуснете бележка за доставка
 DocType: Price List,Price Not UOM Dependent,Цена не зависи от UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} вариантите са създадени.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Споразумение за ниво на услуга по подразбиране вече съществува.
@@ -6217,6 +6248,7 @@
 DocType: Vehicle,Last Carbon Check,Последна проверка на въглерода
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Правни разноски
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,"Моля, изберете количество на ред"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Работна поръчка {0}: работна карта не е намерена за операцията {1}
 DocType: Purchase Invoice,Posting Time,Време на осчетоводяване
 DocType: Timesheet,% Amount Billed,% Фактурирана сума
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Разходите за телефония
@@ -6319,7 +6351,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Данъци и такси - Добавени
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,"Амортизационен ред {0}: Следващата дата на амортизация не може да бъде преди датата, която е налице за използване"
 ,Sales Funnel,Фуния на продажбите
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Код на артикула&gt; Група артикули&gt; Марка
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Съкращението е задължително
 DocType: Project,Task Progress,Задача Прогрес
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Количка
@@ -6414,6 +6445,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS профил изисква да направи POS Влизане
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Точките на лоялност ще се изчисляват от направеното направено (чрез фактурата за продажби), въз основа на посочения коефициент на събираемост."
 DocType: Program Enrollment Tool,Enroll Students,Прием на студенти
+DocType: Pricing Rule,Coupon Code Based,На базата на кода на купона
 DocType: Company,HRA Settings,HRA Настройки
 DocType: Homepage,Hero Section,Раздел Герой
 DocType: Employee Transfer,Transfer Date,Дата на прехвърляне
@@ -6529,6 +6561,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',"Моля, поставете фирмения филтър празен, ако Group By е &quot;Company&quot;"
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Публикуване Дата не може да бъде бъдеща дата
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: Пореден № {1} не съвпада с {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,"Моля, настройте номерацията на сериите за посещаемост чрез Настройка&gt; Серия за номериране"
 DocType: Stock Entry,Target Warehouse Address,Адрес на целевия склад
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Регулярен отпуск
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,"Времето преди началния час на смяната, през който се приема за напускане на служителите за присъствие."
@@ -6563,7 +6596,6 @@
 DocType: Employee Grade,Employee Grade,Степен на заетост
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Работа заплащана на парче
 DocType: GSTR 3B Report,June,юни
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Доставчик&gt; Тип доставчик
 DocType: Share Balance,From No,От №
 DocType: Shift Type,Early Exit Grace Period,Период за ранно излизане от грация
 DocType: Task,Actual Time (in Hours),Действителното време (в часове)
@@ -6848,7 +6880,6 @@
 DocType: Warehouse,Warehouse Name,Склад - Име
 DocType: Naming Series,Select Transaction,Изберете транзакция
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,"Моля, въведете Приемане Role или одобряването на потребителя"
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Коефициент на конверсия на UOM ({0} -&gt; {1}) не е намерен за елемент: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Споразумение за ниво на услуга с тип субект {0} и субект {1} вече съществува.
 DocType: Journal Entry,Write Off Entry,Въвеждане на отписване
 DocType: BOM,Rate Of Materials Based On,Курсове на материали на основата на
@@ -6986,6 +7017,7 @@
 DocType: Budget,Warn,Предупреждавай
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Всички елементи вече са прехвърлени за тази поръчка.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Всякакви други забележки, отбелязване на усилието, които трябва да отиде в регистрите."
+DocType: Bank Account,Company Account,Фирмена сметка
 DocType: Asset Maintenance,Manufacturing User,Потребител - производство
 DocType: Purchase Invoice,Raw Materials Supplied,Суровини - доставени
 DocType: Subscription Plan,Payment Plan,Платежен план
@@ -7027,6 +7059,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) не може да бъде по-голямо от планираното количество ({2}) в работната поръчка {3}
 DocType: Certification Application,Name of Applicant,Име на кандидата
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Time Sheet за производство.
+DocType: Quick Stock Balance,Quick Stock Balance,Бърз баланс на запасите
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Междинна сума
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,"Не може да се променят свойствата на Variant след транзакция с акции. Ще трябва да направите нова позиция, за да направите това."
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA мандат
@@ -7353,6 +7386,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},"Моля, задайте {0}"
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} е неактивен студент
 DocType: Employee,Health Details,Здравни Детайли
+DocType: Coupon Code,Coupon Type,Тип купон
 DocType: Leave Encashment,Encashable days,Дни за включване
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,"За да създадете референтен документ за искане за плащане, се изисква"
 DocType: Soil Texture,Sandy Clay,Санди Клей
@@ -7635,6 +7669,7 @@
 DocType: Hotel Room Package,Amenities,Удобства
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Автоматично извличане на условията за плащане
 DocType: QuickBooks Migrator,Undeposited Funds Account,Сметка за неплатени средства
+DocType: Coupon Code,Uses,употреби
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Не е разрешен няколко начина на плащане по подразбиране
 DocType: Sales Invoice,Loyalty Points Redemption,Изплащане на точки за лоялност
 ,Appointment Analytics,Анализ за назначаване
@@ -7651,6 +7686,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Общ бюджет
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Оставете празно, ако правите групи ученици на година"
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Ако е избрано, Total не. на работните дни ще включва празници, а това ще доведе до намаляване на стойността на Заплата на ден"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Неуспешно добавяне на домейн
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","За да разрешите свръх получаване / доставка, актуализирайте &quot;Над получаване / Позволение за доставка&quot; в Настройки на запасите или артикула."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Приложенията, използващи текущия ключ, няма да имат достъп, вярно ли е?"
 DocType: Subscription Settings,Prorate,разпределям пропорционално
@@ -7663,6 +7699,7 @@
 ,BOM Stock Report,BOM Доклад за наличност
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Ако няма определен времеви интервал, комуникацията ще се обработва от тази група"
 DocType: Stock Reconciliation Item,Quantity Difference,Количествена разлика
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Доставчик&gt; Тип доставчик
 DocType: Opportunity Item,Basic Rate,Основен курс
 DocType: GL Entry,Credit Amount,Кредитна сметка
 ,Electronic Invoice Register,Регистър на електронни фактури
@@ -7916,6 +7953,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Данъци и такси - Удръжки (фирмена валута)
 DocType: Item Group,General Settings,Основни настройки
 DocType: Article,Article,статия
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,"Моля, въведете кода на купона !!"
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,От Валута и да валути не могат да бъдат едни и същи
 DocType: Taxable Salary Slab,Percent Deduction,Процентно отчисление
 DocType: GL Entry,To Rename,За преименуване
diff --git a/erpnext/translations/bn.csv b/erpnext/translations/bn.csv
index 31be0b4..67ef377 100644
--- a/erpnext/translations/bn.csv
+++ b/erpnext/translations/bn.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,Mat-মোর্চা-.YYYY.-
 DocType: Purchase Order,Customer Contact,গ্রাহকের পরিচিতি
 DocType: Shift Type,Enable Auto Attendance,স্বয়ংক্রিয় উপস্থিতি সক্ষম করুন
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,গুদাম এবং তারিখ প্রবেশ করুন
 DocType: Lost Reason Detail,Opportunity Lost Reason,সুযোগ হারানো কারণ
 DocType: Patient Appointment,Check availability,গ্রহণযোগ্যতা যাচাই
 DocType: Retention Bonus,Bonus Payment Date,বোনাস প্রদানের তারিখ
@@ -263,6 +264,7 @@
 ,Completed Work Orders,সম্পন্ন কাজ আদেশ
 DocType: Support Settings,Forum Posts,ফোরাম পোস্ট
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage",কাজটি পটভূমির কাজ হিসাবে সজ্জিত করা হয়েছে। ব্যাকগ্রাউন্ডে প্রক্রিয়াজাতকরণের ক্ষেত্রে যদি কোনও সমস্যা থাকে তবে সিস্টেমটি এই স্টক পুনর্মিলন সংক্রান্ত ত্রুটি সম্পর্কে একটি মন্তব্য যুক্ত করবে এবং খসড়া পর্যায়ে ফিরে যাবে vert
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","দুঃখিত, কুপন কোডের বৈধতা শুরু হয়নি"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,করযোগ্য অর্থ
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},আপনি আগে এন্ট্রি যোগ করতে অথবা আপডেট করার জন্য অনুমতিপ্রাপ্ত নন {0}
 DocType: Leave Policy,Leave Policy Details,শর্তাবলী |
@@ -327,6 +329,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Consumable
 DocType: Student,B-,বি-
 DocType: Assessment Result,Grade,শ্রেণী
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,আইটেম কোড&gt; আইটেম গ্রুপ&gt; ব্র্যান্ড
 DocType: Restaurant Table,No of Seats,আসন সংখ্যা নেই
 DocType: Sales Invoice,Overdue and Discounted,অতিরিক্ত ও ছাড়যুক্ত
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,কল সংযোগ বিচ্ছিন্ন
@@ -503,6 +506,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,কথায় পরিমাণ জন্য রেখার মধ্যবর্তী স্থান
 DocType: Vehicle,Additional Details,অতিরিক্ত তথ্য
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,দেওয়া কোন বিবরণ
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,গুদাম থেকে আইটেম আনুন
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,কেনার জন্য অনুরোধ জানান.
 DocType: POS Closing Voucher Details,Collected Amount,সংগৃহীত পরিমাণ
 DocType: Lab Test,Submitted Date,জমা দেওয়া তারিখ
@@ -609,6 +613,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,শেখা
 ,Trial Balance (Simple),পরীক্ষার ভারসাম্য (সহজ)
 DocType: Purchase Invoice Item,Enable Deferred Expense,বিলম্বিত ব্যয় সক্রিয় করুন
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,প্রয়োগকৃত কুপন কোড
 DocType: Asset,Next Depreciation Date,পরবর্তী অবচয় তারিখ
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,কর্মচারী প্রতি কার্যকলাপ খরচ
 DocType: Accounts Settings,Settings for Accounts,অ্যাকাউন্ট এর জন্য সেটিং
@@ -839,8 +844,6 @@
 DocType: BOM,Work Order,কাজের আদেশ
 DocType: Sales Invoice,Total Qty,মোট Qty
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 ইমেইল আইডি
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","এই নথিটি বাতিল করতে দয়া করে কর্মচারী <a href=""#Form/Employee/{0}"">{0}</a> delete মুছুন"
 DocType: Item,Show in Website (Variant),ওয়েবসাইট দেখান (বৈকল্পিক)
 DocType: Employee,Health Concerns,স্বাস্থ সচেতন
 DocType: Payroll Entry,Select Payroll Period,বেতনের সময়কাল নির্বাচন
@@ -1001,6 +1004,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,কর আটকানোর অ্যাকাউন্ট
 DocType: Pricing Rule,Sales Partner,বিক্রয় অংশীদার
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,সমস্ত সরবরাহকারী স্কোরকার্ড
+DocType: Coupon Code,To be used to get discount,ছাড় পেতে ব্যবহার করা
 DocType: Buying Settings,Purchase Receipt Required,কেনার রসিদ প্রয়োজনীয়
 DocType: Sales Invoice,Rail,রেল
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,প্রকৃত দাম
@@ -1049,6 +1053,7 @@
 DocType: Production Plan,Production Plan,উৎপাদন পরিকল্পনা
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,ইনভয়েস ক্রিয়েশন টুল খুলছে
 DocType: Salary Component,Round to the Nearest Integer,নিকটতম পূর্ণসংখ্যার রাউন্ড
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,স্টকে থাকা আইটেমগুলিকে কার্টে যুক্ত করার অনুমতি দিন
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,সেলস প্রত্যাবর্তন
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,সিরিয়াল কোন ইনপুটের উপর ভিত্তি করে লেনদেনের পরিমাণ নির্ধারণ করুন
 ,Total Stock Summary,মোট শেয়ার সারাংশ
@@ -1175,6 +1180,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),বেজ কেয়ামত হার (কোম্পানির মুদ্রা)
 ,Qty To Be Billed,কিটি টু বি বিল!
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,বিতরিত পরিমাণ
+DocType: Coupon Code,Gift Card,উপহার কার্ড
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,উত্পাদনের জন্য সংরক্ষিত পরিমাণ: উত্পাদন আইটেমগুলি তৈরির কাঁচামাল পরিমাণ।
 DocType: Loyalty Point Entry Redemption,Redemption Date,রিডমপশন তারিখ
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,এই ব্যাংকের লেনদেন ইতিমধ্যে সম্পূর্ণরূপে মিলিত হয়েছে
@@ -1262,6 +1268,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,টাইমসীট তৈরি করুন
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,অ্যাকাউন্ট {0} একাধিক বার প্রবেশ করানো হয়েছে
 DocType: Account,Expenses Included In Valuation,খরচ মূল্যনির্ধারণ অন্তর্ভুক্ত
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,চালান চালান
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,আপনার সদস্যপদ 30 দিনের মধ্যে মেয়াদ শেষ হয়ে গেলে আপনি শুধুমাত্র নবায়ন করতে পারেন
 DocType: Shopping Cart Settings,Show Stock Availability,স্টক প্রাপ্যতা দেখান
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},সম্পদ বিভাগ {1} বা কোম্পানী {0} সেট করুন {2}
@@ -1799,6 +1806,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,আইটেম এবং ইউওএম আমদানি করা হচ্ছে
 DocType: Repayment Schedule,Balance Loan Amount,ব্যালেন্স ঋণের পরিমাণ
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,বিস্তারিত যোগ করা হয়েছে
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","দুঃখিত, কুপন কোডটি নিঃশেষ হয়ে গেছে"
 DocType: Communication Medium,Catch All,সমস্ত ধরুন
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,সূচি কোর্স
 DocType: Budget,Applicable on Material Request,উপাদান অনুরোধ প্রযোজ্য
@@ -1966,6 +1974,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,অবৈধ অ্যাট্রিবিউট
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} দাখিল করতে হবে
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,ইমেল প্রচারণা
+DocType: Sales Partner,To Track inbound purchase,অন্তর্মুখী ক্রয় ট্র্যাক করতে
 DocType: Buying Settings,Default Supplier Group,ডিফল্ট সরবরাহকারী গ্রুপ
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},পরিমাণ থেকে কম বা সমান হতে হবে {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},{0} উপাত্তের জন্য সর্বোচ্চ পরিমাণ {1} অতিক্রম করে
@@ -2119,7 +2128,6 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,স্টক এন্ট্রি করুন
 DocType: Hotel Room Reservation,Hotel Reservation User,হোটেল রিজার্ভেশন ইউজার
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,স্থিতি সেট করুন
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,দয়া করে সেটআপ&gt; নম্বরিং সিরিজের মাধ্যমে উপস্থিতির জন্য সংখ্যায়ন সিরিজটি সেট করুন
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,প্রথম উপসর্গ নির্বাচন করুন
 DocType: Contract,Fulfilment Deadline,পূরণের সময়সীমা
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,আপনার কাছাকাছি
@@ -2243,6 +2251,7 @@
 DocType: Quality Meeting Table,Under Review,পর্যালোচনা অধীনে
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,লগ ইনে ব্যর্থ
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,সম্পদ {0} তৈরি করা হয়েছে
+DocType: Coupon Code,Promotional,প্রোমোশনাল
 DocType: Special Test Items,Special Test Items,বিশেষ টেস্ট আইটেম
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,মার্কেটপ্লেসে রেজিস্টার করার জন্য আপনাকে সিস্টেম ম্যানেজার এবং আইটেম ম্যানেজার ভূমিকার সাথে একজন ব্যবহারকারী হওয়া প্রয়োজন।
 apps/erpnext/erpnext/config/buying.py,Key Reports,কী রিপোর্ট
@@ -2280,6 +2289,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,ডক ধরন
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,সেলস টিম জন্য মোট বরাদ্দ শতাংশ 100 হওয়া উচিত
 DocType: Subscription Plan,Billing Interval Count,বিলিং বিরতি গণনা
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","এই নথিটি বাতিল করতে দয়া করে কর্মচারী <a href=""#Form/Employee/{0}"">{0}</a> delete মুছুন"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,নিয়োগ এবং রোগীর এনকাউন্টার
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,মূল্য অনুপস্থিত
 DocType: Employee,Department and Grade,বিভাগ এবং গ্রেড
@@ -2379,6 +2390,7 @@
 DocType: Project,Start and End Dates,শুরু এবং তারিখগুলি End
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,চুক্তি টেমপ্লেট পূরণের শর্তাবলী
 ,Delivered Items To Be Billed,বিতরণ আইটেম বিল তৈরি করা
+DocType: Coupon Code,Maximum Use,সর্বাধিক ব্যবহার
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},ওপেন BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,ওয়ারহাউস সিরিয়াল নং জন্য পরিবর্তন করা যাবে না
 DocType: Authorization Rule,Average Discount,গড় মূল্য ছাড়ের
@@ -2538,6 +2550,7 @@
 DocType: Item,Inventory,জায়
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,জসন হিসাবে ডাউনলোড করুন
 DocType: Item,Sales Details,বিক্রয় বিবরণ
+DocType: Coupon Code,Used,ব্যবহৃত
 DocType: Opportunity,With Items,জানানোর সঙ্গে
 DocType: Asset Maintenance,Maintenance Team,রক্ষণাবেক্ষণ দল
 DocType: Homepage Section,"Order in which sections should appear. 0 is first, 1 is second and so on.","বিভাগে উপস্থিত হওয়া উচিত অর্ডার। 0 প্রথম হয়, 1 দ্বিতীয় হয় এবং আরও।"
@@ -2664,7 +2677,7 @@
 						Serial No cannot be ensured",আইটেমের জন্য কোনও সক্রিয় BOM পাওয়া যায়নি {0}। \ Serial No দ্বারা ডেলিভারি নিশ্চিত করা যাবে না
 DocType: Sales Partner,Sales Partner Target,বিক্রয় অংশীদার উদ্দিষ্ট
 DocType: Loan Type,Maximum Loan Amount,সর্বোচ্চ ঋণের পরিমাণ
-DocType: Pricing Rule,Pricing Rule,প্রাইসিং রুল
+DocType: Coupon Code,Pricing Rule,প্রাইসিং রুল
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},শিক্ষার্থীর জন্য ডুপ্লিকেট রোল নম্বর {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,আদেশ ক্রয় উপাদানের জন্য অনুরোধ
 DocType: Company,Default Selling Terms,ডিফল্ট বিক্রয় শর্তাদি
@@ -2741,6 +2754,7 @@
 DocType: Payment Schedule,Payment Amount,পরিশোধিত অর্থ
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,কাজের তারিখ এবং কাজের শেষ তারিখের মধ্যে অর্ধ দিবসের তারিখ হওয়া উচিত
 DocType: Healthcare Settings,Healthcare Service Items,স্বাস্থ্যসেবা সেবা আইটেম
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,অবৈধ বারকোড। এই বারকোডের সাথে কোনও আইটেম সংযুক্ত নেই।
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,ক্ষয়প্রাপ্ত পরিমাণ
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,ক্যাশ মধ্যে নিট পরিবর্তন
 DocType: Assessment Plan,Grading Scale,শূন্য স্কেল
@@ -2858,7 +2872,6 @@
 DocType: Share Transfer,Asset Account,সম্পদ অ্যাকাউন্ট
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,নতুন প্রকাশের তারিখটি ভবিষ্যতে হওয়া উচিত
 DocType: Purchase Invoice,End date of current invoice's period,বর্তমান চালান এর সময়ের শেষ তারিখ
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,মানব সম্পদ&gt; এইচআর সেটিংসে কর্মচারী নামকরণ সিস্টেম সেটআপ করুন
 DocType: Lab Test,Technician Name,প্রযুক্তিবিদ নাম
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3135,7 +3148,6 @@
 DocType: Student,Student Mobile Number,শিক্ষার্থীর মোবাইল নম্বর
 DocType: Item,Has Variants,ধরন আছে
 DocType: Employee Benefit Claim,Claim Benefit For,জন্য বেনিফিট দাবি
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","{2} এর চেয়ে বেশি {1} সারিতে আইটেম {0} জন্য ওভারব্রিল করা যাবে না। ওভার-বিলিং করার অনুমতি দেওয়ার জন্য, স্টক সেটিংসে সেট করুন"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,প্রতিক্রিয়া আপডেট করুন
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},আপনি ইতিমধ্যে থেকে আইটেম নির্বাচন করা আছে {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,মাসিক বন্টন নাম
@@ -3420,6 +3432,7 @@
 DocType: Vehicle,Fuel Type,জ্বালানীর ধরণ
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,কোম্পানি মুদ্রা উল্লেখ করুন
 DocType: Workstation,Wages per hour,প্রতি ঘন্টায় মজুরী
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,গ্রাহক&gt; গ্রাহক গোষ্ঠী&gt; অঞ্চল
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},ব্যাচ স্টক ব্যালেন্স {0} হয়ে যাবে ঋণাত্মক {1} ওয়্যারহাউস এ আইটেম {2} জন্য {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,উপাদান অনুরোধ নিম্নলিখিত আইটেম এর পুনরায় আদেশ স্তরের উপর ভিত্তি করে স্বয়ংক্রিয়ভাবে উত্থাপিত হয়েছে
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},অ্যাকাউন্ট {0} অবৈধ. অ্যাকাউন্টের মুদ্রা হতে হবে {1}
@@ -3749,6 +3762,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,বেতন স্লিপ জমা
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,স্হগিত
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,একটি দণ্ডে কমপক্ষে একটি সঠিক বিকল্প থাকতে হবে
+apps/erpnext/erpnext/hooks.py,Purchase Orders,ক্রয় আদেশ
 DocType: Account,Inter Company Account,ইন্টার কোম্পানি অ্যাকাউন্ট
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,বাল্ক মধ্যে আমদানি
 DocType: Sales Partner,Address & Contacts,ঠিকানা ও যোগাযোগ
@@ -3759,6 +3773,7 @@
 DocType: POS Profile,[Select],[নির্বাচন]
 DocType: Staffing Plan Detail,Number Of Positions,অবস্থানের সংখ্যা
 DocType: Vital Signs,Blood Pressure (diastolic),রক্তচাপ (ডায়স্টোলিক)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,দয়া করে গ্রাহক নির্বাচন করুন।
 DocType: SMS Log,Sent To,প্রেরিত
 DocType: Agriculture Task,Holiday Management,হলিডে ম্যানেজমেন্ট
 DocType: Payment Request,Make Sales Invoice,বিক্রয় চালান করুন
@@ -3965,7 +3980,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} দাখিল করা হয় না
 DocType: Subscription,Trialling,trialling
 DocType: Sales Invoice Item,Deferred Revenue,বিলম্বিত রাজস্ব
-DocType: Bank Account,GL Account,জিএল অ্যাকাউন্ট
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,ক্যাশ অ্যাকাউন্ট সেলস ইনভয়েস নির্মাণের জন্য ব্যবহার করা হবে
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,অব্যাহতি উপ বিভাগ
 DocType: Member,Membership Expiry Date,সদস্যপদ মেয়াদ শেষের তারিখ
@@ -4364,13 +4378,13 @@
 DocType: C-Form Invoice Detail,Territory,এলাকা
 DocType: Pricing Rule,Apply Rule On Item Code,আইটেম কোডে বিধি প্রয়োগ করুন
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,প্রয়োজনীয় ভিজিট কোন উল্লেখ করুন
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,স্টক ব্যালেন্স রিপোর্ট
 DocType: Stock Settings,Default Valuation Method,ডিফল্ট মূল্যনির্ধারণ পদ্ধতি
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,ফী
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,সংখ্যার পরিমাণ দেখান
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,অগ্রগতি আপডেট. এটি একটি সময় নিতে পারে.
 DocType: Production Plan Item,Produced Qty,উত্পাদিত পরিমাণ
 DocType: Vehicle Log,Fuel Qty,জ্বালানীর Qty
-DocType: Stock Entry,Target Warehouse Name,লক্ষ্য গুদাম নাম
 DocType: Work Order Operation,Planned Start Time,পরিকল্পনা শুরুর সময়
 DocType: Course,Assessment,অ্যাসেসমেন্ট
 DocType: Payment Entry Reference,Allocated,বরাদ্দ
@@ -4436,10 +4450,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","স্ট্যান্ডার্ড শর্তাবলী এবং বিক্রয় এবং ক্রয় যোগ করা যেতে পারে যে শর্তাবলী. উদাহরণ: প্রস্তাব 1. বৈধতা. 1. অর্থপ্রদান শর্তাদি (ক্রেডিট অগ্রিম, অংশ অগ্রিম ইত্যাদি). 1. অতিরিক্ত (বা গ্রাহকের দ্বারা প্রদেয়) কি. 1. নিরাপত্তা / ব্যবহার সতর্কবাণী. 1. পাটা কোন তাহলে. 1. আয় নীতি. শিপিং 1. শর্তাবলী, যদি প্রযোজ্য হয়. বিরোধ অ্যাড্রেসিং, ক্ষতিপূরণ, দায় 1. উপায়, ইত্যাদি 1. ঠিকানা এবং আপনার কোম্পানীর সাথে যোগাযোগ করুন."
 DocType: Homepage Section,Section Based On,বিভাগ উপর ভিত্তি করে
+DocType: Shopping Cart Settings,Show Apply Coupon Code,আবেদন কুপন কোড দেখান
 DocType: Issue,Issue Type,ইস্যু প্রকার
 DocType: Attendance,Leave Type,ছুটি টাইপ
 DocType: Purchase Invoice,Supplier Invoice Details,সরবরাহকারী চালানের বিশদ বিবরণ
 DocType: Agriculture Task,Ignore holidays,ছুটির দিন উপেক্ষা করুন
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,কুপন শর্তাদি যুক্ত / সম্পাদনা করুন
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,ব্যয় / পার্থক্য অ্যাকাউন্ট ({0}) একটি &#39;লাভ বা ক্ষতি&#39; অ্যাকাউন্ট থাকতে হবে
 DocType: Stock Entry Detail,Stock Entry Child,স্টক এন্ট্রি চাইল্ড
 DocType: Project,Copied From,থেকে অনুলিপি
@@ -4610,6 +4626,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,অ্যাসেসমেন্ট পরিকল্পনা নির্ণায়ক
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,লেনদেন
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,ক্রয় আদেশ আটকান
+DocType: Coupon Code,Coupon Name,কুপন নাম
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,সমর্থ
 DocType: Email Campaign,Scheduled,তালিকাভুক্ত
 DocType: Shift Type,Working Hours Calculation Based On,ওয়ার্কিং আওয়ারস গণনা ভিত্তিক
@@ -4626,7 +4643,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,ধরন তৈরি
 DocType: Vehicle,Diesel,ডীজ়ল্
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,মূল্য তালিকা মুদ্রা একক নির্বাচন করবেন
+DocType: Quick Stock Balance,Available Quantity,উপলব্ধ পরিমাণ
 DocType: Purchase Invoice,Availed ITC Cess,এজিড আইটিসি সেস
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,শিক্ষা&gt; শিক্ষামূলক সেটিংসে প্রশিক্ষক নামকরণ সিস্টেম সেটআপ করুন up
 ,Student Monthly Attendance Sheet,শিক্ষার্থীর মাসের এ্যাটেনডেন্স পত্রক
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,শপিং শাসন কেবল বিক্রয় জন্য প্রযোজ্য
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,হ্রাস সারি {0}: পরবর্তী দাম্পত্য তারিখ ক্রয় তারিখ আগে হতে পারে না
@@ -4694,6 +4713,7 @@
 DocType: Quality Meeting,Quality Meeting,মান সভা
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,অ গ্রুপ গ্রুপ
 DocType: Employee,ERPNext User,ERPNext ব্যবহারকারী
+DocType: Coupon Code,Coupon Description,কুপন বর্ণনা
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},ব্যাচ সারিতে বাধ্যতামূলক {0}
 DocType: Company,Default Buying Terms,ডিফল্ট কেনার শর্তাদি
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,কেনার রসিদ আইটেম সরবরাহ
@@ -4855,6 +4875,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,ডকুমেন্ট বিস্তারিত বিরুদ্ধে কোন
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},দেশের জন্য অপসারণের অনুমতি নেই {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,পার্টির প্রকার বাধ্যতামূলক
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,কুপন কোড প্রয়োগ করুন
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","জব কার্ড {0} এর জন্য, আপনি কেবলমাত্র &#39;ম্যাটেরিয়াল ট্রান্সফার ফর ম্যানুফ্যাকচারিং&#39; টাইপ স্টক এন্ট্রি করতে পারেন"
 DocType: Quality Inspection,Outgoing,বহির্গামী
 DocType: Customer Feedback Table,Customer Feedback Table,গ্রাহক প্রতিক্রিয়া সারণী
@@ -5003,7 +5024,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,ক্রয় আদেশ জমা দেওয়ার সময়
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,সমস্ত সরবরাহকারী যোগ করুন
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,সারি # {0}: বরাদ্দ বকেয়া পরিমাণ পরিমাণ তার চেয়ে অনেক বেশী হতে পারে না।
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,গ্রাহক&gt; গ্রাহক গোষ্ঠী&gt; অঞ্চল
 DocType: Tally Migration,Parties,দল
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,ব্রাউজ BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,নিরাপদ ঋণ
@@ -5035,7 +5055,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},আইটেম জন্য বিকল্প আইটেম সেট করতে অনুমতি দেয় না {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,তারিখ পুনরাবৃত্তি করা হয়
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,অনুমোদিত স্বাক্ষরকারী
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,দয়া করে শিক্ষা&gt; শিক্ষা সেটিংসে প্রশিক্ষক নামকরণ সিস্টেম সেটআপ করুন
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),নেট আইটিসি উপলব্ধ (এ) - (খ)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,ফি তৈরি করুন
 DocType: Project,Total Purchase Cost (via Purchase Invoice),মোট ক্রয় খরচ (ক্রয় চালান মাধ্যমে)
@@ -5060,6 +5079,7 @@
 DocType: Quiz Result,Wrong,ভুল
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,হারে যা মূল্যতালিকা মুদ্রার এ গ্রাহকের বেস কারেন্সি রূপান্তরিত হয়
 DocType: Purchase Invoice Item,Net Amount (Company Currency),থোক (কোম্পানি একক)
+DocType: Sales Partner,Referral Code,রেফারেল কোড
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,মোট অগ্রিম পরিমাণ মোট অনুমোদিত পরিমাণের চেয়ে বেশি হতে পারে না
 DocType: Salary Slip,Hour Rate,ঘন্টা হার
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,অটো রি-অর্ডার সক্ষম করুন
@@ -5186,6 +5206,7 @@
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},আইটেম {0} বিরুদ্ধে BOM নির্বাচন করুন
 DocType: Shopping Cart Settings,Show Stock Quantity,স্টক পরিমাণ দেখান
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,অপারেশন থেকে নিট ক্যাশ
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},ইউওএম রূপান্তর ফ্যাক্টর ({0} -&gt; {1}) আইটেমটির জন্য পাওয়া যায় নি: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,আইটেম 4
 DocType: Student Admission,Admission End Date,ভর্তি শেষ তারিখ
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,সাব-কন্ট্রাক্ট
@@ -5208,6 +5229,7 @@
 DocType: Travel Request,Fully Sponsored,সম্পূর্ণ স্পনসর
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,বিপরীত জার্নাল এন্ট্রি
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,জব কার্ড তৈরি করুন
+DocType: Quotation,Referral Sales Partner,রেফারেল বিক্রয় অংশীদার
 DocType: Quality Procedure Process,Process Description,প্রক্রিয়া বর্ণনা
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,গ্রাহক {0} তৈরি করা হয়।
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,বর্তমানে কোন গুদামে পন্য উপলব্ধ নেই
@@ -5246,6 +5268,7 @@
 apps/erpnext/erpnext/setup/doctype/company/company.js,Company name not same,কোম্পানির নাম একই নয়
 DocType: Lead,Address Desc,নিম্নক্রমে ঠিকানার
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party is mandatory,পার্টির বাধ্যতামূলক
+apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.py,Please set account heads in GST Settings for Compnay {0},অনুগ্রহপূর্বক জিএসটি সেটিংসে অ্যাকাউন্ট প্রধান সেট করুন {0}
 DocType: Course Topic,Topic Name,টপিক নাম
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Approval Notification in HR Settings.,এইচআর সেটিংস এ অনুমোদন বিজ্ঞপ্তি বরখাস্ত করতে ডিফল্ট টেমপ্লেট সেট করুন।
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Atleast one of the Selling or Buying must be selected,বিক্রি বা কেনার অন্তত একটি নির্বাচন করতে হবে
@@ -5339,6 +5362,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM হার
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,আপলোড করা ফাইল পড়া
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","বন্ধ করা অর্ডারের অর্ডার বাতিল করা যাবে না, বাতিল করার জন্য এটি প্রথম থেকে বন্ধ করুন"
+DocType: Coupon Code,Coupon Code,কুপন কোড
 DocType: Asset,Journal Entry for Scrap,স্ক্র্যাপ জন্য জার্নাল এন্ট্রি
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,হুণ্ডি থেকে আইটেম টান অনুগ্রহ
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},সারি {0}: অপারেশন {1} বিরুদ্ধে ওয়ার্কস্টেশন নির্বাচন করুন
@@ -5419,6 +5443,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;তারিখ&#39; প্রয়োজন
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},দরুন / রেফারেন্স তারিখ পরে হতে পারে না {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,ডেটা আমদানি ও রপ্তানি
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","দুঃখিত, কুপন কোডের মেয়াদ শেষ হয়ে গেছে"
 DocType: Bank Account,Account Details,বিস্তারিত হিসাব
 DocType: Crop,Materials Required,সামগ্রী প্রয়োজনীয়
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,কোন ছাত্র পাওয়া
@@ -5456,6 +5481,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,ব্যবহারকারীদের কাছে যান
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,প্রদত্ত পরিমাণ পরিমাণ সর্বমোট তার চেয়ে অনেক বেশী হতে পারে না বন্ধ লিখুন + +
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} আইটেম জন্য একটি বৈধ ব্যাচ নম্বর নয় {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,বৈধ কুপন কোড প্রবেশ করুন!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},উল্লেখ্য: ছুটি টাইপ জন্য যথেষ্ট ছুটি ভারসাম্য নেই {0}
 DocType: Task,Task Description,কার্য বিবরণী
 DocType: Training Event,Seminar,সেমিনার
@@ -5717,6 +5743,7 @@
 ,TDS Payable Monthly,টিডিএস মাসিক মাসিক
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,BOM প্রতিস্থাপন জন্য সারিবদ্ধ এটি কয়েক মিনিট সময় নিতে পারে।
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',বিভাগ &#39;মূল্যনির্ধারণ&#39; বা &#39;মূল্যনির্ধারণ এবং মোট&#39; জন্য যখন বিয়োগ করা যাবে
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,মানব সম্পদ&gt; এইচআর সেটিংসে কর্মচারী নামকরণ সিস্টেম সেটআপ করুন
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,মোট পেমেন্টস
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},ধারাবাহিকভাবে আইটেম জন্য সিরিয়াল আমরা প্রয়োজনীয় {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,চালানসমূহ সঙ্গে ম্যাচ পেমেন্টস্
@@ -5804,6 +5831,7 @@
 DocType: Production Plan,Get Raw Materials For Production,উত্পাদনের জন্য কাঁচামাল পান
 DocType: Job Opening,Job Title,কাজের শিরোনাম
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,ভবিষ্যতের পেমেন্ট রেফ
+DocType: Quotation,Additional Discount and Coupon Code,অতিরিক্ত ছাড় এবং কুপন কোড
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} ইঙ্গিত দেয় যে {1} একটি উদ্ধৃতি প্রদান করবে না, কিন্তু সমস্ত আইটেম উদ্ধৃত করা হয়েছে। আরএফকিউ কোট অবস্থা স্থির করা"
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,সর্বাধিক নমুনা - {0} ইতিমধ্যে ব্যাচ {1} এবং আইটেম {2} ব্যাচ {3} এর জন্য সংরক্ষিত হয়েছে।
@@ -6027,6 +6055,7 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,ওয়েবসাইট হোমপেজে জন্য সেটিংস
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{1} পর্যন্ত {1} ধরে রাখা হয়
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},{1} এর স্কোরকার্ড স্থানের কারণে {0} জন্য RFQs অনুমোদিত নয়
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,ক্রয় চালান করুন
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,ব্যবহৃত পাখি
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,আপনি কি উপাদান অনুরোধ জমা দিতে চান?
 DocType: Job Offer,Awaiting Response,প্রতিক্রিয়ার জন্য অপেক্ষা
@@ -6041,6 +6070,7 @@
 DocType: Training Event Employee,Optional,ঐচ্ছিক
 DocType: Salary Slip,Earning & Deduction,রোজগার &amp; সিদ্ধান্তগ্রহণ
 DocType: Agriculture Analysis Criteria,Water Analysis,জল বিশ্লেষণ
+DocType: Sales Order,Skip Delivery Note,ডেলিভারি নোট এড়িয়ে যান
 DocType: Price List,Price Not UOM Dependent,মূল্য ইউওএম নির্ভর নয়
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} বৈকল্পিক তৈরি করা হয়েছে।
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,একটি ডিফল্ট পরিষেবা স্তর চুক্তি ইতিমধ্যে বিদ্যমান।
@@ -6144,6 +6174,7 @@
 DocType: Vehicle,Last Carbon Check,সর্বশেষ কার্বন চেক
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,আইনি খরচ
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,দয়া করে সারিতে পরিমাণ নির্বাচন
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},কাজের আদেশ {0}: কাজের জন্য কার্ড খুঁজে পাওয়া যায় নি {1}
 DocType: Purchase Invoice,Posting Time,পোস্টিং সময়
 DocType: Timesheet,% Amount Billed,% পরিমাণ চালান করা হয়েছে
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,টেলিফোন খরচ
@@ -6244,7 +6275,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,কর ও চার্জ যোগ
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,হ্রাস সারি {0}: পরবর্তী অবচয় তারিখটি আগে উপলব্ধ নাও হতে পারে ব্যবহারের জন্য তারিখ
 ,Sales Funnel,বিক্রয় ফানেল
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,আইটেম কোড&gt; আইটেম গ্রুপ&gt; ব্র্যান্ড
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,সমাহার বাধ্যতামূলক
 DocType: Project,Task Progress,টাস্ক অগ্রগতি
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,কার্ট
@@ -6338,6 +6368,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,পিওএস প্রোফাইল পিওএস এন্ট্রি করতে প্রয়োজন
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","আনুগত্য পয়েন্টগুলি খরচ করা হবে (বিক্রয় চালান মাধ্যমে), সংগ্রহ ফ্যাক্টর উপর ভিত্তি করে উল্লিখিত।"
 DocType: Program Enrollment Tool,Enroll Students,শিক্ষার্থীরা তালিকাভুক্ত
+DocType: Pricing Rule,Coupon Code Based,কুপন কোড ভিত্তিক
 DocType: Company,HRA Settings,এইচআরএ সেটিংস
 DocType: Homepage,Hero Section,হিরো বিভাগ
 DocType: Employee Transfer,Transfer Date,তারিখ স্থানান্তর
@@ -6451,6 +6482,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',দয়া করে কোম্পানির ফাঁকা ফিল্টার সেট করুন যদি একদল &#39;কোম্পানি&#39; হল
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,পোস্টিং তারিখ ভবিষ্যতে তারিখে হতে পারে না
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},সারি # {0}: সিরিয়াল কোন {1} সঙ্গে মেলে না {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,দয়া করে সেটআপ&gt; নম্বরিং সিরিজের মাধ্যমে উপস্থিতির জন্য সংখ্যায়ন সিরিজটি সেট করুন
 DocType: Stock Entry,Target Warehouse Address,লক্ষ্য গুদাম ঠিকানা
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,নৈমিত্তিক ছুটি
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,শিফট শুরুর আগে যে সময়টিতে কর্মচারী চেক-ইন উপস্থিতির জন্য বিবেচিত হয়।
@@ -6485,7 +6517,6 @@
 DocType: Employee Grade,Employee Grade,কর্মচারী গ্রেড
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,ফুরণ
 DocType: GSTR 3B Report,June,জুন
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,সরবরাহকারী&gt; সরবরাহকারী প্রকার
 DocType: Share Balance,From No,না থেকে
 DocType: Shift Type,Early Exit Grace Period,প্রারম্ভিক প্রস্থান গ্রেস পিরিয়ড
 DocType: Task,Actual Time (in Hours),(ঘন্টায়) প্রকৃত সময়
@@ -6768,7 +6799,6 @@
 DocType: Warehouse,Warehouse Name,ওয়ারহাউস নাম
 DocType: Naming Series,Select Transaction,নির্বাচন লেনদেন
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,ভূমিকা অনুমোদন বা ব্যবহারকারী অনুমদন লিখুন দয়া করে
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},ইউওএম রূপান্তর ফ্যাক্টর ({0} -&gt; {1}) আইটেমটির জন্য পাওয়া যায় নি: {2}
 DocType: Journal Entry,Write Off Entry,এন্ট্রি বন্ধ লিখুন
 DocType: BOM,Rate Of Materials Based On,হার উপকরণ ভিত্তি করে
 DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","যদি সক্রিয় থাকে, তাহলে প্রোগ্রাম এনরোলমেন্ট টুল এ ক্ষেত্রটি একাডেমিক টার্ম বাধ্যতামূলক হবে।"
@@ -6904,6 +6934,7 @@
 DocType: Budget,Warn,সতর্ক করো
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,এই ওয়ার্ক অর্ডারের জন্য সমস্ত আইটেম ইতিমধ্যে স্থানান্তর করা হয়েছে।
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","অন্য কোন মন্তব্য, রেকর্ড মধ্যে যেতে হবে যে উল্লেখযোগ্য প্রচেষ্টা."
+DocType: Bank Account,Company Account,কোম্পানির অ্যাকাউন্ট
 DocType: Asset Maintenance,Manufacturing User,উৎপাদন ব্যবহারকারী
 DocType: Purchase Invoice,Raw Materials Supplied,কাঁচামালের সরবরাহ
 DocType: Subscription Plan,Payment Plan,পরিশোধের পরিকল্পনা
@@ -6945,6 +6976,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) কর্ম আদেশ {3} থেকে পরিকল্পিত পরিমাণ ({2}) এর চেয়ে বড় হতে পারে না
 DocType: Certification Application,Name of Applicant,আবেদনকারীর নাম
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,উত্পাদন জন্য টাইম শিট.
+DocType: Quick Stock Balance,Quick Stock Balance,দ্রুত স্টক ব্যালেন্স
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,উপমোট
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,স্টক লেনদেনের পরে বৈকল্পিক বৈশিষ্ট্য পরিবর্তন করা যাবে না। আপনি এটি করতে একটি নতুন আইটেম করতে হবে।
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA আদেশ
@@ -7268,6 +7300,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},সেট করুন {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} নিষ্ক্রিয় ছাত্র-ছাত্রী
 DocType: Employee,Health Details,স্বাস্থ্য বিবরণ
+DocType: Coupon Code,Coupon Type,কুপন প্রকার
 DocType: Leave Encashment,Encashable days,এনক্যাশেবল দিন
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,একটি পেমেন্ট অনুরোধ রেফারেন্স ডকুমেন্ট প্রয়োজন বোধ করা হয় তৈরি করতে
 DocType: Soil Texture,Sandy Clay,স্যান্ডী ক্লে
@@ -7548,6 +7581,7 @@
 DocType: Hotel Room Package,Amenities,সুযোগ-সুবিধা
 DocType: Accounts Settings,Automatically Fetch Payment Terms,স্বয়ংক্রিয়ভাবে প্রদানের শর্তাদি আনুন
 DocType: QuickBooks Migrator,Undeposited Funds Account,Undeposited তহবিল অ্যাকাউন্ট
+DocType: Coupon Code,Uses,ব্যবহারসমূহ
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,পেমেন্ট একাধিক ডিফল্ট মোড অনুমতি দেওয়া হয় না
 DocType: Sales Invoice,Loyalty Points Redemption,আনুগত্য পয়েন্ট রিডমপশন
 ,Appointment Analytics,নিয়োগের বিশ্লেষণ
@@ -7564,6 +7598,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,মোট বাজেট
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,ফাঁকা ছেড়ে দিন যদি আপনি প্রতি বছরে শিক্ষার্থীদের গ্রুপ করা
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","চেক করা থাকলে, মোট কোন. কার্যদিবসের ছুটির অন্তর্ভুক্ত করা হবে, এবং এই বেতন প্রতি দিন মূল্য কমাতে হবে"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,ডোমেন যুক্ত করতে ব্যর্থ
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","প্রাপ্তি / বিতরণকে অনুমতি দেওয়ার জন্য, স্টক সেটিংস বা আইটেমটিতে &quot;ওভার রসিদ / বিতরণ ভাতা&quot; আপডেট করুন।"
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","বর্তমান কী ব্যবহার করে অ্যাপস অ্যাক্সেস করতে পারবে না, আপনি কি নিশ্চিত?"
 DocType: Subscription Settings,Prorate,Prorate
@@ -7576,6 +7611,7 @@
 ,BOM Stock Report,BOM স্টক রিপোর্ট
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group",যদি কোনও নির্ধারিত টাইমলট না থাকে তবে যোগাযোগটি এই গোষ্ঠী দ্বারা পরিচালিত হবে
 DocType: Stock Reconciliation Item,Quantity Difference,পরিমাণ পার্থক্য
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,সরবরাহকারী&gt; সরবরাহকারী প্রকার
 DocType: Opportunity Item,Basic Rate,মৌলিক হার
 DocType: GL Entry,Credit Amount,ক্রেডিট পরিমাণ
 ,Electronic Invoice Register,বৈদ্যুতিন চালান নিবন্ধ
@@ -7828,6 +7864,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),কর ও শুল্ক বাদ (কোম্পানি একক)
 DocType: Item Group,General Settings,সাধারণ বিন্যাস
 DocType: Article,Article,প্রবন্ধ
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,কুপন কোড প্রবেশ করুন!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,মুদ্রা থেকে এবং মুদ্রার একই হতে পারে না
 DocType: Taxable Salary Slab,Percent Deduction,শতকরা হার
 DocType: GL Entry,To Rename,নতুন নামকরণ
diff --git a/erpnext/translations/bs.csv b/erpnext/translations/bs.csv
index 4f2eb73..fe7d8c8 100644
--- a/erpnext/translations/bs.csv
+++ b/erpnext/translations/bs.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-YYYY.-
 DocType: Purchase Order,Customer Contact,Kontakt kupca
 DocType: Shift Type,Enable Auto Attendance,Omogući automatsko prisustvo
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Unesite skladište i datum
 DocType: Lost Reason Detail,Opportunity Lost Reason,Prilika izgubljen razlog
 DocType: Patient Appointment,Check availability,Provjera dostupnosti
 DocType: Retention Bonus,Bonus Payment Date,Datum isplate bonusa
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Završene radne naloge
 DocType: Support Settings,Forum Posts,Forum Posts
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Zadatak je zamišljen kao pozadinski posao. U slučaju da u pozadini postoji problem s obradom, sistem će dodati komentar o grešci u ovom usklađivanju dionica i vratiti se u fazu skica"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Nažalost, valjanost koda kupona nije započela"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,oporezivi iznos
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Niste ovlašteni za dodati ili ažurirati unose prije {0}
 DocType: Leave Policy,Leave Policy Details,Ostavite detalje o politici
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Potrošni
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,razred
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kod artikla&gt; Grupa artikala&gt; Marka
 DocType: Restaurant Table,No of Seats,Broj sedišta
 DocType: Sales Invoice,Overdue and Discounted,Zakašnjeli i sniženi
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Poziv prekinuti
@@ -506,6 +509,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Prored za iznos u riječima
 DocType: Vehicle,Additional Details,Dodatni Detalji
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Nema opisa dano
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Dohvaćanje predmeta iz skladišta
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Zahtjev za kupnju.
 DocType: POS Closing Voucher Details,Collected Amount,Prikupljeni iznos
 DocType: Lab Test,Submitted Date,Datum podnošenja
@@ -613,6 +617,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Učiti
 ,Trial Balance (Simple),Probni balans (jednostavan)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Omogućite odloženi trošak
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Primenjeni kod kupona
 DocType: Asset,Next Depreciation Date,Sljedeća Amortizacija Datum
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Aktivnost Trošak po zaposlenom
 DocType: Accounts Settings,Settings for Accounts,Postavke za račune
@@ -848,8 +853,6 @@
 DocType: BOM,Work Order,Radni nalog
 DocType: Sales Invoice,Total Qty,Ukupno Qty
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 Email ID
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Izbrišite zaposlenika <a href=""#Form/Employee/{0}"">{0}</a> \ da biste otkazali ovaj dokument"
 DocType: Item,Show in Website (Variant),Pokaži u Web (Variant)
 DocType: Employee,Health Concerns,Zdravlje Zabrinutost
 DocType: Payroll Entry,Select Payroll Period,Odaberite perioda isplate
@@ -1013,6 +1016,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Porez na odbitak
 DocType: Pricing Rule,Sales Partner,Prodajni partner
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Sve ispostavne kartice.
+DocType: Coupon Code,To be used to get discount,Da biste iskoristili popust
 DocType: Buying Settings,Purchase Receipt Required,Kupnja Potvrda Obvezno
 DocType: Sales Invoice,Rail,Rail
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Stvarni trošak
@@ -1063,6 +1067,7 @@
 DocType: Production Plan,Production Plan,Plan proizvodnje
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Otvaranje alata za kreiranje fakture
 DocType: Salary Component,Round to the Nearest Integer,Zaokružite na najbliži cijeli broj
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Dopustite da se dodaju u košaricu artikli koji nisu na zalihama
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Povrat robe
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Postavite količinu u transakcijama na osnovu Serijski broj ulaza
 ,Total Stock Summary,Ukupno Stock Pregled
@@ -1192,6 +1197,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Base Hour Rate (Company Valuta)
 ,Qty To Be Billed,Količina za naplatu
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Isporučena Iznos
+DocType: Coupon Code,Gift Card,Poklon kartica
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Količina rezervirane za proizvodnju: Količina sirovina za izradu proizvodnih predmeta.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Datum otkupljenja
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Ova je bankarska transakcija već u potpunosti usklađena
@@ -1279,6 +1285,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Napravite Timesheet
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Račun {0} je ušao više puta
 DocType: Account,Expenses Included In Valuation,Troškovi uključeni u vrednovanje
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Računi za kupovinu
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Možete obnoviti samo ako vaše članstvo istekne u roku od 30 dana
 DocType: Shopping Cart Settings,Show Stock Availability,Show Stock Availability
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Postavite {0} u kategoriji aktive {1} ili kompaniju {2}
@@ -1837,6 +1844,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Uvoz predmeta i UOM-ova
 DocType: Repayment Schedule,Balance Loan Amount,Balance Iznos kredita
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Dodato na detalje
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Izvinite, kod kupona je iscrpljen"
 DocType: Communication Medium,Catch All,Catch All
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Raspored predmeta
 DocType: Budget,Applicable on Material Request,Primenljivo na zahtev za materijal
@@ -2004,6 +2012,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Invalid Atributi
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} mora biti podnesen
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Kampanja e-pošte
+DocType: Sales Partner,To Track inbound purchase,Da biste pratili ulaznu kupovinu
 DocType: Buying Settings,Default Supplier Group,Podrazumevana grupa dobavljača
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Količina mora biti manji ili jednak {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Maksimalni iznos koji odgovara komponenti {0} prelazi {1}
@@ -2159,8 +2168,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Unesite zalihe
 DocType: Hotel Room Reservation,Hotel Reservation User,Rezervacija korisnika hotela
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Postavite status
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Molimo podesite seriju brojeva za Attendance putem Podešavanje&gt; Serija numeriranja
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Odaberite prefiks prvi
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Molimo postavite Naming Series za {0} putem Podešavanje&gt; Podešavanja&gt; Imenovanje serije
 DocType: Contract,Fulfilment Deadline,Rok ispunjenja
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,U vašoj blizini
 DocType: Student,O-,O-
@@ -2284,6 +2293,7 @@
 DocType: Quality Meeting Table,Under Review,U pregledu
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Neuspešno se prijaviti
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Sredstvo {0} kreirano
+DocType: Coupon Code,Promotional,Promotivni
 DocType: Special Test Items,Special Test Items,Specijalne testne jedinice
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Potrebno je da budete korisnik sa ulogama System Manager i Item Manager za prijavljivanje na Marketplace.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Ključni izvještaji
@@ -2321,6 +2331,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc tip
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Ukupno dodijeljeno postotak za prodajni tim bi trebao biti 100
 DocType: Subscription Plan,Billing Interval Count,Interval broja obračuna
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Izbrišite zaposlenika <a href=""#Form/Employee/{0}"">{0}</a> \ da biste otkazali ovaj dokument"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Imenovanja i susreti sa pacijentom
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Nedostaje vrijednost
 DocType: Employee,Department and Grade,Odeljenje i razred
@@ -2423,6 +2435,7 @@
 DocType: Project,Start and End Dates,Datume početka i završetka
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Uslovi ispunjavanja obrasca ugovora
 ,Delivered Items To Be Billed,Isporučeni proizvodi za naplatiti
+DocType: Coupon Code,Maximum Use,Maksimalna upotreba
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Otvorena BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Skladište se ne može promijeniti za serijskog broja
 DocType: Authorization Rule,Average Discount,Prosječni popust
@@ -2585,6 +2598,7 @@
 DocType: Item,Inventory,Inventar
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Preuzmi kao Json
 DocType: Item,Sales Details,Prodajni detalji
+DocType: Coupon Code,Used,Rabljeni
 DocType: Opportunity,With Items,Sa stavkama
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Kampanja &#39;{0}&#39; već postoji za {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Tim za održavanje
@@ -2714,7 +2728,7 @@
 						Serial No cannot be ensured",Nije pronađena aktivna BOM za stavku {0}. Ne može se osigurati isporuka sa \ Serial No.
 DocType: Sales Partner,Sales Partner Target,Prodaja partner Target
 DocType: Loan Type,Maximum Loan Amount,Maksimalni iznos kredita
-DocType: Pricing Rule,Pricing Rule,cijene Pravilo
+DocType: Coupon Code,Pricing Rule,cijene Pravilo
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplikat broj roll za studentske {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Materijal Zahtjev za narudžbenice
 DocType: Company,Default Selling Terms,Uobičajeni prodajni uslovi
@@ -2793,6 +2807,7 @@
 DocType: Payment Schedule,Payment Amount,Plaćanje Iznos
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Datum poluvremena treba da bude između rada od datuma i datuma rada
 DocType: Healthcare Settings,Healthcare Service Items,Stavke zdravstvene zaštite
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Nevažeći barkod. Nijedna stavka nije priložena ovom barkodu.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Consumed Iznos
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Neto promjena u gotovini
 DocType: Assessment Plan,Grading Scale,Pravilo Scale
@@ -2912,7 +2927,6 @@
 DocType: Share Transfer,Asset Account,Račun imovine
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Novi datum izlaska trebao bi biti u budućnosti
 DocType: Purchase Invoice,End date of current invoice's period,Kraj datum tekućeg razdoblja dostavnice
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Postavite sistem imenovanja zaposlenika u ljudskim resursima&gt; HR postavke
 DocType: Lab Test,Technician Name,Ime tehničara
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3023,6 +3037,7 @@
 DocType: Products Settings,Hide Variants,Sakrij varijante
 DocType: Lead,Next Contact By,Sledeci put kontaktirace ga
 DocType: Compensatory Leave Request,Compensatory Leave Request,Kompenzacijski zahtev za odlazak
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Ne mogu se preplatiti za stavku {0} u redu {1} više od {2}. Da biste omogućili prekomerno naplaćivanje, molimo postavite dodatak u Postavkama računa"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Količina potrebna za točke {0} je u redu {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Skladište {0} ne može biti izbrisano ako na njemu ima artikal {1}
 DocType: Blanket Order,Order Type,Vrsta narudžbe
@@ -3191,7 +3206,6 @@
 DocType: Student,Student Mobile Number,Student Broj mobilnog
 DocType: Item,Has Variants,Ima Varijante
 DocType: Employee Benefit Claim,Claim Benefit For,Claim Benefit For
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Ne mogu preoptereti za stavku {0} u redu {1} više od {2}. Da biste omogućili prekomerno obračunavanje, molimo vas postavite u postavke zaliha"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Update Response
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Vi ste već odabrane stavke iz {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Naziv Mjesečni distribucije
@@ -3482,6 +3496,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Navedite valuta u Company
 DocType: Workstation,Wages per hour,Plaće po satu
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Konfigurišite {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Kupac&gt; grupa kupaca&gt; teritorija
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Stock balans u Batch {0} će postati negativan {1} {2} za tačka na skladištu {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Nakon materijala Zahtjevi su automatski podignuta na osnovu nivou ponovnog reda stavke
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Račun {0} je nevažeća. Račun valuta mora biti {1}
@@ -3811,6 +3826,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Slanje plaće Slip
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Na čekanju
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Qurance mora imati najmanje jednu ispravnu opciju
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Narudžbenice
 DocType: Account,Inter Company Account,Inter Company Account
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Uvoz u rinfuzi
 DocType: Sales Partner,Address & Contacts,Adresa i kontakti
@@ -3821,6 +3837,7 @@
 DocType: POS Profile,[Select],[ izaberite ]
 DocType: Staffing Plan Detail,Number Of Positions,Broj pozicija
 DocType: Vital Signs,Blood Pressure (diastolic),Krvni pritisak (dijastolni)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Molimo odaberite kupca.
 DocType: SMS Log,Sent To,Poslati
 DocType: Agriculture Task,Holiday Management,Holiday Management
 DocType: Payment Request,Make Sales Invoice,Ostvariti prodaju fakturu
@@ -4029,7 +4046,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} nije proslijedjen
 DocType: Subscription,Trialling,Trialling
 DocType: Sales Invoice Item,Deferred Revenue,Odloženi prihodi
-DocType: Bank Account,GL Account,GL račun
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Gotovinski račun će se koristiti za kreiranje prodajne fakture
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Izuzetna podkategorija
 DocType: Member,Membership Expiry Date,Datum isteka članstva
@@ -4453,13 +4469,13 @@
 DocType: C-Form Invoice Detail,Territory,Regija
 DocType: Pricing Rule,Apply Rule On Item Code,Primijenite pravilo na kod predmeta
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Molimo spomenuti nema posjeta potrebnih
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Izvještaj o stanju zaliha
 DocType: Stock Settings,Default Valuation Method,Zadana metoda vrednovanja
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,provizija
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Prikaži kumulativni iznos
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Ažuriranje je u toku. Možda će potrajati neko vrijeme.
 DocType: Production Plan Item,Produced Qty,Proizveden količina
 DocType: Vehicle Log,Fuel Qty,gorivo Količina
-DocType: Stock Entry,Target Warehouse Name,Ime ciljne magacine
 DocType: Work Order Operation,Planned Start Time,Planirani Start Time
 DocType: Course,Assessment,procjena
 DocType: Payment Entry Reference,Allocated,Izdvojena
@@ -4537,10 +4553,12 @@
  1. Načini adresiranja sporova, naknadu štete, odgovornosti, itd 
  1. Adresu i kontakt vaše kompanije."
 DocType: Homepage Section,Section Based On,Odeljak na osnovu
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Prikaži Primjeni kod kupona
 DocType: Issue,Issue Type,Vrsta izdanja
 DocType: Attendance,Leave Type,Ostavite Vid
 DocType: Purchase Invoice,Supplier Invoice Details,Dobavljač Račun Detalji
 DocType: Agriculture Task,Ignore holidays,Ignoriši praznike
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Dodavanje / uređivanje uvjeta kupona
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Rashodi / Razlika računa ({0}) mora biti račun 'dobit ili gubitak'
 DocType: Stock Entry Detail,Stock Entry Child,Dijete ulaska na zalihe
 DocType: Project,Copied From,kopira iz
@@ -4715,6 +4733,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Kriteriji Plan Procjena
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Transakcije
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Sprečite kupovne naloge
+DocType: Coupon Code,Coupon Name,Naziv kupona
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Podložno
 DocType: Email Campaign,Scheduled,Planirano
 DocType: Shift Type,Working Hours Calculation Based On,Proračun radnog vremena na osnovu
@@ -4731,7 +4750,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Kreirajte Varijante
 DocType: Vehicle,Diesel,dizel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Cjenik valuta ne bira
+DocType: Quick Stock Balance,Available Quantity,Dostupna količina
 DocType: Purchase Invoice,Availed ITC Cess,Iskoristio ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Postavite sistem imenovanja instruktora u Obrazovanje&gt; Postavke obrazovanja
 ,Student Monthly Attendance Sheet,Student Mjesečni Posjeta list
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Pravilo o isporuci primenjuje se samo za prodaju
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Redosled amortizacije {0}: Sledeći datum amortizacije ne može biti pre datuma kupovine
@@ -4798,8 +4819,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Red {0}: Advance protiv Klijent mora biti kredit
 DocType: Quality Meeting,Quality Meeting,Sastanak kvaliteta
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-grupe do grupe
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Molimo postavite Naming Series za {0} putem Podešavanje&gt; Podešavanja&gt; Imenovanje serije
 DocType: Employee,ERPNext User,ERPNext User
+DocType: Coupon Code,Coupon Description,Opis kupona
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Serija je obavezno u nizu {0}
 DocType: Company,Default Buying Terms,Uvjeti kupnje
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Kupnja Prijem artikla Isporuka
@@ -4962,6 +4983,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Protiv dokumenta Detalj No
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Brisanje nije dozvoljeno za zemlju {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Party Tip je obavezno
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Primijenite kupon kod
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",Za radnu karticu {0} možete izvršiti samo unos tipa „Prijenos materijala za proizvodnju“
 DocType: Quality Inspection,Outgoing,Društven
 DocType: Customer Feedback Table,Customer Feedback Table,Tabela povratnih informacija korisnika
@@ -5111,7 +5133,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Prilikom narudžbe
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Dodajte sve dobavljače
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Row # {0}: dodijeljeni iznos ne može biti veći od preostalog iznosa.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Kupac&gt; grupa kupaca&gt; teritorija
 DocType: Tally Migration,Parties,Stranke
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Browse BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,osigurani krediti
@@ -5143,7 +5164,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Ne dozvolite postavljanje alternativne stavke za stavku {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Datum se ponavlja
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Ovlašteni potpisnik
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Postavite sistem imenovanja instruktora u Obrazovanje&gt; Postavke obrazovanja
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Neto dostupan ITC (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Kreiraj naknade
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Ukupno TROŠKA (preko fakturi)
@@ -5168,6 +5188,7 @@
 DocType: Quiz Result,Wrong,Pogrešno
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Stopa po kojoj Cjenik valute se pretvaraju u kupca osnovne valute
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Neto iznos (Company valuta)
+DocType: Sales Partner,Referral Code,Kod preporuke
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Ukupan iznos avansa ne može biti veći od ukupnog sankcionisanog iznosa
 DocType: Salary Slip,Hour Rate,Cijena sata
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Omogući automatsku ponovnu narudžbu
@@ -5296,6 +5317,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Show Stock Quantity
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Neto novčani tok od operacije
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Redak broj {0}: Status mora biti {1} za popust fakture {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Faktor konverzije UOM ({0} -&gt; {1}) nije pronađen za stavku: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Stavka 4
 DocType: Student Admission,Admission End Date,Prijem Završni datum
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Podugovaranje
@@ -5318,6 +5340,7 @@
 DocType: Travel Request,Fully Sponsored,Fully Sponsored
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Povratni dnevnik
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Kreirajte Job Card
+DocType: Quotation,Referral Sales Partner,Preporuka prodajni partner
 DocType: Quality Procedure Process,Process Description,Opis procesa
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Klijent {0} je kreiran.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Trenutno nema dostupnih trgovina na zalihama
@@ -5452,6 +5475,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM Rate
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Čitanje preuzete datoteke
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Prekinuto radno porudžbanje ne može se otkazati, Unstop prvi da otkaže"
+DocType: Coupon Code,Coupon Code,Kupon kod
 DocType: Asset,Journal Entry for Scrap,Journal Entry za otpad
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Molimo povucite stavke iz Dostavnica
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Red {0}: izaberite radnu stanicu protiv operacije {1}
@@ -5534,6 +5558,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,Obavezan je datum
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Zbog / Reference Datum ne može biti nakon {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Podataka uvoz i izvoz
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Žao nam je, rok valjanosti kupona je istekao"
 DocType: Bank Account,Account Details,Detalji konta
 DocType: Crop,Materials Required,Potrebni materijali
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,No studenti Found
@@ -5571,6 +5596,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Idite na Korisnike
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Uplaćeni iznos + otpis iznos ne može biti veći od SVEUKUPNO
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} nije ispravan broj serije za artikal {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Unesite važeći kod kupona !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Napomena : Nema dovoljno ravnotežu dopust za dozvolu tipa {0}
 DocType: Task,Task Description,Opis zadatka
 DocType: Training Event,Seminar,seminar
@@ -5834,6 +5860,7 @@
 ,TDS Payable Monthly,TDS se plaća mesečno
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Očekuje se zamena BOM-a. Može potrajati nekoliko minuta.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Ne mogu odbiti kada kategorija je "" vrednovanje "" ili "" Vrednovanje i Total '"
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Postavite sistem imenovanja zaposlenika u ljudskim resursima&gt; HR postavke
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Ukupna plaćanja
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serijski Nos potrebna za serijaliziranom točke {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Meč plaćanja fakture
@@ -5923,6 +5950,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Uzmite sirovine za proizvodnju
 DocType: Job Opening,Job Title,Titula
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Buduće plaćanje Ref
+DocType: Quotation,Additional Discount and Coupon Code,Dodatni popust i kod kupona
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} označava da {1} neće dati citat, ali su svi stavci \ citirani. Ažuriranje statusa RFQ citata."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maksimalni uzorci - {0} su već zadržani za Batch {1} i Item {2} u Batch {3}.
@@ -6150,7 +6178,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Postavke za web stranice homepage
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} je na čekanju do {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ-ovi nisu dozvoljeni za {0} zbog stanja karte za rezultat {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Napravite kupnje proizvoda
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Korišćeni listovi
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Kupon se koristi {1}. Dozvoljena količina se iscrpljuje
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Želite li poslati materijalni zahtjev
 DocType: Job Offer,Awaiting Response,Čeka se odgovor
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-YYYY.-
@@ -6164,6 +6194,7 @@
 DocType: Training Event Employee,Optional,Neobavezno
 DocType: Salary Slip,Earning & Deduction,Zarada &amp; Odbitak
 DocType: Agriculture Analysis Criteria,Water Analysis,Analiza vode
+DocType: Sales Order,Skip Delivery Note,Preskočite dostavnicu
 DocType: Price List,Price Not UOM Dependent,Cijena nije UOM zavisna
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} kreirane varijante.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Ugovor o nivou usluge već postoji.
@@ -6268,6 +6299,7 @@
 DocType: Vehicle,Last Carbon Check,Zadnji Carbon Check
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Pravni troškovi
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Molimo odaberite Količina na red
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Radni nalog {0}: kartica posla nije pronađena za operaciju {1}
 DocType: Purchase Invoice,Posting Time,Objavljivanje Vrijeme
 DocType: Timesheet,% Amount Billed,% Naplaćenog iznosa
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Telefonski troškovi
@@ -6370,7 +6402,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Porezi i naknade Dodano
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Redosled amortizacije {0}: Sledeći datum amortizacije ne može biti pre datuma raspoloživog za upotrebu
 ,Sales Funnel,Tok prodaje (Funnel)
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kod artikla&gt; Grupa artikala&gt; Marka
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Skraćenica je obavezno
 DocType: Project,Task Progress,zadatak Napredak
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Kolica
@@ -6466,6 +6497,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS Profil potrebno da bi POS upis
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Točke lojalnosti će se izračunati iz potrošene (preko fakture za prodaju), na osnovu navedenog faktora sakupljanja."
 DocType: Program Enrollment Tool,Enroll Students,upisati studenti
+DocType: Pricing Rule,Coupon Code Based,Na osnovu koda kupona
 DocType: Company,HRA Settings,HRA Settings
 DocType: Homepage,Hero Section,Sekcija heroja
 DocType: Employee Transfer,Transfer Date,Datum prenosa
@@ -6581,6 +6613,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Molimo podesite Company filter prazno ako Skupina Od je &#39;Company&#39;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Datum knjiženja ne može biti u budućnosti
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: {1} Serial No ne odgovara {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Molimo podesite seriju brojeva za Attendance putem Podešavanje&gt; Serija numeriranja
 DocType: Stock Entry,Target Warehouse Address,Adresa ciljne magacine
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Casual dopust
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,Vrijeme prije početka vremena smjene tijekom kojeg se prijava zaposlenika uzima u obzir za prisustvo.
@@ -6615,7 +6648,6 @@
 DocType: Employee Grade,Employee Grade,Razred zaposlenih
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,rad plaćen na akord
 DocType: GSTR 3B Report,June,Juna
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dobavljač&gt; vrsta dobavljača
 DocType: Share Balance,From No,Od br
 DocType: Shift Type,Early Exit Grace Period,Period prijevremenog izlaska
 DocType: Task,Actual Time (in Hours),Stvarno vrijeme (u satima)
@@ -6900,7 +6932,6 @@
 DocType: Warehouse,Warehouse Name,Naziv skladišta
 DocType: Naming Series,Select Transaction,Odaberite transakciju
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Unesite Odobravanje ulogu ili Odobravanje korisnike
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Faktor konverzije UOM ({0} -&gt; {1}) nije pronađen za stavku: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Ugovor o nivou usluge sa tipom entiteta {0} i entitetom {1} već postoji.
 DocType: Journal Entry,Write Off Entry,Napišite Off Entry
 DocType: BOM,Rate Of Materials Based On,Stopa materijali na temelju
@@ -7038,6 +7069,7 @@
 DocType: Budget,Warn,Upozoriti
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Svi predmeti su već preneti za ovaj radni nalog.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Bilo koji drugi primjedbe, napomenuti napor koji treba da ide u evidenciji."
+DocType: Bank Account,Company Account,Račun kompanije
 DocType: Asset Maintenance,Manufacturing User,Proizvodnja korisnika
 DocType: Purchase Invoice,Raw Materials Supplied,Sirovine nabavlja
 DocType: Subscription Plan,Payment Plan,Plan placanja
@@ -7079,6 +7111,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) ne može biti veća od planirane količine ({2}) u radnom nalogu {3}
 DocType: Certification Application,Name of Applicant,Ime podnosioca zahteva
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Time Sheet za proizvodnju.
+DocType: Quick Stock Balance,Quick Stock Balance,Brzi bilans stanja
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,suma stavke
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Ne mogu promijeniti svojstva varijante nakon transakcije sa akcijama. Za to ćete morati napraviti novu stavku.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA Mandat
@@ -7405,6 +7438,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},Molimo postavite {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} je neaktivan student
 DocType: Employee,Health Details,Zdravlje Detalji
+DocType: Coupon Code,Coupon Type,Vrsta kupona
 DocType: Leave Encashment,Encashable days,Encashable days
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Za kreiranje plaćanja Zahtjev je potrebno referentni dokument
 DocType: Soil Texture,Sandy Clay,Sandy Clay
@@ -7688,6 +7722,7 @@
 DocType: Hotel Room Package,Amenities,Pogodnosti
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Automatski preuzmi Uvjete plaćanja
 DocType: QuickBooks Migrator,Undeposited Funds Account,Račun Undeposited Funds
+DocType: Coupon Code,Uses,Upotrebe
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Višestruki način plaćanja nije dozvoljen
 DocType: Sales Invoice,Loyalty Points Redemption,Povlačenje lojalnosti
 ,Appointment Analytics,Imenovanje analitike
@@ -7704,6 +7739,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Ukupni budžet
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Ostavite prazno ako napravite grupa studenata godišnje
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Ako je označeno, Ukupan broj. radnih dana će uključiti odmor, a to će smanjiti vrijednost plaća po danu"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Nije moguće dodati Domen
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Da biste omogućili primanje / isporuku, ažurirajte &quot;Over Receipt / Dozvola za isporuku&quot; u Postavke zaliha ili Artikl."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Aplikacije koje koriste trenutni ključ neće moći da pristupe, da li ste sigurni?"
 DocType: Subscription Settings,Prorate,Prorate
@@ -7716,6 +7752,7 @@
 ,BOM Stock Report,BOM Stock Report
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Ako nema dodeljenog vremenskog intervala, komunikacija će upravljati ovom grupom"
 DocType: Stock Reconciliation Item,Quantity Difference,Količina Razlika
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dobavljač&gt; vrsta dobavljača
 DocType: Opportunity Item,Basic Rate,Osnovna stopa
 DocType: GL Entry,Credit Amount,Iznos kredita
 ,Electronic Invoice Register,Registar elektroničkih računa
@@ -7969,6 +8006,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Porezi i naknade Umanjenja (Društvo valuta)
 DocType: Item Group,General Settings,General Settings
 DocType: Article,Article,Član
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Unesite kod kupona !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Od valute i valuta ne mogu biti isti
 DocType: Taxable Salary Slab,Percent Deduction,Procenat odbijanja
 DocType: GL Entry,To Rename,Preimenovati
diff --git a/erpnext/translations/ca.csv b/erpnext/translations/ca.csv
index e2e8ae2..da6edd5 100644
--- a/erpnext/translations/ca.csv
+++ b/erpnext/translations/ca.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Client Contacte
 DocType: Shift Type,Enable Auto Attendance,Activa l&#39;assistència automàtica
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Introduïu la data i el magatzem
 DocType: Lost Reason Detail,Opportunity Lost Reason,Motiu perdut per l&#39;oportunitat
 DocType: Patient Appointment,Check availability,Comprova disponibilitat
 DocType: Retention Bonus,Bonus Payment Date,Data de pagament addicional
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Comandes de treball realitzats
 DocType: Support Settings,Forum Posts,Missatges del Fòrum
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","La tasca es va obtenir com a tasca de fons. En cas que hi hagi algun problema sobre el processament en segon pla, el sistema afegirà un comentari sobre l&#39;error d&#39;aquesta reconciliació d&#39;existències i tornarà a la fase d&#39;esborrany."
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Ho sentim, la validesa del codi de cupó no s&#39;ha iniciat"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,base imposable
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},No té permisos per afegir o actualitzar les entrades abans de {0}
 DocType: Leave Policy,Leave Policy Details,Deixeu els detalls de la política
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Consumible
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,grau
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Codi de l&#39;article&gt; Grup d&#39;articles&gt; Marca
 DocType: Restaurant Table,No of Seats,No de seients
 DocType: Sales Invoice,Overdue and Discounted,Retardat i descomptat
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Trucada desconnectada
@@ -506,6 +509,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,interlineat de la suma en paraules
 DocType: Vehicle,Additional Details,Detalls addicionals
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Cap descripció donada
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Obtenir articles de magatzem
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Sol·licitud de venda.
 DocType: POS Closing Voucher Details,Collected Amount,Import acumulat
 DocType: Lab Test,Submitted Date,Data enviada
@@ -613,6 +617,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Aprendre
 ,Trial Balance (Simple),Saldo de prova (simple)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Activa la despesa diferida
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Codi de cupó aplicat
 DocType: Asset,Next Depreciation Date,Següent Depreciació Data
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Cost Activitat per Empleat
 DocType: Accounts Settings,Settings for Accounts,Ajustaments de Comptes
@@ -848,8 +853,6 @@
 DocType: BOM,Work Order,Ordre de treball
 DocType: Sales Invoice,Total Qty,Quantitat total
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 ID de correu electrònic
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Si us plau, suprimiu l&#39;empleat <a href=""#Form/Employee/{0}"">{0}</a> \ per cancel·lar aquest document"
 DocType: Item,Show in Website (Variant),Mostra en el lloc web (variant)
 DocType: Employee,Health Concerns,Problemes de Salut
 DocType: Payroll Entry,Select Payroll Period,Seleccioneu el període de nòmina
@@ -1013,6 +1016,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Compte de retenció d&#39;impostos
 DocType: Pricing Rule,Sales Partner,Soci de vendes
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Tots els quadres de comandament del proveïdor.
+DocType: Coupon Code,To be used to get discount,Per ser utilitzat per obtenir descompte
 DocType: Buying Settings,Purchase Receipt Required,Es requereix rebut de compra
 DocType: Sales Invoice,Rail,Ferrocarril
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Cost real
@@ -1063,6 +1067,7 @@
 DocType: Production Plan,Production Plan,Pla de producció
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Obrir l&#39;eina de creació de la factura
 DocType: Salary Component,Round to the Nearest Integer,Ronda a l’entitat més propera
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Permetre afegir articles a la cistella
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Devolucions de vendes
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Establir Qty en les transaccions basades en la entrada sense sèrie
 ,Total Stock Summary,Resum de la total
@@ -1192,6 +1197,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),La tarifa bàsica d&#39;Hora (Companyia de divises)
 ,Qty To Be Billed,Quantitat per ser facturat
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Quantitat lliurada
+DocType: Coupon Code,Gift Card,Targeta Regal
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Quantitat reservada per a la producció: quantitat de matèries primeres per fabricar articles de fabricació.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Data de reemborsament
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Aquesta transacció bancària ja està totalment conciliada
@@ -1279,6 +1285,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Crea un full de temps
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Compte {0} s&#39;ha introduït diverses vegades
 DocType: Account,Expenses Included In Valuation,Despeses incloses en la valoració
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Factures de compra
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Només podeu renovar si la vostra pertinença caduca en un termini de 30 dies
 DocType: Shopping Cart Settings,Show Stock Availability,Mostra la disponibilitat d&#39;existències
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Estableix {0} a la categoria d&#39;actius {1} o a l&#39;empresa {2}
@@ -1837,6 +1844,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Importació d&#39;elements i OIM
 DocType: Repayment Schedule,Balance Loan Amount,Saldo del Préstec Monto
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,S&#39;ha afegit als detalls
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Ho sentim, el codi de cupó s&#39;ha esgotat"
 DocType: Communication Medium,Catch All,Agafa tot
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Calendari de Cursos
 DocType: Budget,Applicable on Material Request,Aplicable a la sol·licitud de material
@@ -2004,6 +2012,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Atribut no vàlid
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} s'ha de Presentar
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Campanyes de correu electrònic
+DocType: Sales Partner,To Track inbound purchase,Per fer el seguiment de la compra entrant
 DocType: Buying Settings,Default Supplier Group,Grup de proveïdors per defecte
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},La quantitat ha de ser menor que o igual a {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},La quantitat màxima elegible per al component {0} supera {1}
@@ -2159,8 +2168,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Fes una entrada en accions
 DocType: Hotel Room Reservation,Hotel Reservation User,Usuari de la reserva d&#39;hotel
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Definiu l&#39;estat
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Configureu les sèries de numeració per assistència mitjançant Configuració&gt; Sèries de numeració
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Seleccioneu el prefix primer
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Configureu Naming Series per {0} a través de Configuració&gt; Configuració&gt; Sèries de noms
 DocType: Contract,Fulfilment Deadline,Termini de compliment
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,A prop teu
 DocType: Student,O-,O-
@@ -2284,6 +2293,7 @@
 DocType: Quality Meeting Table,Under Review,Sota revisió
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,No s&#39;ha pogut iniciar la sessió
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Asset {0} creat
+DocType: Coupon Code,Promotional,Promocional
 DocType: Special Test Items,Special Test Items,Elements de prova especials
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Heu de ser un usuari amb les funcions d&#39;Administrador del sistema i d&#39;Administrador d&#39;elements per registrar-se a Marketplace.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Informes clau
@@ -2321,6 +2331,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Tipus Doc
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,El Percentatge del total assignat per a l'equip de vendes ha de ser de 100
 DocType: Subscription Plan,Billing Interval Count,Compte d&#39;interval de facturació
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Elimineu l&#39;empleat <a href=""#Form/Employee/{0}"">{0}</a> \ per cancel·lar aquest document"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Nomenaments i trobades de pacients
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Valor que falta
 DocType: Employee,Department and Grade,Departament i grau
@@ -2423,6 +2435,7 @@
 DocType: Project,Start and End Dates,Les dates d&#39;inici i fi
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Termes de compliment de la plantilla de contracte
 ,Delivered Items To Be Billed,Articles lliurats pendents de facturar
+DocType: Coupon Code,Maximum Use,Ús màxim
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Obrir la llista de materials {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Magatzem no pot ser canviat pel Nº de Sèrie
 DocType: Authorization Rule,Average Discount,Descompte Mig
@@ -2585,6 +2598,7 @@
 DocType: Item,Inventory,Inventari
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Descarregueu com a Json
 DocType: Item,Sales Details,Detalls de venda
+DocType: Coupon Code,Used,Utilitzat
 DocType: Opportunity,With Items,Amb articles
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',La campanya &#39;{0}&#39; ja existeix per a la {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Equip de manteniment
@@ -2714,7 +2728,7 @@
 						Serial No cannot be ensured",No s&#39;ha trobat cap BOM actiu per a l&#39;element {0}. El lliurament per \ Serial No no es pot garantir
 DocType: Sales Partner,Sales Partner Target,Sales Partner Target
 DocType: Loan Type,Maximum Loan Amount,La quantitat màxima del préstec
-DocType: Pricing Rule,Pricing Rule,Regla preus
+DocType: Coupon Code,Pricing Rule,Regla preus
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},nombre de rotllo duplicat per a l&#39;estudiant {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Sol·licitud de materials d&#39;Ordre de Compra
 DocType: Company,Default Selling Terms,Condicions de venda predeterminades
@@ -2793,6 +2807,7 @@
 DocType: Payment Schedule,Payment Amount,Quantitat de pagament
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,La data de mig dia ha d&#39;estar entre el treball des de la data i la data de finalització del treball
 DocType: Healthcare Settings,Healthcare Service Items,Articles de serveis sanitaris
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Codi de barres no vàlid. No hi ha cap article adjunt a aquest codi de barres.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Quantitat consumida
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Canvi Net en Efectiu
 DocType: Assessment Plan,Grading Scale,Escala de Qualificació
@@ -2912,7 +2927,6 @@
 DocType: Share Transfer,Asset Account,Compte d&#39;actius
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,La nova data de llançament hauria de ser en el futur
 DocType: Purchase Invoice,End date of current invoice's period,Data de finalització del període de facturació actual
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Configureu el sistema de nominació dels empleats a Recursos humans&gt; Configuració de recursos humans
 DocType: Lab Test,Technician Name,Tècnic Nom
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3023,6 +3037,7 @@
 DocType: Products Settings,Hide Variants,Amagueu les variants
 DocType: Lead,Next Contact By,Següent Contactar Per
 DocType: Compensatory Leave Request,Compensatory Leave Request,Sol·licitud de baixa compensatòria
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","No es pot generar l&#39;excés de l&#39;element {0} a la fila {1} més de {2}. Per permetre l&#39;excés de facturació, establiu la quantitat a la configuració del compte"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Quantitat necessària per Punt {0} a la fila {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Magatzem {0} no es pot eliminar com existeix quantitat d'article {1}
 DocType: Blanket Order,Order Type,Tipus d'ordre
@@ -3192,7 +3207,6 @@
 DocType: Student,Student Mobile Number,Nombre mòbil Estudiant
 DocType: Item,Has Variants,Té variants
 DocType: Employee Benefit Claim,Claim Benefit For,Reclamació per benefici
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","No es pot superar l&#39;element {0} a la fila {1} més que {2}. Per permetre una facturació excessiva, configureu-la a Configuració de valors"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Actualitza la resposta
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Ja ha seleccionat articles de {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Nom de la Distribució Mensual
@@ -3483,6 +3497,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,"Si us plau, especifiqui la moneda a l'empresa"
 DocType: Workstation,Wages per hour,Els salaris per hora
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Configura {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Client&gt; Grup de clients&gt; Territori
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Estoc equilibri en Lot {0} es convertirà en negativa {1} per a la partida {2} a Magatzem {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Després de sol·licituds de materials s&#39;han plantejat de forma automàtica segons el nivell de re-ordre de l&#39;article
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Compte {0} no és vàlid. Compte moneda ha de ser {1}
@@ -3812,6 +3827,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Presentar nòmina
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,En espera
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Una qustion ha de tenir almenys una opció correcta
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Ordres de compra
 DocType: Account,Inter Company Account,Compte d&#39;empresa Inter
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Importació a granel
 DocType: Sales Partner,Address & Contacts,Direcció i contactes
@@ -3822,6 +3838,7 @@
 DocType: POS Profile,[Select],[Seleccionar]
 DocType: Staffing Plan Detail,Number Of Positions,Nombre de posicions
 DocType: Vital Signs,Blood Pressure (diastolic),Pressió sanguínia (diastòlica)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Seleccioneu el client.
 DocType: SMS Log,Sent To,Enviat A
 DocType: Agriculture Task,Holiday Management,Gestió de vacances
 DocType: Payment Request,Make Sales Invoice,Fer Factura Vendes
@@ -4031,7 +4048,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} no está presentat
 DocType: Subscription,Trialling,Trialling
 DocType: Sales Invoice Item,Deferred Revenue,Ingressos diferits
-DocType: Bank Account,GL Account,Compte GL
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,El compte de caixa s&#39;utilitzarà per a la creació de factures de vendes
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Subcategoria d&#39;exempció
 DocType: Member,Membership Expiry Date,Data de venciment de la pertinença
@@ -4455,13 +4471,13 @@
 DocType: C-Form Invoice Detail,Territory,Territori
 DocType: Pricing Rule,Apply Rule On Item Code,Aplica la regla del codi de l&#39;article
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,"Si us plau, no de visites requerides"
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Informe de saldos
 DocType: Stock Settings,Default Valuation Method,Mètode de valoració predeterminat
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,quota
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Mostra la quantitat acumulativa
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Actualització en progrés. Pot trigar un temps.
 DocType: Production Plan Item,Produced Qty,Quant produït
 DocType: Vehicle Log,Fuel Qty,Quantitat de combustible
-DocType: Stock Entry,Target Warehouse Name,Nom del magatzem de destinació
 DocType: Work Order Operation,Planned Start Time,Planificació de l'hora d'inici
 DocType: Course,Assessment,valoració
 DocType: Payment Entry Reference,Allocated,Situat
@@ -4539,10 +4555,12 @@
  1. Formes de disputes que aborden, indemnització, responsabilitat, etc. 
  1. Adreça i contacte de la seva empresa."
 DocType: Homepage Section,Section Based On,Secció Basada en
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Mostra Aplica el codi de cupó
 DocType: Issue,Issue Type,Tipus d&#39;emissió
 DocType: Attendance,Leave Type,Tipus de llicència
 DocType: Purchase Invoice,Supplier Invoice Details,Detalls de la factura del proveïdor
 DocType: Agriculture Task,Ignore holidays,Ignora les vacances
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Afegiu / editeu les condicions del cupó
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"El compte de despeses / diferències ({0}) ha de ser un compte ""Guany o Pèrdua '"
 DocType: Stock Entry Detail,Stock Entry Child,Entrada d’accions d’infants
 DocType: Project,Copied From,de copiat
@@ -4717,6 +4735,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Criteris d&#39;avaluació del pla
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Transaccions
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Evitar les comandes de compra
+DocType: Coupon Code,Coupon Name,Nom del cupó
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Susceptible
 DocType: Email Campaign,Scheduled,Programat
 DocType: Shift Type,Working Hours Calculation Based On,Basat en el càlcul de les hores de treball
@@ -4733,7 +4752,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Crear Variants
 DocType: Vehicle,Diesel,dièsel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,No s'ha escollit una divisa per la llista de preus
+DocType: Quick Stock Balance,Available Quantity,Quantitat disponible
 DocType: Purchase Invoice,Availed ITC Cess,Aprovat ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Configureu un sistema de nom de l’Instructor a Educació&gt; Configuració d’educació
 ,Student Monthly Attendance Sheet,Estudiant Full d&#39;Assistència Mensual
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,La norma d&#39;enviament només és aplicable per a la venda
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Fila d&#39;amortització {0}: la següent data de depreciació no pot ser abans de la data de compra
@@ -4800,8 +4821,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Fila {0}: Avanç contra el Client ha de ser de crèdit
 DocType: Quality Meeting,Quality Meeting,Reunió de qualitat
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,No al Grup Grup
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Configureu Naming Series per {0} a través de Configuració&gt; Configuració&gt; Sèries de noms
 DocType: Employee,ERPNext User,Usuari ERPNext
+DocType: Coupon Code,Coupon Description,Descripció del cupó
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Lot és obligatori a la fila {0}
 DocType: Company,Default Buying Terms,Condicions de compra per defecte
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Rebut de compra dels articles subministrats
@@ -4964,6 +4985,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Contra Detall del document núm
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},La supressió no està permesa per al país {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Tipus del partit és obligatori
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Apliqueu el codi de cupó
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","Per a la targeta de treball {0}, només podeu fer l&#39;entrada al material &quot;Tipus de transferència de material per a la fabricació&quot;"
 DocType: Quality Inspection,Outgoing,Extravertida
 DocType: Customer Feedback Table,Customer Feedback Table,Taula de comentaris dels clients
@@ -5113,7 +5135,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Enviament de la comanda de compra
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Afegeix tots els proveïdors
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Fila # {0}: quantitat assignada no pot ser més gran que la quantitat pendent.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Client&gt; Grup de clients&gt; Territori
 DocType: Tally Migration,Parties,Festa
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Navegar per llista de materials
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Préstecs Garantits
@@ -5145,7 +5166,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},No permetis establir un element alternatiu per a l&#39;element {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Data repetida
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Signant Autoritzat
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Configureu un sistema de nom de l’Instructor a Educació&gt; Configuració d’educació
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),TIC net disponible (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Crea tarifes
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Cost total de compra (mitjançant compra de la factura)
@@ -5170,6 +5190,7 @@
 DocType: Quiz Result,Wrong,Mal
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Velocitat a la qual la llista de preus de divises es converteix la moneda base del client
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Import net (Companyia moneda)
+DocType: Sales Partner,Referral Code,Codi de Referència
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,L&#39;import anticipat total no pot ser superior al total de la quantitat sancionada
 DocType: Salary Slip,Hour Rate,Hour Rate
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Activa la reordena automàtica
@@ -5298,6 +5319,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Mostra la quantitat d&#39;existències
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Efectiu net de les operacions
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Fila # {0}: l&#39;estat ha de ser {1} per descomptar la factura {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Factor de conversió UOM ({0} -&gt; {1}) no trobat per a l&#39;element: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Article 4
 DocType: Student Admission,Admission End Date,L&#39;entrada Data de finalització
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,la subcontractació
@@ -5320,6 +5342,7 @@
 DocType: Travel Request,Fully Sponsored,Totalment patrocinat
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Entrada periòdica inversa
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Crea la targeta de treball
+DocType: Quotation,Referral Sales Partner,Soci de vendes de derivacions
 DocType: Quality Procedure Process,Process Description,Descripció del procés
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,S&#39;ha creat el client {0}.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Actualment no hi ha existències disponibles en cap magatzem
@@ -5454,6 +5477,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM Rate
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Llegint el fitxer carregat
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","No es pot cancel·lar la comanda de treball parada, sense desactivar-lo primer a cancel·lar"
+DocType: Coupon Code,Coupon Code,Codi de cupó
 DocType: Asset,Journal Entry for Scrap,Entrada de diari de la ferralla
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,"Si us plau, tiri d'articles de lliurament Nota"
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Fila {0}: seleccioneu l&#39;estació de treball contra l&#39;operació {1}
@@ -5536,6 +5560,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,És necessària la «data»
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},A causa / Data de referència no pot ser posterior a {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Les dades d&#39;importació i exportació
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Ho sentim, la validesa del codi de cupó ha caducat"
 DocType: Bank Account,Account Details,Detalls del compte
 DocType: Crop,Materials Required,Materials obligatoris
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,No s&#39;han trobat estudiants
@@ -5573,6 +5598,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Aneu als usuaris
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Quantitat pagada + s'amortitza La quantitat no pot ser més gran que la Gran Total
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},El Número de Lot {0} de l'Article {1} no és vàlid
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Introduïu el codi de cupó vàlid !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Note: There is not enough leave balance for Leave Type {0}
 DocType: Task,Task Description,Descripció de la tasca
 DocType: Training Event,Seminar,seminari
@@ -5837,6 +5863,7 @@
 ,TDS Payable Monthly,TDS mensuals pagables
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,En espera per reemplaçar la BOM. Pot trigar uns minuts.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',No es pot deduir quan categoria és per a 'Valoració' o 'Valoració i Total'
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Configureu el sistema de nominació dels empleats a Recursos humans&gt; Configuració de recursos humans
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Total de pagaments
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Nº de Sèrie Necessari per article serialitzat {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Els pagaments dels partits amb les factures
@@ -5926,6 +5953,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Obtenir matèries primeres per a la producció
 DocType: Job Opening,Job Title,Títol Professional
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Pagament futur Ref
+DocType: Quotation,Additional Discount and Coupon Code,Codi de descompte addicional i cupó
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} indica que {1} no proporcionarà una cita, però tots els ítems s&#39;han citat. Actualització de l&#39;estat de la cotització de RFQ."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,S&#39;han conservat les mostres màximes ({0}) per al lot {1} i l&#39;element {2} en lot {3}.
@@ -6153,7 +6181,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Ajustos per a la pàgina d&#39;inici pàgina web
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} està en espera fins a {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},Les RFQ no estan permeses per {0} a causa d&#39;un quadre de comandament de peu de {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Feu Compra Factura
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Fulles utilitzades
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} El cupó utilitzat són {1}. La quantitat permesa s’esgota
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Voleu enviar la sol·licitud de material
 DocType: Job Offer,Awaiting Response,Espera de la resposta
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH -YYYY.-
@@ -6167,6 +6197,7 @@
 DocType: Training Event Employee,Optional,Opcional
 DocType: Salary Slip,Earning & Deduction,Guanyar i Deducció
 DocType: Agriculture Analysis Criteria,Water Analysis,Anàlisi de l&#39;aigua
+DocType: Sales Order,Skip Delivery Note,Omet el lliurament
 DocType: Price List,Price Not UOM Dependent,Preu no dependent de UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,S&#39;han creat {0} variants.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Ja existeix un acord de nivell de servei per defecte.
@@ -6271,6 +6302,7 @@
 DocType: Vehicle,Last Carbon Check,Últim control de Carboni
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Despeses legals
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Si us plau seleccioni la quantitat al corredor
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Ordre de treball {0}: no s&#39;ha trobat la targeta de treball per a l&#39;operació {1}
 DocType: Purchase Invoice,Posting Time,Temps d'enviament
 DocType: Timesheet,% Amount Billed,% Import Facturat
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Despeses telefòniques
@@ -6373,7 +6405,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Impostos i càrregues afegides
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,La fila de depreciació {0}: la següent data de la depreciació no pot ser abans de la data d&#39;ús disponible
 ,Sales Funnel,Sales Funnel
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Codi de l&#39;article&gt; Grup d&#39;articles&gt; Marca
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Abreviatura és obligatori
 DocType: Project,Task Progress,Grup de Progrés
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Carro
@@ -6469,6 +6500,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS perfil requerit per fer l&#39;entrada POS
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Els punts de fidelització es calcularan a partir del fet gastat (a través de la factura de vendes), segons el factor de recollida esmentat."
 DocType: Program Enrollment Tool,Enroll Students,inscriure els estudiants
+DocType: Pricing Rule,Coupon Code Based,Basat en codi de cupó
 DocType: Company,HRA Settings,Configuració HRA
 DocType: Homepage,Hero Section,Secció Herois
 DocType: Employee Transfer,Transfer Date,Data de transferència
@@ -6584,6 +6616,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Si us plau ajust empresa de filtres en blanc si és Agrupa per &#39;empresa&#39;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Data d&#39;entrada no pot ser data futura
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Fila # {0}: Nombre de sèrie {1} no coincideix amb {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Configureu les sèries de numeració per assistència mitjançant Configuració&gt; Sèries de numeració
 DocType: Stock Entry,Target Warehouse Address,Adreça de destinació de magatzem
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Deixar Casual
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,El temps abans de l&#39;hora d&#39;inici del torn durant el qual es preveu el registre d&#39;entrada dels empleats per assistència.
@@ -6618,7 +6651,6 @@
 DocType: Employee Grade,Employee Grade,Grau d&#39;empleat
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Treball a preu fet
 DocType: GSTR 3B Report,June,juny
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Proveïdor&gt; Tipus de proveïdor
 DocType: Share Balance,From No,Del núm
 DocType: Shift Type,Early Exit Grace Period,Període de gràcia de sortida
 DocType: Task,Actual Time (in Hours),Temps real (en hores)
@@ -6903,7 +6935,6 @@
 DocType: Warehouse,Warehouse Name,Nom Magatzem
 DocType: Naming Series,Select Transaction,Seleccionar Transacció
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Si us plau entra el rol d'aprovació o l'usuari aprovador
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Factor de conversió UOM ({0} -&gt; {1}) no trobat per a l&#39;element: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Ja existeix un contracte de nivell de servei amb el tipus d&#39;entitat {0} i l&#39;entitat {1}.
 DocType: Journal Entry,Write Off Entry,Escriu Off Entrada
 DocType: BOM,Rate Of Materials Based On,Tarifa de materials basats en
@@ -7041,6 +7072,7 @@
 DocType: Budget,Warn,Advertir
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Ja s&#39;han transferit tots els ítems per a aquesta Ordre de treball.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Altres observacions, esforç notable que ha d&#39;anar en els registres."
+DocType: Bank Account,Company Account,Compte de l&#39;empresa
 DocType: Asset Maintenance,Manufacturing User,Usuari de fabricació
 DocType: Purchase Invoice,Raw Materials Supplied,Matèries primeres subministrades
 DocType: Subscription Plan,Payment Plan,Pla de pagament
@@ -7082,6 +7114,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) no pot ser major que la quantitat planificada  ({2}) a l'Ordre de Treball {3}
 DocType: Certification Application,Name of Applicant,Nom del sol · licitant
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Full de temps per a la fabricació.
+DocType: Quick Stock Balance,Quick Stock Balance,Saldo de valors ràpids
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,total parcial
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,No es poden canviar les propietats de variants després de la transacció d&#39;accions. Haureu de fer un nou element per fer-ho.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,Mandat de SEPA GoCardless
@@ -7408,6 +7441,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},"Si us plau, estableix {0}"
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} és estudiant inactiu
 DocType: Employee,Health Details,Detalls de la Salut
+DocType: Coupon Code,Coupon Type,Tipus de cupó
 DocType: Leave Encashment,Encashable days,Dies incondicionals
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Per a crear una sol·licitud de pagament es requereix document de referència
 DocType: Soil Texture,Sandy Clay,Sandy Clay
@@ -7691,6 +7725,7 @@
 DocType: Hotel Room Package,Amenities,Serveis
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Recupera automàticament els termes de pagament
 DocType: QuickBooks Migrator,Undeposited Funds Account,Compte de fons no transferit
+DocType: Coupon Code,Uses,Usos
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,No es permet el mode de pagament múltiple per defecte
 DocType: Sales Invoice,Loyalty Points Redemption,Punts de lleialtat Redenció
 ,Appointment Analytics,Anàlisi de cites
@@ -7707,6 +7742,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Pressupost total
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Deixar en blanc si fas grups d&#39;estudiants per any
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Si es marca, número total. de dies de treball s'inclouran els festius, i això reduirà el valor de Salari per dia"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,No s&#39;ha pogut afegir domini
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Per permetre el rebut / lliurament, actualitzeu &quot;Indemnització de recepció / lliurament&quot; a la configuració de les accions o a l&#39;article."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Les aplicacions que utilitzin la clau actual no podran accedir, segurament?"
 DocType: Subscription Settings,Prorate,Prorate
@@ -7719,6 +7755,7 @@
 ,BOM Stock Report,La llista de materials d&#39;Informe
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Si no hi ha un timelot assignat, aquest grup la gestionarà la comunicació"
 DocType: Stock Reconciliation Item,Quantity Difference,quantitat Diferència
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Proveïdor&gt; Tipus de proveïdor
 DocType: Opportunity Item,Basic Rate,Tarifa Bàsica
 DocType: GL Entry,Credit Amount,Suma de crèdit
 ,Electronic Invoice Register,Registre de factures electròniques
@@ -7972,6 +8009,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Impostos i despeses deduïdes (Companyia moneda)
 DocType: Item Group,General Settings,Configuració general
 DocType: Article,Article,Article
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Introduïu el codi del cupó !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Des moneda i moneda no pot ser el mateix
 DocType: Taxable Salary Slab,Percent Deduction,Deducció per cent
 DocType: GL Entry,To Rename,Per canviar el nom
diff --git a/erpnext/translations/cs.csv b/erpnext/translations/cs.csv
index aa526b1..6859665 100644
--- a/erpnext/translations/cs.csv
+++ b/erpnext/translations/cs.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Kontakt se zákazníky
 DocType: Shift Type,Enable Auto Attendance,Povolit automatickou účast
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Zadejte prosím sklad a datum
 DocType: Lost Reason Detail,Opportunity Lost Reason,Příležitost Ztracený důvod
 DocType: Patient Appointment,Check availability,Zkontrolujte dostupnost
 DocType: Retention Bonus,Bonus Payment Date,Bonus Datum platby
@@ -264,6 +265,7 @@
 ,Completed Work Orders,Dokončené pracovní příkazy
 DocType: Support Settings,Forum Posts,Příspěvky ve fóru
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage",Úkol byl označen jako úloha na pozadí. V případě jakéhokoli problému se zpracováním na pozadí přidá systém komentář k chybě v tomto smíření zásob a vrátí se do fáze konceptu.
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Litujeme, platnost kódu kupónu nezačala"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Zdanitelná částka
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Nejste oprávněni přidávat nebo aktualizovat údaje před {0}
 DocType: Leave Policy,Leave Policy Details,Zanechat podrobnosti o zásadách
@@ -329,6 +331,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Spotřební
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,Školní známka
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kód položky&gt; Skupina položek&gt; Značka
 DocType: Restaurant Table,No of Seats,Počet sedadel
 DocType: Sales Invoice,Overdue and Discounted,Po lhůtě splatnosti a se slevou
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Hovor byl odpojen
@@ -505,6 +508,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,řádkování za částku ve slovech
 DocType: Vehicle,Additional Details,další detaily
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,No vzhledem k tomu popis
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Načíst položky ze skladu
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Žádost o koupi.
 DocType: POS Closing Voucher Details,Collected Amount,Sběrná částka
 DocType: Lab Test,Submitted Date,Datum odeslání
@@ -612,6 +616,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Učit se
 ,Trial Balance (Simple),Zkušební zůstatek (jednoduchý)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Aktivovat odložený náklad
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Kód použitého kupónu
 DocType: Asset,Next Depreciation Date,Vedle Odpisy Datum
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Náklady na činnost na jednoho zaměstnance
 DocType: Accounts Settings,Settings for Accounts,Nastavení účtů
@@ -847,8 +852,6 @@
 DocType: BOM,Work Order,Zakázka
 DocType: Sales Invoice,Total Qty,Celkem Množství
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,ID e-mailu Guardian2
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Chcete-li tento dokument zrušit, prosím odstraňte zaměstnance <a href=""#Form/Employee/{0}"">{0}</a> \"
 DocType: Item,Show in Website (Variant),Show do webových stránek (Variant)
 DocType: Employee,Health Concerns,Zdravotní Obavy
 DocType: Payroll Entry,Select Payroll Period,Vyberte mzdové
@@ -1012,6 +1015,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Účet pro zadržení daně
 DocType: Pricing Rule,Sales Partner,Sales Partner
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Všechna hodnocení dodavatelů.
+DocType: Coupon Code,To be used to get discount,Slouží k získání slevy
 DocType: Buying Settings,Purchase Receipt Required,Příjmka je vyžadována
 DocType: Sales Invoice,Rail,Železnice
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Aktuální cena
@@ -1062,6 +1066,7 @@
 DocType: Production Plan,Production Plan,Plán produkce
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Otevření nástroje pro vytváření faktur
 DocType: Salary Component,Round to the Nearest Integer,Zaokrouhlí na nejbližší celé číslo
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,"Povolit přidání zboží, které není na skladě, do košíku"
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Sales Return
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Nastavte počet transakcí na základě sériového č. Vstupu
 ,Total Stock Summary,Shrnutí souhrnného stavu
@@ -1191,6 +1196,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Základna hodinová sazba (Company měny)
 ,Qty To Be Billed,Množství k vyúčtování
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Dodává Částka
+DocType: Coupon Code,Gift Card,Dárková poukázka
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Vyhrazeno Množství pro výrobu: Množství surovin pro výrobu výrobních položek.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Datum vykoupení
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Tato bankovní transakce je již plně sladěna
@@ -1278,6 +1284,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Vytvoření časového rozvrhu
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Účet {0} byl zadán vícekrát
 DocType: Account,Expenses Included In Valuation,Náklady ceně oceňování
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Nákup faktur
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,"Můžete obnovit pouze tehdy, pokud vaše členství vyprší během 30 dnů"
 DocType: Shopping Cart Settings,Show Stock Availability,Zobrazit dostupnost skladem
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Nastavte {0} v kategorii aktiv {1} nebo ve firmě {2}
@@ -1836,6 +1843,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Import položek a UOM
 DocType: Repayment Schedule,Balance Loan Amount,Balance Výše úvěru
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Přidáno do podrobností
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Litujeme, kód kupónu je vyčerpán"
 DocType: Communication Medium,Catch All,Chytit vše
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,rozvrh
 DocType: Budget,Applicable on Material Request,Použitelné na žádosti o materiál
@@ -2003,6 +2011,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Neplatný Atribut
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} musí být odeslaný
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,E-mailové kampaně
+DocType: Sales Partner,To Track inbound purchase,Chcete-li sledovat příchozí nákup
 DocType: Buying Settings,Default Supplier Group,Výchozí skupina dodavatelů
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Množství musí být menší než nebo rovno {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Maximální částka způsobilá pro komponentu {0} přesahuje {1}
@@ -2158,8 +2167,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Proveďte zadávání zásob
 DocType: Hotel Room Reservation,Hotel Reservation User,Uživatel rezervace ubytování
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Nastavit stav
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Nastavte číslovací řady pro Docházku prostřednictvím Nastavení&gt; Číslovací řady
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,"Prosím, vyberte první prefix"
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Nastavte Naming Series pro {0} prostřednictvím Nastavení&gt; Nastavení&gt; Naming Series
 DocType: Contract,Fulfilment Deadline,Termín splnění
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Ve vašem okolí
 DocType: Student,O-,Ó-
@@ -2283,6 +2292,7 @@
 DocType: Quality Meeting Table,Under Review,Probíhá kontrola
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Přihlášení selhalo
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Asset {0} vytvořen
+DocType: Coupon Code,Promotional,Propagační
 DocType: Special Test Items,Special Test Items,Speciální zkušební položky
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,"Musíte být uživatelem s rolí Správce systému a Správce položek, který se má zaregistrovat na webu Marketplace."
 apps/erpnext/erpnext/config/buying.py,Key Reports,Klíčové zprávy
@@ -2320,6 +2330,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc Type
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Celkové přidělené procento prodejní tým by měl být 100
 DocType: Subscription Plan,Billing Interval Count,Počet fakturačních intervalů
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Chcete-li tento dokument zrušit, prosím odstraňte zaměstnance <a href=""#Form/Employee/{0}"">{0}</a> \"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Setkání a setkání s pacienty
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Hodnota chybí
 DocType: Employee,Department and Grade,Oddělení a stupeň
@@ -2422,6 +2434,7 @@
 DocType: Project,Start and End Dates,Datum zahájení a ukončení
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Podmínky splnění šablony smlouvy
 ,Delivered Items To Be Billed,Dodávaných výrobků fakturovaných
+DocType: Coupon Code,Maximum Use,Maximální využití
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Otevřená BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Warehouse nemůže být změněn pro Serial No.
 DocType: Authorization Rule,Average Discount,Průměrná sleva
@@ -2584,6 +2597,7 @@
 DocType: Item,Inventory,Inventář
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Stáhnout jako Json
 DocType: Item,Sales Details,Prodejní Podrobnosti
+DocType: Coupon Code,Used,Použitý
 DocType: Opportunity,With Items,S položkami
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Kampaň &#39;{0}&#39; již existuje pro {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Tým údržby
@@ -2713,7 +2727,7 @@
 						Serial No cannot be ensured",Pro položku {0} nebyl nalezen žádný aktivní kusovníček. Dodání pomocí \ sériového čísla nemůže být zajištěno
 DocType: Sales Partner,Sales Partner Target,Sales Partner Target
 DocType: Loan Type,Maximum Loan Amount,Maximální výše úvěru
-DocType: Pricing Rule,Pricing Rule,Ceny Pravidlo
+DocType: Coupon Code,Pricing Rule,Ceny Pravidlo
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplicitní číslo role pro studenty {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Materiál Žádost o příkazu k nákupu
 DocType: Company,Default Selling Terms,Výchozí prodejní podmínky
@@ -2792,6 +2806,7 @@
 DocType: Payment Schedule,Payment Amount,Částka platby
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Den poločasu by měl být mezi dnem práce a datem ukončení práce
 DocType: Healthcare Settings,Healthcare Service Items,Položky zdravotnické služby
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Neplatný čárový kód. K tomuto čárovému kódu není připojena žádná položka.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Spotřebovaném množství
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Čistá změna v hotovosti
 DocType: Assessment Plan,Grading Scale,Klasifikační stupnice
@@ -2911,7 +2926,6 @@
 DocType: Share Transfer,Asset Account,Účet aktiv
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Nové datum vydání by mělo být v budoucnosti
 DocType: Purchase Invoice,End date of current invoice's period,Datum ukončení doby aktuální faktury je
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Nastavte prosím systém názvů zaměstnanců v části Lidské zdroje&gt; Nastavení lidských zdrojů
 DocType: Lab Test,Technician Name,Jméno technika
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3022,6 +3036,7 @@
 DocType: Products Settings,Hide Variants,Skrýt varianty
 DocType: Lead,Next Contact By,Další Kontakt By
 DocType: Compensatory Leave Request,Compensatory Leave Request,Žádost o kompenzační dovolenou
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Nelze přeplatit za položku {0} v řádku {1} více než {2}. Chcete-li povolit nadměrnou fakturaci, nastavte v Nastavení účtu povolenky"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Množství požadované pro bodě {0} v řadě {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},"Sklad {0} nelze smazat, protože existuje množství k položce {1}"
 DocType: Blanket Order,Order Type,Typ objednávky
@@ -3191,7 +3206,6 @@
 DocType: Student,Student Mobile Number,Student Číslo mobilního telefonu
 DocType: Item,Has Variants,Má varianty
 DocType: Employee Benefit Claim,Claim Benefit For,Nárok na dávku pro
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Nelze přepsat položku {0} v řádku {1} více než {2}. Chcete-li povolit přeúčtování, nastavte prosím nastavení akcií"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Aktualizace odpovědi
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Již jste vybrané položky z {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Název měsíční výplatou
@@ -3482,6 +3496,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,"Uveďte prosím měnu, ve společnosti"
 DocType: Workstation,Wages per hour,Mzda za hodinu
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Konfigurovat {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Zákazník&gt; Skupina zákazníků&gt; Území
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Sklad bilance v dávce {0} se zhorší {1} k bodu {2} ve skladu {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Následující materiál žádosti byly automaticky zvýšena na základě úrovni re-pořadí položky
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Účet {0} je neplatný. Měna účtu musí být {1}
@@ -3811,6 +3826,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Odeslat výplatní pásce
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Pozastaveno
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Spalování musí mít alespoň jednu správnou možnost
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Objednávky
 DocType: Account,Inter Company Account,Inter podnikový účet
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Dovoz hromadnou
 DocType: Sales Partner,Address & Contacts,Adresa a kontakty
@@ -3821,6 +3837,7 @@
 DocType: POS Profile,[Select],[Vybrat]
 DocType: Staffing Plan Detail,Number Of Positions,Počet pozic
 DocType: Vital Signs,Blood Pressure (diastolic),Krevní tlak (diastolický)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Vyberte prosím zákazníka.
 DocType: SMS Log,Sent To,Odeslána
 DocType: Agriculture Task,Holiday Management,Správa prázdnin
 DocType: Payment Request,Make Sales Invoice,Proveďte prodejní faktuře
@@ -4030,7 +4047,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} není odesláno
 DocType: Subscription,Trialling,Testování
 DocType: Sales Invoice Item,Deferred Revenue,Odložené výnosy
-DocType: Bank Account,GL Account,GL účet
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Hotovostní účet bude použit pro vytvoření faktury
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Osvobození podkategorie
 DocType: Member,Membership Expiry Date,Datum ukončení členství
@@ -4454,13 +4470,13 @@
 DocType: C-Form Invoice Detail,Territory,Území
 DocType: Pricing Rule,Apply Rule On Item Code,Použít pravidlo na kód položky
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,"Prosím, uveďte počet požadovaných návštěv"
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Zpráva o stavu zásob
 DocType: Stock Settings,Default Valuation Method,Výchozí metoda ocenění
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Poplatek
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Zobrazit kumulativní částku
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Aktualizace probíhá. Může chvíli trvat.
 DocType: Production Plan Item,Produced Qty,Vyrobeno množství
 DocType: Vehicle Log,Fuel Qty,palivo Množství
-DocType: Stock Entry,Target Warehouse Name,Název cílového skladu
 DocType: Work Order Operation,Planned Start Time,Plánované Start Time
 DocType: Course,Assessment,Posouzení
 DocType: Payment Entry Reference,Allocated,Přidělené
@@ -4538,10 +4554,12 @@
  1. Způsoby řešení sporů, náhrady škody, odpovědnosti za škodu, atd 
  1. Adresa a kontakt na vaši společnost."
 DocType: Homepage Section,Section Based On,Sekce založená na
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Zobrazit Použít kód kupónu
 DocType: Issue,Issue Type,Typ vydání
 DocType: Attendance,Leave Type,Typ absence
 DocType: Purchase Invoice,Supplier Invoice Details,Dodavatel fakturační údaje
 DocType: Agriculture Task,Ignore holidays,Ignorovat svátky
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Přidat / upravit podmínky kupónu
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Náklady / Rozdíl účtu ({0}), musí být ""zisk nebo ztráta"" účet"
 DocType: Stock Entry Detail,Stock Entry Child,Zásoby dítě
 DocType: Project,Copied From,Zkopírován z
@@ -4716,6 +4734,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Plan Assessment Criteria
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Transakce
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Zabránit nákupním objednávkám
+DocType: Coupon Code,Coupon Name,Název kupónu
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Citlivý
 DocType: Email Campaign,Scheduled,Plánované
 DocType: Shift Type,Working Hours Calculation Based On,Výpočet pracovní doby na základě
@@ -4732,7 +4751,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Vytvoření variant
 DocType: Vehicle,Diesel,motorová nafta
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Ceníková Měna není zvolena
+DocType: Quick Stock Balance,Available Quantity,dostupné množství
 DocType: Purchase Invoice,Availed ITC Cess,Využil ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Nastavte prosím Pojmenovací systém instruktorů v sekci Vzdělávání&gt; Nastavení vzdělávání
 ,Student Monthly Attendance Sheet,Student měsíční návštěvnost Sheet
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Pravidlo plavby platí pouze pro prodej
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Odpisový řádek {0}: Další datum odpisu nemůže být před datem nákupu
@@ -4799,8 +4820,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Řádek {0}: Advance proti zákazník musí být úvěr
 DocType: Quality Meeting,Quality Meeting,Kvalitní setkání
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-skupiny ke skupině
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Nastavte Naming Series pro {0} prostřednictvím Nastavení&gt; Nastavení&gt; Naming Series
 DocType: Employee,ERPNext User,ERPN další uživatel
+DocType: Coupon Code,Coupon Description,Popis kupónu
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Dávka je povinná v řádku {0}
 DocType: Company,Default Buying Terms,Výchozí nákupní podmínky
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Doklad o koupi Item Dodávané
@@ -4963,6 +4984,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Proti Detail dokumentu č
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Smazání není povoleno pro zemi {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Typ strana je povinná
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Použijte kód kupónu
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",U karty zaměstnání {0} můžete provést pouze záznam typu „Převod materiálu pro výrobu“
 DocType: Quality Inspection,Outgoing,Vycházející
 DocType: Customer Feedback Table,Customer Feedback Table,Tabulka zpětné vazby od zákazníka
@@ -5112,7 +5134,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Při zadávání objednávky
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Přidat všechny dodavatele
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Řádek # {0}: Přidělená částka nesmí být vyšší než zůstatek.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Zákazník&gt; Skupina zákazníků&gt; Území
 DocType: Tally Migration,Parties,Strany
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Procházet kusovník
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Zajištěné úvěry
@@ -5144,7 +5165,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Neumožňuje nastavit alternativní položku pro položku {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Datum se opakuje
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Prokurista
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Nastavte prosím Pojmenovací systém instruktorů v sekci Vzdělávání&gt; Nastavení vzdělávání
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Dostupné ITC (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Vytvořte poplatky
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Celkové pořizovací náklady (přes nákupní faktury)
@@ -5169,6 +5189,7 @@
 DocType: Quiz Result,Wrong,Špatně
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Sazba, za kterou je ceníková měna převedena na základní měnu zákazníka"
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Čistá částka (Company Měna)
+DocType: Sales Partner,Referral Code,Kód doporučení
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Celková výše zálohy nesmí být vyšší než celková částka sankce
 DocType: Salary Slip,Hour Rate,Hour Rate
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Povolit automatické opětovné objednání
@@ -5296,6 +5317,7 @@
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},Vyberte prosím kusovníku podle položky {0}
 DocType: Shopping Cart Settings,Show Stock Quantity,Zobrazit množství zásob
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Čistý peněžní tok z provozní
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM konverzní faktor ({0} -&gt; {1}) nebyl nalezen pro položku: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Bod 4
 DocType: Student Admission,Admission End Date,Vstupné Datum ukončení
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Subdodávky
@@ -5318,6 +5340,7 @@
 DocType: Travel Request,Fully Sponsored,Plně sponzorováno
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Zadání reverzního deníku
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Vytvořit pracovní kartu
+DocType: Quotation,Referral Sales Partner,Prodejní partner pro doporučení
 DocType: Quality Procedure Process,Process Description,Popis procesu
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Zákazník {0} je vytvořen.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,V současné době žádné skladové zásoby nejsou k dispozici
@@ -5452,6 +5475,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM Rate
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Čtení nahraného souboru
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Zastavená pracovní objednávka nemůže být zrušena, zrušte její zrušení"
+DocType: Coupon Code,Coupon Code,Kód kupónu
 DocType: Asset,Journal Entry for Scrap,Zápis do deníku do šrotu
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,"Prosím, vytáhněte položky z dodací list"
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Řádek {0}: vyberte pracovní stanici proti operaci {1}
@@ -5534,6 +5558,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,Je požadováno „datum“
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Vzhledem / Referenční datum nemůže být po {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Import dat a export
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Litujeme, platnost kódu kupónu vypršela"
 DocType: Bank Account,Account Details,Údaje o účtu
 DocType: Crop,Materials Required,Potřebné materiály
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Žádní studenti Nalezené
@@ -5571,6 +5596,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Přejděte na položku Uživatelé
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Uhrazená částka + odepsaná částka nesmí být větší než celková částka
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} není platná Šarže pro Položku {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Zadejte prosím platný kuponový kód !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Poznámka: Není k dispozici dostatek zůstatek dovolené dovolená za kalendářní typ {0}
 DocType: Task,Task Description,Popis ulohy
 DocType: Training Event,Seminar,Seminář
@@ -5834,6 +5860,7 @@
 ,TDS Payable Monthly,TDS splatné měsíčně
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Naléhá na výměnu kusovníku. Může to trvat několik minut.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Nelze odečíst, pokud kategorie je určena pro ""ocenění"" nebo ""oceňování a celkový"""
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Nastavte prosím systém názvů zaměstnanců v části Lidské zdroje&gt; Nastavení lidských zdrojů
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Celkové platby
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serial Nos Požadováno pro serializovaném bodu {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Zápas platby fakturami
@@ -5923,6 +5950,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Získejte suroviny pro výrobu
 DocType: Job Opening,Job Title,Název pozice
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Budoucí platba Ref
+DocType: Quotation,Additional Discount and Coupon Code,Další slevový a kuponový kód
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} znamená, že {1} neposkytne citát, ale byly citovány všechny položky \. Aktualizace stavu nabídky RFQ."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maximální vzorky - {0} již byly zadány v dávce {1} a položce {2} v dávce {3}.
@@ -6150,7 +6178,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Nastavení titulní stránce webu
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} je podržen do {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQs nejsou povoleny pro {0} kvůli stavu scorecard {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Proveďte nákupní faktury
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Použité listy
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Použitý kupón je {1}. Povolené množství je vyčerpáno
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Chcete odeslat materiální žádost
 DocType: Job Offer,Awaiting Response,Čeká odpověď
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6164,6 +6194,7 @@
 DocType: Training Event Employee,Optional,Volitelný
 DocType: Salary Slip,Earning & Deduction,Výdělek a dedukce
 DocType: Agriculture Analysis Criteria,Water Analysis,Analýza vody
+DocType: Sales Order,Skip Delivery Note,Přeskočit dodací list
 DocType: Price List,Price Not UOM Dependent,Cena není závislá na UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,Vytvořeny varianty {0}.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Výchozí dohoda o úrovni služeb již existuje.
@@ -6268,6 +6299,7 @@
 DocType: Vehicle,Last Carbon Check,Poslední Carbon Check
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Výdaje na právní služby
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Vyberte množství v řadě
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Pracovní objednávka {0}: pracovní list nebyl nalezen pro operaci {1}
 DocType: Purchase Invoice,Posting Time,Čas zadání
 DocType: Timesheet,% Amount Billed,% Fakturované částky
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Telefonní Náklady
@@ -6370,7 +6402,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Daně a poplatky přidané
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Odpisový řádek {0}: Další datum odpisování nemůže být před datem k dispozici
 ,Sales Funnel,Prodej Nálevka
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kód položky&gt; Skupina položek&gt; Značka
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Zkratka je povinná
 DocType: Project,Task Progress,Pokrok úkol
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Vozík
@@ -6466,6 +6497,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,"POS Profile požadováno, aby POS Vstup"
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",Věrnostní body budou vypočteny z vynaložených výdajů (prostřednictvím faktury k prodeji) na základě zmíněného faktoru sběru.
 DocType: Program Enrollment Tool,Enroll Students,zapsat studenti
+DocType: Pricing Rule,Coupon Code Based,Kód založený na kupónu
 DocType: Company,HRA Settings,Nastavení HRA
 DocType: Homepage,Hero Section,Hero Section
 DocType: Employee Transfer,Transfer Date,Datum přenosu
@@ -6581,6 +6613,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',"Nastavte filtr společnosti prázdný, pokud je Skupina By je &#39;Company&#39;"
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Vysílání datum nemůže být budoucí datum
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Řádek # {0}: Výrobní číslo {1} neodpovídá {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Nastavte číslovací řady pro Docházku prostřednictvím Nastavení&gt; Číslovací řady
 DocType: Stock Entry,Target Warehouse Address,Cílová adresa skladu
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Casual Leave
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,"Čas před začátkem směny, během kterého je za účast považováno přihlášení zaměstnanců."
@@ -6615,7 +6648,6 @@
 DocType: Employee Grade,Employee Grade,Pracovní zařazení
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Úkolová práce
 DocType: GSTR 3B Report,June,červen
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dodavatel&gt; Typ dodavatele
 DocType: Share Balance,From No,Od č
 DocType: Shift Type,Early Exit Grace Period,Časné ukončení odkladu
 DocType: Task,Actual Time (in Hours),Skutečná doba (v hodinách)
@@ -6900,7 +6932,6 @@
 DocType: Warehouse,Warehouse Name,Název Skladu
 DocType: Naming Series,Select Transaction,Vybrat Transaction
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Zadejte Schvalování role nebo Schvalování Uživatel
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM konverzní faktor ({0} -&gt; {1}) nebyl nalezen pro položku: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Dohoda o úrovni služeb s typem entity {0} a entitou {1} již existuje.
 DocType: Journal Entry,Write Off Entry,Odepsat Vstup
 DocType: BOM,Rate Of Materials Based On,Ocenění materiálů na bázi
@@ -7038,6 +7069,7 @@
 DocType: Budget,Warn,Varovat
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Všechny položky byly již převedeny pro tuto pracovní objednávku.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Jakékoli jiné poznámky, pozoruhodné úsilí, které by měly jít v záznamech."
+DocType: Bank Account,Company Account,Firemní účet
 DocType: Asset Maintenance,Manufacturing User,Výroba Uživatel
 DocType: Purchase Invoice,Raw Materials Supplied,Dodává suroviny
 DocType: Subscription Plan,Payment Plan,Platebni plan
@@ -7079,6 +7111,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) nemůže být větší než plánované množství ({2}) v pracovní objednávce {3}
 DocType: Certification Application,Name of Applicant,Jméno žadatele
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Čas list pro výrobu.
+DocType: Quick Stock Balance,Quick Stock Balance,Rychlá bilance zásob
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,mezisoučet
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,"Vlastnosti Variantu nelze změnit po transakci akcií. Budete muset vytvořit novou položku, abyste to udělali."
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA mandát
@@ -7405,6 +7438,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},Prosím nastavte {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} je neaktivní student
 DocType: Employee,Health Details,Zdravotní Podrobnosti
+DocType: Coupon Code,Coupon Type,Typ kupónu
 DocType: Leave Encashment,Encashable days,Dny zapamatovatelné
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,"Chcete-li vytvořit referenční dokument žádosti o platbu, je třeba"
 DocType: Soil Texture,Sandy Clay,Sandy Clay
@@ -7688,6 +7722,7 @@
 DocType: Hotel Room Package,Amenities,Vybavení
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Automaticky načíst platební podmínky
 DocType: QuickBooks Migrator,Undeposited Funds Account,Účet neukladaných prostředků
+DocType: Coupon Code,Uses,Použití
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Vícenásobný výchozí způsob platby není povolen
 DocType: Sales Invoice,Loyalty Points Redemption,Věrnostní body Vykoupení
 ,Appointment Analytics,Aplikace Analytics
@@ -7704,6 +7739,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Celkový rozpočet
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Nechte prázdné, pokud rodíte studentské skupiny ročně"
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Pokud je zaškrtnuto, Total no. pracovních dnů bude zahrnovat dovolenou, a to sníží hodnotu platu za každý den"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Nepodařilo se přidat doménu
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Chcete-li povolit příjem / doručení, aktualizujte položku „Příjem / příjem“ v Nastavení skladu nebo v položce."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Aplikace s použitím aktuálního klíče nebudou mít přístup, jste si jisti?"
 DocType: Subscription Settings,Prorate,Prorate
@@ -7716,6 +7752,7 @@
 ,BOM Stock Report,BOM Sklad Zpráva
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Pokud není přiřazen žádný časový interval, bude komunikace probíhat touto skupinou"
 DocType: Stock Reconciliation Item,Quantity Difference,množství Rozdíl
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dodavatel&gt; Typ dodavatele
 DocType: Opportunity Item,Basic Rate,Basic Rate
 DocType: GL Entry,Credit Amount,Výše úvěru
 ,Electronic Invoice Register,Elektronický fakturační registr
@@ -7969,6 +8006,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Daně a poplatky odečteny (Company měna)
 DocType: Item Group,General Settings,Obecné nastavení
 DocType: Article,Article,Článek
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Zadejte kód kupónu !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Z měny a měny nemůže být stejné
 DocType: Taxable Salary Slab,Percent Deduction,Procentní odpočet
 DocType: GL Entry,To Rename,Přejmenovat
diff --git a/erpnext/translations/da.csv b/erpnext/translations/da.csv
index 4f7b189..1f185f1 100644
--- a/erpnext/translations/da.csv
+++ b/erpnext/translations/da.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Kundeservicekontakt
 DocType: Shift Type,Enable Auto Attendance,Aktivér automatisk deltagelse
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Indtast venligst lager og dato
 DocType: Lost Reason Detail,Opportunity Lost Reason,Mulighed mistet grund
 DocType: Patient Appointment,Check availability,Tjek tilgængelighed
 DocType: Retention Bonus,Bonus Payment Date,Bonus Betalingsdato
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Afsluttede arbejdsordrer
 DocType: Support Settings,Forum Posts,Forumindlæg
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Opgaven er valgt som et baggrundsjob. I tilfælde af, at der er noget problem med behandling i baggrunden, tilføjer systemet en kommentar om fejlen i denne aktieafstemning og vender tilbage til udkastet."
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Beklager, gyldigheden af kuponkoden er ikke startet"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Skattepligtigt beløb
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Du har ikke tilladelse til at tilføje eller opdatere poster før {0}
 DocType: Leave Policy,Leave Policy Details,Forlad politikoplysninger
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Forbrugsmaterialer
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,Grad
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Varekode&gt; Varegruppe&gt; Mærke
 DocType: Restaurant Table,No of Seats,Ingen pladser
 DocType: Sales Invoice,Overdue and Discounted,Forfaldne og nedsatte
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Opkald frakoblet
@@ -506,6 +509,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Linjeafstand for beløb i ord
 DocType: Vehicle,Additional Details,Yderligere detaljer
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Ingen beskrivelse
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Hent genstande fra lageret
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Indkøbsanmodning.
 DocType: POS Closing Voucher Details,Collected Amount,Samlet beløb
 DocType: Lab Test,Submitted Date,Indsendt dato
@@ -613,6 +617,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Hjælp
 ,Trial Balance (Simple),Testbalance (enkel)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Aktivér udskudt udgift
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Anvendt kuponkode
 DocType: Asset,Next Depreciation Date,Næste afskrivningsdato
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Aktivitet Omkostninger per Medarbejder
 DocType: Accounts Settings,Settings for Accounts,Indstillinger for regnskab
@@ -848,8 +853,6 @@
 DocType: BOM,Work Order,Arbejdsordre
 DocType: Sales Invoice,Total Qty,Antal i alt
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 Email ID
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Slet medarbejderen <a href=""#Form/Employee/{0}"">{0}</a> \ for at annullere dette dokument"
 DocType: Item,Show in Website (Variant),Vis på hjemmesiden (Variant)
 DocType: Employee,Health Concerns,Sundhedsmæssige betænkeligheder
 DocType: Payroll Entry,Select Payroll Period,Vælg Lønperiode
@@ -1013,6 +1016,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Skat tilbageholdende konto
 DocType: Pricing Rule,Sales Partner,Forhandler
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Alle leverandør scorecards.
+DocType: Coupon Code,To be used to get discount,Bruges til at få rabat
 DocType: Buying Settings,Purchase Receipt Required,Købskvittering påkrævet
 DocType: Sales Invoice,Rail,Rail
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Faktiske omkostninger
@@ -1063,6 +1067,7 @@
 DocType: Production Plan,Production Plan,Produktionsplan
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Åbning af fakturaoprettelsesværktøj
 DocType: Salary Component,Round to the Nearest Integer,Rund til det nærmeste heltal
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,"Tillad, at varer, der ikke er på lager, lægges i indkøbskurven"
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Salg Return
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Indstil antal i transaktioner baseret på serienummerindgang
 ,Total Stock Summary,Samlet lageroversigt
@@ -1192,6 +1197,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Basistimesats (firmavaluta)
 ,Qty To Be Billed,"Antal, der skal faktureres"
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Leveres Beløb
+DocType: Coupon Code,Gift Card,Gavekort
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Reserveret antal til produktion: Råvaremængde til fremstilling af produktionsartikler.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Indløsningsdato
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Denne banktransaktion er allerede fuldt afstemt
@@ -1279,6 +1285,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Opret timeseddel
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Konto {0} er indtastet flere gange
 DocType: Account,Expenses Included In Valuation,Udgifter inkluderet i Værdiansættelse
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Køb fakturaer
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,"Du kan kun forny, hvis dit medlemskab udløber inden for 30 dage"
 DocType: Shopping Cart Settings,Show Stock Availability,Vis lager tilgængelighed
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Indstil {0} i aktivkategori {1} eller firma {2}
@@ -1818,6 +1825,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Import af varer og UOM&#39;er
 DocType: Repayment Schedule,Balance Loan Amount,Balance Lånebeløb
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Tilføjet til detaljer
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Beklager, kuponkoden er opbrugt"
 DocType: Communication Medium,Catch All,Fang alle
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Kursusskema
 DocType: Budget,Applicable on Material Request,Gælder for materialeanmodning
@@ -1985,6 +1993,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Ugyldig Attribut
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} skal godkendes
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,E-mail-kampagner
+DocType: Sales Partner,To Track inbound purchase,For at spore indgående køb
 DocType: Buying Settings,Default Supplier Group,Standardleverandørgruppe
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Antal skal være mindre end eller lig med {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},"Maksimumsbeløb, der er berettiget til komponenten {0}, overstiger {1}"
@@ -2140,8 +2149,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Foretag lagerindtastning
 DocType: Hotel Room Reservation,Hotel Reservation User,Hotel Reservation Bruger
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Indstil status
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Indstil nummerserier for deltagelse via Opsætning&gt; Nummereringsserie
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Vælg venligst præfiks først
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Indstil Naming Series for {0} via Setup&gt; Settings&gt; Naming Series
 DocType: Contract,Fulfilment Deadline,Opfyldelsesfrist
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,I nærheden af dig
 DocType: Student,O-,O-
@@ -2265,6 +2274,7 @@
 DocType: Quality Meeting Table,Under Review,Under gennemsyn
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Kunne ikke logge ind
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Aktiv {0} oprettet
+DocType: Coupon Code,Promotional,Salgsfremmende
 DocType: Special Test Items,Special Test Items,Særlige testelementer
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Du skal være en bruger med System Manager og Item Manager roller til at registrere på Marketplace.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Nøglerapporter
@@ -2302,6 +2312,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc Type
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Samlede fordelte procentdel for salgsteam bør være 100
 DocType: Subscription Plan,Billing Interval Count,Faktureringsintervaltælling
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Slet medarbejderen <a href=""#Form/Employee/{0}"">{0}</a> \ for at annullere dette dokument"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Aftaler og patientmøder
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Værdi mangler
 DocType: Employee,Department and Grade,Afdeling og Grad
@@ -2404,6 +2416,7 @@
 DocType: Project,Start and End Dates,Start- og slutdato
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Kontraktskabelopfyldelsesbetingelser
 ,Delivered Items To Be Billed,Leverede varer at blive faktureret
+DocType: Coupon Code,Maximum Use,Maksimal brug
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Åben stykliste {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Lager kan ikke ændres for serienummeret
 DocType: Authorization Rule,Average Discount,Gennemsnitlig rabat
@@ -2565,6 +2578,7 @@
 DocType: Item,Inventory,Inventory
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Download som Json
 DocType: Item,Sales Details,Salg Detaljer
+DocType: Coupon Code,Used,Brugt
 DocType: Opportunity,With Items,Med varer
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Kampagnen &#39;{0}&#39; findes allerede for {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Vedligeholdelse Team
@@ -2694,7 +2708,7 @@
 						Serial No cannot be ensured",Ingen aktiv BOM fundet for punkt {0}. Levering med \ Serienummer kan ikke sikres
 DocType: Sales Partner,Sales Partner Target,Forhandlermål
 DocType: Loan Type,Maximum Loan Amount,Maksimalt lånebeløb
-DocType: Pricing Rule,Pricing Rule,Prisfastsættelsesregel
+DocType: Coupon Code,Pricing Rule,Prisfastsættelsesregel
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Dupliceringsrulle nummer for studerende {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Materialeanmodning til indkøbsordre
 DocType: Company,Default Selling Terms,Standard salgsbetingelser
@@ -2773,6 +2787,7 @@
 DocType: Payment Schedule,Payment Amount,Betaling Beløb
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Halvdagsdato skal være mellem arbejde fra dato og arbejdsdato
 DocType: Healthcare Settings,Healthcare Service Items,Sundhedsydelser
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Ugyldig stregkode. Der er ingen ting knyttet til denne stregkode.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Forbrugt Mængde
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Nettoændring i kontanter
 DocType: Assessment Plan,Grading Scale,karakterbekendtgørelsen
@@ -2892,7 +2907,6 @@
 DocType: Share Transfer,Asset Account,Aktiver konto
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Ny udgivelsesdato skulle være i fremtiden
 DocType: Purchase Invoice,End date of current invoice's period,Slutdato for aktuelle faktura menstruation
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Indstil venligst medarbejdernavningssystem i menneskelig ressource&gt; HR-indstillinger
 DocType: Lab Test,Technician Name,Tekniker navn
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3003,6 +3017,7 @@
 DocType: Products Settings,Hide Variants,Skjul varianter
 DocType: Lead,Next Contact By,Næste kontakt af
 DocType: Compensatory Leave Request,Compensatory Leave Request,Kompenserende Forladelsesanmodning
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings",Kan ikke overbillede for vare {0} i række {1} mere end {2}. For at tillade overfakturering skal du angive kvote i Kontoindstillinger
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},"Mængde, der kræves for Item {0} i række {1}"
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},"Lager {0} kan ikke slettes, da der eksisterer et antal varer {1} på lageret"
 DocType: Blanket Order,Order Type,Bestil Type
@@ -3172,7 +3187,6 @@
 DocType: Student,Student Mobile Number,Studerende mobiltelefonnr.
 DocType: Item,Has Variants,Har Varianter
 DocType: Employee Benefit Claim,Claim Benefit For,Claim fordele for
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Kan ikke overbillet for vare {0} i række {1} mere end {2}. For at tillade overfakturering, skal du angive lagerindstillinger"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Opdater svar
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Du har allerede valgt elementer fra {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Navnet på den månedlige Distribution
@@ -3462,6 +3476,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Angiv venligst valuta i firmaet
 DocType: Workstation,Wages per hour,Timeløn
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Konfigurer {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Kunde&gt; Kundegruppe&gt; Territorium
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Lagersaldo i parti {0} vil blive negativ {1} for vare {2} på lager {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Følgende materialeanmodninger er blevet dannet automatisk baseret på varens genbestillelsesniveau
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Konto {0} er ugyldig. Konto Valuta skal være {1}
@@ -3791,6 +3806,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Godkend lønseddel
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,I venteposition
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Et spørgsmål skal have mindst én korrekte indstillinger
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Indkøbsordre
 DocType: Account,Inter Company Account,Inter Company Account
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Import i bulk
 DocType: Sales Partner,Address & Contacts,Adresse & kontaktpersoner
@@ -3801,6 +3817,7 @@
 DocType: POS Profile,[Select],[Vælg]
 DocType: Staffing Plan Detail,Number Of Positions,Antal positioner
 DocType: Vital Signs,Blood Pressure (diastolic),Blodtryk (diastolisk)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Vælg kunden.
 DocType: SMS Log,Sent To,Sendt Til
 DocType: Agriculture Task,Holiday Management,Holiday Management
 DocType: Payment Request,Make Sales Invoice,Opret salgsfaktura
@@ -4010,7 +4027,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} er ikke godkendt
 DocType: Subscription,Trialling,afprøvning
 DocType: Sales Invoice Item,Deferred Revenue,Udskudte indtægter
-DocType: Bank Account,GL Account,GL-konto
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Kontantkonto bruges til oprettelse af salgsfaktura
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Fritagelsesunderkategori
 DocType: Member,Membership Expiry Date,Medlemskabets udløbsdato
@@ -4414,13 +4430,13 @@
 DocType: C-Form Invoice Detail,Territory,Område
 DocType: Pricing Rule,Apply Rule On Item Code,Anvend regel om varekode
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,"Henvis ikke af besøg, der kræves"
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Aktiebalancerapport
 DocType: Stock Settings,Default Valuation Method,Standard værdiansættelsesmetode
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Betaling
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Vis kumulativ mængde
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Opdatering i gang. Det kan tage et stykke tid.
 DocType: Production Plan Item,Produced Qty,Produceret antal
 DocType: Vehicle Log,Fuel Qty,Brændstofmængde
-DocType: Stock Entry,Target Warehouse Name,Mållagernavn
 DocType: Work Order Operation,Planned Start Time,Planlagt starttime
 DocType: Course,Assessment,Vurdering
 DocType: Payment Entry Reference,Allocated,Tildelt
@@ -4486,10 +4502,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","Standardvilkår og -betingelser, der kan føjes til salg og køb. Eksempler: 1. gyldighed for tilbuddet. 1. Betalingsbetingelser (på forhånd, på kredit, delvist på forhånd osv). 1. Hvad er ekstra (eller skal betales af kunden). 1. Sikkerhed / forbrugerinformation. 1. Garanti (hvis nogen). 1. Returpolitik. 1. Betingelser for skibsfart (hvis relevant). 1. Håndtering af tvister, erstatning, ansvar mv 1. Adresse og kontakt i din virksomhed."
 DocType: Homepage Section,Section Based On,Sektion baseret på
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Vis Anvend kuponkode
 DocType: Issue,Issue Type,Udstedelsestype
 DocType: Attendance,Leave Type,Fraværstype
 DocType: Purchase Invoice,Supplier Invoice Details,Leverandør fakturadetaljer
 DocType: Agriculture Task,Ignore holidays,Ignorer ferie
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Tilføj / rediger kuponbetingelser
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Udgifts- differencekonto ({0}) skal være en resultatskonto
 DocType: Stock Entry Detail,Stock Entry Child,Lagerindgangsbarn
 DocType: Project,Copied From,Kopieret fra
@@ -4664,6 +4682,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Vurdering Plan Kriterier
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Transaktioner
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Forhindre indkøbsordrer
+DocType: Coupon Code,Coupon Name,Kuponnavn
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,modtagelig
 DocType: Email Campaign,Scheduled,Planlagt
 DocType: Shift Type,Working Hours Calculation Based On,Beregning af arbejdstid baseret på
@@ -4680,7 +4699,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Opret Varianter
 DocType: Vehicle,Diesel,Diesel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Prisliste Valuta ikke valgt
+DocType: Quick Stock Balance,Available Quantity,Tilgængeligt antal
 DocType: Purchase Invoice,Availed ITC Cess,Benyttet ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Opsæt instruktør navngivningssystem i uddannelse&gt; Uddannelsesindstillinger
 ,Student Monthly Attendance Sheet,Student Månedlig Deltagelse Sheet
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Forsendelsesregel gælder kun for salg
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Afskrivningsrække {0}: Næste afskrivningsdato kan ikke være før købsdato
@@ -4747,8 +4768,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Række {0}: Advance mod Kunden skal være kredit
 DocType: Quality Meeting,Quality Meeting,Kvalitetsmøde
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Ikke-gruppe til gruppe
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Indstil Naming Series for {0} via Setup&gt; Settings&gt; Naming Series
 DocType: Employee,ERPNext User,ERPNæste bruger
+DocType: Coupon Code,Coupon Description,Kuponbeskrivelse
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Parti er obligatorisk i række {0}
 DocType: Company,Default Buying Terms,Standard købsbetingelser
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Købskvittering leveret vare
@@ -4911,6 +4932,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Imod Dokument Detalje Nr.
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Sletning er ikke tilladt for land {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Selskabstypen er obligatorisk
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Anvend kuponkode
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",For jobkort {0} kan du kun foretage lagerstatus &#39;Materialeoverførsel til fremstilling&#39;
 DocType: Quality Inspection,Outgoing,Udgående
 DocType: Customer Feedback Table,Customer Feedback Table,Tabel om kundefeedback
@@ -5060,7 +5082,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Ved levering af indkøbsordre
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Tilføj alle leverandører
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Row # {0}: Allokeret beløb kan ikke være større end udestående beløb.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Kunde&gt; Kundegruppe&gt; Territorium
 DocType: Tally Migration,Parties,parterne
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Gennemse styklister
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Sikrede lån
@@ -5092,7 +5113,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Tillad ikke at indstille alternativt element til varen {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Datoen er gentaget
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Tegningsberettiget
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Opsæt instruktør navngivningssystem i uddannelse&gt; Uddannelsesindstillinger
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Net ITC tilgængelig (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Opret gebyrer
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Samlet anskaffelsespris (via købsfaktura)
@@ -5117,6 +5137,7 @@
 DocType: Quiz Result,Wrong,Forkert
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Hastighed, hvormed Prisliste valuta omregnes til kundens basisvaluta"
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Nettobeløb (firmavaluta)
+DocType: Sales Partner,Referral Code,Henvisningskode
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Samlet forskudsbeløb kan ikke være større end det samlede sanktionerede beløb
 DocType: Salary Slip,Hour Rate,Timesats
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Aktivér automatisk ombestilling
@@ -5245,6 +5266,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Vis lager Antal
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Netto kontant fra drift
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Række nr. {0}: Status skal være {1} for fakturaborting {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM-konverteringsfaktor ({0} -&gt; {1}) ikke fundet for varen: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Vare 4
 DocType: Student Admission,Admission End Date,Optagelse Slutdato
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Underleverandører
@@ -5267,6 +5289,7 @@
 DocType: Travel Request,Fully Sponsored,Fuldt sponsoreret
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Reverse Journal Entry
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Opret jobkort
+DocType: Quotation,Referral Sales Partner,Henvisning Salgspartner
 DocType: Quality Procedure Process,Process Description,Procesbeskrivelse
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Kunden {0} er oprettet.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Der er i øjeblikket ingen lager på lageret
@@ -5401,6 +5424,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM Rate
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Læsning af uploadet fil
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Stoppet Arbejdsordre kan ikke annulleres, Unstop det først for at annullere"
+DocType: Coupon Code,Coupon Code,Kuponkode
 DocType: Asset,Journal Entry for Scrap,Kassekladde til skrot
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Træk varene fra følgeseddel
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Række {0}: vælg arbejdsstationen imod operationen {1}
@@ -5483,6 +5507,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;Dato&#39; er påkrævet
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Due / reference Dato kan ikke være efter {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Dataind- og udlæsning
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Beklager, gyldigheden af kuponkoden er udløbet"
 DocType: Bank Account,Account Details,konto detaljer
 DocType: Crop,Materials Required,Materialer krævet
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Ingen studerende Fundet
@@ -5520,6 +5545,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Gå til Brugere
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Betalt beløb + Skriv Off Beløb kan ikke være større end beløb i alt
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} er ikke et gyldigt partinummer for vare {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Indtast en gyldig kuponkode !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Bemærk: Der er ikke nok dage til rådighed til fraværstype {0}
 DocType: Task,Task Description,Opgavebeskrivelse
 DocType: Training Event,Seminar,Seminar
@@ -5784,6 +5810,7 @@
 ,TDS Payable Monthly,TDS betales månedligt
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Kø for at erstatte BOM. Det kan tage et par minutter.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Ikke kan fradrage, når kategorien er for &quot;Værdiansættelse&quot; eller &quot;Værdiansættelse og Total &#39;"
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Indstil venligst medarbejdernavningssystem i menneskelig ressource&gt; HR-indstillinger
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Samlede betalinger
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serienummer påkrævet for serienummervare {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Match betalinger med fakturaer
@@ -5873,6 +5900,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Få råmaterialer til produktion
 DocType: Job Opening,Job Title,Titel
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Fremtidig betaling Ref
+DocType: Quotation,Additional Discount and Coupon Code,Yderligere rabat- og kuponkode
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} indikerer at {1} ikke giver et citat, men alle elementer \ er blevet citeret. Opdatering af RFQ citat status."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maksimale prøver - {0} er allerede bevaret for Batch {1} og Item {2} i Batch {3}.
@@ -6100,7 +6128,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Indstillinger for hjemmesidens startside
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} er på vent indtil {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ&#39;er er ikke tilladt for {0} på grund af et scorecard stående på {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Make købsfaktura
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Brugte blade
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Brugt kupon er {1}. Den tilladte mængde er opbrugt
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Ønsker du at indsende den materielle anmodning
 DocType: Job Offer,Awaiting Response,Afventer svar
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6114,6 +6144,7 @@
 DocType: Training Event Employee,Optional,Valgfri
 DocType: Salary Slip,Earning & Deduction,Tillæg & fradrag
 DocType: Agriculture Analysis Criteria,Water Analysis,Vandanalyse
+DocType: Sales Order,Skip Delivery Note,Spring over leveringsnotat
 DocType: Price List,Price Not UOM Dependent,Pris ikke UOM-afhængig
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} varianter oprettet.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,En standard serviceniveauaftale findes allerede.
@@ -6218,6 +6249,7 @@
 DocType: Vehicle,Last Carbon Check,Sidste synsdato
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Advokatudgifter
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Vælg venligst antal på række
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Arbejdsordre {0}: jobkort findes ikke til operationen {1}
 DocType: Purchase Invoice,Posting Time,Bogføringsdato og -tid
 DocType: Timesheet,% Amount Billed,% Faktureret beløb
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Telefonudgifter
@@ -6320,7 +6352,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Skatter og Afgifter Tilføjet
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Afskrivnings række {0}: Næste afskrivningsdato kan ikke være før tilgængelig dato
 ,Sales Funnel,Salgstragt
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Varekode&gt; Varegruppe&gt; Mærke
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Forkortelsen er obligatorisk
 DocType: Project,Task Progress,Opgave-fremskridt
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Kurv
@@ -6415,6 +6446,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS profil kræves for at gøre POS indtastning
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Loyalitetspoint beregnes ud fra det brugte udbytte (via salgsfakturaen), baseret på den nævnte indsamlingsfaktor."
 DocType: Program Enrollment Tool,Enroll Students,Tilmeld Studerende
+DocType: Pricing Rule,Coupon Code Based,Baseret på kuponkode
 DocType: Company,HRA Settings,HRA-indstillinger
 DocType: Homepage,Hero Section,Heltesektion
 DocType: Employee Transfer,Transfer Date,Overførselsdato
@@ -6530,6 +6562,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',"Indstil Firmafilter blankt, hvis Group By er &#39;Company&#39;"
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Bogføringsdato kan ikke være en fremtidig dato
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Række # {0}: serienummer {1} matcher ikke med {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Indstil nummerserier for deltagelse via Opsætning&gt; Nummereringsserie
 DocType: Stock Entry,Target Warehouse Address,Mållagerhusadresse
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Casual Leave
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,"Tiden før skiftets starttid, hvor medarbejderindtjekning overvejes til deltagelse."
@@ -6564,7 +6597,6 @@
 DocType: Employee Grade,Employee Grade,Medarbejderklasse
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Akkordarbejde
 DocType: GSTR 3B Report,June,juni
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Leverandør&gt; Leverandørtype
 DocType: Share Balance,From No,Fra nr
 DocType: Shift Type,Early Exit Grace Period,Tidlig afgangsperiode
 DocType: Task,Actual Time (in Hours),Faktisk tid (i timer)
@@ -6849,7 +6881,6 @@
 DocType: Warehouse,Warehouse Name,Lagernavn
 DocType: Naming Series,Select Transaction,Vælg Transaktion
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Indtast Godkendelse Rolle eller godkender Bruger
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM-konverteringsfaktor ({0} -&gt; {1}) ikke fundet for varen: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Serviceniveauaftale med entitetstype {0} og enhed {1} findes allerede.
 DocType: Journal Entry,Write Off Entry,Skriv Off indtastning
 DocType: BOM,Rate Of Materials Based On,Rate Of materialer baseret på
@@ -6987,6 +7018,7 @@
 DocType: Budget,Warn,Advar
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Alle elementer er allerede overført til denne Arbejdsordre.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Alle andre bemærkninger, bemærkelsesværdigt indsats, skal gå i registrene."
+DocType: Bank Account,Company Account,Firmakonto
 DocType: Asset Maintenance,Manufacturing User,Produktionsbruger
 DocType: Purchase Invoice,Raw Materials Supplied,Leverede råvarer
 DocType: Subscription Plan,Payment Plan,Betalingsplan
@@ -7028,6 +7060,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) kan ikke være større end den planlagte mængde ({2}) i Work Order {3}
 DocType: Certification Application,Name of Applicant,Ansøgerens navn
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Tidsregistrering til Produktion.
+DocType: Quick Stock Balance,Quick Stock Balance,Hurtig lagerbalance
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Subtotal
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Kan ikke ændre Variantegenskaber efter aktiehandel. Du bliver nødt til at lave en ny vare til at gøre dette.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA Mandat
@@ -7354,6 +7387,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},Indstil {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} er inaktiv studerende
 DocType: Employee,Health Details,Sundhedsdetaljer
+DocType: Coupon Code,Coupon Type,Kupon type
 DocType: Leave Encashment,Encashable days,Encashable dage
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,For at oprette en betalingsanmodning kræves referencedokument
 DocType: Soil Texture,Sandy Clay,Sandy Clay
@@ -7636,6 +7670,7 @@
 DocType: Hotel Room Package,Amenities,Faciliteter
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Hent automatisk betalingsbetingelser
 DocType: QuickBooks Migrator,Undeposited Funds Account,Undeposited Funds Account
+DocType: Coupon Code,Uses,Anvendelser
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Flere standard betalingsmåder er ikke tilladt
 DocType: Sales Invoice,Loyalty Points Redemption,Loyalitetspoint Indfrielse
 ,Appointment Analytics,Aftale Analytics
@@ -7652,6 +7687,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Samlet budget
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Lad feltet stå tomt, hvis du laver elevergrupper hvert år"
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Hvis markeret, Total nej. af Arbejdsdage vil omfatte helligdage, og dette vil reducere værdien af Løn Per Day"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Kunne ikke tilføje domæne
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.",For at tillade overmodtagelse / levering skal du opdatere &quot;Overmodtagelse / leveringstilladelse&quot; i lagerindstillinger eller varen.
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Apps, der bruger den nuværende nøgle, vil ikke kunne få adgang til, er du sikker?"
 DocType: Subscription Settings,Prorate,prorate
@@ -7664,6 +7700,7 @@
 ,BOM Stock Report,BOM Stock Rapport
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Hvis der ikke er tildelt timeslot, håndteres kommunikation af denne gruppe"
 DocType: Stock Reconciliation Item,Quantity Difference,Mængdeforskel
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Leverandør&gt; Leverandørtype
 DocType: Opportunity Item,Basic Rate,Grundlæggende Rate
 DocType: GL Entry,Credit Amount,Kreditbeløb
 ,Electronic Invoice Register,Elektronisk fakturaregister
@@ -7917,6 +7954,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Skatter og Afgifter Fratrukket (Company Valuta)
 DocType: Item Group,General Settings,Generelle indstillinger
 DocType: Article,Article,Genstand
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Indtast kuponkode !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Fra Valuta og Til valuta ikke kan være samme
 DocType: Taxable Salary Slab,Percent Deduction,Procent Fradrag
 DocType: GL Entry,To Rename,At omdøbe
diff --git a/erpnext/translations/de.csv b/erpnext/translations/de.csv
index 297da9f..5239468 100644
--- a/erpnext/translations/de.csv
+++ b/erpnext/translations/de.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Kundenkontakt
 DocType: Shift Type,Enable Auto Attendance,Automatische Teilnahme aktivieren
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Bitte geben Sie Lager und Datum ein
 DocType: Lost Reason Detail,Opportunity Lost Reason,Verlorene Gelegenheitsgründe
 DocType: Patient Appointment,Check availability,Verfügbarkeit prüfen
 DocType: Retention Bonus,Bonus Payment Date,Bonuszahlungsdatum
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Abgeschlossene Arbeitsaufträge
 DocType: Support Settings,Forum Posts,Forum Beiträge
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Die Aufgabe wurde als Hintergrundjob in die Warteschlange gestellt. Falls bei der Verarbeitung im Hintergrund Probleme auftreten, fügt das System einen Kommentar zum Fehler in dieser Bestandsabstimmung hinzu und kehrt zum Entwurfsstadium zurück"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started",Die Gültigkeit des Gutscheincodes hat leider nicht begonnen
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Steuerpflichtiger Betrag
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Sie haben keine Berechtigung Buchungen vor {0} hinzuzufügen oder zu aktualisieren
 DocType: Leave Policy,Leave Policy Details,Urlaubsrichtliniendetails
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Verbrauchsgut
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,Klasse
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Artikelcode&gt; Artikelgruppe&gt; Marke
 DocType: Restaurant Table,No of Seats,Anzahl der Sitze
 DocType: Sales Invoice,Overdue and Discounted,Überfällig und abgezinst
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Anruf getrennt
@@ -506,6 +509,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Zeilenabstand für Betrag in Worten
 DocType: Vehicle,Additional Details,Weitere Details
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Keine Beschreibung angegeben
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Abrufen von Artikeln aus dem Lager
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Lieferantenanfrage
 DocType: POS Closing Voucher Details,Collected Amount,Gesammelte Menge
 DocType: Lab Test,Submitted Date,Eingeschriebenes Datum
@@ -613,6 +617,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Lernen
 ,Trial Balance (Simple),Probebilanz (einfach)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Aktivieren Sie den Rechnungsabgrenzungsposten
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Angewandter Gutscheincode
 DocType: Asset,Next Depreciation Date,Nächstes Abschreibungsdatum
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Aktivitätskosten je Mitarbeiter
 DocType: Accounts Settings,Settings for Accounts,Konteneinstellungen
@@ -848,8 +853,6 @@
 DocType: BOM,Work Order,Arbeitsauftrag
 DocType: Sales Invoice,Total Qty,Gesamtmenge
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 E-Mail-ID
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Bitte löschen Sie den Mitarbeiter <a href=""#Form/Employee/{0}"">{0}</a> \, um dieses Dokument zu stornieren"
 DocType: Item,Show in Website (Variant),Auf der Website anzeigen (Variante)
 DocType: Employee,Health Concerns,Gesundheitsfragen
 DocType: Payroll Entry,Select Payroll Period,Wählen Sie Abrechnungsperiode
@@ -1013,6 +1016,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Steuerrückbehaltkonto
 DocType: Pricing Rule,Sales Partner,Vertriebspartner
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Alle Lieferanten-Scorecards.
+DocType: Coupon Code,To be used to get discount,"Verwendet werden, um Rabatt zu bekommen"
 DocType: Buying Settings,Purchase Receipt Required,Kaufbeleg notwendig
 DocType: Sales Invoice,Rail,Schiene
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Tatsächliche Kosten
@@ -1063,6 +1067,7 @@
 DocType: Production Plan,Production Plan,Produktionsplan
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Öffnen des Rechnungserstellungswerkzeugs
 DocType: Salary Component,Round to the Nearest Integer,Runde auf die nächste Ganzzahl
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,"Artikel, die nicht auf Lager sind, können in den Warenkorb gelegt werden"
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Rücklieferung
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Legen Sie Menge in Transaktionen basierend auf Serial No Input fest
 ,Total Stock Summary,Gesamt Stock Zusammenfassung
@@ -1192,6 +1197,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Basis Stundensatz (Unternehmenswährung)
 ,Qty To Be Billed,Abzurechnende Menge
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Gelieferte Menge
+DocType: Coupon Code,Gift Card,Geschenkkarte
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Reservierte Menge für die Produktion: Rohstoffmenge zur Herstellung von Produktionsartikeln.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Rückzahlungsdatum
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Diese Banküberweisung ist bereits vollständig abgeglichen
@@ -1279,6 +1285,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Arbeitszeittabelle erstellen
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Konto {0} wurde mehrmals eingegeben
 DocType: Account,Expenses Included In Valuation,In der Bewertung enthaltene Aufwendungen
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Rechnungen kaufen
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,"Sie können nur verlängern, wenn Ihre Mitgliedschaft innerhalb von 30 Tagen abläuft"
 DocType: Shopping Cart Settings,Show Stock Availability,Bestandsverfügbarkeit anzeigen
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Legen Sie {0} in der Anlagekategorie {1} oder in Unternehmen {2} fest.
@@ -1837,6 +1844,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Importieren von Artikeln und Mengeneinheiten
 DocType: Repayment Schedule,Balance Loan Amount,Bilanz Darlehensbetrag
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Zu Details hinzugefügt
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted",Der Gutscheincode ist leider erschöpft
 DocType: Communication Medium,Catch All,Fang alle
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Unterrichtszeiten
 DocType: Budget,Applicable on Material Request,Anwendbar auf Materialanforderung
@@ -2004,6 +2012,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Ungültige Attribute
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} muss vorgelegt werden
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,E-Mail-Kampagnen
+DocType: Sales Partner,To Track inbound purchase,Um eingehende Einkäufe zu verfolgen
 DocType: Buying Settings,Default Supplier Group,Standardlieferantengruppe
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Menge muss kleiner oder gleich {0} sein
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Der für die Komponente {0} zulässige Höchstbetrag übersteigt {1}
@@ -2159,8 +2168,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Bestandserfassung vornehmen
 DocType: Hotel Room Reservation,Hotel Reservation User,Hotelreservierung Benutzer
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Status setzen
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Richten Sie die Nummerierungsserie für die Teilnahme über Setup&gt; Nummerierungsserie ein
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Bitte zuerst Präfix auswählen
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Stellen Sie die Benennungsserie für {0} über Setup&gt; Einstellungen&gt; Benennungsserie ein
 DocType: Contract,Fulfilment Deadline,Erfüllungsfrist
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Nahe bei dir
 DocType: Student,O-,O-
@@ -2284,6 +2293,7 @@
 DocType: Quality Meeting Table,Under Review,Unter Überprüfung
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Einloggen fehlgeschlagen
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Vermögenswert {0} erstellt.
+DocType: Coupon Code,Promotional,Werbeartikel
 DocType: Special Test Items,Special Test Items,Spezielle Testartikel
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,"Sie müssen ein Benutzer mit System Manager- und Element-Manager-Rollen sein, um sich auf Marketplace registrieren zu können."
 apps/erpnext/erpnext/config/buying.py,Key Reports,Wichtige Berichte
@@ -2321,6 +2331,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Dokumententyp
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Insgesamt verteilte Prozentmenge für Vertriebsteam sollte 100 sein
 DocType: Subscription Plan,Billing Interval Count,Abrechnungsintervall Anzahl
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Bitte löschen Sie den Mitarbeiter <a href=""#Form/Employee/{0}"">{0}</a> \, um dieses Dokument abzubrechen"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Termine und Patienten-Begegnungen
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Fehlender Wert
 DocType: Employee,Department and Grade,Abteilung und Klasse
@@ -2423,6 +2435,7 @@
 DocType: Project,Start and End Dates,Start- und Enddatum
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Bedingungen für Vertragsvorlagen-Erfüllung
 ,Delivered Items To Be Billed,"Gelieferte Artikel, die abgerechnet werden müssen"
+DocType: Coupon Code,Maximum Use,Maximale Nutzung
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Stückliste {0} öffnen
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Lager kann für Seriennummer nicht geändert werden
 DocType: Authorization Rule,Average Discount,Durchschnittlicher Rabatt
@@ -2584,6 +2597,7 @@
 DocType: Item,Inventory,Lagerbestand
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Als Json herunterladen
 DocType: Item,Sales Details,Verkaufsdetails
+DocType: Coupon Code,Used,Benutzt
 DocType: Opportunity,With Items,Mit Artikeln
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Die Kampagne &#39;{0}&#39; existiert bereits für die {1} &#39;{2}&#39;.
 DocType: Asset Maintenance,Maintenance Team,Wartungs Team
@@ -2713,7 +2727,7 @@
 						Serial No cannot be ensured",Für die Position {0} wurde keine aktive Stückliste gefunden. Die Lieferung per \ Seriennummer kann nicht gewährleistet werden
 DocType: Sales Partner,Sales Partner Target,Vertriebspartner-Ziel
 DocType: Loan Type,Maximum Loan Amount,Maximaler Darlehensbetrag
-DocType: Pricing Rule,Pricing Rule,Preisregel
+DocType: Coupon Code,Pricing Rule,Preisregel
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplikat Rollennummer für den Schüler {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Von der Materialanfrage zum Lieferantenauftrag
 DocType: Company,Default Selling Terms,Standardverkaufsbedingungen
@@ -2792,6 +2806,7 @@
 DocType: Payment Schedule,Payment Amount,Zahlungsbetrag
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Das Halbtagesdatum sollte zwischen Arbeitstag und Enddatum liegen
 DocType: Healthcare Settings,Healthcare Service Items,Healthcare Service Artikel
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Ungültiger Barcode. Es ist kein Artikel an diesen Barcode angehängt.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Verbrauchte Menge
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Nettoveränderung der Barmittel
 DocType: Assessment Plan,Grading Scale,Bewertungsskala
@@ -2911,7 +2926,6 @@
 DocType: Share Transfer,Asset Account,Anlagenkonto
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Das neue Erscheinungsdatum sollte in der Zukunft liegen
 DocType: Purchase Invoice,End date of current invoice's period,Schlußdatum der laufenden Eingangsrechnungsperiode
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Richten Sie das Employee Naming System unter Human Resource&gt; HR Settings ein
 DocType: Lab Test,Technician Name,Techniker Name
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3022,6 +3036,7 @@
 DocType: Products Settings,Hide Variants,Varianten ausblenden
 DocType: Lead,Next Contact By,Nächster Kontakt durch
 DocType: Compensatory Leave Request,Compensatory Leave Request,Ausgleichsurlaubsantrag
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Artikel {0} in Zeile {1} kann nicht mehr als {2} in Rechnung gestellt werden. Um eine Überberechnung zuzulassen, legen Sie die Überberechnung in den Kontoeinstellungen fest"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Für Artikel {0} in Zeile {1} benötigte Menge
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},"Lager {0} kann nicht gelöscht werden, da noch ein Bestand für Artikel {1} existiert"
 DocType: Blanket Order,Order Type,Bestellart
@@ -3191,7 +3206,6 @@
 DocType: Student,Student Mobile Number,Student Mobile Number
 DocType: Item,Has Variants,Hat Varianten
 DocType: Employee Benefit Claim,Claim Benefit For,Anspruchsvorteil für
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Für Artikel {0} in Zeile {1} kann mehr als {2} nicht überbucht werden. Um Überfakturierung zu ermöglichen, legen Sie bitte in Stock Settings fest"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Antwort aktualisieren
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Sie haben bereits Elemente aus {0} {1} gewählt
 DocType: Monthly Distribution,Name of the Monthly Distribution,Bezeichnung der monatsweisen Verteilung
@@ -3481,6 +3495,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Bitte die Unternehmenswährung angeben
 DocType: Workstation,Wages per hour,Lohn pro Stunde
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},{0} konfigurieren
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Kunde&gt; Kundengruppe&gt; Gebiet
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Lagerbestand in Charge {0} wird für Artikel {2} im Lager {3} negativ {1}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Folgende Materialanfragen wurden automatisch auf der Grundlage der Nachbestellmenge des Artikels generiert
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Konto {0} ist ungültig. Kontenwährung muss {1} sein
@@ -3810,6 +3825,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Gehaltsabrechnung übertragen
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,In Wartestellung
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Eine Frage muss mindestens eine richtige Option haben
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Kauforder
 DocType: Account,Inter Company Account,Unternehmensübergreifendes Konto
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Mengenimport
 DocType: Sales Partner,Address & Contacts,Adresse & Kontaktinformationen
@@ -3820,6 +3836,7 @@
 DocType: POS Profile,[Select],[Auswählen]
 DocType: Staffing Plan Detail,Number Of Positions,Anzahl der Positionen
 DocType: Vital Signs,Blood Pressure (diastolic),Blutdruck (diastolisch)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Bitte wählen Sie den Kunden aus.
 DocType: SMS Log,Sent To,Gesendet An
 DocType: Agriculture Task,Holiday Management,Ferienmanagement
 DocType: Payment Request,Make Sales Invoice,Verkaufsrechnung erstellen
@@ -4028,7 +4045,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} wurde nicht übertragen
 DocType: Subscription,Trialling,Erprobung
 DocType: Sales Invoice Item,Deferred Revenue,Rechnungsabgrenzung
-DocType: Bank Account,GL Account,GL Konto
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Cash Account wird für die Erstellung von Verkaufsrechnungen verwendet
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Unterkategorie der Befreiung
 DocType: Member,Membership Expiry Date,Ablaufdatum der Mitgliedschaft
@@ -4452,13 +4468,13 @@
 DocType: C-Form Invoice Detail,Territory,Region
 DocType: Pricing Rule,Apply Rule On Item Code,Regel auf Artikelcode anwenden
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,"Bitte bei ""Besuche erforderlich"" NEIN angeben"
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Bestandsbilanzbericht
 DocType: Stock Settings,Default Valuation Method,Standard-Bewertungsmethode
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Gebühr
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Kumulativen Betrag anzeigen
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Aktualisierung läuft. Es könnte eine Weile dauern.
 DocType: Production Plan Item,Produced Qty,Produzierte Menge
 DocType: Vehicle Log,Fuel Qty,Kraftstoff-Menge
-DocType: Stock Entry,Target Warehouse Name,Name des Ziellagers
 DocType: Work Order Operation,Planned Start Time,Geplante Startzeit
 DocType: Course,Assessment,Beurteilung
 DocType: Payment Entry Reference,Allocated,Zugewiesen
@@ -4536,10 +4552,12 @@
 8. Beschwerdemanagement, Schadensersatz, Haftung usw. 
 9. Adresse und Kontaktdaten des Unternehmens."
 DocType: Homepage Section,Section Based On,Abschnitt basierend auf
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Gutscheincode anwenden anzeigen
 DocType: Issue,Issue Type,Fehlertyp
 DocType: Attendance,Leave Type,Urlaubstyp
 DocType: Purchase Invoice,Supplier Invoice Details,Lieferant Rechnungsdetails
 DocType: Agriculture Task,Ignore holidays,Feiertage ignorieren
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Gutscheinbedingungen hinzufügen / bearbeiten
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Aufwands-/Differenz-Konto ({0}) muss ein ""Gewinn oder Verlust""-Konto sein"
 DocType: Stock Entry Detail,Stock Entry Child,Stock Entry Child
 DocType: Project,Copied From,Kopiert von
@@ -4714,6 +4732,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Kriterien des Beurteilungsplans
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Transaktionen
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Vermeidung von Bestellungen
+DocType: Coupon Code,Coupon Name,Gutschein Name
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Anfällig
 DocType: Email Campaign,Scheduled,Geplant
 DocType: Shift Type,Working Hours Calculation Based On,Arbeitszeitberechnung basierend auf
@@ -4730,7 +4749,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Varianten erstellen
 DocType: Vehicle,Diesel,Diesel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Preislistenwährung nicht ausgewählt
+DocType: Quick Stock Balance,Available Quantity,verfügbare Anzahl
 DocType: Purchase Invoice,Availed ITC Cess,Erreichte ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Richten Sie das Instructor Naming System unter Education&gt; Education Settings ein
 ,Student Monthly Attendance Sheet,Schüler-Monatsanwesenheitsliste
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Versandregel gilt nur für den Verkauf
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Abschreibungszeile {0}: Das nächste Abschreibungsdatum darf nicht vor dem Kaufdatum liegen
@@ -4797,8 +4818,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Row {0}: Voraus gegen Kunde muss Kredit
 DocType: Quality Meeting,Quality Meeting,Qualitätstreffen
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-Group-Gruppe
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Stellen Sie die Benennungsserie für {0} über Setup&gt; Einstellungen&gt; Benennungsserie ein
 DocType: Employee,ERPNext User,ERPNext Benutzer
+DocType: Coupon Code,Coupon Description,Coupon Beschreibung
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Batch ist obligatorisch in Zeile {0}
 DocType: Company,Default Buying Terms,Standard-Einkaufsbedingungen
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Kaufbeleg-Artikel geliefert
@@ -4961,6 +4982,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Zu Dokumentendetail Nr.
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Das Löschen ist für das Land {0} nicht zulässig.
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Party-Typ ist Pflicht
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Gutscheincode anwenden
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",Für die Jobkarte {0} können Sie nur die Bestandsbuchung vom Typ &#39;Materialtransfer für Fertigung&#39; vornehmen
 DocType: Quality Inspection,Outgoing,Ausgang
 DocType: Customer Feedback Table,Customer Feedback Table,Kunden-Feedback-Tabelle
@@ -5110,7 +5132,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,On Purchase Order Submission
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Alle Lieferanten hinzufügen
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Zeile # {0}: Zugeordneter Betrag darf nicht größer als ausstehender Betrag sein.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Kunde&gt; Kundengruppe&gt; Gebiet
 DocType: Tally Migration,Parties,Parteien
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Stückliste durchsuchen
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Gedeckte Kredite
@@ -5142,7 +5163,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},"Nicht zulassen, alternative Artikel für den Artikel {0} festzulegen"
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Ereignis wiederholen
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Zeichnungsberechtigte/-r
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Richten Sie das Instructor Naming System unter Education&gt; Education Settings ein
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Netto-ITC verfügbar (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Gebühren anlegen
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Summe Einkaufskosten (über Einkaufsrechnung)
@@ -5167,6 +5187,7 @@
 DocType: Quiz Result,Wrong,Falsch
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Kurs, zu dem die Währung der Preisliste in die Basiswährung des Kunden umgerechnet wird"
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Nettobetrag (Unternehmenswährung)
+DocType: Sales Partner,Referral Code,Referenzcode
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Der gesamte Vorschussbetrag darf nicht höher sein als der Gesamtbetrag der Sanktion
 DocType: Salary Slip,Hour Rate,Stundensatz
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Aktivieren Sie die automatische Nachbestellung
@@ -5295,6 +5316,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Bestandsmenge anzeigen
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Nettocashflow aus laufender Geschäftstätigkeit
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Zeile # {0}: Status muss {1} für Rechnungsrabatt {2} sein
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM-Umrechnungsfaktor ({0} -&gt; {1}) für Artikel nicht gefunden: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Position 4
 DocType: Student Admission,Admission End Date,Stichtag für Zulassungsende
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Zulieferung
@@ -5317,6 +5339,7 @@
 DocType: Travel Request,Fully Sponsored,Vollständig gesponsert
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Journaleintrag umkehren
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Jobkarte erstellen
+DocType: Quotation,Referral Sales Partner,Empfehlungs-Vertriebspartner
 DocType: Quality Procedure Process,Process Description,Prozessbeschreibung
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Kunde {0} wird erstellt.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Derzeit ist kein Bestand in einem Lager verfügbar
@@ -5451,6 +5474,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,Stückpreis
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Hochgeladene Datei lesen
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Der angehaltene Arbeitsauftrag kann nicht abgebrochen werden. Stoppen Sie ihn zuerst, um ihn abzubrechen"
+DocType: Coupon Code,Coupon Code,Gutscheincode
 DocType: Asset,Journal Entry for Scrap,Journaleintrag für Ausschuss
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Bitte Artikel vom Lieferschein nehmen
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Zeile {0}: Wählen Sie die Arbeitsstation für die Operation {1} aus.
@@ -5533,6 +5557,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;Datum&#39; ist erforderlich
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Fälligkeits-/Stichdatum kann nicht nach {0} liegen
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Daten-Import und -Export
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired",Die Gültigkeit des Gutscheincodes ist leider abgelaufen
 DocType: Bank Account,Account Details,Kontendaten
 DocType: Crop,Materials Required,Benötigte Materialien
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Keine Studenten gefunden
@@ -5570,6 +5595,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Gehen Sie zu den Benutzern
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Summe aus gezahltem Betrag + ausgebuchter Betrag darf nicht größer der Gesamtsumme sein
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} ist keine gültige Chargennummer für Artikel {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Bitte geben Sie einen gültigen Gutscheincode ein !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Hinweis: Es gibt nicht genügend Urlaubsguthaben für Abwesenheitstyp {0}
 DocType: Task,Task Description,Aufgabenbeschreibung
 DocType: Training Event,Seminar,Seminar
@@ -5833,6 +5859,7 @@
 ,TDS Payable Monthly,TDS monatlich zahlbar
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,In Warteschlange zum Ersetzen der Stückliste. Dies kann einige Minuten dauern.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Abzug nicht möglich, wenn Kategorie ""Wertbestimmtung"" oder ""Wertbestimmung und Summe"" ist"
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Richten Sie das Employee Naming System unter Human Resource&gt; HR Settings ein
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Gesamtzahlungen
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Seriennummern sind erforderlich für den Artikel mit Seriennummer {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Zahlungen und Rechnungen abgleichen
@@ -5922,6 +5949,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Holen Sie sich Rohstoffe für die Produktion
 DocType: Job Opening,Job Title,Stellenbezeichnung
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Zukünftige Zahlung
+DocType: Quotation,Additional Discount and Coupon Code,Zusätzlicher Rabatt und Gutscheincode
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} zeigt an, dass {1} kein Angebot anbieten wird, aber alle Items wurden zitiert. Aktualisieren des RFQ-Angebotsstatus."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maximum Samples - {0} wurden bereits für Batch {1} und Artikel {2} in Batch {3} gespeichert.
@@ -6149,7 +6177,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Einstellungen für die Internet-Homepage
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} ist zurückgestellt bis {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQs sind nicht zulässig für {0} aufgrund einer Scorecard von {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Einkaufsrechnung erstellen
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Genutzter Urlaub
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,Verwendeter {0} -Coupon ist {1}. Zulässige Menge ist erschöpft
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Möchten Sie die Materialanfrage einreichen?
 DocType: Job Offer,Awaiting Response,Warte auf Antwort
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6163,6 +6193,7 @@
 DocType: Training Event Employee,Optional,Optional
 DocType: Salary Slip,Earning & Deduction,Einkünfte & Abzüge
 DocType: Agriculture Analysis Criteria,Water Analysis,Wasseranalyse
+DocType: Sales Order,Skip Delivery Note,Lieferschein überspringen
 DocType: Price List,Price Not UOM Dependent,Preis nicht UOM abhängig
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} Varianten erstellt.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Eine Standard-Service-Level-Vereinbarung ist bereits vorhanden.
@@ -6267,6 +6298,7 @@
 DocType: Vehicle,Last Carbon Check,Last Kohlenstoff prüfen
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Rechtskosten
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Bitte wählen Sie die Menge aus
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Fertigungsauftrag {0}: Auftragskarte für den Vorgang {1} nicht gefunden
 DocType: Purchase Invoice,Posting Time,Buchungszeit
 DocType: Timesheet,% Amount Billed,% des Betrages berechnet
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Telefonkosten
@@ -6369,7 +6401,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Steuern und Gebühren hinzugefügt
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Abschreibungszeile {0}: Das nächste Abschreibungsdatum darf nicht vor dem Verfügbarkeitsdatum liegen
 ,Sales Funnel,Verkaufstrichter
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Artikelcode&gt; Artikelgruppe&gt; Marke
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Abkürzung ist zwingend erforderlich
 DocType: Project,Task Progress,Vorgangsentwicklung
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Einkaufswagen
@@ -6464,6 +6495,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,"Verkaufsstellen-Profil benötigt, um Verkaufsstellen-Buchung zu erstellen"
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Treuepunkte werden aus dem ausgegebenen Betrag (über die Verkaufsrechnung) berechnet, basierend auf dem genannten Sammelfaktor."
 DocType: Program Enrollment Tool,Enroll Students,einschreiben Studenten
+DocType: Pricing Rule,Coupon Code Based,Gutscheincode basiert
 DocType: Company,HRA Settings,HRA-Einstellungen
 DocType: Homepage,Hero Section,Helden-Sektion
 DocType: Employee Transfer,Transfer Date,Überweisungsdatum
@@ -6579,6 +6611,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',"Bitte den Filter ""Unternehmen"" leeren, wenn nach Unternehmen gruppiert wird"
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Buchungsdatum kann nicht Datum in der Zukunft sein
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Zeile # {0}: Seriennummer {1} stimmt nicht mit {2} {3} überein
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Richten Sie die Nummerierungsserie für die Teilnahme über Setup&gt; Nummerierungsserie ein
 DocType: Stock Entry,Target Warehouse Address,Ziellageradresse
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Erholungsurlaub
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,"Die Zeit vor dem Schichtbeginn, in der der Mitarbeiter-Check-in für die Anwesenheit berücksichtigt wird."
@@ -6613,7 +6646,6 @@
 DocType: Employee Grade,Employee Grade,Mitarbeiterklasse
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Akkordarbeit
 DocType: GSTR 3B Report,June,Juni
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Lieferant&gt; Lieferantentyp
 DocType: Share Balance,From No,Von Nr
 DocType: Shift Type,Early Exit Grace Period,Early Exit Grace Period
 DocType: Task,Actual Time (in Hours),Tatsächliche Zeit (in Stunden)
@@ -6896,7 +6928,6 @@
 DocType: Warehouse,Warehouse Name,Lagername
 DocType: Naming Series,Select Transaction,Bitte Transaktionen auswählen
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Bitte genehmigende Rolle oder genehmigenden Nutzer eingeben
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM-Umrechnungsfaktor ({0} -&gt; {1}) für Artikel nicht gefunden: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Service Level Agreement mit Entitätstyp {0} und Entität {1} ist bereits vorhanden.
 DocType: Journal Entry,Write Off Entry,Abschreibungsbuchung
 DocType: BOM,Rate Of Materials Based On,Anteil der zu Grunde liegenden Materialien
@@ -7034,6 +7065,7 @@
 DocType: Budget,Warn,Warnen
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Alle Positionen wurden bereits für diesen Arbeitsauftrag übertragen.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Sonstige wichtige Anmerkungen, die in die Datensätze aufgenommen werden sollten."
+DocType: Bank Account,Company Account,Firmenkonto
 DocType: Asset Maintenance,Manufacturing User,Nutzer Fertigung
 DocType: Purchase Invoice,Raw Materials Supplied,Gelieferte Rohmaterialien
 DocType: Subscription Plan,Payment Plan,Zahlungsplan
@@ -7075,6 +7107,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) darf nicht größer als die geplante Menge ({2}) im Arbeitsauftrag {3} sein
 DocType: Certification Application,Name of Applicant,Name des Bewerbers
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Zeitblatt für die Fertigung.
+DocType: Quick Stock Balance,Quick Stock Balance,Schneller Lagerbestand
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Zwischensumme
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Die Eigenschaften der Variante können nach der Buchung nicht mehr verändert werden. Hierzu muss ein neuer Artikel erstellt werden.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA-Mandat
@@ -7401,6 +7434,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},Bitte {0} setzen
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} ist ein inaktiver Schüler
 DocType: Employee,Health Details,Gesundheitsdaten
+DocType: Coupon Code,Coupon Type,Coupon-Typ
 DocType: Leave Encashment,Encashable days,Bezwingbare Tage
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Zur Erstellung eines Zahlungsauftrags ist ein Referenzdokument erforderlich
 DocType: Soil Texture,Sandy Clay,Sandiger Lehm
@@ -7684,6 +7718,7 @@
 DocType: Hotel Room Package,Amenities,Ausstattung
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Zahlungsbedingungen automatisch abrufen
 DocType: QuickBooks Migrator,Undeposited Funds Account,Konto für nicht eingezahlte Gelder
+DocType: Coupon Code,Uses,Verwendet
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Mehrere Standard-Zahlungsarten sind nicht erlaubt
 DocType: Sales Invoice,Loyalty Points Redemption,Treuepunkte-Einlösung
 ,Appointment Analytics,Terminanalytik
@@ -7700,6 +7735,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Gesamtbudget; Gesamtetat
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Lassen Sie dies leer, wenn Sie Studentengruppen pro Jahr anlegen."
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Falls diese Option aktiviert ist, beinhaltet die Gesamtanzahl der Arbeitstage auch Feiertage und der Wert ""Gehalt pro Tag"" wird reduziert"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Fehler beim Hinzufügen der Domain
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Um eine Überbestätigung / Überlieferung zu ermöglichen, aktualisieren Sie &quot;Überbestätigung / Überlieferung&quot; in den Lagereinstellungen oder im Artikel."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Apps, die den aktuellen Schlüssel verwenden, werden den Zugriff verlieren. Trotzdem fortfahren?"
 DocType: Subscription Settings,Prorate,Prorieren
@@ -7712,6 +7748,7 @@
 ,BOM Stock Report,BOM Stock Report
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Wenn kein Zeitschlitz zugewiesen ist, wird die Kommunikation von dieser Gruppe behandelt"
 DocType: Stock Reconciliation Item,Quantity Difference,Mengendifferenz
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Lieferant&gt; Lieferantentyp
 DocType: Opportunity Item,Basic Rate,Grundpreis
 DocType: GL Entry,Credit Amount,Guthaben-Summe
 ,Electronic Invoice Register,Elektronisches Rechnungsregister
@@ -7965,6 +8002,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Steuern und Gebühren abgezogen (Unternehmenswährung)
 DocType: Item Group,General Settings,Grundeinstellungen
 DocType: Article,Article,Artikel
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Bitte Gutscheincode eingeben !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Von-Währung und Bis-Währung können nicht gleich sein
 DocType: Taxable Salary Slab,Percent Deduction,Prozentabzug
 DocType: GL Entry,To Rename,Umbenennen
diff --git a/erpnext/translations/el.csv b/erpnext/translations/el.csv
index 5f460ef..faac064 100644
--- a/erpnext/translations/el.csv
+++ b/erpnext/translations/el.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Επικοινωνία Πελατών
 DocType: Shift Type,Enable Auto Attendance,Ενεργοποίηση αυτόματης παρακολούθησης
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Πληκτρολογήστε την Αποθήκη και την ημερομηνία
 DocType: Lost Reason Detail,Opportunity Lost Reason,Ευκαιρία χαμένος λόγος
 DocType: Patient Appointment,Check availability,Ελέγξτε διαθεσιμότητα
 DocType: Retention Bonus,Bonus Payment Date,Ημερομηνία πληρωμής μπόνους
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Ολοκληρωμένες Εντολές Εργασίας
 DocType: Support Settings,Forum Posts,Δημοσιεύσεις φόρουμ
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Η εργασία έχει τεθεί ως εργασία υποβάθρου. Σε περίπτωση που υπάρχει θέμα επεξεργασίας στο παρασκήνιο, το σύστημα θα προσθέσει ένα σχόλιο σχετικά με το σφάλμα σε αυτήν την Συμφωνία Χρηματιστηρίου και θα επανέλθει στο στάδιο του Σχεδίου"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Λυπούμαστε, η εγκυρότητα του κωδικού κουπονιού δεν έχει ξεκινήσει"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Υποχρεωτικό ποσό
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Δεν επιτρέπεται να προσθέσετε ή να ενημερώσετε τις καταχωρήσεις πριν από {0}
 DocType: Leave Policy,Leave Policy Details,Αφήστε τα στοιχεία πολιτικής
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Αναλώσιμα
 DocType: Student,B-,ΣΙ-
 DocType: Assessment Result,Grade,Βαθμός
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Κωδικός στοιχείου&gt; Ομάδα στοιχείων&gt; Μάρκα
 DocType: Restaurant Table,No of Seats,Αριθμός καθισμάτων
 DocType: Sales Invoice,Overdue and Discounted,Καθυστερημένη και εκπτωτική
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Κλήση αποσυνδεδεμένο
@@ -506,6 +509,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,διάστιχο για ποσό ολογράφως
 DocType: Vehicle,Additional Details,Επιπλέον Λεπτομέρειες
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Δεν έχει δοθεί περιγραφή
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Λήψη στοιχείων από την αποθήκη
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Αίτηση αγοράς.
 DocType: POS Closing Voucher Details,Collected Amount,Συγκεντρωμένο ποσό
 DocType: Lab Test,Submitted Date,Ημερομηνία υποβολής
@@ -613,6 +617,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Μαθαίνω
 ,Trial Balance (Simple),Δοκιμαστικό υπόλοιπο (απλό)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Ενεργοποίηση αναβαλλόμενου εξόδου
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Κωδικός εφαρμοσμένου κουπονιού
 DocType: Asset,Next Depreciation Date,Επόμενο Ημερομηνία Αποσβέσεις
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Δραστηριότητα κόστος ανά εργαζόμενο
 DocType: Accounts Settings,Settings for Accounts,Ρυθμίσεις για τους λογαριασμούς
@@ -848,8 +853,6 @@
 DocType: BOM,Work Order,Παραγγελία εργασίας
 DocType: Sales Invoice,Total Qty,Συνολική ποσότητα
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Όνομα ταυτότητας ηλεκτρονικού ταχυδρομείου Guardian2
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Διαγράψτε τον υπάλληλο <a href=""#Form/Employee/{0}"">{0}</a> \ για να ακυρώσετε αυτό το έγγραφο"
 DocType: Item,Show in Website (Variant),Εμφάνιση στην ιστοσελίδα (Παραλλαγή)
 DocType: Employee,Health Concerns,Ανησυχίες για την υγεία
 DocType: Payroll Entry,Select Payroll Period,Επιλέξτε Περίοδο Μισθοδοσίας
@@ -1013,6 +1016,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Λογαριασμός παρακράτησης φόρου
 DocType: Pricing Rule,Sales Partner,Συνεργάτης πωλήσεων
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Όλες οι scorecards του προμηθευτή.
+DocType: Coupon Code,To be used to get discount,Να χρησιμοποιηθούν για να λάβετε έκπτωση
 DocType: Buying Settings,Purchase Receipt Required,Απαιτείται αποδεικτικό παραλαβής αγοράς
 DocType: Sales Invoice,Rail,Ράγα
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Πραγματικό κόστος
@@ -1063,6 +1067,7 @@
 DocType: Production Plan,Production Plan,Σχέδιο παραγωγής
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Άνοιγμα εργαλείου δημιουργίας τιμολογίου
 DocType: Salary Component,Round to the Nearest Integer,Στρογγυλά στο πλησιέστερο ακέραιο
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Να επιτρέπεται η προσθήκη προϊόντων στο καλάθι
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Επιστροφή πωλήσεων
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Ορισμός ποσότητας στις συναλλαγές με βάση την αύξουσα σειρά εισόδου
 ,Total Stock Summary,Συνολική σύνοψη μετοχών
@@ -1192,6 +1197,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Βάση ώρα Rate (Εταιρεία νομίσματος)
 ,Qty To Be Billed,Ποσότητα που χρεώνεται
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Ποσό που παραδόθηκε
+DocType: Coupon Code,Gift Card,Δωροκάρτα
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Ποσότητα εφοδιασμού για την παραγωγή: Ποσότητα πρώτων υλών για την κατασκευή ειδών κατασκευής.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Ημερομηνία Εξαγοράς
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Αυτή η τραπεζική συναλλαγή έχει ήδη συμφωνηθεί πλήρως
@@ -1279,6 +1285,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Δημιουργία φύλλου εργασίας
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Ο λογαριασμός {0} έχει τεθεί πολλές φορές
 DocType: Account,Expenses Included In Valuation,Δαπάνες που περιλαμβάνονται στην αποτίμηση
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Αγορά τιμολογίων
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Μπορείτε να το ανανεώσετε μόνο αν λήξει η ιδιότητά σας εντός 30 ημερών
 DocType: Shopping Cart Settings,Show Stock Availability,Εμφάνιση διαθεσιμότητας αποθεμάτων
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Ορίστε {0} στην κατηγορία στοιχείων {1} ή στην εταιρεία {2}
@@ -1837,6 +1844,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Εισαγωγή στοιχείων και UOMs
 DocType: Repayment Schedule,Balance Loan Amount,Υπόλοιπο Ποσό Δανείου
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Προστέθηκαν στις λεπτομέρειες
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Λυπούμαστε, ο κωδικός κουπονιού εξαντλείται"
 DocType: Communication Medium,Catch All,Πιάστε όλα
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Μάθημα πρόγραμμα
 DocType: Budget,Applicable on Material Request,Ισχύει για Αίτηση υλικού
@@ -2004,6 +2012,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Μη έγκυρη Χαρακτηριστικό
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} Πρέπει να υποβληθεί
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Καμπάνιες ηλεκτρονικού ταχυδρομείου
+DocType: Sales Partner,To Track inbound purchase,Για την παρακολούθηση της εισερχόμενης αγοράς
 DocType: Buying Settings,Default Supplier Group,Προεπιλεγμένη ομάδα προμηθευτών
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Ποσότητα πρέπει να είναι μικρότερη ή ίση με {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Το μέγιστο ποσό που είναι επιλέξιμο για το στοιχείο {0} υπερβαίνει το {1}
@@ -2159,8 +2168,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Κάντε καταχώρηση αποθέματος
 DocType: Hotel Room Reservation,Hotel Reservation User,Χρήστης κράτησης ξενοδοχείων
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Ορισμός κατάστασης
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Ρυθμίστε τη σειρά αρίθμησης για τη συμμετοχή μέσω του προγράμματος Εγκατάστασης&gt; Σειρά αρίθμησης
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Παρακαλώ επιλέξτε πρόθεμα πρώτα
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Ορίστε την Ονοματοδοσία για {0} μέσω του Setup&gt; Settings&gt; Naming Series
 DocType: Contract,Fulfilment Deadline,Προθεσμία εκπλήρωσης
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Κοντά σας
 DocType: Student,O-,Ο-
@@ -2284,6 +2293,7 @@
 DocType: Quality Meeting Table,Under Review,Υπό εξέταση
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Αποτυχία σύνδεσης
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Το στοιχείο {0} δημιουργήθηκε
+DocType: Coupon Code,Promotional,Διαφήμιση
 DocType: Special Test Items,Special Test Items,Ειδικά στοιχεία δοκιμής
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Πρέπει να είστε χρήστης με ρόλους του Διαχειριστή Συστήματος και Στοιχεία διαχειριστή στοιχείων για να εγγραφείτε στο Marketplace.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Αναφορές κλειδιών
@@ -2321,6 +2331,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Τύπος εγγράφου
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Το σύνολο των κατανεμημέωνων ποσοστών για την ομάδα πωλήσεων πρέπει να είναι 100
 DocType: Subscription Plan,Billing Interval Count,Χρονικό διάστημα χρέωσης
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Διαγράψτε τον υπάλληλο <a href=""#Form/Employee/{0}"">{0}</a> \ για να ακυρώσετε αυτό το έγγραφο"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Ραντεβού και συναντήσεων ασθενών
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Η αξία λείπει
 DocType: Employee,Department and Grade,Τμήμα και βαθμό
@@ -2423,6 +2435,7 @@
 DocType: Project,Start and End Dates,Ημερομηνίες έναρξης και λήξης
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Όροι εκπλήρωσης προτύπου συμβολαίου
 ,Delivered Items To Be Billed,Είδη για χρέωση που έχουν παραδοθεί
+DocType: Coupon Code,Maximum Use,Μέγιστη χρήση
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Ανοίξτε το BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Η αποθήκη δεν μπορεί να αλλάξει για τον σειριακό αριθμό
 DocType: Authorization Rule,Average Discount,Μέση έκπτωση
@@ -2584,6 +2597,7 @@
 DocType: Item,Inventory,Απογραφή
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Λήψη ως Json
 DocType: Item,Sales Details,Λεπτομέρειες πωλήσεων
+DocType: Coupon Code,Used,Μεταχειρισμένος
 DocType: Opportunity,With Items,Με Αντικείμενα
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Η καμπάνια &#39;{0}&#39; υπάρχει ήδη για το {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Ομάδα συντήρησης
@@ -2713,7 +2727,7 @@
 						Serial No cannot be ensured",Δεν βρέθηκε ενεργό BOM για το στοιχείο {0}. Δεν είναι δυνατή η εξασφάλιση της παράδοσης με τον \ Αύξοντα Αριθμό
 DocType: Sales Partner,Sales Partner Target,Στόχος συνεργάτη πωλήσεων
 DocType: Loan Type,Maximum Loan Amount,Ανώτατο ποσό του δανείου
-DocType: Pricing Rule,Pricing Rule,Κανόνας τιμολόγησης
+DocType: Coupon Code,Pricing Rule,Κανόνας τιμολόγησης
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Διπλότυπος αριθμός κυλίνδρου για φοιτητή {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Υλικό αίτηση για αγορά Παραγγελία
 DocType: Company,Default Selling Terms,Προεπιλεγμένοι όροι πώλησης
@@ -2792,6 +2806,7 @@
 DocType: Payment Schedule,Payment Amount,Ποσό πληρωμής
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Ημερομηνία ημ / νίας ημέρας πρέπει να είναι μεταξύ της εργασίας από την ημερομηνία και της ημερομηνίας λήξης εργασίας
 DocType: Healthcare Settings,Healthcare Service Items,Στοιχεία Υπηρεσίας Υγείας
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Μη έγκυρος γραμμικός κώδικας. Δεν υπάρχει στοιχείο συνδεδεμένο σε αυτόν τον γραμμωτό κώδικα.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Ποσό που καταναλώθηκε
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Καθαρή Αλλαγή σε μετρητά
 DocType: Assessment Plan,Grading Scale,Κλίμακα βαθμολόγησης
@@ -2911,7 +2926,6 @@
 DocType: Share Transfer,Asset Account,Λογαριασμός Asset
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Νέα ημερομηνία κυκλοφορίας θα πρέπει να είναι στο μέλλον
 DocType: Purchase Invoice,End date of current invoice's period,Ημερομηνία λήξης της περιόδου του τρέχοντος τιμολογίου
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Ρυθμίστε το Σύστημα Ονοματοδοσίας Εργαζομένων σε Ανθρώπινο Δυναμικό&gt; Ρυθμίσεις HR
 DocType: Lab Test,Technician Name,Όνομα τεχνικού
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3022,6 +3036,7 @@
 DocType: Products Settings,Hide Variants,Απόκρυψη παραλλαγών
 DocType: Lead,Next Contact By,Επόμενη επικοινωνία από
 DocType: Compensatory Leave Request,Compensatory Leave Request,Αίτημα αντισταθμιστικής άδειας
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Δεν είναι δυνατή η υπερπαραγωγή στοιχείου {0} στη σειρά {1} περισσότερο από {2}. Για να επιτρέψετε την υπερχρέωση, παρακαλούμε να ορίσετε το επίδομα στις Ρυθμίσεις Λογαριασμών"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Η ποσότητα για το είδος {0} στη γραμμή {1} είναι απαραίτητη.
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},"Η αποθήκη {0} δεν μπορεί να διαγραφεί, γιατί υπάρχει ποσότητα για το είδος {1}"
 DocType: Blanket Order,Order Type,Τύπος παραγγελίας
@@ -3191,7 +3206,6 @@
 DocType: Student,Student Mobile Number,Φοιτητής Αριθμός Κινητού
 DocType: Item,Has Variants,Έχει παραλλαγές
 DocType: Employee Benefit Claim,Claim Benefit For,Απαίτηση
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Δεν είναι δυνατή η υπερπαραγωγή στοιχείου {0} στη σειρά {1} περισσότερο από {2}. Για να επιτρέψετε την υπερβολική τιμολόγηση, ρυθμίστε τις ρυθμίσεις αποθεμάτων"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Ενημέρωση απόκρισης
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Έχετε ήδη επιλεγμένα αντικείμενα από {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Όνομα της μηνιαίας διανομής
@@ -3481,6 +3495,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Παρακαλώ ορίστε το νόμισμα στην εταιρεία
 DocType: Workstation,Wages per hour,Μισθοί ανά ώρα
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Ρύθμιση {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Πελάτης&gt; Ομάδα πελατών&gt; Επικράτεια
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Το ισοζύγιο αποθεμάτων στην παρτίδα {0} θα γίνει αρνητικό {1} για το είδος {2} στην αποθήκη {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Μετά από αιτήματα Υλικό έχουν τεθεί αυτόματα ανάλογα με το επίπεδο εκ νέου την τάξη αντικειμένου
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Ο Λογαριασμός {0} είναι άκυρος. Η Νομισματική Μονάδα πρέπει να είναι {1}
@@ -3810,6 +3825,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Υποβολή βεβαίωσης αποδοχών
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Σε κράτηση
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Μια λύση πρέπει να έχει τουλάχιστον μία σωστή επιλογή
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Εντολές αγοράς
 DocType: Account,Inter Company Account,Εταιρικός λογαριασμός
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Εισαγωγή χύδην
 DocType: Sales Partner,Address & Contacts,Διεύθυνση & Επαφές
@@ -3820,6 +3836,7 @@
 DocType: POS Profile,[Select],[ Επιλέξτε ]
 DocType: Staffing Plan Detail,Number Of Positions,Αριθμός θέσεων
 DocType: Vital Signs,Blood Pressure (diastolic),Πίεση αίματος (διαστολική)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Επιλέξτε τον πελάτη.
 DocType: SMS Log,Sent To,Αποστέλλονται
 DocType: Agriculture Task,Holiday Management,Διαχείριση Διακοπών
 DocType: Payment Request,Make Sales Invoice,Δημιούργησε τιμολόγιο πώλησης
@@ -4029,7 +4046,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} Δεν έχει υποβληθεί
 DocType: Subscription,Trialling,Δοκιμάζοντας
 DocType: Sales Invoice Item,Deferred Revenue,Αναβαλλόμενα έσοδα
-DocType: Bank Account,GL Account,Λογαριασμός GL
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Ο λογαριασμός μετρητών θα χρησιμοποιηθεί για τη δημιουργία τιμολογίου πωλήσεων
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Εξαίρεση κατηγορίας
 DocType: Member,Membership Expiry Date,Ημερομηνία λήξης μέλους
@@ -4453,13 +4469,13 @@
 DocType: C-Form Invoice Detail,Territory,Περιοχή
 DocType: Pricing Rule,Apply Rule On Item Code,Εφαρμογή κανόνα στον κωδικό στοιχείου
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Παρακαλώ να αναφέρετε τον αριθμό των επισκέψεων που απαιτούνται
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Έκθεση ισοζυγίου αποθεμάτων
 DocType: Stock Settings,Default Valuation Method,Προεπιλεγμένη μέθοδος αποτίμησης
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Τέλη
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Εμφάνιση αθροιστικού ποσού
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Ενημέρωση σε εξέλιξη. Μπορεί να πάρει λίγο χρόνο.
 DocType: Production Plan Item,Produced Qty,Παραγόμενη ποσότητα
 DocType: Vehicle Log,Fuel Qty,Ποσότητα καυσίμου
-DocType: Stock Entry,Target Warehouse Name,Όνομα στόχου αποθήκης
 DocType: Work Order Operation,Planned Start Time,Προγραμματισμένη ώρα έναρξης
 DocType: Course,Assessment,Εκτίμηση
 DocType: Payment Entry Reference,Allocated,Κατανεμήθηκε
@@ -4537,10 +4553,12 @@
  8. Τρόποι αντιμετώπισης των διαφορών, αποζημίωση, ευθύνη, κλπ ||| 
  9. Διεύθυνση και στοιχεία επικοινωνίας της εταιρείας σας."
 DocType: Homepage Section,Section Based On,Ενότητα βασισμένη σε
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Εμφάνιση εφαρμογής κωδικού κουπονιού
 DocType: Issue,Issue Type,Τύπος Θέματος
 DocType: Attendance,Leave Type,Τύπος άδειας
 DocType: Purchase Invoice,Supplier Invoice Details,Προμηθευτής Λεπτομέρειες Τιμολογίου
 DocType: Agriculture Task,Ignore holidays,Αγνόηση των διακοπών
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Προσθήκη / Επεξεργασία Όρων Κουπονιού
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Η δαπάνη / διαφορά λογαριασμού ({0}) πρέπει να είναι λογαριασμός τύπου 'κέρδη ή ζημίες'
 DocType: Stock Entry Detail,Stock Entry Child,Αποθήκη παιδιού
 DocType: Project,Copied From,Αντιγραφή από
@@ -4715,6 +4733,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Κριτήρια Σχεδίου Αξιολόγησης
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Συναλλαγές
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Αποτροπή παραγγελιών αγοράς
+DocType: Coupon Code,Coupon Name,Όνομα κουπονιού
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Ευαίσθητος
 DocType: Email Campaign,Scheduled,Προγραμματισμένη
 DocType: Shift Type,Working Hours Calculation Based On,Υπολογισμός Ώρας Λειτουργίας με βάση
@@ -4731,7 +4750,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Δημιουργήστε παραλλαγές
 DocType: Vehicle,Diesel,Ντίζελ
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Το νόμισμα του τιμοκαταλόγου δεν έχει επιλεγεί
+DocType: Quick Stock Balance,Available Quantity,διαθέσιμη ποσότητα
 DocType: Purchase Invoice,Availed ITC Cess,Επωφεληθεί ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Ρυθμίστε το Σύστημα Ονοματοδοσίας Εκπαιδευτών στην Εκπαίδευση&gt; Ρυθμίσεις Εκπαίδευσης
 ,Student Monthly Attendance Sheet,Φοιτητής Φύλλο Μηνιαία Συμμετοχή
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Κανονισμός αποστολής ισχύει μόνο για την πώληση
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Γραμμή απόσβεσης {0}: Η επόμενη ημερομηνία απόσβεσης δεν μπορεί να είναι πριν από την ημερομηνία αγοράς
@@ -4798,8 +4819,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Σειρά {0}: Προκαταβολή έναντι των πελατών πρέπει να είναι πιστωτικά
 DocType: Quality Meeting,Quality Meeting,Πραγματική συνάντηση
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Μη-ομάδα σε ομάδα
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Ορίστε την Ονοματοδοσία για {0} μέσω του Setup&gt; Settings&gt; Naming Series
 DocType: Employee,ERPNext User,ERPΕπόμενο χρήστη
+DocType: Coupon Code,Coupon Description,Περιγραφή κουπονιού
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Η παρτίδα είναι υποχρεωτική στη σειρά {0}
 DocType: Company,Default Buying Terms,Προεπιλεγμένοι όροι αγοράς
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Το είδος στο αποδεικτικό παραλαβής αγοράς έχει προμηθευτεί
@@ -4962,6 +4983,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Κατά λεπτομέρειες εγγράφου αρ.
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Η διαγραφή δεν επιτρέπεται για τη χώρα {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Κόμμα Τύπος είναι υποχρεωτική
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Εφαρμόστε τον κωδικό κουπονιού
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","Για την καρτέλα εργασίας {0}, μπορείτε να πραγματοποιήσετε μόνο την καταχώρηση αποθεμάτων τύπου &quot;Μεταφορά υλικού για παραγωγή&quot;"
 DocType: Quality Inspection,Outgoing,Εξερχόμενος
 DocType: Customer Feedback Table,Customer Feedback Table,Πίνακας σχολίων πελατών
@@ -5111,7 +5133,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Στην υποβολή της παραγγελίας αγοράς
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Προσθήκη όλων των προμηθευτών
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Σειρά # {0}: Το κατανεμημένο ποσό δεν μπορεί να είναι μεγαλύτερο από το οφειλόμενο ποσό.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Πελάτης&gt; Ομάδα πελατών&gt; Επικράτεια
 DocType: Tally Migration,Parties,Συμβαλλόμενα μέρη
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Αναζήτηση BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Εξασφαλισμένα δάνεια
@@ -5143,7 +5164,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Δεν επιτρέπεται να ορίσετε εναλλακτικό στοιχείο για το στοιχείο {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Η ημερομηνία επαναλαμβάνεται
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Εξουσιοδοτημένο υπογράφοντα
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Ρυθμίστε το Σύστημα Ονοματοδοσίας Εκπαιδευτών στην Εκπαίδευση&gt; Ρυθμίσεις Εκπαίδευσης
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Διαθέσιμο διαθέσιμο ITC (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Δημιουργία τελών
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Συνολικό Κόστος Αγοράς (μέσω του τιμολογίου αγοράς)
@@ -5168,6 +5188,7 @@
 DocType: Quiz Result,Wrong,Λανθασμένος
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Ισοτιμία με την οποία το νόμισμα τιμοκαταλόγου μετατρέπεται στο βασικό νόμισμα του πελάτη
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Καθαρό Ποσό (Εταιρεία νομίσματος)
+DocType: Sales Partner,Referral Code,Κωδικός παραπομπής
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Το συνολικό ποσό προκαταβολής δεν μπορεί να είναι μεγαλύτερο από το συνολικό ποσό που έχει επιβληθεί
 DocType: Salary Slip,Hour Rate,Χρέωση ανά ώρα
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Ενεργοποιήστε την αυτόματη αναδιάταξη
@@ -5296,6 +5317,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Εμφάνιση ποσότητας αποθέματος
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Καθαρές ροές από λειτουργικές δραστηριότητες
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Σειρά # {0}: Η κατάσταση πρέπει να είναι {1} για την έκπτωση τιμολογίων {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM Ο συντελεστής μετατροπής ({0} -&gt; {1}) δεν βρέθηκε για το στοιχείο: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Στοιχείο 4
 DocType: Student Admission,Admission End Date,Η είσοδος Ημερομηνία Λήξης
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Υπεργολαβίες
@@ -5318,6 +5340,7 @@
 DocType: Travel Request,Fully Sponsored,Πλήρης χορηγία
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Αντίστροφη εγγραφή ημερολογίου
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Δημιουργία κάρτας εργασίας
+DocType: Quotation,Referral Sales Partner,Συνεργάτης πωλήσεων παραπομπής
 DocType: Quality Procedure Process,Process Description,Περιγραφή διαδικασίας
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Ο πελάτης {0} δημιουργείται.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Προς το παρων δεν υπάρχει διαθέσιμο απόθεμα σε καμία αποθήκη
@@ -5452,6 +5475,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,Τιμή Λ.Υ.
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Ανάγνωση αρχείου που μεταφορτώθηκε
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Δεν είναι δυνατή η ακύρωση της Παραγγελίας Παραγγελίας, Απεγκαταστήστε την πρώτα για ακύρωση"
+DocType: Coupon Code,Coupon Code,Κωδικός κουπονιού
 DocType: Asset,Journal Entry for Scrap,Εφημερίδα Έναρξη για παλιοσίδερα
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Παρακαλώ κάντε λήψη ειδών από το δελτίο αποστολής
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Γραμμή {0}: επιλέξτε τη θέση εργασίας σε σχέση με τη λειτουργία {1}
@@ -5534,6 +5558,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,Απαιτείται η &quot;Ημερομηνία&quot;
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Η ημερομηνία λήξης προθεσμίας / αναφοράς δεν μπορεί να είναι μετά από {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Δεδομένα εισαγωγής και εξαγωγής
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Λυπούμαστε, η ισχύς του κωδικού κουπονιού έχει λήξει"
 DocType: Bank Account,Account Details,Στοιχεία λογαριασμού
 DocType: Crop,Materials Required,Απαιτούμενα υλικά
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Δεν μαθητές Βρέθηκαν
@@ -5571,6 +5596,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Μεταβείτε στους χρήστες
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Το άθροισμα από το καταβληθέν ποσό και το ποσό που διαγράφηκε δεν μπορεί να είναι μεγαλύτερο από το γενικό σύνολο
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},Ο {0} δεν είναι έγκυρος αριθμός παρτίδας για το είδος {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Εισαγάγετε τον έγκυρο κωδικό κουπονιού !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Σημείωση : δεν υπάρχει αρκετό υπόλοιπο άδειας για τον τύπο άδειας {0}
 DocType: Task,Task Description,Περιγραφή των εργασιών
 DocType: Training Event,Seminar,Σεμινάριο
@@ -5834,6 +5860,7 @@
 ,TDS Payable Monthly,TDS πληρωτέα μηνιαία
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Ρυθμίζεται για αντικατάσταση του BOM. Μπορεί να χρειαστούν μερικά λεπτά.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Δεν μπορούν να αφαιρεθούν όταν η κατηγορία είναι για αποτίμηση ή αποτίμηση και σύνολο
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Ρυθμίστε το Σύστημα Ονοματοδοσίας Εργαζομένων σε Ανθρώπινο Δυναμικό&gt; Ρυθμίσεις HR
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Συνολικές Πληρωμές
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Οι σειριακοί αριθμοί είναι απαραίτητοι για το είδος με σειρά {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Πληρωμές αγώνα με τιμολόγια
@@ -5923,6 +5950,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Πάρτε πρώτες ύλες για παραγωγή
 DocType: Job Opening,Job Title,Τίτλος εργασίας
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Μελλοντική Πληρωμή Ref
+DocType: Quotation,Additional Discount and Coupon Code,Πρόσθετος κωδικός έκπτωσης και κουπονιού
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} υποδεικνύει ότι η {1} δεν θα παράσχει μια προσφορά, αλλά  όλα τα στοιχεία έχουν αναφερθεί  \. Ενημέρωση κατάστασης  ""Αίτηση για προσφορά""."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Τα μέγιστα δείγματα - {0} έχουν ήδη διατηρηθεί για το Παρτίδα {1} και το στοιχείο {2} στην Παρτίδα {3}.
@@ -6150,7 +6178,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Ρυθμίσεις για την ιστοσελίδα αρχική σελίδα
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} είναι σε αναμονή μέχρι την {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},Οι RFQ δεν επιτρέπονται για {0} λόγω μίας κάρτας αποτελεσμάτων {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Δημιούργησε τιμολόγιο αγοράς
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Χρησιμοποιημένα φύλλα
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Το κουπόνι που χρησιμοποιείται είναι {1}. Η επιτρεπόμενη ποσότητα έχει εξαντληθεί
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Θέλετε να υποβάλετε το αίτημα υλικού
 DocType: Job Offer,Awaiting Response,Αναμονή Απάντησης
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6164,6 +6194,7 @@
 DocType: Training Event Employee,Optional,Προαιρετικός
 DocType: Salary Slip,Earning & Deduction,Κέρδος και έκπτωση
 DocType: Agriculture Analysis Criteria,Water Analysis,Ανάλυση Νερού
+DocType: Sales Order,Skip Delivery Note,Παράλειψη σημείωσης παράδοσης
 DocType: Price List,Price Not UOM Dependent,Τιμή δεν εξαρτάται από UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} δημιουργήθηκαν παραλλαγές.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Υπάρχει ήδη συμβατική συμφωνία επιπέδου υπηρεσιών.
@@ -6268,6 +6299,7 @@
 DocType: Vehicle,Last Carbon Check,Τελευταία Carbon Έλεγχος
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Νομικές δαπάνες
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Παρακαλούμε επιλέξτε ποσότητα σε σειρά
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Παραγγελία εργασίας {0}: δεν βρέθηκε κάρτα εργασίας για τη λειτουργία {1}
 DocType: Purchase Invoice,Posting Time,Ώρα αποστολής
 DocType: Timesheet,% Amount Billed,Ποσό που χρεώνεται%
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Δαπάνες τηλεφώνου
@@ -6370,7 +6402,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Φόροι και επιβαρύνσεις που προστέθηκαν
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Απόσβεση γραμμής {0}: Η επόμενη ημερομηνία απόσβεσης δεν μπορεί να γίνει πριν από την Ημερομηνία διαθέσιμης για χρήση
 ,Sales Funnel,Χοάνη πωλήσεων
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Κωδικός στοιχείου&gt; Ομάδα στοιχείων&gt; Μάρκα
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Σύντμηση είναι υποχρεωτική
 DocType: Project,Task Progress,Task Progress
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Το Καλάθι
@@ -6466,6 +6497,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS Προφίλ απαιτούνται για να κάνουν POS Έναρξη
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Οι Πόντοι Πίστης θα υπολογίζονται από το ποσό που πραγματοποιήθηκε (μέσω του Τιμολογίου Πωλήσεων), με βάση τον συντελεστή συλλογής που αναφέρεται."
 DocType: Program Enrollment Tool,Enroll Students,εγγραφούν μαθητές
+DocType: Pricing Rule,Coupon Code Based,Κωδικός βάσει κουπονιού
 DocType: Company,HRA Settings,Ρυθμίσεις HRA
 DocType: Homepage,Hero Section,Τμήμα ήρωας
 DocType: Employee Transfer,Transfer Date,Ημερομηνία μεταφοράς
@@ -6581,6 +6613,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',"Ρυθμίστε το φίλτρο Εταιρεία κενό, εάν η ομάδα είναι &quot;Εταιρεία&quot;"
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Απόσπαση ημερομηνία αυτή δεν μπορεί να είναι μελλοντική ημερομηνία
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Σειρά # {0}: Αύξων αριθμός {1} δεν ταιριάζει με το {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Ρυθμίστε τη σειρά αρίθμησης για τη συμμετοχή μέσω του προγράμματος Εγκατάστασης&gt; Σειρά αρίθμησης
 DocType: Stock Entry,Target Warehouse Address,Διεύθυνση στόχου αποθήκης
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Περιστασιακή άδεια
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,Ο χρόνος πριν από την ώρα έναρξης της αλλαγής ταχυτήτων κατά τη διάρκεια της οποίας εξετάζεται η συμμετοχή του υπαλλήλου για συμμετοχή.
@@ -6615,7 +6648,6 @@
 DocType: Employee Grade,Employee Grade,Υπάλληλος βαθμού
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Εργασία με το κομμάτι
 DocType: GSTR 3B Report,June,Ιούνιος
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Προμηθευτής&gt; Τύπος προμηθευτή
 DocType: Share Balance,From No,Από τον αριθμό
 DocType: Shift Type,Early Exit Grace Period,Πρώτη περίοδος χάριτος εξόδου
 DocType: Task,Actual Time (in Hours),Πραγματικός χρόνος (σε ώρες)
@@ -6900,7 +6932,6 @@
 DocType: Warehouse,Warehouse Name,Όνομα αποθήκης
 DocType: Naming Series,Select Transaction,Επιλέξτε συναλλαγή
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Παρακαλώ εισάγετε ρόλο έγκρισης ή χρήστη έγκρισης
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM Ο συντελεστής μετατροπής ({0} -&gt; {1}) δεν βρέθηκε για το στοιχείο: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Συμφωνία επιπέδου υπηρεσίας με τον τύπο οντότητας {0} και την οντότητα {1} υπάρχει ήδη.
 DocType: Journal Entry,Write Off Entry,Καταχώρηση διαγραφής
 DocType: BOM,Rate Of Materials Based On,Τιμή υλικών με βάση
@@ -7038,6 +7069,7 @@
 DocType: Budget,Warn,Προειδοποιώ
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Όλα τα στοιχεία έχουν ήδη μεταφερθεί για αυτήν την εντολή εργασίας.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Οποιεσδήποτε άλλες παρατηρήσεις, αξιοσημείωτη προσπάθεια που πρέπει να πάει στα αρχεία."
+DocType: Bank Account,Company Account,Εταιρικός λογαριασμός
 DocType: Asset Maintenance,Manufacturing User,Χρήστης παραγωγής
 DocType: Purchase Invoice,Raw Materials Supplied,Πρώτες ύλες που προμηθεύτηκαν
 DocType: Subscription Plan,Payment Plan,Σχέδιο πληρωμής
@@ -7079,6 +7111,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) δεν μπορεί να είναι μεγαλύτερη από την προγραμματισμένη ποσότητα ({2}) στην Παραγγελία Εργασίας {3}
 DocType: Certification Application,Name of Applicant,Όνομα του αιτούντος
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Ώρα Φύλλο για την κατασκευή.
+DocType: Quick Stock Balance,Quick Stock Balance,Γρήγορη ισορροπία αποθεμάτων
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Μερικό σύνολο
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Δεν είναι δυνατή η αλλαγή ιδιοτήτων παραλλαγής μετά από συναλλαγή μετοχών. Θα χρειαστεί να δημιουργήσετε ένα νέο στοιχείο για να το κάνετε αυτό.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless Εντολή SEPA
@@ -7405,6 +7438,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},Παρακαλώ να ορίσετε {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} είναι ανενεργός φοιτητής
 DocType: Employee,Health Details,Λεπτομέρειες υγείας
+DocType: Coupon Code,Coupon Type,Τύπος κουπονιού
 DocType: Leave Encashment,Encashable days,Ενδεχόμενες ημέρες
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Για να δημιουργήσετε ένα έγγραφο αναφοράς αιτήματος πληρωμής απαιτείται
 DocType: Soil Texture,Sandy Clay,Sandy Clay
@@ -7687,6 +7721,7 @@
 DocType: Hotel Room Package,Amenities,Ανεσεις
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Αυτόματη εξαγωγή όρων πληρωμής
 DocType: QuickBooks Migrator,Undeposited Funds Account,Λογαριασμός χωρίς καταθέσεις
+DocType: Coupon Code,Uses,Χρησιμοποιεί
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Δεν επιτρέπεται πολλαπλή μέθοδος προεπιλογής πληρωμής
 DocType: Sales Invoice,Loyalty Points Redemption,Πίστωση Πόντων Αποπληρωμή
 ,Appointment Analytics,Αντιστοίχιση Analytics
@@ -7703,6 +7738,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Συνολικός προϋπολογισμός
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Αφήστε κενό αν κάνετε ομάδες φοιτητών ανά έτος
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Εάν είναι επιλεγμένο, ο συνολικός αριθμός των εργάσιμων ημερών θα περιλαμβάνει τις αργίες, και αυτό θα μειώσει την αξία του μισθού ανά ημέρα"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Αποτυχία προσθήκης τομέα
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Για να επιτρέψετε την παραλαβή / παράδοση, ενημερώστε την &quot;Over Allowance Receipt / Delivery Allowance&quot; στις Ρυθμίσεις Αποθέματος ή στο Στοιχείο."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Οι εφαρμογές που χρησιμοποιούν το τρέχον κλειδί δεν θα έχουν πρόσβαση, είστε βέβαιοι;"
 DocType: Subscription Settings,Prorate,Φροντίστε
@@ -7715,6 +7751,7 @@
 ,BOM Stock Report,Αναφορά Αποθεματικού BOM
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Αν δεν υπάρχει καθορισμένη χρονική περίοδος, τότε η επικοινωνία θα γίνεται από αυτήν την ομάδα"
 DocType: Stock Reconciliation Item,Quantity Difference,ποσότητα Διαφορά
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Προμηθευτής&gt; Τύπος προμηθευτή
 DocType: Opportunity Item,Basic Rate,Βασική τιμή
 DocType: GL Entry,Credit Amount,Πιστωτικές Ποσό
 ,Electronic Invoice Register,Ηλεκτρονικό μητρώο τιμολογίων
@@ -7968,6 +8005,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Φόροι και επιβαρύνσεις που παρακρατήθηκαν (νόμισμα της εταιρείας)
 DocType: Item Group,General Settings,Γενικές ρυθμίσεις
 DocType: Article,Article,Αρθρο
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Παρακαλώ εισάγετε τον κωδικό κουπονιού !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Από το νόμισμα και σε νόμισμα δεν μπορεί να είναι ίδια
 DocType: Taxable Salary Slab,Percent Deduction,Ποσοστιαία Αφαίρεση
 DocType: GL Entry,To Rename,Για να μετονομάσετε
diff --git a/erpnext/translations/es.csv b/erpnext/translations/es.csv
index 9de782d..18fd8c8 100644
--- a/erpnext/translations/es.csv
+++ b/erpnext/translations/es.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Contacto del Cliente
 DocType: Shift Type,Enable Auto Attendance,Habilitar asistencia automática
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,"Por favor, introduzca el almacén y la fecha"
 DocType: Lost Reason Detail,Opportunity Lost Reason,Oportunidad Razón perdida
 DocType: Patient Appointment,Check availability,Consultar disponibilidad
 DocType: Retention Bonus,Bonus Payment Date,Fecha de Pago de Bonificación
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Órdenes de Trabajo completadas
 DocType: Support Settings,Forum Posts,Publicaciones del Foro
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","La tarea se ha puesto en cola como un trabajo en segundo plano. En caso de que haya algún problema con el procesamiento en segundo plano, el sistema agregará un comentario sobre el error en esta Reconciliación de inventario y volverá a la etapa Borrador"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Lo sentimos, la validez del código de cupón no ha comenzado"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Base Imponible
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},No tiene permisos para agregar o actualizar las entradas antes de {0}
 DocType: Leave Policy,Leave Policy Details,Dejar detalles de la política
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Consumible
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,Grado
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Código de artículo&gt; Grupo de artículos&gt; Marca
 DocType: Restaurant Table,No of Seats,Nro de Asientos
 DocType: Sales Invoice,Overdue and Discounted,Atrasado y con descuento
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Llamada desconectada
@@ -506,6 +509,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,interlineado de la suma en palabras
 DocType: Vehicle,Additional Details,Detalles adicionales
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Ninguna descripción definida
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Obtener artículos del almacén
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Solicitudes de compra.
 DocType: POS Closing Voucher Details,Collected Amount,Cantidad Cobrada
 DocType: Lab Test,Submitted Date,Fecha de Envío
@@ -613,6 +617,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Aprender
 ,Trial Balance (Simple),Balance de Sumas y Saldos (Simple)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Habilitar el Gasto Diferido
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Código de cupón aplicado
 DocType: Asset,Next Depreciation Date,Siguiente Fecha de Depreciación
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Coste de actividad por empleado
 DocType: Accounts Settings,Settings for Accounts,Ajustes de contabilidad
@@ -848,8 +853,6 @@
 DocType: BOM,Work Order,Órden de Trabajo
 DocType: Sales Invoice,Total Qty,Cantidad Total
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,ID de correo electrónico del Tutor2
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Elimine el empleado <a href=""#Form/Employee/{0}"">{0}</a> \ para cancelar este documento"
 DocType: Item,Show in Website (Variant),Mostrar en el sitio web (variante)
 DocType: Employee,Health Concerns,Problemas de salud
 DocType: Payroll Entry,Select Payroll Period,Seleccione el Período de Nómina
@@ -1013,6 +1016,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Cuenta de Retención de Impuestos
 DocType: Pricing Rule,Sales Partner,Socio de ventas
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Todas las Evaluaciones del Proveedor
+DocType: Coupon Code,To be used to get discount,Para ser utilizado para obtener descuento
 DocType: Buying Settings,Purchase Receipt Required,Recibo de compra requerido
 DocType: Sales Invoice,Rail,Carril
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Costo real
@@ -1063,6 +1067,7 @@
 DocType: Production Plan,Production Plan,Plan de Producción
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Herramienta de Apertura de Creación de Facturas
 DocType: Salary Component,Round to the Nearest Integer,Redondear al entero más cercano
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Permitir que los artículos no en stock se agreguen al carrito
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Devoluciones de ventas
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Establezca la cantidad en transacciones basadas en la entrada del Numero de Serie
 ,Total Stock Summary,Resumen de stock total
@@ -1192,6 +1197,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),La tarifa básica de Hora (divisa de la Compañía)
 ,Qty To Be Billed,Cantidad a facturar
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Importe entregado
+DocType: Coupon Code,Gift Card,Tarjeta de regalo
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Cantidad reservada para producción: Cantidad de materias primas para fabricar artículos.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Fecha de Redención
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Esta transacción bancaria ya está completamente conciliada
@@ -1279,6 +1285,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Crear parte de horas
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Cuenta {0} se ha introducido varias veces
 DocType: Account,Expenses Included In Valuation,GASTOS DE VALORACIÓN
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Facturas de compra
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Solo puede renovar si su membresía vence dentro de los 30 días
 DocType: Shopping Cart Settings,Show Stock Availability,Mostrar Disponibilidad de Stock
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Establezca {0} en la categoría de activos {1} o en la empresa {2}
@@ -1818,6 +1825,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Importar artículos y unidades de medida
 DocType: Repayment Schedule,Balance Loan Amount,Saldo del balance del préstamo
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Agregado a los Detalles
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Lo sentimos, el código de cupón está agotado"
 DocType: Communication Medium,Catch All,Atrapar a todos
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Calendario de Cursos
 DocType: Budget,Applicable on Material Request,Aplicable en la Solicitud de Material
@@ -1985,6 +1993,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Atributo no válido
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} debe ser presentado
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Campañas de correo electrónico
+DocType: Sales Partner,To Track inbound purchase,Para rastrear la compra entrante
 DocType: Buying Settings,Default Supplier Group,Grupo de Proveedores Predeterminado
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},La cantidad debe ser menor que o igual a {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},La cantidad máxima elegible para el componente {0} excede de {1}
@@ -2140,8 +2149,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Hacer entrada de stock
 DocType: Hotel Room Reservation,Hotel Reservation User,Usuario de Reserva de Hotel
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Establecer estado
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Configure la serie de numeración para la asistencia a través de Configuración&gt; Serie de numeración
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,"Por favor, seleccione primero el prefijo"
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Configure Naming Series para {0} a través de Configuración&gt; Configuración&gt; Naming Series
 DocType: Contract,Fulfilment Deadline,Fecha límite de Cumplimiento
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Cerca de usted
 DocType: Student,O-,O-
@@ -2265,6 +2274,7 @@
 DocType: Quality Meeting Table,Under Review,Bajo revisión
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Error al iniciar sesión
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Activo {0} creado
+DocType: Coupon Code,Promotional,Promocional
 DocType: Special Test Items,Special Test Items,Artículos de Especiales de Prueba
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Debe ser un usuario con funciones de Administrador del sistema y Administrador de artículos para registrarse en Marketplace.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Reportes clave
@@ -2302,6 +2312,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,DocType
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Porcentaje del total asignado para el equipo de ventas debe ser de 100
 DocType: Subscription Plan,Billing Interval Count,Contador de Intervalo de Facturación
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Elimine el empleado <a href=""#Form/Employee/{0}"">{0}</a> \ para cancelar este documento"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Citas y Encuentros de Pacientes
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Valor que Falta
 DocType: Employee,Department and Grade,Departamento y Grado
@@ -2404,6 +2416,7 @@
 DocType: Project,Start and End Dates,Fechas de Inicio y Fin
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Términos de Cumplimiento de Plantilla de Contrato
 ,Delivered Items To Be Billed,Envios por facturar
+DocType: Coupon Code,Maximum Use,Uso maximo
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Abrir la lista de materiales {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Almacén no se puede cambiar para el N º de serie
 DocType: Authorization Rule,Average Discount,Descuento Promedio
@@ -2565,6 +2578,7 @@
 DocType: Item,Inventory,inventario
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Descargar como Json
 DocType: Item,Sales Details,Detalles de ventas
+DocType: Coupon Code,Used,Usado
 DocType: Opportunity,With Items,Con Productos
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',La campaña &#39;{0}&#39; ya existe para {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Equipo de Mantenimiento
@@ -2694,7 +2708,7 @@
 						Serial No cannot be ensured",No se encontró una lista de materiales activa para el artículo {0}. La entrega por \ Serial No no puede garantizarse
 DocType: Sales Partner,Sales Partner Target,Metas de socio de ventas
 DocType: Loan Type,Maximum Loan Amount,Cantidad máxima del préstamo
-DocType: Pricing Rule,Pricing Rule,Regla de precios
+DocType: Coupon Code,Pricing Rule,Regla de precios
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Número de rol duplicado para el estudiante {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Requisición de materiales hacia órden de compra
 DocType: Company,Default Selling Terms,Términos de venta predeterminados
@@ -2773,6 +2787,7 @@
 DocType: Payment Schedule,Payment Amount,Importe Pagado
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,La fecha de medio día debe estar entre la fecha de trabajo y la fecha de finalización del trabajo
 DocType: Healthcare Settings,Healthcare Service Items,Artículos de servicios de salud
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Código de barras inválido. No hay ningún elemento adjunto a este código de barras.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Monto consumido
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Cambio Neto en efectivo
 DocType: Assessment Plan,Grading Scale,Escala de calificación
@@ -2892,7 +2907,6 @@
 DocType: Share Transfer,Asset Account,Cuenta de Activos
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,La nueva fecha de lanzamiento debe estar en el futuro
 DocType: Purchase Invoice,End date of current invoice's period,Fecha final del periodo de facturación actual
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Configure el Sistema de nombres de empleados en Recursos humanos&gt; Configuración de recursos humanos
 DocType: Lab Test,Technician Name,Nombre del Técnico
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3003,6 +3017,7 @@
 DocType: Products Settings,Hide Variants,Ocultar variantes
 DocType: Lead,Next Contact By,Siguiente contacto por
 DocType: Compensatory Leave Request,Compensatory Leave Request,Solicitud de licencia compensatoria
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","No se puede facturar en exceso el artículo {0} en la fila {1} más de {2}. Para permitir una facturación excesiva, configure la asignación en la Configuración de cuentas"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Cantidad requerida para el producto {0} en la línea {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},El almacén {0} no se puede eliminar ya que existen elementos para el Producto {1}
 DocType: Blanket Order,Order Type,Tipo de orden
@@ -3172,7 +3187,6 @@
 DocType: Student,Student Mobile Number,Número móvil del Estudiante
 DocType: Item,Has Variants,Posee variantes
 DocType: Employee Benefit Claim,Claim Benefit For,Beneficio de reclamo por
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","No se puede sobrefacturar para el Artículo {0} en la fila {1} más que {2}. Para permitir la sobrefacturación, configura en Configuración de Stock"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Actualizar Respuesta
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Ya ha seleccionado artículos de {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Defina el nombre de la distribución mensual
@@ -3462,6 +3476,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,"Por favor, especifique la divisa en la compañía"
 DocType: Workstation,Wages per hour,Salarios por hora
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Configurar {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Cliente&gt; Grupo de clientes&gt; Territorio
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},El balance de Inventario en el lote {0} se convertirá en negativo {1} para el producto {2} en el almacén {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Las Solicitudes de Materiales siguientes se han planteado de forma automática según el nivel de re-pedido del articulo
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},La cuenta {0} no es válida. La divisa de la cuenta debe ser {1}
@@ -3791,6 +3806,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Validar nómina salarial
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,En Espera
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Una pregunta debe tener al menos una opción correcta
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Ordenes de compra
 DocType: Account,Inter Company Account,Cuenta Inter Company
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Importación en masa
 DocType: Sales Partner,Address & Contacts,Dirección y Contactos
@@ -3801,6 +3817,7 @@
 DocType: POS Profile,[Select],[Seleccionar]
 DocType: Staffing Plan Detail,Number Of Positions,Numero de Posiciones
 DocType: Vital Signs,Blood Pressure (diastolic),Presión Arterial (diastólica)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Por favor seleccione el cliente.
 DocType: SMS Log,Sent To,Enviado a
 DocType: Agriculture Task,Holiday Management,Gestión de Vacaciones
 DocType: Payment Request,Make Sales Invoice,Crear Factura de Venta
@@ -4010,7 +4027,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} no se ha enviado
 DocType: Subscription,Trialling,Periodo de Prueba
 DocType: Sales Invoice Item,Deferred Revenue,Ingresos Diferidos
-DocType: Bank Account,GL Account,Cuenta GL
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,La cuenta de efectivo se usará para la creación de facturas de ventas
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Subcategoría de Exención
 DocType: Member,Membership Expiry Date,Fecha de Vencimiento de Membresía
@@ -4414,13 +4430,13 @@
 DocType: C-Form Invoice Detail,Territory,Territorio
 DocType: Pricing Rule,Apply Rule On Item Code,Aplicar regla en código de artículo
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,"Por favor, indique el numero de visitas requeridas"
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Informe de saldo de existencias
 DocType: Stock Settings,Default Valuation Method,Método predeterminado de valoración
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Cuota
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Mostrar la Cantidad Acumulada
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Actualización en progreso. Podría tomar un tiempo.
 DocType: Production Plan Item,Produced Qty,Cantidad Producida
 DocType: Vehicle Log,Fuel Qty,Cantidad de Combustible
-DocType: Stock Entry,Target Warehouse Name,Nombre del Almacén de Destino
 DocType: Work Order Operation,Planned Start Time,Hora prevista de inicio
 DocType: Course,Assessment,Evaluación
 DocType: Payment Entry Reference,Allocated,Numerado
@@ -4498,10 +4514,12 @@
  1. Formas de abordar disputas, indemnización, responsabilidad, etc. 
  1. Dirección y contacto de su empresa."
 DocType: Homepage Section,Section Based On,Sección basada en
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Mostrar aplicar código de cupón
 DocType: Issue,Issue Type,Tipo de Problema
 DocType: Attendance,Leave Type,Tipo de Licencia
 DocType: Purchase Invoice,Supplier Invoice Details,Detalles de la factura del proveedor
 DocType: Agriculture Task,Ignore holidays,Ignorar vacaciones
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Agregar / editar condiciones de cupón
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"La cuenta de Gastos/Diferencia ({0}) debe ser una cuenta de 'utilidad o pérdida """
 DocType: Stock Entry Detail,Stock Entry Child,Niño de entrada de stock
 DocType: Project,Copied From,Copiado de
@@ -4676,6 +4694,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Criterios de evaluación del plan
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Transacciones
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Evitar Órdenes de Compra
+DocType: Coupon Code,Coupon Name,Nombre del cupón
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Susceptible
 DocType: Email Campaign,Scheduled,Programado.
 DocType: Shift Type,Working Hours Calculation Based On,Cálculo de horas de trabajo basado en
@@ -4692,7 +4711,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Crear Variantes
 DocType: Vehicle,Diesel,Diesel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,El tipo de divisa para la lista de precios no ha sido seleccionado
+DocType: Quick Stock Balance,Available Quantity,Cantidad disponible
 DocType: Purchase Invoice,Availed ITC Cess,Cess ITC disponible
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Configure el Sistema de nombres de instructores en Educación&gt; Configuración de educación
 ,Student Monthly Attendance Sheet,Hoja de Asistencia Mensual de Estudiante
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Regla de Envío solo aplicable para Ventas
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Fila de depreciación {0}: la siguiente fecha de depreciación no puede ser anterior a la fecha de compra
@@ -4759,8 +4780,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Fila {0}: Avance contra el Cliente debe ser de crédito
 DocType: Quality Meeting,Quality Meeting,Reunión de calidad
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,No-Grupo a Grupo
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Configure Naming Series para {0} a través de Configuración&gt; Configuración&gt; Naming Series
 DocType: Employee,ERPNext User,Usuario ERPNext
+DocType: Coupon Code,Coupon Description,Descripción del cupón
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},El lote es obligatorio en la fila {0}
 DocType: Company,Default Buying Terms,Términos de compra predeterminados
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Recibo de compra del producto suministrado
@@ -4923,6 +4944,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Contra documento No.
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},La Eliminación no está permitida para el país {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Tipo de parte es obligatorio
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Aplicar código de cupón
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","Para la tarjeta de trabajo {0}, solo puede realizar la entrada de stock del tipo &#39;Transferencia de material para fabricación&#39;"
 DocType: Quality Inspection,Outgoing,Saliente
 DocType: Customer Feedback Table,Customer Feedback Table,Tabla de comentarios del cliente
@@ -5072,7 +5094,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,En el envío de la orden de compra
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Añadir todos los Proveedores
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Fila #{0}: Importe asignado no puede ser mayor que la cantidad pendiente.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Cliente&gt; Grupo de clientes&gt; Territorio
 DocType: Tally Migration,Parties,Fiestas
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Explorar la lista de materiales
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Prestamos en garantía
@@ -5104,7 +5125,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},No permitir establecer un elemento alternativo para el Artículo {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,La fecha está repetida
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Firmante Autorizado
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Configure el Sistema de nombres de instructores en Educación&gt; Configuración de educación
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),ITC neto disponible (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Crear Tarifas
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Costo total de compra (vía facturas de compra)
@@ -5129,6 +5149,7 @@
 DocType: Quiz Result,Wrong,Incorrecto
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Tasa por la cual la lista de precios es convertida como base del cliente.
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Importe neto (Divisa de la empresa)
+DocType: Sales Partner,Referral Code,código de referencia
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,El monto total anticipado no puede ser mayor que la cantidad total autorizada
 DocType: Salary Slip,Hour Rate,Salario por hora
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Habilitar reordenamiento automático
@@ -5257,6 +5278,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Mostrar Cantidad en Stock
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Efectivo neto de las operaciones
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Fila # {0}: El estado debe ser {1} para el descuento de facturas {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Factor de conversión de UOM ({0} -&gt; {1}) no encontrado para el elemento: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Elemento 4
 DocType: Student Admission,Admission End Date,Fecha de finalización de la admisión
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Subcontratación
@@ -5279,6 +5301,7 @@
 DocType: Travel Request,Fully Sponsored,Totalmente Patrocinado
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Invertir Entrada de Diario
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Crear tarjeta de trabajo
+DocType: Quotation,Referral Sales Partner,Socio de ventas de referencia
 DocType: Quality Procedure Process,Process Description,Descripción del proceso
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Se crea el Cliente {0}.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Actualmente no hay stock disponible en ningún almacén
@@ -5413,6 +5436,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,Coeficiente de la lista de materiales (LdM)
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Leer el archivo cargado
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","La Órden de Trabajo detenida no se puede cancelar, desactívela primero para cancelarla"
+DocType: Coupon Code,Coupon Code,Código promocional
 DocType: Asset,Journal Entry for Scrap,Entrada de diario para desguace
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,"Por favor, extraiga los productos de la nota de entrega"
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Fila {0}: seleccione la estación de trabajo contra la operación {1}
@@ -5495,6 +5519,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,Se requiere &#39;Fecha&#39;
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Vencimiento / Fecha de referencia no puede ser posterior a {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Importación y exportación de datos
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Lo sentimos, la validez del código de cupón ha caducado"
 DocType: Bank Account,Account Details,Detalles de la Cuenta
 DocType: Crop,Materials Required,Materiales Necesarios
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,No se han encontrado estudiantes
@@ -5532,6 +5557,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Ir a Usuarios
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,"El total de la cantidad pagada + desajuste, no puede ser mayor que el gran total"
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} no es un número de lote válido para el artículo {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Por favor ingrese un código de cupón válido !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Nota : No cuenta con suficientes días para la ausencia del tipo {0}
 DocType: Task,Task Description,Descripción de la tarea
 DocType: Training Event,Seminar,Seminario
@@ -5795,6 +5821,7 @@
 ,TDS Payable Monthly,TDS pagables Mensualmente
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,En cola para reemplazar la BOM. Puede tomar unos minutos..
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',No se puede deducir cuando categoría es para ' Valoración ' o ' de Valoración y Total '
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Configure el Sistema de nombres de empleados en Recursos humanos&gt; Configuración de recursos humanos
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Pagos totales
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Número de serie requerido para el producto serializado {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Conciliacion de pagos con facturas
@@ -5884,6 +5911,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Obtener Materias Primas para Producción
 DocType: Job Opening,Job Title,Título del trabajo
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Ref. De pago futuro
+DocType: Quotation,Additional Discount and Coupon Code,Descuento adicional y código de cupón
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} indica que {1} no proporcionará una cita, pero todos los elementos \ han sido citados. Actualización del estado de cotización RFQ."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Las muestras máximas - {0} ya se han conservado para el lote {1} y el elemento {2} en el lote {3}.
@@ -6111,7 +6139,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Ajustes para la página de inicio de la página web
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} está en espera hasta {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},Las solicitudes de Presupuesto (RFQs) no están permitidas para {0} debido a un puntaje de {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Hacer factura de compra
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Licencias Usadas
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,Los cupones {0} utilizados son {1}. La cantidad permitida se agota
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,¿Quieres enviar la solicitud de material?
 DocType: Job Offer,Awaiting Response,Esperando Respuesta
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6125,6 +6155,7 @@
 DocType: Training Event Employee,Optional,Opcional
 DocType: Salary Slip,Earning & Deduction,Ingresos y Deducciones
 DocType: Agriculture Analysis Criteria,Water Analysis,Análisis de Agua
+DocType: Sales Order,Skip Delivery Note,Saltar nota de entrega
 DocType: Price List,Price Not UOM Dependent,Precio no dependiente de UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} variantes creadas
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Ya existe un Acuerdo de nivel de servicio predeterminado.
@@ -6229,6 +6260,7 @@
 DocType: Vehicle,Last Carbon Check,Último control de Carbono
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,GASTOS LEGALES
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,"Por favor, seleccione la cantidad en la fila"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Orden de trabajo {0}: tarjeta de trabajo no encontrada para la operación {1}
 DocType: Purchase Invoice,Posting Time,Hora de Contabilización
 DocType: Timesheet,% Amount Billed,% importe facturado
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Cuenta telefonica
@@ -6331,7 +6363,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Impuestos y cargos adicionales
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Fila de depreciación {0}: la siguiente fecha de depreciación no puede ser anterior Fecha disponible para usar
 ,Sales Funnel,"""Embudo"" de ventas"
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Código de artículo&gt; Grupo de artículos&gt; Marca
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,La abreviatura es obligatoria
 DocType: Project,Task Progress,Progreso de Tarea
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Carrito
@@ -6426,6 +6457,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,Se requiere un perfil de TPV para crear entradas en el punto de venta
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Los puntos de fidelidad se calcularán a partir del gasto realizado (a través de la factura de venta), según el factor de recaudación mencionado."
 DocType: Program Enrollment Tool,Enroll Students,Inscribir Estudiantes
+DocType: Pricing Rule,Coupon Code Based,Código de cupón basado
 DocType: Company,HRA Settings,Configuración de HRA
 DocType: Homepage,Hero Section,Sección de héroe
 DocType: Employee Transfer,Transfer Date,Fecha de Transferencia
@@ -6541,6 +6573,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',"Por favor, ponga el filtro de la Compañía en blanco si el Grupo Por es ' Empresa'."
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Fecha de entrada no puede ser fecha futura
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Fila #{0}: Número de serie {1} no coincide con {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Configure la serie de numeración para la asistencia a través de Configuración&gt; Serie de numeración
 DocType: Stock Entry,Target Warehouse Address,Dirección del Almacén de Destino
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Permiso ocacional
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,El tiempo antes de la hora de inicio del turno durante el cual se considera la asistencia del Empleado Check-in.
@@ -6575,7 +6608,6 @@
 DocType: Employee Grade,Employee Grade,Grado del Empleado
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Trabajo por obra
 DocType: GSTR 3B Report,June,junio
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Proveedor&gt; Tipo de proveedor
 DocType: Share Balance,From No,Desde Nro
 DocType: Shift Type,Early Exit Grace Period,Período de gracia de salida temprana
 DocType: Task,Actual Time (in Hours),Tiempo real (en horas)
@@ -6860,7 +6892,6 @@
 DocType: Warehouse,Warehouse Name,Nombre del Almacén
 DocType: Naming Series,Select Transaction,Seleccione el tipo de transacción
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,"Por favor, introduzca 'Función para aprobar' o 'Usuario de aprobación'---"
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Factor de conversión de UOM ({0} -&gt; {1}) no encontrado para el elemento: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,El acuerdo de nivel de servicio con el tipo de entidad {0} y la entidad {1} ya existe.
 DocType: Journal Entry,Write Off Entry,Diferencia de desajuste
 DocType: BOM,Rate Of Materials Based On,Valor de materiales basado en
@@ -6998,6 +7029,7 @@
 DocType: Budget,Warn,Advertir
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Todos los artículos ya han sido transferidos para esta Orden de Trabajo.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Otras observaciones, que deben ir en los registros."
+DocType: Bank Account,Company Account,Cuenta de la compañia
 DocType: Asset Maintenance,Manufacturing User,Usuario de Producción
 DocType: Purchase Invoice,Raw Materials Supplied,Materias primas suministradas
 DocType: Subscription Plan,Payment Plan,Plan de Pago
@@ -7039,6 +7071,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) no puede ser mayor que la cantidad planificada ({2}) en la Orden de trabajo {3}
 DocType: Certification Application,Name of Applicant,Nombre del Solicitante
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Hoja de tiempo para la fabricación.
+DocType: Quick Stock Balance,Quick Stock Balance,Balance de stock rápido
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Subtotal
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,No se pueden cambiar las propiedades de la Variante después de una transacción de stock. Deberá crear un nuevo ítem para hacer esto.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,Mandato de SEPA GoCardless
@@ -7365,6 +7398,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},"Por favor, configure {0}"
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} es un estudiante inactivo
 DocType: Employee,Health Details,Detalles de salud
+DocType: Coupon Code,Coupon Type,Tipo de cupón
 DocType: Leave Encashment,Encashable days,Días de Cobro
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Para crear una Solicitud de Pago se requiere el documento de referencia
 DocType: Soil Texture,Sandy Clay,Arcilla Arenosa
@@ -7648,6 +7682,7 @@
 DocType: Hotel Room Package,Amenities,Comodidades
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Obtener automáticamente las condiciones de pago
 DocType: QuickBooks Migrator,Undeposited Funds Account,Cuenta de Fondos no Depositados
+DocType: Coupon Code,Uses,Usos
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,No se permiten múltiple métodos de pago predeterminados
 DocType: Sales Invoice,Loyalty Points Redemption,Redención de Puntos de Lealtad
 ,Appointment Analytics,Análisis de Citas
@@ -7664,6 +7699,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Presupuesto Total
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Deje en blanco si hace grupos de estudiantes por año
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Si se marca, el número total de días trabajados incluirá las vacaciones, y este reducirá el salario por día."
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Error al agregar dominio
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Para permitir sobre recibo / entrega, actualice &quot;Recibo sobre recibo / entrega&quot; en la Configuración de inventario o en el Artículo."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Las Aplicaciones que usen la clave actual no podrán acceder, ¿está seguro?"
 DocType: Subscription Settings,Prorate,Prorratear
@@ -7676,6 +7712,7 @@
 ,BOM Stock Report,Reporte de Stock de BOM
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Si no hay un intervalo de tiempo asignado, la comunicación será manejada por este grupo"
 DocType: Stock Reconciliation Item,Quantity Difference,Diferencia de Cantidad
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Proveedor&gt; Tipo de proveedor
 DocType: Opportunity Item,Basic Rate,Precio Base
 DocType: GL Entry,Credit Amount,Importe acreditado
 ,Electronic Invoice Register,Registro Electrónico de Facturas
@@ -7929,6 +7966,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Impuestos y gastos deducibles (Divisa por defecto)
 DocType: Item Group,General Settings,Configuración General
 DocType: Article,Article,Artículo
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Por favor ingrese el código de cupón
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,'Desde moneda - a moneda' no pueden ser las mismas
 DocType: Taxable Salary Slab,Percent Deduction,Deducción Porcentual
 DocType: GL Entry,To Rename,Renombrar
diff --git a/erpnext/translations/es_pe.csv b/erpnext/translations/es_pe.csv
index 970f2d5..578e5f8 100644
--- a/erpnext/translations/es_pe.csv
+++ b/erpnext/translations/es_pe.csv
@@ -318,7 +318,7 @@
 apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py,Receiver List is empty. Please create Receiver List,"Lista de receptores está vacía. Por favor, cree Lista de receptores"
 DocType: Production Plan Sales Order,Production Plan Sales Order,Plan de producción de la orden de ventas (OV)
 DocType: Sales Partner,Sales Partner Target,Socio de Ventas Objetivo
-DocType: Pricing Rule,Pricing Rule,Reglas de Precios
+DocType: Coupon Code,Pricing Rule,Reglas de Precios
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Requisición de materiales hacia la órden de compra
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Returned Item {1} does not exists in {2} {3},Fila # {0}: El artículo vuelto {1} no existe en {2} {3}
 ,Bank Reconciliation Statement,Extractos Bancarios
diff --git a/erpnext/translations/et.csv b/erpnext/translations/et.csv
index 0e86e1c..7b87342 100644
--- a/erpnext/translations/et.csv
+++ b/erpnext/translations/et.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Klienditeenindus Kontakt
 DocType: Shift Type,Enable Auto Attendance,Luba automaatne osalemine
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Palun sisestage ladu ja kuupäev
 DocType: Lost Reason Detail,Opportunity Lost Reason,Võimaluse kaotamise põhjus
 DocType: Patient Appointment,Check availability,Kontrollige saadavust
 DocType: Retention Bonus,Bonus Payment Date,Boonustasu maksmise kuupäev
@@ -263,6 +264,7 @@
 ,Completed Work Orders,Lõppenud töökorraldused
 DocType: Support Settings,Forum Posts,Foorumi postitused
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","See ülesanne on sisse löödud tausttööna. Kui tausttöötlemisel on probleeme, lisab süsteem kommentaari selle varude lepitamise vea kohta ja naaseb mustandi etappi"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started",Kahjuks pole kupongi koodi kehtivus alanud
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,maksustatav summa
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Sa ei ole volitatud lisada või uuendada oma andmeid enne {0}
 DocType: Leave Policy,Leave Policy Details,Jäta poliitika üksikasjad
@@ -327,6 +329,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Tarbitav
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,hinne
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kauba kood&gt; esemerühm&gt; kaubamärk
 DocType: Restaurant Table,No of Seats,Istekohtade arv
 DocType: Sales Invoice,Overdue and Discounted,Tähtaja ületanud ja soodushinnaga
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Kõne katkestati
@@ -503,6 +506,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Reavahe eest summa sõnadega
 DocType: Vehicle,Additional Details,Täiendavad detailid
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,No kirjeldusest
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Toodete laost toomine
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Küsi osta.
 DocType: POS Closing Voucher Details,Collected Amount,Kogutud summa
 DocType: Lab Test,Submitted Date,Esitatud kuupäev
@@ -610,6 +614,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Õpi
 ,Trial Balance (Simple),Proovitasakaal (lihtne)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Lubatud edasilükatud kulu
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Rakendatud kupongi kood
 DocType: Asset,Next Depreciation Date,Järgmine kulum kuupäev
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Aktiivsus töötaja kohta
 DocType: Accounts Settings,Settings for Accounts,Seaded konto
@@ -845,8 +850,6 @@
 DocType: BOM,Work Order,Töökäsk
 DocType: Sales Invoice,Total Qty,Kokku Kogus
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 Saatke ID
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Selle dokumendi tühistamiseks kustutage töötaja <a href=""#Form/Employee/{0}"">{0}</a> \"
 DocType: Item,Show in Website (Variant),Näita Veebileht (Variant)
 DocType: Employee,Health Concerns,Terviseprobleemid
 DocType: Payroll Entry,Select Payroll Period,Vali palgaarvestuse Periood
@@ -1009,6 +1012,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Maksu kinnipidamise konto
 DocType: Pricing Rule,Sales Partner,Müük Partner
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Kõik tarnija skoorikaardid.
+DocType: Coupon Code,To be used to get discount,Kasutatakse allahindluse saamiseks
 DocType: Buying Settings,Purchase Receipt Required,Ostutšekk Vajalikud
 DocType: Sales Invoice,Rail,Raudtee
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Tegelik maksumus
@@ -1059,6 +1063,7 @@
 DocType: Production Plan,Production Plan,Tootmisplaan
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Arve koostamise tööriista avamine
 DocType: Salary Component,Round to the Nearest Integer,Ümarda lähima täisarvuni
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Lubamata toodete lisamine ostukorvi
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Müügitulu
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Määrake tehingute arv järjekorranumbriga
 ,Total Stock Summary,Kokku Stock kokkuvõte
@@ -1188,6 +1193,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Base Hour Rate (firma Valuuta)
 ,Qty To Be Billed,Tühi arve
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Tarnitakse summa
+DocType: Coupon Code,Gift Card,Kinkekaart
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Tootmiseks reserveeritud kogus: toorainekogus toodete valmistamiseks.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Lunastamiskuupäev
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,See pangatehing on juba täielikult lepitud
@@ -1275,6 +1281,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Loo ajaleht
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Konto {0} on sisestatud mitu korda
 DocType: Account,Expenses Included In Valuation,Kulud sisalduvad Hindamine
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Ostuarved
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,"Te saate uuendada ainult siis, kui teie liikmelisus lõpeb 30 päeva jooksul"
 DocType: Shopping Cart Settings,Show Stock Availability,Näita toote laost
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Määra {0} varakategoorias {1} või ettevõtte {2}
@@ -1814,6 +1821,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Üksuste ja UOM-ide importimine
 DocType: Repayment Schedule,Balance Loan Amount,Tasakaal Laenusumma
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Lisatud üksikasjadesse
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Vabandame, kupongi kood on ammendatud"
 DocType: Communication Medium,Catch All,Saagi kõik
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Ajakava kursus
 DocType: Budget,Applicable on Material Request,Kohaldatav materiaalse päringu korral
@@ -1981,6 +1989,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Vale Oskus
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} tuleb esitada
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,E-posti kampaaniad
+DocType: Sales Partner,To Track inbound purchase,Sissetuleva ostu jälgimiseks
 DocType: Buying Settings,Default Supplier Group,Vaikepakkumise grupp
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Kogus peab olema väiksem või võrdne {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Komponendi {0} jaoks maksimaalne summa ületab {1}
@@ -2136,8 +2145,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Tee aktsiatest kanne
 DocType: Hotel Room Reservation,Hotel Reservation User,Hotelli broneeringu kasutaja
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Määra olek
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Palun seadistage kohaloleku jaoks numeratsiooniseeria seadistamise&gt; Numeratsiooniseeria kaudu
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Palun valige eesliide esimene
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Valige Seadistamise seeria väärtuseks {0} menüüst Seadistamine&gt; Seaded&gt; Seeria nimetamine
 DocType: Contract,Fulfilment Deadline,Täitmise tähtaeg
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Sinu lähedal
 DocType: Student,O-,O-
@@ -2261,6 +2270,7 @@
 DocType: Quality Meeting Table,Under Review,Ülevaatlusel
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Sisselogimine ebaõnnestus
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Vara {0} loodud
+DocType: Coupon Code,Promotional,Reklaam
 DocType: Special Test Items,Special Test Items,Spetsiaalsed katseüksused
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,"Turult registreerumiseks peate olema kasutaja, kellel on süsteemihaldur ja üksuste juhtide roll."
 apps/erpnext/erpnext/config/buying.py,Key Reports,Põhiaruanded
@@ -2298,6 +2308,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc Type
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Kokku eraldatakse protsent müügimeeskond peaks olema 100
 DocType: Subscription Plan,Billing Interval Count,Arveldusvahemiku arv
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Selle dokumendi tühistamiseks kustutage töötaja <a href=""#Form/Employee/{0}"">{0}</a> \"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Kohtumised ja patsiendikontaktid
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Väärtus on puudu
 DocType: Employee,Department and Grade,Osakond ja aste
@@ -2400,6 +2412,7 @@
 DocType: Project,Start and End Dates,Algus- ja lõppkuupäev
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Lepingu malli täitmise tingimused
 ,Delivered Items To Be Billed,Tarnitakse punkte arve
+DocType: Coupon Code,Maximum Use,Maksimaalne kasutamine
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Avatud Bom {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Ladu ei saa muuta Serial No.
 DocType: Authorization Rule,Average Discount,Keskmine Soodus
@@ -2561,6 +2574,7 @@
 DocType: Item,Inventory,Inventory
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Laadige alla kui Json
 DocType: Item,Sales Details,Müük Üksikasjad
+DocType: Coupon Code,Used,Kasutatud
 DocType: Opportunity,With Items,Objekte
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Kampaania &#39;{0}&#39; on juba {1} &#39;{2}&#39; jaoks olemas
 DocType: Asset Maintenance,Maintenance Team,Hooldus meeskond
@@ -2690,7 +2704,7 @@
 						Serial No cannot be ensured",Elemendile {0} ei leitud aktiivset BOM-i. Toimetaja \ Serial No ei saa tagada
 DocType: Sales Partner,Sales Partner Target,Müük Partner Target
 DocType: Loan Type,Maximum Loan Amount,Maksimaalne laenusumma
-DocType: Pricing Rule,Pricing Rule,Hinnakujundus reegel
+DocType: Coupon Code,Pricing Rule,Hinnakujundus reegel
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplicate valtsi arvu üliõpilaste {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Materjal Ostusoov Telli
 DocType: Company,Default Selling Terms,Müügitingimused vaikimisi
@@ -2769,6 +2783,7 @@
 DocType: Payment Schedule,Payment Amount,Makse summa
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Poolpäeva kuupäev peab olema ajavahemikus Töö kuupäevast kuni töö lõppkuupäevani
 DocType: Healthcare Settings,Healthcare Service Items,Tervishoiuteenuse üksused
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Kehtetu vöötkood. Sellele vöötkoodile pole lisatud üksust.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Tarbitud
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Net muutus Cash
 DocType: Assessment Plan,Grading Scale,hindamisskaala
@@ -2888,7 +2903,6 @@
 DocType: Share Transfer,Asset Account,Varakonto
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Uus väljalaskekuupäev peaks olema tulevikus
 DocType: Purchase Invoice,End date of current invoice's period,Lõppkuupäev jooksva arve on periood
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Palun seadistage töötajate nimetamise süsteem personaliressursist&gt; HR-sätted
 DocType: Lab Test,Technician Name,Tehniku nimi
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -2999,6 +3013,7 @@
 DocType: Products Settings,Hide Variants,Peida variandid
 DocType: Lead,Next Contact By,Järgmine kontakteeruda
 DocType: Compensatory Leave Request,Compensatory Leave Request,Hüvitise saamise taotlus
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings",Üksuse {0} reas {1} ei saa ülearveldada rohkem kui {2}. Ülearvelduste lubamiseks määrake konto konto seadetes soodustus
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Kogus vaja Punkt {0} järjest {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},"Ladu {0} ei saa kustutada, kui kvantiteet on olemas Punkt {1}"
 DocType: Blanket Order,Order Type,Tellimus Type
@@ -3167,7 +3182,6 @@
 DocType: Student,Student Mobile Number,Student Mobile arv
 DocType: Item,Has Variants,Omab variandid
 DocType: Employee Benefit Claim,Claim Benefit For,Nõude hüvitis
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings",Elemendile {0} ei saa realt {1} rohkem kui {2} üle märkida. Ülekarvete lubamiseks määrake varude seadistused
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Uuenda vastust
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Olete juba valitud objektide {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Nimi Kuu Distribution
@@ -3457,6 +3471,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Palun täpsustage valuuta Company
 DocType: Workstation,Wages per hour,Palk tunnis
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Seadista {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Klient&gt; kliendigrupp&gt; territoorium
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Stock tasakaalu Partii {0} halveneb {1} jaoks Punkt {2} lattu {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Pärast Material taotlused on tõstatatud automaatselt vastavalt objekti ümber korraldada tasemel
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Konto {0} on kehtetu. Konto Valuuta peab olema {1}
@@ -3786,6 +3801,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Esita palgatõend
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Ootel
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Seadmel peab olema vähemalt üks õige valik
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Ostutellimused
 DocType: Account,Inter Company Account,Ettevõtte konto konto
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Import in Bulk
 DocType: Sales Partner,Address & Contacts,Aadress ja Kontakt
@@ -3796,6 +3812,7 @@
 DocType: POS Profile,[Select],[Vali]
 DocType: Staffing Plan Detail,Number Of Positions,Positsioonide arv
 DocType: Vital Signs,Blood Pressure (diastolic),Vererõhk (diastoolne)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Valige klient.
 DocType: SMS Log,Sent To,Saadetud
 DocType: Agriculture Task,Holiday Management,Holiday Management
 DocType: Payment Request,Make Sales Invoice,Tee müügiarve
@@ -4005,7 +4022,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} ei ole esitatud
 DocType: Subscription,Trialling,Triallimine
 DocType: Sales Invoice Item,Deferred Revenue,Edasilükkunud tulud
-DocType: Bank Account,GL Account,GL konto
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Sularahakontot kasutatakse müügiarve loomiseks
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Vabastuse alamkategooria
 DocType: Member,Membership Expiry Date,Liikmestaatuse lõppkuupäev
@@ -4407,13 +4423,13 @@
 DocType: C-Form Invoice Detail,Territory,Territoorium
 DocType: Pricing Rule,Apply Rule On Item Code,Rakenda reeglit üksuse koodil
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Palume mainida ei külastuste vaja
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Varude bilansi aruanne
 DocType: Stock Settings,Default Valuation Method,Vaikimisi hindamismeetod
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,tasu
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Kuva kumulatiivne summa
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Värskendamine toimub See võib võtta veidi aega.
 DocType: Production Plan Item,Produced Qty,Toodetud kogus
 DocType: Vehicle Log,Fuel Qty,Kütus Kogus
-DocType: Stock Entry,Target Warehouse Name,Target Warehouse Nimi
 DocType: Work Order Operation,Planned Start Time,Planeeritud Start Time
 DocType: Course,Assessment,Hindamine
 DocType: Payment Entry Reference,Allocated,paigutatud
@@ -4479,10 +4495,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","Tüüptingimused, mida saab lisada ost ja müük. Näited: 1. kehtivus pakkumisi. 1. Maksetingimused (ette, krediidi osa eelnevalt jne). 1. Mis on ekstra (või mida klient maksab). 1. Safety / kasutamise hoiatus. 1. Garantii kui tahes. 1. Annab Policy. 1. Tingimused shipping vajaduse korral. 1. viise, kuidas lahendada vaidlusi, hüvitis, vastutus jms 1. Aadress ja Kontakt firma."
 DocType: Homepage Section,Section Based On,Sektsioon põhineb
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Kuva Kupongi koodi rakendamine
 DocType: Issue,Issue Type,Probleemi tüüp
 DocType: Attendance,Leave Type,Jäta Type
 DocType: Purchase Invoice,Supplier Invoice Details,Pakkuja Arve andmed
 DocType: Agriculture Task,Ignore holidays,Ignoreeri puhkust
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Kupongitingimuste lisamine / muutmine
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Kulu / Difference konto ({0}) peab olema &quot;kasum või kahjum&quot; kontole
 DocType: Stock Entry Detail,Stock Entry Child,Laosissetuleku laps
 DocType: Project,Copied From,kopeeritud
@@ -4657,6 +4675,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Hindamise kava kriteeriumid
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Tehingud
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Vältida ostutellimusi
+DocType: Coupon Code,Coupon Name,Kupongi nimi
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Tundlik
 DocType: Email Campaign,Scheduled,Plaanitud
 DocType: Shift Type,Working Hours Calculation Based On,Tööaja arvestus põhineb
@@ -4673,7 +4692,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Loo variandid
 DocType: Vehicle,Diesel,diisel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Hinnakiri Valuuta ole valitud
+DocType: Quick Stock Balance,Available Quantity,Saadaval kogus
 DocType: Purchase Invoice,Availed ITC Cess,Availed ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Seadistage juhendaja nimetamise süsteem jaotises Haridus&gt; Hariduse sätted
 ,Student Monthly Attendance Sheet,Student Kuu osavõtt Sheet
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Müügi reegel kehtib ainult Müügi kohta
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Amortisatsiooni rea {0}: järgmine amortisatsiooniaeg ei saa olla enne Ostupäeva
@@ -4740,8 +4761,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Row {0}: Advance vastu Klient peab olema krediidi
 DocType: Quality Meeting,Quality Meeting,Kvaliteedikohtumine
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-Group Group
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,"Valige Seadistamise seeria väärtuseks {0}, mis asub seadistuse&gt; Seadistused&gt; Seeriate nimetamine"
 DocType: Employee,ERPNext User,ERPNext kasutaja
+DocType: Coupon Code,Coupon Description,Kupongi kirjeldus
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Partii on kohustuslik rida {0}
 DocType: Company,Default Buying Terms,Ostmise vaiketingimused
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Ostutšekk tooteühiku
@@ -4904,6 +4925,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Vastu Dokumendi Detail Ei
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Kustutamine ei ole lubatud riigis {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Partei Type on kohustuslik
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Rakenda kupongikood
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",Töökaardi {0} korral saate teha kande „Tootmiseks mõeldud materjali ülekandmine”
 DocType: Quality Inspection,Outgoing,Väljuv
 DocType: Customer Feedback Table,Customer Feedback Table,Klientide tagasiside tabel
@@ -5053,7 +5075,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Ostutellimuse esitamisel
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Lisa kõik pakkujad
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Row # {0}: Eraldatud summa ei saa olla suurem kui tasumata summa.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Klient&gt; kliendigrupp&gt; territoorium
 DocType: Tally Migration,Parties,Pooled
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Sirvi Bom
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Tagatud laenud
@@ -5085,7 +5106,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Mitte lubada elemendi {0} jaoks alternatiivset elementi
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Kuupäev korratakse
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Allkirjaõiguslik
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Seadistage juhendaja nimetamise süsteem jaotises Haridus&gt; Hariduse sätted
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Net ITC saadaval (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Loo lõivu
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Kokku ostukulud (via ostuarve)
@@ -5110,6 +5130,7 @@
 DocType: Quiz Result,Wrong,Vale
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Hinda kus Hinnakiri valuuta konverteeritakse kliendi baasvaluuta
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Netosumma (firma Valuuta)
+DocType: Sales Partner,Referral Code,Soovituskood
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Ettemakse kogusumma ei tohi olla suurem kui sanktsioonide kogusumma
 DocType: Salary Slip,Hour Rate,Tund Rate
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Luba automaatne ümberkorraldus
@@ -5236,6 +5257,8 @@
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},Palun vali BOM seoses elemendiga {0}
 DocType: Shopping Cart Settings,Show Stock Quantity,Näita tootekogust
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Rahavood äritegevusest
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Rida {0}: arve diskonteerimisel peab olek olema {1} {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM teisendustegurit ({0} -&gt; {1}) üksusele {2} ei leitud
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Punkt 4
 DocType: Student Admission,Admission End Date,Sissepääs End Date
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Alltöövõtt
@@ -5258,6 +5281,7 @@
 DocType: Travel Request,Fully Sponsored,Täielikult sponsor
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Pöördteadaande kande number
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Looge töökaart
+DocType: Quotation,Referral Sales Partner,Soovituslik müügipartner
 DocType: Quality Procedure Process,Process Description,Protsessi kirjeldus
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Klient {0} on loodud.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Praegu pole ühtegi ladu saadaval
@@ -5392,6 +5416,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,Bom Rate
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Üleslaaditud faili lugemine
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel",Peatatud töökorraldust ei saa tühistada. Lõpeta see esmalt tühistamiseks
+DocType: Coupon Code,Coupon Code,kupongi kood
 DocType: Asset,Journal Entry for Scrap,Päevikusissekanne Vanametalli
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Palun tõmmake esemed Saateleht
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Rida {0}: valige tööjaam operatsiooni vastu {1}
@@ -5474,6 +5499,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,Vajalik on kuupäev
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Tänu / Viitekuupäev ei saa pärast {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Andmete impordi ja ekspordi
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired",Kahjuks on kupongikoodi kehtivus aegunud
 DocType: Bank Account,Account Details,Konto üksikasjad
 DocType: Crop,Materials Required,Nõutavad materjalid
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,No õpilased Leitud
@@ -5511,6 +5537,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Mine kasutajatele
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Paide summa + maha summa ei saa olla suurem kui Grand Total
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} ei ole kehtiv Partii number jaoks Punkt {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Sisestage kehtiv kupongi kood !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Märkus: Ei ole piisavalt puhkust tasakaalu Jäta tüüp {0}
 DocType: Task,Task Description,Ülesande kirjeldus
 DocType: Training Event,Seminar,seminar
@@ -5772,6 +5799,7 @@
 ,TDS Payable Monthly,TDS makstakse igakuiselt
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,BOMi asendamine on järjekorras. See võib võtta paar minutit.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Ei saa maha arvata, kui kategooria on &quot;Hindamine&quot; või &quot;Hindamine ja kokku&quot;"
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Palun seadistage töötajate nimetamise süsteem personaliressursist&gt; HR-sätted
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Maksed kokku
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serial nr Nõutav SERIALIZED Punkt {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Match Maksed arvetega
@@ -5861,6 +5889,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Hankige toorainet tootmiseks
 DocType: Job Opening,Job Title,Töö nimetus
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Tulevaste maksete ref
+DocType: Quotation,Additional Discount and Coupon Code,Täiendav allahindlus ja kuponkikood
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} näitab, et {1} ei anna hinnapakkumist, kuid kõik esemed \ on tsiteeritud. RFQ tsiteeritud oleku värskendamine."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Suurimad proovid - {0} on partii {1} ja pootise {2} jaoks juba paketi {3} jaoks juba salvestatud.
@@ -6088,6 +6117,7 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Seaded veebisaidi avalehel
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} on ootel kuni {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},"RFQ-d pole {0} jaoks lubatud, kuna tulemuskaardi väärtus on {1}"
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Ostuarve koostamine
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Kasutatud lehed
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Kas soovite esitada materjalitaotluse?
 DocType: Job Offer,Awaiting Response,Vastuse ootamine
@@ -6102,6 +6132,7 @@
 DocType: Training Event Employee,Optional,Valikuline
 DocType: Salary Slip,Earning & Deduction,Teenimine ja mahaarvamine
 DocType: Agriculture Analysis Criteria,Water Analysis,Vee analüüs
+DocType: Sales Order,Skip Delivery Note,Jäta vahele saateleht
 DocType: Price List,Price Not UOM Dependent,Hind ei sõltu UOM-ist
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} variandid on loodud.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Teenuse vaiketaseme leping on juba olemas.
@@ -6206,6 +6237,7 @@
 DocType: Vehicle,Last Carbon Check,Viimati Carbon Check
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Kohtukulude
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Palun valige kogus real
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Töökäsk {0}: töökaarti ei leitud toiminguks {1}
 DocType: Purchase Invoice,Posting Time,Foorumi aeg
 DocType: Timesheet,% Amount Billed,% Arve summa
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Telefoni kulud
@@ -6308,7 +6340,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Maksude ja tasude lisatud
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Amortisatsiooni rea {0}: järgmine amortisatsiooni kuupäev ei saa olla enne kasutatavat kuupäeva
 ,Sales Funnel,Müügi lehtri
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kauba kood&gt; esemerühm&gt; kaubamärk
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Lühend on kohustuslik
 DocType: Project,Task Progress,ülesanne Progress
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Ostukorvi
@@ -6403,6 +6434,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS Profile vaja teha POS Entry
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",Lojaalsuspunktid arvutatakse tehtud kulutustest (müügiarve kaudu) vastavalt mainitud kogumisfaktorile.
 DocType: Program Enrollment Tool,Enroll Students,õppima üliõpilasi
+DocType: Pricing Rule,Coupon Code Based,Kupongi koodil põhinev
 DocType: Company,HRA Settings,HRA seaded
 DocType: Homepage,Hero Section,Kangelaseks
 DocType: Employee Transfer,Transfer Date,Ülekande kuupäev
@@ -6518,6 +6550,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',"Määrake Company filtreerida tühjaks, kui rühm Autor on &quot;Firma&quot;"
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Postitamise kuupäev ei saa olla tulevikus
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: Serial No {1} ei ühti {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Palun seadistage kohaloleku jaoks numeratsiooniseeria seadistamise&gt; Numeratsiooniseeria kaudu
 DocType: Stock Entry,Target Warehouse Address,Target Warehouse Aadress
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Casual Leave
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,"Aeg enne vahetuse algusaega, mille jooksul arvestatakse töötajate registreerimist osalemiseks."
@@ -6552,7 +6585,6 @@
 DocType: Employee Grade,Employee Grade,Töötajate hinne
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Tükitöö
 DocType: GSTR 3B Report,June,Juuni
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Tarnija&gt; Tarnija tüüp
 DocType: Share Balance,From No,Alates nr
 DocType: Shift Type,Early Exit Grace Period,Varajase lahkumise ajapikendus
 DocType: Task,Actual Time (in Hours),Tegelik aeg (tundides)
@@ -6837,7 +6869,6 @@
 DocType: Warehouse,Warehouse Name,Ladu nimi
 DocType: Naming Series,Select Transaction,Vali Tehing
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Palun sisestage kinnitamine Role või heaks Kasutaja
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM teisendustegurit ({0} -&gt; {1}) üksusele {2} ei leitud
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Teenuse taseme leping üksuse tüübiga {0} ja olemiga {1} on juba olemas.
 DocType: Journal Entry,Write Off Entry,Kirjutage Off Entry
 DocType: BOM,Rate Of Materials Based On,Hinda põhinevatest materjalidest
@@ -6975,6 +7006,7 @@
 DocType: Budget,Warn,Hoiatama
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Kõik üksused on selle töökorralduse jaoks juba üle antud.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Muid märkusi, tähelepanuväärne jõupingutusi, et peaks minema arvestust."
+DocType: Bank Account,Company Account,Ettevõtte konto
 DocType: Asset Maintenance,Manufacturing User,Tootmine Kasutaja
 DocType: Purchase Invoice,Raw Materials Supplied,Tarnitud tooraine
 DocType: Subscription Plan,Payment Plan,Makseplaan
@@ -7016,6 +7048,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) ei tohi olla suurem kui kavandatud kogus ({2}) töökorralduses {3}
 DocType: Certification Application,Name of Applicant,Taotleja nimi
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Aeg Sheet valmistamiseks.
+DocType: Quick Stock Balance,Quick Stock Balance,Kiire laobilanss
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,osakokkuvõte
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Variandi omadusi pole võimalik vahetada pärast aktsiatehingut. Selle tegemiseks peate tegema uue punkti.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA volitus
@@ -7342,6 +7375,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},Palun määra {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} on mitteaktiivne õpilane
 DocType: Employee,Health Details,Tervis Üksikasjad
+DocType: Coupon Code,Coupon Type,Kupongi tüüp
 DocType: Leave Encashment,Encashable days,Encashable päeva
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Et luua maksenõude viide dokument on nõutav
 DocType: Soil Texture,Sandy Clay,Sandy Clay
@@ -7624,6 +7658,7 @@
 DocType: Hotel Room Package,Amenities,Lisavõimalused
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Maksetingimuste automaatne toomine
 DocType: QuickBooks Migrator,Undeposited Funds Account,Rahuldamata rahaliste vahendite konto
+DocType: Coupon Code,Uses,Kasutab
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Mitu vaiketüüpi ei ole lubatud
 DocType: Sales Invoice,Loyalty Points Redemption,Lojaalsuspunktide lunastamine
 ,Appointment Analytics,Kohtumise analüüs
@@ -7640,6 +7675,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Kogu eelarve
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Jäta tühjaks, kui teete õpilast rühmade aastas"
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Kui see on märgitud, kokku ei. tööpäevade hulka puhkusereisid ja see vähendab väärtust Palk päevas"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Domeeni lisamine ebaõnnestus
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.",Üle kättesaamise / kohaletoimetamise lubamiseks värskendage laoseadetes või üksuses jaotist &quot;Üle kättesaamise / kohaletoimetamise toetus&quot;.
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Praeguse võtmega rakendused ei pääse juurde, kas olete kindel?"
 DocType: Subscription Settings,Prorate,Prorate
@@ -7652,6 +7688,7 @@
 ,BOM Stock Report,Bom Stock aruanne
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Kui määratud ajapilu pole, siis tegeleb selle grupiga suhtlus"
 DocType: Stock Reconciliation Item,Quantity Difference,Koguse erinevus
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Tarnija&gt; Tarnija tüüp
 DocType: Opportunity Item,Basic Rate,Põhimäär
 DocType: GL Entry,Credit Amount,Krediidi summa
 ,Electronic Invoice Register,Elektrooniline arvete register
@@ -7905,6 +7942,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Maksude ja tasude maha (firma Valuuta)
 DocType: Item Group,General Settings,General Settings
 DocType: Article,Article,Artikkel
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Palun sisestage kupongi kood !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Siit Valuuta ja valuuta ei saa olla sama
 DocType: Taxable Salary Slab,Percent Deduction,Väljamakse protsentides
 DocType: GL Entry,To Rename,Ümbernimetamiseks
diff --git a/erpnext/translations/fa.csv b/erpnext/translations/fa.csv
index 15e2430..ffd013e 100644
--- a/erpnext/translations/fa.csv
+++ b/erpnext/translations/fa.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT- .YYYY.-
 DocType: Purchase Order,Customer Contact,مشتریان تماس با
 DocType: Shift Type,Enable Auto Attendance,حضور و غیاب خودکار را فعال کنید
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,لطفا انبار و تاریخ را وارد کنید
 DocType: Lost Reason Detail,Opportunity Lost Reason,فرصت از دست رفته دلیل
 DocType: Patient Appointment,Check availability,بررسی در دسترس بودن
 DocType: Retention Bonus,Bonus Payment Date,تاریخ پرداخت پاداش
@@ -263,6 +264,7 @@
 ,Completed Work Orders,سفارشات کاری کامل شده است
 DocType: Support Settings,Forum Posts,پست های انجمن
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage",این کار به عنوان یک کار پس زمینه درج شده است. در صورت بروز مشکل در پردازش در پس زمینه ، سیستم در مورد خطا در این آشتی سهام نظر می دهد و به مرحله پیش نویس بازگشت.
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started",متأسفیم ، اعتبار کد کوپن شروع نشده است
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,مبلغ مشمول مالیات
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},شما مجاز به اضافه و یا به روز رسانی مطالب قبل از {0} نیستید
 DocType: Leave Policy,Leave Policy Details,ترک جزئیات سیاست
@@ -327,6 +329,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,مصرفی
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,مقطع تحصیلی
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,کد کالا&gt; گروه مورد&gt; نام تجاری
 DocType: Restaurant Table,No of Seats,بدون صندلی
 DocType: Sales Invoice,Overdue and Discounted,عقب افتاده و تخفیف
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,تماس قطع شد
@@ -502,6 +505,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,فاصله بین خطوط برای مبلغ به حروف
 DocType: Vehicle,Additional Details,توضیحات بیشتر
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,بدون شرح داده می شود
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,گرفتن موارد از انبار
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,درخواست برای خرید.
 DocType: POS Closing Voucher Details,Collected Amount,مقدار جمع آوری شده
 DocType: Lab Test,Submitted Date,تاریخ ارسال شده
@@ -609,6 +613,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,فرا گرفتن
 ,Trial Balance (Simple),موجودی آزمایشی (ساده)
 DocType: Purchase Invoice Item,Enable Deferred Expense,فعال کردن هزینه معوق
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,کد کوپن کاربردی
 DocType: Asset,Next Depreciation Date,بعدی تاریخ استهلاک
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,هزینه فعالیت به ازای هر کارمند
 DocType: Accounts Settings,Settings for Accounts,تنظیمات برای حساب
@@ -839,8 +844,6 @@
 DocType: BOM,Work Order,سفارش کار
 DocType: Sales Invoice,Total Qty,مجموع تعداد
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 ID ایمیل
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","لطفاً برای لغو این سند ، <a href=""#Form/Employee/{0}"">{0}</a> \ کارمند را حذف کنید"
 DocType: Item,Show in Website (Variant),نمایش در وب سایت (نوع)
 DocType: Employee,Health Concerns,نگرانی های بهداشتی
 DocType: Payroll Entry,Select Payroll Period,انتخاب کنید حقوق و دستمزد دوره
@@ -1001,6 +1004,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,حساب سپرده مالیاتی
 DocType: Pricing Rule,Sales Partner,شریک فروش
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,همه کارت امتیازی ارائه شده.
+DocType: Coupon Code,To be used to get discount,مورد استفاده قرار می گیرد برای گرفتن تخفیف
 DocType: Buying Settings,Purchase Receipt Required,رسید خرید مورد نیاز
 DocType: Sales Invoice,Rail,ریل
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,هزینه واقعی
@@ -1049,6 +1053,7 @@
 DocType: Production Plan,Production Plan,برنامه تولید
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,افتتاح حساب ایجاد ابزار
 DocType: Salary Component,Round to the Nearest Integer,دور تا نزدیکترین علاقه
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,اجازه دهید مواردی که موجود نیستند به سبد خرید اضافه شوند
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,برگشت فروش
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,مقدار در معاملات را بر اساس سریال بدون ورودی تنظیم کنید
 ,Total Stock Summary,خلاصه سهام مجموع
@@ -1175,6 +1180,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),یک ساعت یک نرخ پایه (شرکت ارز)
 ,Qty To Be Billed,Qty به صورتحساب است
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,تحویل مبلغ
+DocType: Coupon Code,Gift Card,کارت هدیه
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,قطعه رزرو شده برای تولید: مقدار مواد اولیه برای ساخت کالاهای تولیدی.
 DocType: Loyalty Point Entry Redemption,Redemption Date,تاریخ رستگاری
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,این تراکنش بانکی قبلاً کاملاً آشتی داده شده است
@@ -1209,6 +1215,7 @@
 DocType: Loan,Total Interest Payable,منافع کل قابل پرداخت
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reason for Hold,دلیل نگه داشتن
 DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,مالیات هزینه فرود آمد و اتهامات
+apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set at Tax Exemption Reason in Sales Taxes and Charges,ردیف {0}: لطفاً دلیل معافیت مالیاتی در مالیات و عوارض فروش را تعیین کنید
 DocType: Quality Goal Objective,Quality Goal Objective,هدف کیفیت هدف
 DocType: Work Order Operation,Actual Start Time,واقعی زمان شروع
 DocType: Purchase Invoice Item,Deferred Expense Account,حساب هزینه معوق
@@ -1230,6 +1237,7 @@
 DocType: Bank Guarantee,Bank Guarantee Number,بانک شماره گارانتی
 DocType: Assessment Criteria,Assessment Criteria,معیارهای ارزیابی
 DocType: BOM Item,Basic Rate (Company Currency),نرخ پایه (شرکت ارز)
+apps/erpnext/erpnext/accounts/doctype/account/account.py,"While creating account for child Company {0}, parent account {1} not found. Please create the parent account in corresponding COA",هنگام ایجاد حساب کاربری برای شرکت کودک {0} ، حساب والدین {1} یافت نشد. لطفاً حساب والدین را در COA مربوطه ایجاد کنید
 apps/erpnext/erpnext/support/doctype/issue/issue.js,Split Issue,موضوع تقسیم شده
 DocType: Student Attendance,Student Attendance,حضور دانش آموز
 apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,No data to export,داده ای برای صادرات وجود ندارد
@@ -1260,6 +1268,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,برگه ایجاد کنید
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,حساب {0} وارد شده است چندین بار
 DocType: Account,Expenses Included In Valuation,هزینه های موجود در ارزش گذاری
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,فاکتورها را خریداری کنید
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,شما فقط می توانید تمدید کنید اگر عضویت شما در 30 روز منقضی شود
 DocType: Shopping Cart Settings,Show Stock Availability,نمایش موجودی
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},{0} را در دسته دارایی {1} یا شرکت {2}
@@ -1797,6 +1806,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,وارد کردن موارد و UOM
 DocType: Repayment Schedule,Balance Loan Amount,تعادل وام مبلغ
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,به جزئیات اضافه شده است
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted",با عرض پوزش ، کد کوپن خسته شده است
 DocType: Communication Medium,Catch All,گرفتن همه
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,دوره برنامه
 DocType: Budget,Applicable on Material Request,قابل اجرا در درخواست مواد
@@ -1964,6 +1974,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,ویژگی معتبر نیست
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} باید قطعی شود
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,کمپین های ایمیل
+DocType: Sales Partner,To Track inbound purchase,برای ردیابی خرید ورودی
 DocType: Buying Settings,Default Supplier Group,گروه پیشفرض شرکت
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},تعداد باید کمتر یا مساوی به {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},حداکثر واجد شرایط برای کامپوننت {0} بیش از {1}
@@ -2117,7 +2128,6 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,ورود سهام
 DocType: Hotel Room Reservation,Hotel Reservation User,کاربر رزرو هتل
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,تنظیم وضعیت
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,لطفاً سریال های شماره گذاری را برای حضور از طریق تنظیم&gt; سری شماره گذاری تنظیم کنید
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,لطفا ابتدا پیشوند انتخاب کنید
 DocType: Contract,Fulfilment Deadline,آخرین مهلت تحویل
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,نزدیک تو
@@ -2241,6 +2251,7 @@
 DocType: Quality Meeting Table,Under Review,تحت بررسی
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,ورود به سیستم ناموفق بود
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,دارایی {0} ایجاد شد
+DocType: Coupon Code,Promotional,تبلیغاتی
 DocType: Special Test Items,Special Test Items,آیتم های تست ویژه
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,برای ثبت نام در Marketplace، باید کاربر با مدیر سیستم مدیریت و نقش آیتم باشد.
 apps/erpnext/erpnext/config/buying.py,Key Reports,گزارش های کلیدی
@@ -2278,6 +2289,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,نوع فیلم کارگردان تهیه کننده
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,درصد اختصاص داده ها را برای تیم فروش باید 100 باشد
 DocType: Subscription Plan,Billing Interval Count,تعداد واسطهای صورتحساب
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","لطفاً برای لغو این سند ، <a href=""#Form/Employee/{0}"">{0}</a> \ کارمند را حذف کنید"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,ملاقات ها و برخورد های بیمار
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,ارزش گمشده
 DocType: Employee,Department and Grade,گروه و درجه
@@ -2377,6 +2390,7 @@
 DocType: Project,Start and End Dates,تاریخ شروع و پایان
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,شرایط قرارداد الگو
 ,Delivered Items To Be Billed,آیتم ها تحویل داده شده به صورتحساب می شود
+DocType: Coupon Code,Maximum Use,حداکثر استفاده
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},گسترش BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,انبار می توانید برای شماره سریال نمی تواند تغییر
 DocType: Authorization Rule,Average Discount,میانگین تخفیف
@@ -2536,6 +2550,7 @@
 DocType: Item,Inventory,فهرست
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,به عنوان Json بارگیری کنید
 DocType: Item,Sales Details,جزییات فروش
+DocType: Coupon Code,Used,استفاده شده
 DocType: Opportunity,With Items,با اقلام
 DocType: Asset Maintenance,Maintenance Team,تیم تعمیر و نگهداری
 DocType: Homepage Section,"Order in which sections should appear. 0 is first, 1 is second and so on.",ترتیب که در آن بخش ها باید ظاهر شوند. 0 در درجه اول ، 1 دوم است و غیره.
@@ -2661,7 +2676,7 @@
 						Serial No cannot be ensured",هیچ BOM فعال برای آیتم {0} یافت نشد. تحویل توسط \ Serial No می تواند تضمین شود
 DocType: Sales Partner,Sales Partner Target,فروش شریک هدف
 DocType: Loan Type,Maximum Loan Amount,حداکثر مبلغ وام
-DocType: Pricing Rule,Pricing Rule,قانون قیمت گذاری
+DocType: Coupon Code,Pricing Rule,قانون قیمت گذاری
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},تعداد رول تکراری برای دانشجویان {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,درخواست مواد به خرید سفارش
 DocType: Company,Default Selling Terms,شرایط فروش پیش فرض
@@ -2740,6 +2755,7 @@
 DocType: Payment Schedule,Payment Amount,مبلغ پرداختی
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,تاریخ نود روز باید بین کار از تاریخ و تاریخ پایان کار باشد
 DocType: Healthcare Settings,Healthcare Service Items,اقلام خدمات بهداشتی
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,بارکد نامعتبر است. هیچ موردی به این بارکد وصل نشده است.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,مقدار مصرف
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,تغییر خالص در نقدی
 DocType: Assessment Plan,Grading Scale,مقیاس درجه بندی
@@ -2858,7 +2874,6 @@
 DocType: Share Transfer,Asset Account,حساب دارایی
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,تاریخ انتشار جدید باید در آینده باشد
 DocType: Purchase Invoice,End date of current invoice's period,تاریخ پایان دوره صورتحساب فعلی
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,لطفاً سیستم نامگذاری کارمندان را در منابع انسانی&gt; تنظیمات HR تنظیم کنید
 DocType: Lab Test,Technician Name,نام تکنسین
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3133,7 +3148,6 @@
 DocType: Student,Student Mobile Number,دانشجو شماره موبایل
 DocType: Item,Has Variants,دارای انواع
 DocType: Employee Benefit Claim,Claim Benefit For,درخواست مزایا برای
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings",{Item} {{0}} در ردیف {1} بیش از {2} نمیتواند برای اجازه دادن به بیش از صدور صورت حساب، لطفا در تنظیمات سهام تنظیم کنید
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,به روز رسانی پاسخ
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},شما در حال حاضر اقلام از انتخاب {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,نام توزیع ماهانه
@@ -3418,6 +3432,7 @@
 DocType: Vehicle,Fuel Type,نوع سوخت
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,لطفا ارز در شرکت مشخص
 DocType: Workstation,Wages per hour,دستمزد در ساعت
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,مشتری&gt; گروه مشتری&gt; سرزمین
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},تعادل سهام در دسته {0} تبدیل خواهد شد منفی {1} برای مورد {2} در انبار {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,پس از درخواست های مواد به طور خودکار بر اساس سطح آیتم سفارش مجدد مطرح شده است
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},حساب {0} نامعتبر است. حساب ارزی باید {1} باشد
@@ -3746,6 +3761,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,ثبت کردن لغزش حقوق
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,در حال برگزاری
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,یک کلاهبرداری حداقل باید یک گزینه صحیح داشته باشد
+apps/erpnext/erpnext/hooks.py,Purchase Orders,سفارشات خرید
 DocType: Account,Inter Company Account,حساب شرکت اینتر
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,واردات به صورت فله
 DocType: Sales Partner,Address & Contacts,آدرس و اطلاعات تماس
@@ -3756,6 +3772,7 @@
 DocType: POS Profile,[Select],[انتخاب]
 DocType: Staffing Plan Detail,Number Of Positions,تعداد موقعیت ها
 DocType: Vital Signs,Blood Pressure (diastolic),فشار خون (دیاستولیک)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,لطفا مشتری را انتخاب کنید.
 DocType: SMS Log,Sent To,فرستادن به
 DocType: Agriculture Task,Holiday Management,مدیریت تعطیلات
 DocType: Payment Request,Make Sales Invoice,ایجاد فاکتور فروش
@@ -3961,7 +3978,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} ثبت نشده است
 DocType: Subscription,Trialling,آزمایشی
 DocType: Sales Invoice Item,Deferred Revenue,درآمد معوق
-DocType: Bank Account,GL Account,حساب GL
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,حساب نقدی برای ایجاد صورتحساب فروش استفاده می شود
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,معافیت زیر رده
 DocType: Member,Membership Expiry Date,عضویت در تاریخ انقضا
@@ -4356,13 +4372,13 @@
 DocType: C-Form Invoice Detail,Territory,منطقه
 DocType: Pricing Rule,Apply Rule On Item Code,استفاده از قانون در مورد کد
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,لطفا از هیچ بازدیدکننده داشته است مورد نیاز ذکر
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,گزارش موجودی سهام
 DocType: Stock Settings,Default Valuation Method,روش های ارزش گذاری پیش فرض
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,پرداخت
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,نمایش مقدار تجمعی
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,در حال بروزرسانی. ممکن است کمی طول بکشد.
 DocType: Production Plan Item,Produced Qty,تعداد تولیدی
 DocType: Vehicle Log,Fuel Qty,تعداد سوخت
-DocType: Stock Entry,Target Warehouse Name,نام انبار هدف
 DocType: Work Order Operation,Planned Start Time,برنامه ریزی زمان شروع
 DocType: Course,Assessment,ارزیابی
 DocType: Payment Entry Reference,Allocated,اختصاص داده
@@ -4428,10 +4444,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.",شرایط و ضوابط استاندارد است که می تواند به خرید و فروش اضافه شده است. مثال: 1. اعتبار ارائه دهد. 1. شرایط پرداخت (در پیش است، در اعتبار، بخشی از پیش و غیره). 1. چه اضافی (یا قابل پرداخت توسط مشتری) می باشد. 1. ایمنی هشدار / استفاده. 1. گارانتی در صورت وجود. 1. بازگرداندن سیاست. 1. شرایط حمل و نقل، اگر قابل اجرا است. 1. راه های مقابله با اختلافات، غرامت، مسئولیت، و غیره 1. آدرس و تماس با شرکت شما.
 DocType: Homepage Section,Section Based On,بخش مبتنی بر
+DocType: Shopping Cart Settings,Show Apply Coupon Code,نمایش درخواست کد کوپن
 DocType: Issue,Issue Type,نوع مقاله
 DocType: Attendance,Leave Type,نوع مرخصی
 DocType: Purchase Invoice,Supplier Invoice Details,عرضه کننده اطلاعات فاکتور
 DocType: Agriculture Task,Ignore holidays,تعطیلات را نادیده بگیرید
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,شرایط کوپن را اضافه یا ویرایش کنید
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,حساب هزینه / تفاوت ({0}) باید یک حساب کاربری &#39;، سود و ضرر باشد
 DocType: Stock Entry Detail,Stock Entry Child,کودک ورود سهام
 DocType: Project,Copied From,کپی شده از
@@ -4601,6 +4619,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,معیارهای ارزیابی طرح
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,معاملات
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,جلوگیری از سفارشات خرید
+DocType: Coupon Code,Coupon Name,نام کوپن
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,حساس
 DocType: Email Campaign,Scheduled,برنامه ریزی
 DocType: Shift Type,Working Hours Calculation Based On,محاسبه ساعت کار بر اساس
@@ -4617,7 +4636,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,ایجاد انواع
 DocType: Vehicle,Diesel,دیزل
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,لیست قیمت ارز انتخاب نشده
+DocType: Quick Stock Balance,Available Quantity,مقدار موجود
 DocType: Purchase Invoice,Availed ITC Cess,ITC به سرقت رفته است
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,لطفاً سیستم نامگذاری مربی را در آموزش و پرورش&gt; تنظیمات آموزش تنظیم کنید
 ,Student Monthly Attendance Sheet,دانشجو جدول حضور ماهانه
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,قانون حمل و نقل فقط برای فروش قابل اجرا است
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,ردۀ تخریب {0}: تاریخ خرابی بعدی بعد از تاریخ خرید نمی تواند باشد
@@ -4685,6 +4706,7 @@
 DocType: Quality Meeting,Quality Meeting,جلسه کیفیت
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,غیر گروه به گروه
 DocType: Employee,ERPNext User,کاربر ERPNext
+DocType: Coupon Code,Coupon Description,توضیحات کوپن
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},دسته ای در ردیف الزامی است {0}
 DocType: Company,Default Buying Terms,شرایط خرید پیش فرض
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,مورد رسید خرید عرضه
@@ -4846,6 +4868,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,جزئیات سند علیه هیچ
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},حذف برای کشور ممنوع است {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,نوع حزب الزامی است
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,کد کوپن را اعمال کنید
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",برای کارت شغلی {0} ، فقط می توانید نوع ورود سهام &quot;انتقال مواد برای ساخت&quot; را تهیه کنید
 DocType: Quality Inspection,Outgoing,خروجی
 DocType: Customer Feedback Table,Customer Feedback Table,جدول بازخورد مشتری
@@ -4994,7 +5017,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,در ارسال سفارش خرید
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,اضافه کردن همه تامین کنندگان
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,ردیف # {0}: مقدار اختصاص داده شده نمی تواند بیشتر از مقدار برجسته.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,مشتری&gt; گروه مشتری&gt; سرزمین
 DocType: Tally Migration,Parties,مهمانی ها
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,مرور BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,وام
@@ -5026,7 +5048,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},اجازه نمیدهد که آیتم جایگزین برای آیتم {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,تاریخ تکرار شده است
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,امضای مجاز
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,لطفاً سیستم نامگذاری مربی را در آموزش و پرورش&gt; تنظیمات آموزش تنظیم کنید
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),ITC خالص موجود (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,ایجاد هزینه ها
 DocType: Project,Total Purchase Cost (via Purchase Invoice),هزینه خرید مجموع (از طریق فاکتورخرید )
@@ -5050,6 +5071,7 @@
 DocType: Quiz Result,Wrong,اشتباه
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,سرعت که در آن لیست قیمت ارز به ارز پایه مشتری تبدیل
 DocType: Purchase Invoice Item,Net Amount (Company Currency),مبلغ خالص (شرکت ارز)
+DocType: Sales Partner,Referral Code,کد ارجاع
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,مبلغ پیشنهادی کل نمیتواند بیشتر از مجموع مبلغ مجاز باشد
 DocType: Salary Slip,Hour Rate,یک ساعت یک نرخ
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,سفارش مجدد خودکار را فعال کنید
@@ -5198,6 +5220,7 @@
 DocType: Travel Request,Fully Sponsored,کاملا حمایت شده
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,ورودی مجله معکوس
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,ایجاد کارت شغلی
+DocType: Quotation,Referral Sales Partner,شریک فروش ارجاع
 DocType: Quality Procedure Process,Process Description,شرح فرایند
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,مشتری {0} ایجاد شده است
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,در حال حاضر هیچ کالایی در انبار وجود ندارد
@@ -5328,6 +5351,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM نرخ
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,خواندن پرونده بارگذاری شده
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel",کار متوقف کار را نمی توان لغو کرد، برای لغو آن ابتدا آن را متوقف کنید
+DocType: Coupon Code,Coupon Code,کد کوپن
 DocType: Asset,Journal Entry for Scrap,ورودی مجله برای ضایعات
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,لطفا توجه داشته باشید تحویل اقلام از جلو
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},ردیف {0}: ایستگاه کاری را در برابر عملیات انتخاب کنید {1}
@@ -5407,6 +5431,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;تاریخ&#39; الزامی است
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},با توجه / مرجع تاریخ نمی تواند بعد {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,اطلاعات واردات و صادرات
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired",متأسفیم ، اعتبار کد کوپن منقضی شده است
 DocType: Bank Account,Account Details,جزئیات حساب
 DocType: Crop,Materials Required,مواد مورد نیاز
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,هیچ دانش آموزان یافت
@@ -5444,6 +5469,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,برو به کاربران
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,مبلغ پرداخت شده + نوشتن کردن مقدار نمی تواند بیشتر از جمع کل
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} است تعداد دسته معتبر برای مورد نمی {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,لطفا کد کوپن معتبر را وارد کنید !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},نکته: تعادل مرخصی به اندازه کافی برای مرخصی نوع وجود ندارد {0}
 DocType: Task,Task Description,شرح وظیفه
 DocType: Training Event,Seminar,سمینار
@@ -5704,6 +5730,7 @@
 ,TDS Payable Monthly,TDS پرداخت ماهانه
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,برای جایگزینی BOM صفر ممکن است چند دقیقه طول بکشد.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',نمی تواند کسر زمانی که دسته بندی است برای ارزش گذاری &quot;یا&quot; ارزش گذاری و مجموع &quot;
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,لطفاً سیستم نامگذاری کارمندان را در منابع انسانی&gt; تنظیمات HR تنظیم کنید
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,کل پرداخت ها
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},سریال شماره سریال مورد نیاز برای مورد {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,پرداخت بازی با فاکتورها
@@ -5792,6 +5819,7 @@
 DocType: Production Plan,Get Raw Materials For Production,دریافت مواد اولیه برای تولید
 DocType: Job Opening,Job Title,عنوان شغلی
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,آینده پرداخت Ref
+DocType: Quotation,Additional Discount and Coupon Code,تخفیف اضافی و کد کوپن
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.",{0} نشان می دهد که {1} یک نقل قول را ارائه نمی کند، اما همه اقلام نقل شده است. به روز رسانی وضعیت نقل قول RFQ.
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,حداکثر نمونه - {0} برای Batch {1} و Item {2} در Batch {3} حفظ شده است.
@@ -5867,6 +5895,7 @@
 DocType: Employee Benefit Application,Dispensed Amount (Pro-rated),مقدار اعطا شده (امتیاز داده شده)
 DocType: Student,Guardian Details,نگهبان جزییات
 DocType: C-Form,C-Form,C-فرم
+apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! First 2 digits of GSTIN should match with State number {0}.,GSTIN نامعتبر است! 2 رقم اول GSTIN باید با شماره دولت {0} مطابقت داشته باشد.
 DocType: Agriculture Task,Start Day,روز شروع
 DocType: Vehicle,Chassis No,شاسی
 DocType: Payment Entry,Initiated,آغاز
@@ -6015,6 +6044,7 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,تنظیمات برای صفحه اصلی وب سایت
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} تا پایان {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ ها برای {0} مجاز نیستند چرا که یک کارت امتیازی از {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,را خریداری فاکتور
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,برگهای مورد استفاده
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,آیا می خواهید درخواست مطالب را ارسال کنید
 DocType: Job Offer,Awaiting Response,در انتظار پاسخ
@@ -6029,6 +6059,7 @@
 DocType: Training Event Employee,Optional,اختیاری
 DocType: Salary Slip,Earning & Deduction,سود و کسر
 DocType: Agriculture Analysis Criteria,Water Analysis,تجزیه و تحلیل آب
+DocType: Sales Order,Skip Delivery Note,پرش به یادداشت تحویل
 DocType: Price List,Price Not UOM Dependent,قیمت وابسته UOM نیست
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} انواع ایجاد شده است.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,توافق نامه سطح سرویس پیش فرض از قبل وجود دارد.
@@ -6233,7 +6264,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,مالیات و هزینه اضافه شده
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,مقدار خسارت ردیف {0}: تاریخ بعد از انهدام بعدی قبل از موجود بودن برای تاریخ استفاده نمی شود
 ,Sales Funnel,قیف فروش
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,کد کالا&gt; گروه مورد&gt; نام تجاری
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,مخفف الزامی است
 DocType: Project,Task Progress,وظیفه پیشرفت
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,گاری
@@ -6327,6 +6357,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,نمایش POS مورد نیاز برای ایجاد POS ورود
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",امتیازات وفاداری از هزینه انجام شده (از طریق صورتحساب فروش) بر اساس فاکتور جمع آوری شده ذکر شده محاسبه خواهد شد.
 DocType: Program Enrollment Tool,Enroll Students,ثبت نام دانش آموزان
+DocType: Pricing Rule,Coupon Code Based,کد کوپن بر اساس
 DocType: Company,HRA Settings,تنظیمات HRA
 DocType: Homepage,Hero Section,بخش قهرمان
 DocType: Employee Transfer,Transfer Date,تاریخ انتقال
@@ -6440,6 +6471,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',لطفا مجموعه شرکت فیلتر خالی اگر گروه توسط است شرکت &#39;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,مجوز های ارسال و تاریخ نمی تواند تاریخ آینده
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},ردیف # {0}: سریال نه {1} با مطابقت ندارد {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,لطفاً سریال های شماره گذاری را برای حضور از طریق تنظیم&gt; سری شماره گذاری تنظیم کنید
 DocType: Stock Entry,Target Warehouse Address,آدرس انبار هدف
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,مرخصی گاه به گاه
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,زمان قبل از شروع کار شیفت که در آن Check-in کارمندان برای حضور در نظر گرفته می شود.
@@ -6474,7 +6506,6 @@
 DocType: Employee Grade,Employee Grade,درجه کارمند
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,کار از روی مقاطعه
 DocType: GSTR 3B Report,June,ژوئن
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,عرضه کننده&gt; نوع عرضه کننده
 DocType: Share Balance,From No,از شماره
 DocType: Shift Type,Early Exit Grace Period,زودرس دوره گریس
 DocType: Task,Actual Time (in Hours),زمان واقعی (در ساعت)
@@ -6891,6 +6922,7 @@
 DocType: Budget,Warn,هشدار دادن
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,همه اقلام در حال حاضر برای این سفارش کار منتقل شده است.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.",هر گونه اظهارات دیگر، تلاش قابل توجه است که باید در پرونده بروید.
+DocType: Bank Account,Company Account,حساب شرکت
 DocType: Asset Maintenance,Manufacturing User,ساخت کاربری
 DocType: Purchase Invoice,Raw Materials Supplied,مواد اولیه عرضه شده
 DocType: Subscription Plan,Payment Plan,برنامه پرداخت
@@ -6932,6 +6964,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) نمیتواند بیشتر از مقدار برنامه ریزی ({2}) در سفارش کاری باشد {3}
 DocType: Certification Application,Name of Applicant,نام متقاضی
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,ورق زمان برای تولید.
+DocType: Quick Stock Balance,Quick Stock Balance,مانده سهام سریع
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,جمع جزء
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,پس از معاملات بورس نمی تواند خواص Variant را تغییر دهد. برای انجام این کار باید یک مورد جدید ایجاد کنید.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless مجوز SEPA
@@ -7253,6 +7286,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},لطفا {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} دانشجوی غیر فعال است
 DocType: Employee,Health Details,جزییات بهداشت
+DocType: Coupon Code,Coupon Type,نوع کوپن
 DocType: Leave Encashment,Encashable days,روزهای Encashable
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,برای ایجاد یک درخواست پاسخ به پرداخت سند مرجع مورد نیاز است
 DocType: Soil Texture,Sandy Clay,خاک رس شنی
@@ -7533,6 +7567,7 @@
 DocType: Hotel Room Package,Amenities,امکانات
 DocType: Accounts Settings,Automatically Fetch Payment Terms,شرایط پرداخت به صورت خودکار را اخذ کنید
 DocType: QuickBooks Migrator,Undeposited Funds Account,حساب صندوق غیرقانونی
+DocType: Coupon Code,Uses,استفاده می کند
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,حالت پیش پرداخت چندگانه مجاز نیست
 DocType: Sales Invoice,Loyalty Points Redemption,بازده وفاداری
 ,Appointment Analytics,انتصاب انتصاب
@@ -7549,6 +7584,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,کل بودجه
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,خالی بگذارید اگر شما را به گروه دانش آموز در سال
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day",اگر علامت زده شود، هیچ مجموع. از روز کاری شامل تعطیلات، و این خواهد شد که ارزش حقوق پستها در طول روز کاهش
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,دامنه اضافه نشد
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.",برای اجازه بیش از دریافت / تحویل ، &quot;تنظیم بیش از دریافت / تحویل&quot; را در تنظیمات سهام یا مورد به روز کنید.
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?",برنامه های کاربردی با استفاده از کلید فعلی قادر به دسترسی نخواهند بود، آیا مطمئن هستید؟
 DocType: Subscription Settings,Prorate,پروانه
@@ -7561,6 +7597,7 @@
 ,BOM Stock Report,BOM گزارش سهام
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group",در صورت عدم وجود زمان بندی اختصاصی ، ارتباطات توسط این گروه انجام می شود
 DocType: Stock Reconciliation Item,Quantity Difference,تفاوت تعداد
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,عرضه کننده&gt; نوع عرضه کننده
 DocType: Opportunity Item,Basic Rate,نرخ پایه
 DocType: GL Entry,Credit Amount,مقدار وام
 ,Electronic Invoice Register,ثبت فاکتور الکترونیکی
@@ -7811,6 +7848,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),مالیات و هزینه کسر (شرکت ارز)
 DocType: Item Group,General Settings,تنظیمات عمومی
 DocType: Article,Article,مقاله
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,لطفا کد کوپن را وارد کنید !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,از پول و ارز را نمی توان همان
 DocType: Taxable Salary Slab,Percent Deduction,کاهش درصد
 DocType: GL Entry,To Rename,تغییر نام دهید
diff --git a/erpnext/translations/fi.csv b/erpnext/translations/fi.csv
index 44f898e..c028c30 100644
--- a/erpnext/translations/fi.csv
+++ b/erpnext/translations/fi.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Asiakaspalvelu Yhteystiedot
 DocType: Shift Type,Enable Auto Attendance,Ota automaattinen läsnäolo käyttöön
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Anna varasto ja päivämäärä
 DocType: Lost Reason Detail,Opportunity Lost Reason,Mahdollisuus menetetty syy
 DocType: Patient Appointment,Check availability,Tarkista saatavuus
 DocType: Retention Bonus,Bonus Payment Date,Bonuspäivä
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Valmistuneet työmääräykset
 DocType: Support Settings,Forum Posts,Foorumin viestit
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Tehtävä on vallattu taustatyöksi. Jos taustalla tapahtuvaan käsittelyyn liittyy ongelmia, järjestelmä lisää kommentin tämän kaluston täsmäytyksen virheestä ja palaa Luonnos-vaiheeseen"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started",Valitettavasti kuponkikoodin voimassaoloaika ei ole alkanut
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,veron perusteena
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},sinulla ei ole lupaa lisätä tai päivittää kirjauksia ennen {0}
 DocType: Leave Policy,Leave Policy Details,Jätä politiikkatiedot
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,käytettävä
 DocType: Student,B-,B -
 DocType: Assessment Result,Grade,Arvosana
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Tuotekoodi&gt; Tuoteryhmä&gt; Tuotemerkki
 DocType: Restaurant Table,No of Seats,Istumapaikkoja
 DocType: Sales Invoice,Overdue and Discounted,Erääntynyt ja alennettu
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Puhelu katkesi
@@ -506,6 +509,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Riviväli varten määrä kirjaimin
 DocType: Vehicle,Additional Details,Lisätiedot
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,ei annettua kuvausta
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Hae tuotteet varastosta
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Pyydä ostaa.
 DocType: POS Closing Voucher Details,Collected Amount,Kerätty määrä
 DocType: Lab Test,Submitted Date,Lähetetty päivämäärä
@@ -613,6 +617,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Käyttö-opastus
 ,Trial Balance (Simple),Koetasapaino (yksinkertainen)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Ota käyttöön laskennallinen kulutus
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Sovellettu kuponkikoodi
 DocType: Asset,Next Depreciation Date,Seuraava poistopäivämäärä
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Aktiviteetti kustannukset työntekijää kohti
 DocType: Accounts Settings,Settings for Accounts,Tilien asetukset
@@ -848,8 +853,6 @@
 DocType: BOM,Work Order,Työjärjestys
 DocType: Sales Invoice,Total Qty,yksikkömäärä yhteensä
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 -sähköpostitunnus
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Poista työntekijä <a href=""#Form/Employee/{0}"">{0}</a> \ peruuttaaksesi tämän asiakirjan"
 DocType: Item,Show in Website (Variant),Näytä Web-sivuston (Variant)
 DocType: Employee,Health Concerns,"terveys, huolenaiheet"
 DocType: Payroll Entry,Select Payroll Period,Valitse Payroll Aika
@@ -1013,6 +1016,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Verotettavaa tiliä
 DocType: Pricing Rule,Sales Partner,Myyntikumppani
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Kaikki toimittajan tuloskortit.
+DocType: Coupon Code,To be used to get discount,Käytetään alennuksen saamiseksi
 DocType: Buying Settings,Purchase Receipt Required,Saapumistosite vaaditaan
 DocType: Sales Invoice,Rail,kisko
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Todellinen kustannus
@@ -1063,6 +1067,7 @@
 DocType: Production Plan,Production Plan,Tuotantosuunnitelma
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Avaustilien luomistyökalu
 DocType: Salary Component,Round to the Nearest Integer,Pyöreä lähimpään kokonaislukuun
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,"Salli tuotteiden, joita ei ole varastossa, lisääminen ostoskoriin"
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Myynti Return
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,"Aseta määrä operaatioihin, jotka perustuvat sarjamuotoiseen tuloon"
 ,Total Stock Summary,Yhteensä Stock Yhteenveto
@@ -1192,6 +1197,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Base Hour Rate (Company valuutta)
 ,Qty To Be Billed,Määrä laskutettavaksi
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,toimitettu
+DocType: Coupon Code,Gift Card,Lahjakortti
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Varattu tuotantomäärä: Raaka-aineiden määrä valmistustuotteiden valmistamiseksi.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Lunastuspäivä
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Tämä pankkitapahtuma on jo täysin sovitettu yhteen
@@ -1279,6 +1285,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Luo aikataulu
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Tili {0} on syötetty useita kertoja
 DocType: Account,Expenses Included In Valuation,Arvoon sisältyvät kustannukset
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Ostolaskut
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,"Voit uusia vain, jos jäsenyytesi päättyy 30 päivän kuluessa"
 DocType: Shopping Cart Settings,Show Stock Availability,Saatavuus Varastossa
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Aseta {0} varallisuusluokkaan {1} tai yritys {2}
@@ -1818,6 +1825,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Tuotteiden tuominen
 DocType: Repayment Schedule,Balance Loan Amount,Balance Lainamäärä
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Lisätty yksityiskohtiin
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted",Valitettavasti kuponkikoodi on käytetty loppuun
 DocType: Communication Medium,Catch All,Catch All
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Aikataulu kurssi
 DocType: Budget,Applicable on Material Request,Sovelletaan materiaalihakemukseen
@@ -1985,6 +1993,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Virheellinen Taito
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} pitää olla vahvistettu
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Sähköposti-kampanjat
+DocType: Sales Partner,To Track inbound purchase,Seurata saapuvaa hankintaa
 DocType: Buying Settings,Default Supplier Group,Oletuksena toimittajaryhmä
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Määrä on oltava pienempi tai yhtä suuri kuin {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Suurin sallittu summa komponentille {0} ylittää {1}
@@ -2140,8 +2149,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Tee osakemerkintä
 DocType: Hotel Room Reservation,Hotel Reservation User,Hotellin varaus käyttäjä
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Aseta tila
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Asenna läsnäolosuhteiden numerointisarjat kohdasta Asetukset&gt; Numerointisarjat
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Ole hyvä ja valitse etuliite ensin
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Aseta Naming-sarjan asetukseksi {0} Asetukset&gt; Asetukset&gt; Sarjojen nimeäminen -kohdassa
 DocType: Contract,Fulfilment Deadline,Täytäntöönpanon määräaika
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Lähellä sinua
 DocType: Student,O-,O -
@@ -2265,6 +2274,7 @@
 DocType: Quality Meeting Table,Under Review,Tarkasteltavana
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Sisäänkirjautuminen epäonnistui
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Asetus {0} luotiin
+DocType: Coupon Code,Promotional,myynninedistämis-
 DocType: Special Test Items,Special Test Items,Erityiset testit
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,"Sinun on oltava käyttäjä, jolla System Manager- ja Item Manager -roolit ovat rekisteröityneet Marketplacessa."
 apps/erpnext/erpnext/config/buying.py,Key Reports,Keskeiset raportit
@@ -2302,6 +2312,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,asiakirja tyyppi
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Myyntitiimin yhteensä lasketun prosenttiosuuden pitää olla 100
 DocType: Subscription Plan,Billing Interval Count,Laskutusväli
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Poista työntekijä <a href=""#Form/Employee/{0}"">{0}</a> \ peruuttaaksesi tämän asiakirjan"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Nimitykset ja potilaskokoukset
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Arvo puuttuu
 DocType: Employee,Department and Grade,Osasto ja palkkaluokka
@@ -2404,6 +2416,7 @@
 DocType: Project,Start and End Dates,Alkamis- ja päättymisajankohta
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Sopimusmallin täyttämisen ehdot
 ,Delivered Items To Be Billed,"toimitettu, laskuttamat"
+DocType: Coupon Code,Maximum Use,Suurin käyttö
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Open BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Sarjanumerolle ei voi muuttaa varastoa
 DocType: Authorization Rule,Average Discount,Keskimääräinen alennus
@@ -2565,6 +2578,7 @@
 DocType: Item,Inventory,inventaario
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Lataa nimellä Json
 DocType: Item,Sales Details,Myynnin lisätiedot
+DocType: Coupon Code,Used,käytetty
 DocType: Opportunity,With Items,Tuotteilla
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Kampanja &#39;{0}&#39; on jo olemassa {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Huoltoryhmä
@@ -2694,7 +2708,7 @@
 						Serial No cannot be ensured",Mitään aktiivista BOM: tä ei löytynyt kohteen {0} kohdalle. Toimitusta \ Serial No ei voida taata
 DocType: Sales Partner,Sales Partner Target,Myyntikumppani tavoite
 DocType: Loan Type,Maximum Loan Amount,Suurin lainamäärä
-DocType: Pricing Rule,Pricing Rule,Hinnoittelusääntö
+DocType: Coupon Code,Pricing Rule,Hinnoittelusääntö
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Päällekkäisiä rullan numero opiskelijan {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Ostotilaus hankintapyynnöstä
 DocType: Company,Default Selling Terms,Oletusmyyntiehdot
@@ -2773,6 +2787,7 @@
 DocType: Payment Schedule,Payment Amount,maksun arvomäärä
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Puolen päivän Päivä pitää olla Työn alkamispäivästä ja Työn päättymispäivästä alkaen
 DocType: Healthcare Settings,Healthcare Service Items,Terveydenhoitopalvelut
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Virheellinen viivakoodi. Tähän viivakoodiin ei ole liitetty tuotetta.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,käytetty arvomäärä
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Rahavarojen muutos
 DocType: Assessment Plan,Grading Scale,Arvosteluasteikko
@@ -2892,7 +2907,6 @@
 DocType: Share Transfer,Asset Account,Omaisuuden tili
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Uuden julkaisupäivän pitäisi olla tulevaisuudessa
 DocType: Purchase Invoice,End date of current invoice's period,nykyisen laskukauden päättymispäivä
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Asenna Työntekijöiden nimeämisjärjestelmä kohtaan Henkilöstöresurssit&gt; HR-asetukset
 DocType: Lab Test,Technician Name,Tekniikan nimi
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3003,6 +3017,7 @@
 DocType: Products Settings,Hide Variants,Piilota variantit
 DocType: Lead,Next Contact By,seuraava yhteydenottohlö
 DocType: Compensatory Leave Request,Compensatory Leave Request,Korvaushyvityspyyntö
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings",Tuotteen {0} rivillä {1} ei voida ylilaskuttaa enemmän kuin {2}. Aseta korvaus Tilin asetukset -kohdassa salliaksesi ylilaskutuksen
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Vaadittu tuotemäärä {0} rivillä {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Varastoa {0} ei voi poistaa koska se sisältää tuotetta {1}
 DocType: Blanket Order,Order Type,Tilaustyyppi
@@ -3172,7 +3187,6 @@
 DocType: Student,Student Mobile Number,Student Mobile Number
 DocType: Item,Has Variants,useita tuotemalleja
 DocType: Employee Benefit Claim,Claim Benefit For,Korvausetu
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Ei voida ylikirjoittaa rivikohta {0} {1} yli {2}. Jotta voit laskuttaa ylimääräisen hinnan, aseta Tukosasetukset"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Päivitä vastaus
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Olet jo valitut kohteet {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,"toimitus kuukaudessa, nimi"
@@ -3462,6 +3476,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Määritä yrityksen valuutta
 DocType: Workstation,Wages per hour,Tuntipalkat
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Määritä {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Asiakas&gt; Asiakasryhmä&gt; Alue
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Erän varastotase {0} muuttuu negatiiviseksi {1} tuotteelle {2} varastossa {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Seuraavat hankintapyynnöt luotu tilauspisteen mukaisesti
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Tili {0} ei kelpaa. Tilin valuutan on oltava {1}
@@ -3791,6 +3806,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Vahvista palkkatosite
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Pidossa
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Lauseessa on oltava ainakin yksi oikea vaihtoehto
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Tilaukset
 DocType: Account,Inter Company Account,Inter Company Account
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,tuo massana
 DocType: Sales Partner,Address & Contacts,osoitteet ja yhteystiedot
@@ -3801,6 +3817,7 @@
 DocType: POS Profile,[Select],[valitse]
 DocType: Staffing Plan Detail,Number Of Positions,Asemien lukumäärä
 DocType: Vital Signs,Blood Pressure (diastolic),Verenpaine (diastolinen)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Ole hyvä ja valitse asiakas.
 DocType: SMS Log,Sent To,Lähetetty kenelle
 DocType: Agriculture Task,Holiday Management,Lomahallinta
 DocType: Payment Request,Make Sales Invoice,tee myyntilasku
@@ -4010,7 +4027,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} ei ole vahvistettu
 DocType: Subscription,Trialling,testaamista
 DocType: Sales Invoice Item,Deferred Revenue,Viivästyneet tulot
-DocType: Bank Account,GL Account,GL-tili
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Rahatiliä käytetään myyntilaskutuksen luomiseen
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Poikkeusluokka
 DocType: Member,Membership Expiry Date,Jäsenyyden päättymispäivä
@@ -4414,13 +4430,13 @@
 DocType: C-Form Invoice Detail,Territory,Alue
 DocType: Pricing Rule,Apply Rule On Item Code,Käytä tuotekoodia
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Vierailujen määrä vaaditaan
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Varastotaseraportti
 DocType: Stock Settings,Default Valuation Method,oletus arvomenetelmä
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Maksu
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Näytä kumulatiivinen määrä
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Päivitys käynnissä. Voi kestää hetken.
 DocType: Production Plan Item,Produced Qty,Tuotettu määrä
 DocType: Vehicle Log,Fuel Qty,polttoaineen määrä
-DocType: Stock Entry,Target Warehouse Name,Kohdevaraston nimi
 DocType: Work Order Operation,Planned Start Time,Suunniteltu aloitusaika
 DocType: Course,Assessment,Arviointi
 DocType: Payment Entry Reference,Allocated,kohdennettu
@@ -4486,10 +4502,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","perusehdot, jotka voidaan lisätä myynteihin ja ostoihin esim, 1. tarjouksen voimassaolo 1. maksuehdot (ennakko, luotto, osaennakko jne) 1. lisäkulut (asiakkaan maksettavaksi) 1. turvallisuus / käyttövaroitukset 1. takuuasiat 1. palautusoikeus. 1. toimitusehdot 1. riita-, korvaus- ja vastuuasioiden käsittely jne 1. omat osoite ja yhteystiedot"
 DocType: Homepage Section,Section Based On,Jakso perustuu
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Näytä Käytä kuponkikoodia
 DocType: Issue,Issue Type,Julkaisutyyppi
 DocType: Attendance,Leave Type,Vapaan tyyppi
 DocType: Purchase Invoice,Supplier Invoice Details,Toimittaja Laskun tiedot
 DocType: Agriculture Task,Ignore holidays,Ohita vapaapäivät
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Lisää / muokkaa kuponkiehtoja
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Kustannus- / erotuksen tili ({0}) tulee olla 'tuloslaskelma' tili
 DocType: Stock Entry Detail,Stock Entry Child,Osakemerkintä lapsi
 DocType: Project,Copied From,kopioitu
@@ -4664,6 +4682,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Assessment Plan Criteria
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,liiketoimet
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Estää ostotilaukset
+DocType: Coupon Code,Coupon Name,Kupongin nimi
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,herkkä
 DocType: Email Campaign,Scheduled,Aikataulutettu
 DocType: Shift Type,Working Hours Calculation Based On,Työajan laskeminen perustuu
@@ -4680,7 +4699,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,tee malleja
 DocType: Vehicle,Diesel,diesel-
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,"Hinnasto, valuutta ole valittu"
+DocType: Quick Stock Balance,Available Quantity,Saatavana oleva määrä
 DocType: Purchase Invoice,Availed ITC Cess,Käytti ITC Cessia
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Asenna ohjaajien nimeämisjärjestelmä kohdassa Koulutus&gt; Koulutusasetukset
 ,Student Monthly Attendance Sheet,Student Kuukauden Läsnäolo Sheet
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Myyntiin sovellettava toimitussääntö
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Poisto Rivi {0}: Seuraava Poistoaika ei voi olla ennen ostopäivää
@@ -4747,8 +4768,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Rivi {0}: Advance vastaan asiakkaan on luotto
 DocType: Quality Meeting,Quality Meeting,Laatukokous
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-ryhmän Group
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Aseta Naming-sarjan asetukseksi {0} Asetukset&gt; Asetukset&gt; Sarjojen nimeäminen -kohdassa
 DocType: Employee,ERPNext User,ERP-lisäkäyttäjä
+DocType: Coupon Code,Coupon Description,Kupongin kuvaus
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Erä on pakollinen rivillä {0}
 DocType: Company,Default Buying Terms,Oletusostoehdot
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Saapumistositteen nimike toimitettu
@@ -4911,6 +4932,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Dokumentin yksityiskohta nro kohdistus
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Poistaminen ei ole sallittua maan {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Osapuoli tyyppi on pakollinen
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Käytä kuponkikoodia
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",Työkortilla {0} voit tehdä vain valmistusmateriaalin siirron
 DocType: Quality Inspection,Outgoing,Lähtevä
 DocType: Customer Feedback Table,Customer Feedback Table,Asiakaspalautetaulukko
@@ -5060,7 +5082,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Ostotilausten toimittaminen
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Lisää kaikki toimittajat
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Rivi # {0}: osuutensa ei voi olla suurempi kuin lainamäärä.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Asiakas&gt; Asiakasryhmä&gt; Alue
 DocType: Tally Migration,Parties,osapuolet
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,selaa BOM:a
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Taatut lainat
@@ -5092,7 +5113,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Älä anna asettaa vaihtoehtoista kohdetta {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Päivä toistetaan
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Valtuutettu allekirjoitus
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Asenna ohjaajien nimeämisjärjestelmä kohtaan Koulutus&gt; Koulutusasetukset
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Net ITC käytettävissä (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Luo palkkioita
 DocType: Project,Total Purchase Cost (via Purchase Invoice),hankintakustannusten kokonaismäärä (ostolaskuista)
@@ -5117,6 +5137,7 @@
 DocType: Quiz Result,Wrong,Väärä
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"taso, jolla hinnasto valuutta muunnetaan asiakkaan käyttämäksi perusvaluutaksi"
 DocType: Purchase Invoice Item,Net Amount (Company Currency),netto (yrityksen valuutassa)
+DocType: Sales Partner,Referral Code,viitekoodi
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Ennakkomaksun kokonaismäärä ei voi olla suurempi kuin kokonainen seuraamusmäärä
 DocType: Salary Slip,Hour Rate,tuntitaso
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Ota automaattinen uudelleenjärjestys käyttöön
@@ -5245,6 +5266,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Näytä varastomäärä
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Liiketoiminnan nettorahavirta
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Rivi # {0}: Tila on oltava {1} laskun alennukselle {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM-muuntokerrointa ({0} -&gt; {1}) ei löydy tuotteelle: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Nimike 4
 DocType: Student Admission,Admission End Date,Pääsymaksu Päättymispäivä
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Alihankinta
@@ -5267,6 +5289,7 @@
 DocType: Travel Request,Fully Sponsored,Täysin sponsoroidut
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Reverse Journal Entry
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Luo työkortti
+DocType: Quotation,Referral Sales Partner,Suosittelumyyntikumppani
 DocType: Quality Procedure Process,Process Description,Prosessin kuvaus
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Asiakas {0} luodaan.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,"Tällä hetkellä ei varastossa,"
@@ -5401,6 +5424,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM taso
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Lähetettyjen tiedostojen lukeminen
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Pysäytettyä työjärjestystä ei voi peruuttaa, keskeyttää se ensin peruuttamalla"
+DocType: Coupon Code,Coupon Code,Kuponkikoodi
 DocType: Asset,Journal Entry for Scrap,Journal Entry for Romu
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Siirrä tuotteita lähetteeltä
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Rivi {0}: valitse työasema operaatiota vastaan {1}
@@ -5483,6 +5507,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;Päivämäärä&#39; vaaditaan
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},erä- / viitepäivä ei voi olla {0} jälkeen
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,tietojen tuonti ja vienti
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired",Valitettavasti kuponkikoodin voimassaoloaika on vanhentunut
 DocType: Bank Account,Account Details,tilin tiedot
 DocType: Crop,Materials Required,Vaaditut materiaalit
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Ei opiskelijat Todettu
@@ -5520,6 +5545,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Siirry Käyttäjiin
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Maksettu arvomäärä + poistotilin summa ei voi olla suurempi kuin kokonaissumma
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} ei sallittu eränumero tuotteelle {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Anna voimassa oleva kuponkikoodi !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Huom: jäännöstyypille {0} ei ole tarpeeksi vapaata jäännöstasetta
 DocType: Task,Task Description,Tehtävän kuvaus
 DocType: Training Event,Seminar,seminaari
@@ -5783,6 +5809,7 @@
 ,TDS Payable Monthly,TDS maksetaan kuukausittain
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Jouduin korvaamaan BOM. Voi kestää muutaman minuutin.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',vähennystä ei voi tehdä jos kategoria on  'arvo'  tai 'arvo ja summa'
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Asenna Työntekijöiden nimeämisjärjestelmä kohtaan Henkilöstöresurssit&gt; HR-asetukset
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Maksut yhteensä
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Sarjanumero tarvitaan sarjanumeroilla seuratulle tuotteelle {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Match Maksut Laskut
@@ -5872,6 +5899,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Hanki raaka-aineita tuotannolle
 DocType: Job Opening,Job Title,Työtehtävä
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Tuleva maksu viite
+DocType: Quotation,Additional Discount and Coupon Code,Lisäalennus ja kuponkikoodi
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} ilmoittaa, että {1} ei anna tarjousta, mutta kaikki kohteet on mainittu. RFQ-lainauksen tilan päivittäminen."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Suurin näytteitä - {0} on jo säilytetty erää {1} ja erää {2} erää {3} varten.
@@ -6099,7 +6127,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Verkkosivun kotisivun asetukset
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} on pidossa kunnes {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},"Tarjouspyynnöt eivät ole sallittuja {0}, koska tuloskortin arvo on {1}"
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,tee ostolasku
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Käytetyt lehdet
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Käytetty kuponki on {1}. Sallittu määrä on käytetty loppuun
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Haluatko lähettää materiaalipyynnön?
 DocType: Job Offer,Awaiting Response,Odottaa vastausta
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6113,6 +6143,7 @@
 DocType: Training Event Employee,Optional,Valinnainen
 DocType: Salary Slip,Earning & Deduction,ansio & vähennys
 DocType: Agriculture Analysis Criteria,Water Analysis,Veden analyysi
+DocType: Sales Order,Skip Delivery Note,Ohita toimitusilmoitus
 DocType: Price List,Price Not UOM Dependent,Hinta ei ole riippuvainen UOM: sta
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} muunnoksia luotu.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Oletuksena oleva palvelutasosopimus on jo olemassa.
@@ -6217,6 +6248,7 @@
 DocType: Vehicle,Last Carbon Check,Viimeksi Carbon Tarkista
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Juridiset kustannukset
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Valitse määrä rivillä
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Työmääräys {0}: työkorttia ei löydy operaatiosta {1}
 DocType: Purchase Invoice,Posting Time,Tositeaika
 DocType: Timesheet,% Amount Billed,% laskutettu arvomäärä
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Puhelinkulut
@@ -6319,7 +6351,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Lisätyt verot ja maksut
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Poistojauhe {0}: Seuraava Poistoaika ei voi olla ennen Käytettävissä olevaa päivämäärää
 ,Sales Funnel,Myyntihankekantaan
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Tuotekoodi&gt; Tuoteryhmä&gt; Tuotemerkki
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Lyhenne on pakollinen
 DocType: Project,Task Progress,tehtävä Progress
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,kori
@@ -6414,6 +6445,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS profiili vaatii POS kirjauksen
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Hyvyyspisteet lasketaan vietyistä (myyntilaskun kautta), jotka perustuvat mainittuun keräyskertoimeen."
 DocType: Program Enrollment Tool,Enroll Students,Ilmoittaudu Opiskelijat
+DocType: Pricing Rule,Coupon Code Based,Kupongikoodi perustuu
 DocType: Company,HRA Settings,HRA-asetukset
 DocType: Homepage,Hero Section,Sankariosa
 DocType: Employee Transfer,Transfer Date,Siirtoaika
@@ -6529,6 +6561,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Aseta Yritysfiltteri tyhjäksi jos Ryhmittelyperuste on &#39;yritys&#39;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Kirjoittamisen päivämäärä ei voi olla tulevaisuudessa
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Rivi # {0}: Sarjanumero {1} ei vastaa {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Asenna läsnäolosuhteiden numerointisarjat kohdasta Asetukset&gt; Numerointisarjat
 DocType: Stock Entry,Target Warehouse Address,Kohdevaraston osoite
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,tavallinen poistuminen
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,"Aika ennen vuoron alkamisaikaa, jonka aikana työntekijän lähtöselvitystä pidetään läsnäolona."
@@ -6563,7 +6596,6 @@
 DocType: Employee Grade,Employee Grade,Työntekijäluokka
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Urakkatyö
 DocType: GSTR 3B Report,June,kesäkuu
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Toimittaja&gt; Toimittajan tyyppi
 DocType: Share Balance,From No,Nro
 DocType: Shift Type,Early Exit Grace Period,Varhaisvaroitusaika
 DocType: Task,Actual Time (in Hours),todellinen aika (tunneissa)
@@ -6854,7 +6886,6 @@
 DocType: Warehouse,Warehouse Name,Varaston nimi
 DocType: Naming Series,Select Transaction,Valitse tapahtuma
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Anna hyväksyminen rooli tai hyväksyminen Käyttäjä
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM-muuntokerrointa ({0} -&gt; {1}) ei löydy tuotteelle: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Palvelutasosopimus entiteettityypin {0} ja kokonaisuuden {1} kanssa on jo olemassa.
 DocType: Journal Entry,Write Off Entry,Poiston kirjaus
 DocType: BOM,Rate Of Materials Based On,Materiaalilaskenta perustuen
@@ -6992,6 +7023,7 @@
 DocType: Budget,Warn,Varoita
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Kaikki kohteet on jo siirretty tähän työjärjestykseen.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","muut huomiot, huomioitavat asiat tulee laittaa tähän tietueeseen"
+DocType: Bank Account,Company Account,Yritystili
 DocType: Asset Maintenance,Manufacturing User,Valmistus peruskäyttäjä
 DocType: Purchase Invoice,Raw Materials Supplied,Raaka-aineet toimitettu
 DocType: Subscription Plan,Payment Plan,Maksusuunnitelma
@@ -7033,6 +7065,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) ei voi olla suurempi kuin suunniteltu määrä ({2}) Työjärjestyksessä {3}
 DocType: Certification Application,Name of Applicant,Hakijan nimi
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Valmistuksen tuntilista
+DocType: Quick Stock Balance,Quick Stock Balance,Nopea varastotase
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Välisumma
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Vaihtoehtoisia ominaisuuksia ei voi muuttaa varastotoiminnan jälkeen. Sinun täytyy tehdä uusi esine tehdä tämä.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA-toimeksianto
@@ -7359,6 +7392,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},Aseta {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} ei ole aktiivinen opiskelija
 DocType: Employee,Health Details,"terveys, lisätiedot"
+DocType: Coupon Code,Coupon Type,Kupongin tyyppi
 DocType: Leave Encashment,Encashable days,Syytettävät päivät
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Luoda maksatuspyyntö viiteasiakirja tarvitaan
 DocType: Soil Texture,Sandy Clay,Sandy Clay
@@ -7641,6 +7675,7 @@
 DocType: Hotel Room Package,Amenities,palveluihin
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Hae maksuehdot automaattisesti
 DocType: QuickBooks Migrator,Undeposited Funds Account,Undeposited Funds Account
+DocType: Coupon Code,Uses,käyttötarkoitukset
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Useita oletusmaksutapoja ei sallita
 DocType: Sales Invoice,Loyalty Points Redemption,Uskollisuuspisteiden lunastus
 ,Appointment Analytics,Nimitys Analytics
@@ -7657,6 +7692,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Kokonaisbudjetti
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Jätä tyhjäksi jos teet opiskelijoiden ryhmää vuodessa
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day",täpättäessä lomapäivät sisältyvät työpäiviin ja tämä lisää palkan avoa / päivä
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Verkkotunnuksen lisääminen epäonnistui
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.",Päivitä &quot;Yli kuitti / toimituskorvaus&quot; varastosäädöissä tai tuotteessa salliaksesi ylivastaanoton / toimituksen.
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Nykyisen avaimen käyttämät sovellukset eivät voi käyttää, oletko varma?"
 DocType: Subscription Settings,Prorate,ositussopimuksen
@@ -7669,6 +7705,7 @@
 ,BOM Stock Report,BOM Stock Report
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Jos määritettyä aikaväliä ei ole, tämä ryhmä hoitaa viestinnän"
 DocType: Stock Reconciliation Item,Quantity Difference,Määrä ero
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Toimittaja&gt; Toimittajan tyyppi
 DocType: Opportunity Item,Basic Rate,perushinta
 DocType: GL Entry,Credit Amount,Luoton määrä
 ,Electronic Invoice Register,Sähköinen laskurekisteri
@@ -7922,6 +7959,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Netto ilman veroja ja kuluja (yrityksen valuutassa)
 DocType: Item Group,General Settings,pääasetukset
 DocType: Article,Article,Artikla
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Anna kuponkikoodi !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Lähde- ja kohdevaluutta eivät voi olla samoja
 DocType: Taxable Salary Slab,Percent Deduction,Prosentuaalinen vähennys
 DocType: GL Entry,To Rename,Nimeä uudelleen
diff --git a/erpnext/translations/fr.csv b/erpnext/translations/fr.csv
index 346765f..67e9885 100644
--- a/erpnext/translations/fr.csv
+++ b/erpnext/translations/fr.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Contact Client
 DocType: Shift Type,Enable Auto Attendance,Activer la présence automatique
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Veuillez entrer entrepôt et date
 DocType: Lost Reason Detail,Opportunity Lost Reason,Raison perdue
 DocType: Patient Appointment,Check availability,Voir les Disponibilités
 DocType: Retention Bonus,Bonus Payment Date,Date de paiement du bonus
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Ordres de travail terminés
 DocType: Support Settings,Forum Posts,Messages du forum
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","La tâche a été mise en file d&#39;attente en tant que tâche en arrière-plan. En cas de problème de traitement en arrière-plan, le système ajoute un commentaire concernant l&#39;erreur sur ce rapprochement des stocks et revient au stade de brouillon."
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Désolé, la validité du code promo n&#39;a pas commencé"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Montant Taxable
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Vous n'êtes pas autorisé à ajouter ou faire une mise à jour des écritures avant le {0}
 DocType: Leave Policy,Leave Policy Details,Détails de la politique de congé
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Consommable
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,Echelon
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Code d&#39;article&gt; Groupe d&#39;articles&gt; Marque
 DocType: Restaurant Table,No of Seats,Nombre de Sièges
 DocType: Sales Invoice,Overdue and Discounted,En retard et à prix réduit
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Appel déconnecté
@@ -506,6 +509,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Espacement des lignes pour le montant en lettres
 DocType: Vehicle,Additional Details,Détails Supplémentaires
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Aucune Description
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Récupérer des articles de l&#39;entrepôt
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Demande d'Achat.
 DocType: POS Closing Voucher Details,Collected Amount,Montant collecté
 DocType: Lab Test,Submitted Date,Date Soumise
@@ -613,6 +617,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Apprendre
 ,Trial Balance (Simple),Balance d&#39;essai (simple)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Activer les frais reportés
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Code de coupon appliqué
 DocType: Asset,Next Depreciation Date,Date de l’Amortissement Suivant
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Coût de l'Activité par Employé
 DocType: Accounts Settings,Settings for Accounts,Paramètres des Comptes
@@ -848,8 +853,6 @@
 DocType: BOM,Work Order,Ordre de Travail
 DocType: Sales Invoice,Total Qty,Qté Totale
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,ID Email du Tuteur2
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Supprimez l&#39;employé <a href=""#Form/Employee/{0}"">{0}</a> \ pour annuler ce document."
 DocType: Item,Show in Website (Variant),Afficher dans le Website (Variant)
 DocType: Employee,Health Concerns,Problèmes de Santé
 DocType: Payroll Entry,Select Payroll Period,Sélectionner la Période de Paie
@@ -1014,6 +1017,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Compte de taxation à la source
 DocType: Pricing Rule,Sales Partner,Partenaire Commercial
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Toutes les Fiches d'Évaluation Fournisseurs.
+DocType: Coupon Code,To be used to get discount,Pour être utilisé pour obtenir une réduction
 DocType: Buying Settings,Purchase Receipt Required,Reçu d’Achat Requis
 DocType: Sales Invoice,Rail,Rail
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Prix actuel
@@ -1064,6 +1068,7 @@
 DocType: Production Plan,Production Plan,Plan de production
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Ouverture de l&#39;outil de création de facture
 DocType: Salary Component,Round to the Nearest Integer,Arrondir à l&#39;entier le plus proche
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Autoriser les articles non en stock à être ajoutés au panier
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Retour de Ventes
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Définir la quantité dans les transactions en fonction des données du numéro de série
 ,Total Stock Summary,Récapitulatif de l'Inventaire Total
@@ -1193,6 +1198,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Taux Horaire de Base (Devise de la Société)
 ,Qty To Be Billed,Qté à facturer
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Montant Livré
+DocType: Coupon Code,Gift Card,Carte cadeau
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Qté réservée à la production: quantité de matières premières permettant de fabriquer des articles de fabrication.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Date de l'échange
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Cette transaction bancaire est déjà totalement réconciliée
@@ -1280,6 +1286,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Créer une feuille de temps
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Le compte {0} a été entré plusieurs fois
 DocType: Account,Expenses Included In Valuation,Charges Incluses dans la Valorisation
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Factures d&#39;achat
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Vous ne pouvez renouveler que si votre abonnement expire dans les 30 jours
 DocType: Shopping Cart Settings,Show Stock Availability,Afficher la disponibilité du stock
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Définissez {0} dans la catégorie d&#39;actifs {1} ou la société {2}
@@ -1839,6 +1846,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Importer des articles et des UOM
 DocType: Repayment Schedule,Balance Loan Amount,Solde du Montant du Prêt
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Ajouté aux détails
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Désolé, le code de coupon est épuisé"
 DocType: Communication Medium,Catch All,Attraper tout
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Cours Calendrier
 DocType: Budget,Applicable on Material Request,Applicable sur la base des requêtes de matériel
@@ -2006,6 +2014,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Attribut Invalide
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} doit être soumis
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Campagnes de courrier électronique
+DocType: Sales Partner,To Track inbound purchase,Pour suivre les achats entrants
 DocType: Buying Settings,Default Supplier Group,Groupe de fournisseurs par défaut
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},La quantité doit être inférieure ou égale à {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Le montant maximal éligible pour le composant {0} dépasse {1}
@@ -2161,8 +2170,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Faire une entrée de stock
 DocType: Hotel Room Reservation,Hotel Reservation User,Utilisateur chargé des réservations d'hôtel
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Définir le statut
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Veuillez configurer les séries de numérotation pour la participation via Configuration&gt; Série de numérotation
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Veuillez d’abord sélectionner un préfixe
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Définissez la série de noms pour {0} via Configuration&gt; Paramètres&gt; Série de noms.
 DocType: Contract,Fulfilment Deadline,Délai d&#39;exécution
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Près de toi
 DocType: Student,O-,O-
@@ -2286,6 +2295,7 @@
 DocType: Quality Meeting Table,Under Review,À l&#39;étude
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Échec de la connexion
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Actif {0} créé
+DocType: Coupon Code,Promotional,Promotionnel
 DocType: Special Test Items,Special Test Items,Articles de Test Spécial
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Vous devez être un utilisateur avec des rôles System Manager et Item Manager pour vous inscrire sur Marketplace.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Rapports clés
@@ -2323,6 +2333,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Type de document
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Pourcentage total attribué à l'équipe commerciale devrait être de 100
 DocType: Subscription Plan,Billing Interval Count,Nombre d&#39;intervalles de facturation
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Supprimez l&#39;employé <a href=""#Form/Employee/{0}"">{0}</a> \ pour annuler ce document."
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Rendez-vous et consultations patients
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Valeur manquante
 DocType: Employee,Department and Grade,Département et échelon
@@ -2425,6 +2437,7 @@
 DocType: Project,Start and End Dates,Dates de Début et de Fin
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Conditions d'exécution du modèle de contrat
 ,Delivered Items To Be Billed,Articles Livrés à Facturer
+DocType: Coupon Code,Maximum Use,Utilisation maximale
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Ouvrir LDM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,L'entrepôt ne peut être modifié pour le N° de Série
 DocType: Authorization Rule,Average Discount,Remise Moyenne
@@ -2586,6 +2599,7 @@
 DocType: Item,Inventory,Inventaire
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Télécharger en Json
 DocType: Item,Sales Details,Détails Ventes
+DocType: Coupon Code,Used,Utilisé
 DocType: Opportunity,With Items,Avec Articles
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',La campagne &#39;{0}&#39; existe déjà pour le {1} &#39;{2}&#39;.
 DocType: Asset Maintenance,Maintenance Team,Équipe de maintenance
@@ -2715,7 +2729,7 @@
 						Serial No cannot be ensured",Aucune nomenclature active trouvée pour l&#39;article {0}. La livraison par \ Serial No ne peut être assurée
 DocType: Sales Partner,Sales Partner Target,Objectif du Partenaire Commercial
 DocType: Loan Type,Maximum Loan Amount,Montant Max du Prêt
-DocType: Pricing Rule,Pricing Rule,Règle de Tarification
+DocType: Coupon Code,Pricing Rule,Règle de Tarification
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Numéro de liste en double pour l'élève {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Demande de Matériel au Bon de Commande
 DocType: Company,Default Selling Terms,Conditions de vente par défaut
@@ -2794,6 +2808,7 @@
 DocType: Payment Schedule,Payment Amount,Montant du paiement
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,La date de la demi-journée doit être comprise entre la date du début du travail et la date de fin du travail
 DocType: Healthcare Settings,Healthcare Service Items,Articles de service de soins de santé
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Code à barres invalide. Il n&#39;y a pas d&#39;article attaché à ce code à barres.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Montant Consommé
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Variation Nette de Trésorerie
 DocType: Assessment Plan,Grading Scale,Échelle de Notation
@@ -2913,7 +2928,6 @@
 DocType: Share Transfer,Asset Account,Compte d&#39;actif
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,La nouvelle date de sortie devrait être dans le futur
 DocType: Purchase Invoice,End date of current invoice's period,Date de fin de la période de facturation en cours
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Veuillez configurer le système de nommage des employés dans Ressources humaines&gt; Paramètres RH
 DocType: Lab Test,Technician Name,Nom du Technicien
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3024,6 +3038,7 @@
 DocType: Products Settings,Hide Variants,Masquer les variantes
 DocType: Lead,Next Contact By,Contact Suivant Par
 DocType: Compensatory Leave Request,Compensatory Leave Request,Demande de congé compensatoire
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","La surfacturation pour le poste {0} dans la ligne {1} ne peut pas dépasser {2}. Pour autoriser la surfacturation, définissez la provision dans les paramètres du compte."
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Quantité requise pour l'Article {0} à la ligne {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},L'entrepôt {0} ne peut pas être supprimé car il existe une quantité pour l'Article {1}
 DocType: Blanket Order,Order Type,Type de Commande
@@ -3193,7 +3208,6 @@
 DocType: Student,Student Mobile Number,Numéro de Mobile de l'Étudiant
 DocType: Item,Has Variants,A Variantes
 DocType: Employee Benefit Claim,Claim Benefit For,Demande de prestations pour
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Impossible de surfacturer plus de {2} pour l'article {0} de la ligne {1}. Pour autoriser la surfacturation, veuillez définir les paramètres du stock."
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Mettre à jour la Réponse
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Vous avez déjà choisi des articles de {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Nom de la Répartition Mensuelle
@@ -3484,6 +3498,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Veuillez spécifier la devise de la Société
 DocType: Workstation,Wages per hour,Salaires par heure
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Configurer {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Client&gt; Groupe de clients&gt; Territoire
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Solde du stock dans le Lot {0} deviendra négatif {1} pour l'Article {2} à l'Entrepôt {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Les Demandes de Matériel suivantes ont été créées automatiquement sur la base du niveau de réapprovisionnement de l’Article
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Le compte {0} est invalide. La Devise du Compte doit être {1}
@@ -3813,6 +3828,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Soumettre la Fiche de Paie
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,En attente
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Une qustion doit avoir au moins une des options correctes
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Acheter en ligne
 DocType: Account,Inter Company Account,Compte inter-sociétés
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Importer en Masse
 DocType: Sales Partner,Address & Contacts,Adresse &amp; Contacts
@@ -3823,6 +3839,7 @@
 DocType: POS Profile,[Select],[Choisir]
 DocType: Staffing Plan Detail,Number Of Positions,Nombre de postes
 DocType: Vital Signs,Blood Pressure (diastolic),Pression Artérielle (Diastolique)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,S&#39;il vous plaît sélectionner le client.
 DocType: SMS Log,Sent To,Envoyé À
 DocType: Agriculture Task,Holiday Management,Gestion des vacances
 DocType: Payment Request,Make Sales Invoice,Faire des Factures de Vente
@@ -4032,7 +4049,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} n'a pas été soumis
 DocType: Subscription,Trialling,Essai
 DocType: Sales Invoice Item,Deferred Revenue,Produits comptabilisés d'avance
-DocType: Bank Account,GL Account,Compte GL
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Le compte de caisse sera utilisé pour la création de la facture de vente
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Sous-catégorie d&#39;exemption
 DocType: Member,Membership Expiry Date,Date d&#39;expiration de l&#39;adhésion
@@ -4456,13 +4472,13 @@
 DocType: C-Form Invoice Detail,Territory,Région
 DocType: Pricing Rule,Apply Rule On Item Code,Appliquer la règle sur le code d&#39;article
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Veuillez indiquer le nb de visites requises
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Rapport de solde des stocks
 DocType: Stock Settings,Default Valuation Method,Méthode de Valorisation par Défaut
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Frais
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Afficher le montant cumulatif
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Mise à jour en cours. Ça peut prendre un moment.
 DocType: Production Plan Item,Produced Qty,Quantité produite
 DocType: Vehicle Log,Fuel Qty,Qté Carburant
-DocType: Stock Entry,Target Warehouse Name,Nom de l&#39;entrepôt cible
 DocType: Work Order Operation,Planned Start Time,Heure de Début Prévue
 DocType: Course,Assessment,Évaluation
 DocType: Payment Entry Reference,Allocated,Alloué
@@ -4540,10 +4556,12 @@
 7. Règlement des litiges, indemnisation, responsabilité, etc. 
 8. Adresse et Contact de votre Société."
 DocType: Homepage Section,Section Based On,Section basée sur
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Afficher appliquer le code de coupon
 DocType: Issue,Issue Type,Type de ticket
 DocType: Attendance,Leave Type,Type de Congé
 DocType: Purchase Invoice,Supplier Invoice Details,Détails de la Facture du Fournisseur
 DocType: Agriculture Task,Ignore holidays,Ignorer les vacances
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Ajouter / Modifier les conditions du coupon
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Compte de Charge / d'Écart ({0}) doit être un Compte «de Résultat»
 DocType: Stock Entry Detail,Stock Entry Child,Entrée de stock enfant
 DocType: Project,Copied From,Copié Depuis
@@ -4718,6 +4736,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Critères du Plan d'Évaluation
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Transactions
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Interdire les Bons de Commande d'Achat
+DocType: Coupon Code,Coupon Name,Nom du coupon
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Sensible
 DocType: Email Campaign,Scheduled,Prévu
 DocType: Shift Type,Working Hours Calculation Based On,Calcul des heures de travail basé sur
@@ -4734,7 +4753,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Créer des variantes
 DocType: Vehicle,Diesel,Diesel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Devise de la Liste de Prix non sélectionnée
+DocType: Quick Stock Balance,Available Quantity,quantité disponible
 DocType: Purchase Invoice,Availed ITC Cess,ITC Cess utilisé
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Veuillez configurer le système de nommage des instructeurs dans Education&gt; Paramètres de formation
 ,Student Monthly Attendance Sheet,Feuille de Présence Mensuelle des Étudiants
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Règle d&#39;expédition applicable uniquement pour la vente
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Ligne d&#39;amortissement {0}: La date d&#39;amortissement suivante ne peut pas être antérieure à la date d&#39;achat
@@ -4801,8 +4822,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Ligne {0} : L’Avance du Client doit être un crédit
 DocType: Quality Meeting,Quality Meeting,Réunion de qualité
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-Groupe à Groupe
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Définissez la série de noms pour {0} via Configuration&gt; Paramètres&gt; Série de noms.
 DocType: Employee,ERPNext User,Utilisateur ERPNext
+DocType: Coupon Code,Coupon Description,Description du coupon
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Le lot est obligatoire dans la ligne {0}
 DocType: Company,Default Buying Terms,Conditions d&#39;achat par défaut
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Articles Fournis du Reçus d’Achat
@@ -4965,6 +4986,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Pour le Détail du Document N°
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},La suppression n&#39;est pas autorisée pour le pays {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Type de Tiers Obligatoire
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Appliquer le code de coupon
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","Pour la carte de travail {0}, vous pouvez uniquement saisir une entrée de stock de type &quot;Transfert d&#39;article pour fabrication&quot;."
 DocType: Quality Inspection,Outgoing,Sortant
 DocType: Customer Feedback Table,Customer Feedback Table,Tableau de commentaires des clients
@@ -5114,7 +5136,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Sur soumission de commande
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Ajouter tous les Fournisseurs
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Ligne # {0}: montant attribué ne peut pas être supérieur au montant en souffrance.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Client&gt; Groupe de clients&gt; Territoire
 DocType: Tally Migration,Parties,Des soirées
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Parcourir la LDM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Prêts Garantis
@@ -5146,7 +5167,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Ne permet pas de définir un autre article pour l'article {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,La Date est répétée
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Signataire Autorisé
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Veuillez configurer le système de nommage des instructeurs dans Education&gt; Paramètres de formation
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),CTI net disponible (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Créer des Honoraires
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Coût d'Achat Total (via Facture d'Achat)
@@ -5171,6 +5191,7 @@
 DocType: Quiz Result,Wrong,Faux
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Taux auquel la devise de la Liste de prix est convertie en devise du client de base
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Montant Net (Devise Société)
+DocType: Sales Partner,Referral Code,Code de Parrainage
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Le montant total de l'avance ne peut être supérieur au montant total approuvé
 DocType: Salary Slip,Hour Rate,Tarif Horaire
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Activer la re-commande automatique
@@ -5299,6 +5320,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Afficher la quantité en stock
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Trésorerie Nette des Opérations
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Ligne n ° {0}: l&#39;état doit être {1} pour l&#39;actualisation de facture {2}.
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Facteur de conversion UOM ({0} -&gt; {1}) introuvable pour l&#39;élément: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Article 4
 DocType: Student Admission,Admission End Date,Date de Fin de l'Admission
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Sous-traitant
@@ -5321,6 +5343,7 @@
 DocType: Travel Request,Fully Sponsored,Entièrement commandité
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Ecriture de journal de contre-passation
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Créer une carte de travail
+DocType: Quotation,Referral Sales Partner,Partenaire commercial de référence
 DocType: Quality Procedure Process,Process Description,Description du processus
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Le client {0} est créé.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,"Actuellement, aucun stock disponible dans aucun entrepôt"
@@ -5455,6 +5478,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,Taux LDM
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Lecture du fichier téléchargé
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Un ordre de travail arrêté ne peut être annulé, Re-démarrez le pour pouvoir l'annuler"
+DocType: Coupon Code,Coupon Code,Code de coupon
 DocType: Asset,Journal Entry for Scrap,Écriture de Journal pour la Mise au Rebut
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Veuillez récupérer les articles des Bons de Livraison
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Ligne {0}: sélectionnez le poste de travail en fonction de l&#39;opération {1}
@@ -5537,6 +5561,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;Date&#39; est requis
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Date d’échéance / de référence ne peut pas être après le {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Importer et Exporter des Données
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Désolé, la validité du code promo a expiré"
 DocType: Bank Account,Account Details,Détails du compte
 DocType: Crop,Materials Required,Matériaux nécessaires
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Aucun étudiant Trouvé
@@ -5574,6 +5599,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Aller aux Utilisateurs
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Le Montant Payé + Montant Repris ne peut pas être supérieur au Total Général
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} n'est pas un Numéro de Lot valide pour l’Article {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Veuillez entrer un code de coupon valide !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Remarque : Le solde de congé est insuffisant pour le Type de Congé {0}
 DocType: Task,Task Description,Description de la tâche
 DocType: Training Event,Seminar,Séminaire
@@ -5837,6 +5863,7 @@
 ,TDS Payable Monthly,TDS Payable Monthly
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,En file d'attente pour remplacer la LDM. Cela peut prendre quelques minutes.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Déduction impossible lorsque la catégorie est pour 'Évaluation' ou 'Vaulation et Total'
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Veuillez configurer le système de nommage des employés dans Ressources humaines&gt; Paramètres RH
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Total des paiements
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},N° de Séries Requis pour Article Sérialisé {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Rapprocher les Paiements avec les Factures
@@ -5926,6 +5953,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Obtenir des matières premières pour la production
 DocType: Job Opening,Job Title,Titre de l'Emploi
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Paiement futur Ref
+DocType: Quotation,Additional Discount and Coupon Code,Code de réduction et de coupon supplémentaire
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} indique que {1} ne fournira pas de devis, mais tous les articles \ ont été évalués. Mise à jour du statut de devis RFQ."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Nombre maximum d&#39;échantillons - {0} ont déjà été conservés pour le lot {1} et l&#39;article {2} dans le lot {3}.
@@ -6153,7 +6181,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Paramètres de la page d'accueil du site
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} est en attente jusqu&#39;à {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},Les Appels d'Offres ne sont pas autorisés pour {0} en raison d'une note de {1} sur la fiche d'évaluation
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Faire la facture d'achat
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Congés utilisés
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,Le {0} coupon utilisé est {1}. La quantité autorisée est épuisée
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Voulez-vous soumettre la demande de matériel
 DocType: Job Offer,Awaiting Response,Attente de Réponse
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.AAAA.-
@@ -6167,6 +6197,7 @@
 DocType: Training Event Employee,Optional,Optionnel
 DocType: Salary Slip,Earning & Deduction,Revenus et Déduction
 DocType: Agriculture Analysis Criteria,Water Analysis,Analyse de l&#39;eau
+DocType: Sales Order,Skip Delivery Note,Ignorer le bon de livraison
 DocType: Price List,Price Not UOM Dependent,Prix non dépendant de l&#39;UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} variantes créées.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Un accord de niveau de service par défaut existe déjà.
@@ -6271,6 +6302,7 @@
 DocType: Vehicle,Last Carbon Check,Dernière Vérification Carbone
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Frais Juridiques
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Veuillez sélectionner la quantité sur la ligne
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Bon de travail {0}: carte de travail non trouvée pour l&#39;opération {1}
 DocType: Purchase Invoice,Posting Time,Heure de Publication
 DocType: Timesheet,% Amount Billed,% Montant Facturé
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Frais Téléphoniques
@@ -6373,7 +6405,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Taxes et Frais Additionnels
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Ligne d'amortissement {0}: La date d'amortissement suivante ne peut pas être antérieure à la date de mise en service
 ,Sales Funnel,Entonnoir de Vente
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Code d&#39;article&gt; Groupe d&#39;articles&gt; Marque
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Abréviation est obligatoire
 DocType: Project,Task Progress,Progression de la Tâche
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Panier
@@ -6468,6 +6499,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,Profil PDV nécessaire pour faire une écriture de PDV
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Les points de fidélité seront calculés à partir des dépenses effectuées (via la facture), en fonction du facteur de collecte sélectionné."
 DocType: Program Enrollment Tool,Enroll Students,Inscrire des Étudiants
+DocType: Pricing Rule,Coupon Code Based,Code de coupon basé
 DocType: Company,HRA Settings,Paramètres de l'allocation logement (HRA)
 DocType: Homepage,Hero Section,Section de héros
 DocType: Employee Transfer,Transfer Date,Date de transfert
@@ -6583,6 +6615,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Veuillez laisser le filtre de la Société vide si Group By est 'Société'
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,La Date de Publication ne peut pas être une date future
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Ligne # {0} : N° de série {1} ne correspond pas à {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Veuillez configurer les séries de numérotation pour la participation via Configuration&gt; Série de numérotation
 DocType: Stock Entry,Target Warehouse Address,Adresse de l&#39;entrepôt cible
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Congé Occasionnel
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,Heure avant l&#39;heure de début du quart pendant laquelle l&#39;enregistrement des employés est pris en compte pour la présence.
@@ -6617,7 +6650,6 @@
 DocType: Employee Grade,Employee Grade,Echelon des employés
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Travail à la Pièce
 DocType: GSTR 3B Report,June,juin
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Fournisseur&gt; Type de fournisseur
 DocType: Share Balance,From No,Du No
 DocType: Shift Type,Early Exit Grace Period,Période de grâce de sortie anticipée
 DocType: Task,Actual Time (in Hours),Temps Réel (en Heures)
@@ -6903,7 +6935,6 @@
 DocType: Warehouse,Warehouse Name,Nom de l'Entrepôt
 DocType: Naming Series,Select Transaction,Sélectionner la Transaction
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Veuillez entrer un Rôle Approbateur ou un Rôle Utilisateur
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Facteur de conversion UOM ({0} -&gt; {1}) introuvable pour l&#39;élément: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,L&#39;accord de niveau de service avec le type d&#39;entité {0} et l&#39;entité {1} existe déjà.
 DocType: Journal Entry,Write Off Entry,Écriture de Reprise
 DocType: BOM,Rate Of Materials Based On,Prix des Matériaux Basé sur
@@ -7041,6 +7072,7 @@
 DocType: Budget,Warn,Avertir
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Tous les articles ont déjà été transférés pour cet ordre de travail.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Toute autre remarque, effort remarquable qui devrait aller dans les dossiers."
+DocType: Bank Account,Company Account,Compte d&#39;entreprise
 DocType: Asset Maintenance,Manufacturing User,Chargé de Production
 DocType: Purchase Invoice,Raw Materials Supplied,Matières Premières Fournies
 DocType: Subscription Plan,Payment Plan,Plan de paiement
@@ -7082,6 +7114,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) ne peut pas être supérieur à la quantité planifiée ({2}) dans l'ordre de travail {3}
 DocType: Certification Application,Name of Applicant,Nom du candidat
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Feuille de Temps pour la production.
+DocType: Quick Stock Balance,Quick Stock Balance,Solde rapide des stocks
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Sous-Total
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Impossible de modifier les propriétés de variante après une transaction de stock. Vous devrez créer un nouvel article pour pouvoir le faire.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,Mandat SEPA GoCardless
@@ -7407,6 +7440,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},Veuillez définir {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} est un étudiant inactif
 DocType: Employee,Health Details,Détails de Santé
+DocType: Coupon Code,Coupon Type,Type de coupon
 DocType: Leave Encashment,Encashable days,Jours encaissables
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,"Pour créer une Demande de Paiement, un document de référence est requis"
 DocType: Soil Texture,Sandy Clay,Argile sableuse
@@ -7689,6 +7723,7 @@
 DocType: Hotel Room Package,Amenities,Équipements
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Récupérer automatiquement les conditions de paiement
 DocType: QuickBooks Migrator,Undeposited Funds Account,Compte de fonds non déposés
+DocType: Coupon Code,Uses,Les usages
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,De multiples modes de paiement par défaut ne sont pas autorisés
 DocType: Sales Invoice,Loyalty Points Redemption,Utilisation des points de fidélité
 ,Appointment Analytics,Analyse des Rendez-Vous
@@ -7705,6 +7740,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Budget total
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Laisser vide si vous faites des groupes d'étudiants par année
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Si cochée, Le nombre total de Jours Ouvrés comprendra les vacances, ce qui réduira la valeur du Salaire Par Jour"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Impossible d&#39;ajouter le domaine
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Pour autoriser le dépassement de réception / livraison, mettez à jour &quot;Limite de dépassement de réception / livraison&quot; dans les paramètres de stock ou le poste."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Les applications utilisant la clé actuelle ne pourront plus y accéder, êtes-vous sûr?"
 DocType: Subscription Settings,Prorate,Calculer au prorata
@@ -7717,6 +7753,7 @@
 ,BOM Stock Report,Rapport de Stock de LDM
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","S&#39;il n&#39;y a pas d&#39;intervalle de temps attribué, la communication sera gérée par ce groupe."
 DocType: Stock Reconciliation Item,Quantity Difference,Différence de Quantité
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Fournisseur&gt; Type de fournisseur
 DocType: Opportunity Item,Basic Rate,Taux de Base
 DocType: GL Entry,Credit Amount,Montant du Crédit
 ,Electronic Invoice Register,Registre de facture électronique
@@ -7970,6 +8007,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Taxes et Frais Déductibles (Devise Société)
 DocType: Item Group,General Settings,Paramètres Généraux
 DocType: Article,Article,Article
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,S&#39;il vous plaît entrer le code coupon !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,La Devise de Base et la Devise de Cotation ne peuvent pas identiques
 DocType: Taxable Salary Slab,Percent Deduction,Pourcentage de déduction
 DocType: GL Entry,To Rename,Renommer
diff --git a/erpnext/translations/gu.csv b/erpnext/translations/gu.csv
index d1d98ac..eb35e24 100644
--- a/erpnext/translations/gu.csv
+++ b/erpnext/translations/gu.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,મેટ-ડીટી-. વાયવાયવાય.-
 DocType: Purchase Order,Customer Contact,ગ્રાહક સંપર્ક
 DocType: Shift Type,Enable Auto Attendance,Autoટો હાજરીને સક્ષમ કરો
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,કૃપા કરીને વેરહાઉસ અને તારીખ દાખલ કરો
 DocType: Lost Reason Detail,Opportunity Lost Reason,તકો ગુમાવેલ કારણ
 DocType: Patient Appointment,Check availability,ઉપલબ્ધતા તપાસો
 DocType: Retention Bonus,Bonus Payment Date,બોનસ ચુકવણી તારીખ
@@ -262,6 +263,7 @@
 ,Completed Work Orders,પૂર્ણ કાર્ય ઓર્ડર્સ
 DocType: Support Settings,Forum Posts,ફોરમ પોસ્ટ્સ
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","કાર્યને પૃષ્ઠભૂમિની નોકરી તરીકે ગોઠવવામાં આવ્યું છે. પૃષ્ઠભૂમિમાં પ્રક્રિયા કરવામાં કોઈ સમસ્યા હોવાના કિસ્સામાં, સિસ્ટમ આ સ્ટોક સમાધાન પરની ભૂલ વિશે ટિપ્પણી ઉમેરશે અને ડ્રાફ્ટ સ્ટેજ પર પાછા આવશે."
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","માફ કરશો, કૂપન કોડ માન્યતા પ્રારંભ થઈ નથી"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,કરપાત્ર રકમ
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},જો તમે પહેલાં પ્રવેશો ઉમેરવા અથવા અપડેટ કરવા માટે અધિકૃત નથી {0}
 DocType: Leave Policy,Leave Policy Details,નીતિ વિગતો છોડો
@@ -326,6 +328,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,ઉપભોજ્ય
 DocType: Student,B-,બી
 DocType: Assessment Result,Grade,ગ્રેડ
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,આઇટમ કોડ&gt; આઇટમ જૂથ&gt; બ્રાન્ડ
 DocType: Restaurant Table,No of Seats,બેઠકોની સંખ્યા
 DocType: Sales Invoice,Overdue and Discounted,ઓવરડ્યુ અને ડિસ્કાઉન્ટેડ
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,ક Callલ ડિસ્કનેક્ટેડ
@@ -501,6 +504,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,શબ્દોમાં રકમ માટે લાઇન અંતર
 DocType: Vehicle,Additional Details,વધારાની વિગતો
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,આપવામાં કોઈ વર્ણન
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,વેરહાઉસમાંથી આઇટમ્સ લાવો
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,ખરીદી માટે વિનંતી.
 DocType: POS Closing Voucher Details,Collected Amount,એકત્રિત રકમ
 DocType: Lab Test,Submitted Date,સબમિટ કરેલી તારીખ
@@ -607,6 +611,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,જાણો
 ,Trial Balance (Simple),ટ્રાયલ બેલેન્સ (સરળ)
 DocType: Purchase Invoice Item,Enable Deferred Expense,ડિફરર્ડ ખર્ચ સક્ષમ કરો
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,લાગુ કુપન કોડ
 DocType: Asset,Next Depreciation Date,આગળ અવમૂલ્યન તારીખ
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,કર્મચારી દીઠ પ્રવૃત્તિ કિંમત
 DocType: Accounts Settings,Settings for Accounts,એકાઉન્ટ્સ માટે સુયોજનો
@@ -837,8 +842,6 @@
 DocType: BOM,Work Order,વર્ક ઓર્ડર
 DocType: Sales Invoice,Total Qty,કુલ Qty
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 ઇમેઇલ આઈડી
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","કૃપા કરીને આ દસ્તાવેજ રદ કરવા માટે કર્મચારી <a href=""#Form/Employee/{0}"">{0}</a> delete કા deleteી નાખો"
 DocType: Item,Show in Website (Variant),વેબસાઇટ બતાવો (variant)
 DocType: Employee,Health Concerns,આરોગ્ય ચિંતા
 DocType: Payroll Entry,Select Payroll Period,પગારપત્રક અવધિ પસંદ
@@ -1000,6 +1003,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,ટેક્સ રોકવાનો એકાઉન્ટ
 DocType: Pricing Rule,Sales Partner,વેચાણ ભાગીદાર
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,બધા પુરવઠોકર્તા સ્કોરકાર્ડ્સ.
+DocType: Coupon Code,To be used to get discount,ડિસ્કાઉન્ટ મેળવવા માટે ઉપયોગમાં લેવાય છે
 DocType: Buying Settings,Purchase Receipt Required,ખરીદી રસીદ જરૂરી
 DocType: Sales Invoice,Rail,રેલ
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,વાસ્તવિક કિંમત
@@ -1049,6 +1053,7 @@
 DocType: Production Plan,Production Plan,ઉત્પાદન યોજના
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,ઇન્વોઇસ બનાવટ ટૂલ ખુલે છે
 DocType: Salary Component,Round to the Nearest Integer,નજીકના પૂર્ણાંક માટેનો ગોળ
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,સ્ટોકમાં ન હોય તેવી આઇટમ્સને કાર્ટમાં ઉમેરવાની મંજૂરી આપો
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,વેચાણ પરત
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,સીરીઅલ ઇનપુટ પર આધારિત વ્યવહારોમાં જથ્થો સેટ કરો
 ,Total Stock Summary,કુલ સ્ટોક સારાંશ
@@ -1175,6 +1180,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),આધાર કલાક રેટ (કંપની ચલણ)
 ,Qty To Be Billed,બીટી બરાબર ક્વોટી
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,વિતરિત રકમ
+DocType: Coupon Code,Gift Card,ગિફ્ટ કાર્ડ
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,ઉત્પાદન માટે અનામત ક્વોટી: ઉત્પાદન વસ્તુઓ બનાવવા માટે કાચી સામગ્રીનો જથ્થો.
 DocType: Loyalty Point Entry Redemption,Redemption Date,રીડેમ્પશન તારીખ
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,આ બેંક વ્યવહાર પહેલાથી સંપૂર્ણ રીતે સમાધાન થયેલ છે
@@ -1261,6 +1267,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,ટાઇમ્સશીટ બનાવો
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,એકાઉન્ટ {0} ઘણી વખત દાખલ કરવામાં આવી છે
 DocType: Account,Expenses Included In Valuation,ખર્ચ વેલ્યુએશનમાં સમાવાયેલ
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,ઇન્વicesઇસેસ ખરીદો
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,જો તમારી સદસ્યતા 30 દિવસની અંદર સમાપ્ત થઈ જાય તો તમે માત્ર રિન્યુ કરી શકો છો
 DocType: Shopping Cart Settings,Show Stock Availability,સ્ટોક ઉપલબ્ધતા બતાવો
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},એસેટ કેટેગરી {1} અથવા કંપનીમાં {0} સેટ કરો {2}
@@ -1797,6 +1804,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,આઇટમ્સ અને યુઓએમ આયાત કરી રહ્યું છે
 DocType: Repayment Schedule,Balance Loan Amount,બેલેન્સ લોન રકમ
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,વિગતોમાં ઉમેરાઈ
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","માફ કરશો, કૂપન કોડ ખતમ થઈ ગયો છે"
 DocType: Communication Medium,Catch All,બધા બો
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,સૂચિ કોર્સ
 DocType: Budget,Applicable on Material Request,ભૌતિક વિનંતી પર લાગુ
@@ -1964,6 +1972,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,અમાન્ય એટ્રીબ્યુટ
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} સબમિટ હોવું જ જોઈએ
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,ઇમેઇલ ઝુંબેશ
+DocType: Sales Partner,To Track inbound purchase,ઇનબાઉન્ડ ખરીદીને ટ્રેક કરવા
 DocType: Buying Settings,Default Supplier Group,ડિફોલ્ટ સપ્લાયર ગ્રુપ
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},જથ્થો કરતાં ઓછી અથવા સમાન હોવા જ જોઈએ {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},ઘટક {0} માટે લાયક મહત્તમ રકમ {1} થી વધી જાય છે
@@ -2116,7 +2125,6 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,સ્ટોક એન્ટ્રી કરો
 DocType: Hotel Room Reservation,Hotel Reservation User,હોટેલ રિઝર્વેશન યુઝર
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,સ્થિતિ સેટ કરો
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,કૃપા કરીને સેટઅપ&gt; નંબરિંગ સિરીઝ દ્વારા હાજરી માટે નંબરિંગ શ્રેણી સેટ કરો
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,પ્રથમ ઉપસર્ગ પસંદ કરો
 DocType: Contract,Fulfilment Deadline,સમાપ્તિની છેલ્લી તારીખ
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,તમારી નજીક
@@ -2240,6 +2248,7 @@
 DocType: Quality Meeting Table,Under Review,સમીક્ષા હેઠળ
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,લૉગિન કરવામાં નિષ્ફળ
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,સંપત્તિ {0} બનાવી
+DocType: Coupon Code,Promotional,પ્રમોશનલ
 DocType: Special Test Items,Special Test Items,ખાસ ટેસ્ટ આઈટમ્સ
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,તમે બજાર પર રજીસ્ટર કરવા માટે સિસ્ટમ મેનેજર અને આઇટમ મેનેજર ભૂમિકાઓ સાથે વપરાશકર્તા બનવાની જરૂર છે.
 apps/erpnext/erpnext/config/buying.py,Key Reports,કી અહેવાલો
@@ -2277,6 +2286,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,ડૉક પ્રકાર
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,વેચાણ ટીમ માટે કુલ ફાળવેલ ટકાવારી 100 પ્રયત્ન કરીશું
 DocType: Subscription Plan,Billing Interval Count,બિલિંગ અંતરાલ ગણક
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","કૃપા કરીને આ દસ્તાવેજ રદ કરવા માટે કર્મચારી <a href=""#Form/Employee/{0}"">{0}</a> delete કા deleteી નાખો"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,નિમણૂંકો અને પેશન્ટ એન્કાઉન્ટર
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,મૂલ્ય ખૂટે છે
 DocType: Employee,Department and Grade,વિભાગ અને ગ્રેડ
@@ -2376,6 +2387,7 @@
 DocType: Project,Start and End Dates,શરૂ કરો અને તારીખો અંત
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,કોન્ટ્રેક્ટ ઢાંચો પૂર્તિ શરતો
 ,Delivered Items To Be Billed,વિતરિત વસ્તુઓ બિલ કરવા
+DocType: Coupon Code,Maximum Use,મહત્તમ ઉપયોગ
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},ઓપન BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,વેરહાઉસ સીરીયલ નંબર માટે બદલી શકાતું નથી
 DocType: Authorization Rule,Average Discount,સરેરાશ ડિસ્કાઉન્ટ
@@ -2535,6 +2547,7 @@
 DocType: Item,Inventory,ઈન્વેન્ટરી
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,જેસન તરીકે ડાઉનલોડ કરો
 DocType: Item,Sales Details,સેલ્સ વિગતો
+DocType: Coupon Code,Used,વપરાયેલ
 DocType: Opportunity,With Items,વસ્તુઓ સાથે
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',ઝુંબેશ &#39;{0}&#39; પહેલાથી જ {1} &#39;{2}&#39; માટે અસ્તિત્વમાં છે
 DocType: Asset Maintenance,Maintenance Team,જાળવણી ટીમ
@@ -2661,7 +2674,7 @@
 						Serial No cannot be ensured",આઇટમ {0} માટે કોઈ સક્રિય BOM મળી નથી. \ Serial No દ્વારા ડિલિવરીની ખાતરી કરી શકાતી નથી
 DocType: Sales Partner,Sales Partner Target,વેચાણ ભાગીદાર લક્ષ્યાંક
 DocType: Loan Type,Maximum Loan Amount,મહત્તમ લોન રકમ
-DocType: Pricing Rule,Pricing Rule,પ્રાઇસીંગ નિયમ
+DocType: Coupon Code,Pricing Rule,પ્રાઇસીંગ નિયમ
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},વિદ્યાર્થી માટે ડુપ્લિકેટ રોલ નંબર {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,ઓર્ડર ખરીદી સામગ્રી વિનંતી
 DocType: Company,Default Selling Terms,ડિફોલ્ટ વેચવાની શરતો
@@ -2738,6 +2751,7 @@
 DocType: Payment Schedule,Payment Amount,ચુકવણી રકમ
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,અર્ધ દિવસની તારીખ કાર્ય તારીખથી અને કાર્ય સમાપ્તિ તારીખ વચ્ચે હોવી જોઈએ
 DocType: Healthcare Settings,Healthcare Service Items,હેલ્થકેર સેવા આઈટમ્સ
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,અમાન્ય બારકોડ. આ બારકોડ સાથે કોઈ આઇટમ જોડાયેલ નથી.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,કમ્પોનન્ટ રકમ
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,કેશ કુલ ફેરફાર
 DocType: Assessment Plan,Grading Scale,ગ્રેડીંગ સ્કેલ
@@ -2855,7 +2869,6 @@
 DocType: Share Transfer,Asset Account,એસેટ એકાઉન્ટ
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,નવી પ્રકાશન તારીખ ભવિષ્યમાં હોવી જોઈએ
 DocType: Purchase Invoice,End date of current invoice's period,વર્તમાન ભરતિયું માતાનો સમયગાળા ઓવરને અંતે તારીખ
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,કૃપા કરીને માનવ સંસાધન&gt; એચઆર સેટિંગ્સમાં કર્મચારી નામકરણ સિસ્ટમ સેટ કરો
 DocType: Lab Test,Technician Name,ટેક્નિશિયન નામ
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3128,7 +3141,6 @@
 DocType: Student,Student Mobile Number,વિદ્યાર્થી મોબાઇલ નંબર
 DocType: Item,Has Variants,ચલો છે
 DocType: Employee Benefit Claim,Claim Benefit For,દાવાના લાભ માટે
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","{2} કરતાં વધુ [{1}} પંક્તિમાં આઇટમ {0} માટે વધુપડતું નથી. ઓવર-બિલિંગને મંજૂરી આપવા માટે, કૃપા કરીને સ્ટોક સેટિંગ્સમાં સેટ કરો"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,પ્રતિભાવ અપડેટ કરો
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},જો તમે પહેલાથી જ વસ્તુઓ પસંદ કરેલ {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,માસિક વિતરણ નામ
@@ -3413,6 +3425,7 @@
 DocType: Vehicle,Fuel Type,ફ્યુઅલ પ્રકાર
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,કંપની ચલણ સ્પષ્ટ કરો
 DocType: Workstation,Wages per hour,કલાક દીઠ વેતન
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,ગ્રાહક&gt; ગ્રાહક જૂથ&gt; ક્ષેત્ર
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},બેચ સ્ટોક બેલેન્સ {0} બનશે નકારાત્મક {1} વેરહાઉસ ખાતે વસ્તુ {2} માટે {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,સામગ્રી અરજીઓ નીચેની આઇટમ ફરીથી ક્રમમાં સ્તર પર આધારિત આપોઆપ ઊભા કરવામાં આવ્યા છે
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},એકાઉન્ટ {0} અમાન્ય છે. એકાઉન્ટ કરન્સી હોવા જ જોઈએ {1}
@@ -3742,6 +3755,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,પગાર સ્લિપ રજુ
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,હોલ્ડ પર
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,ક્યુશનમાં ઓછામાં ઓછા એક સાચા વિકલ્પો હોવા આવશ્યક છે
+apps/erpnext/erpnext/hooks.py,Purchase Orders,ખરીદી ઓર્ડર
 DocType: Account,Inter Company Account,ઇન્ટર કંપની એકાઉન્ટ
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,બલ્ક આયાત
 DocType: Sales Partner,Address & Contacts,સરના સંપર્કો
@@ -3752,6 +3766,7 @@
 DocType: POS Profile,[Select],[પસંદ કરો]
 DocType: Staffing Plan Detail,Number Of Positions,સ્થાનોની સંખ્યા
 DocType: Vital Signs,Blood Pressure (diastolic),બ્લડ પ્રેશર (ડાયાસ્ટોલિક)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,કૃપા કરીને ગ્રાહક પસંદ કરો.
 DocType: SMS Log,Sent To,મોકલવામાં
 DocType: Agriculture Task,Holiday Management,હોલીડે મેનેજમેન્ટ
 DocType: Payment Request,Make Sales Invoice,સેલ્સ ભરતિયું બનાવો
@@ -3958,7 +3973,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} અપર્ણ ન કરાય
 DocType: Subscription,Trialling,ટ્રાયલિંગ
 DocType: Sales Invoice Item,Deferred Revenue,વિલંબિત આવક
-DocType: Bank Account,GL Account,જીએલ એકાઉન્ટ
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,કેશ એકાઉન્ટ સેલ્સ ઇન્વૉઇસ બનાવટ માટે ઉપયોગમાં લેવાશે
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,મુક્તિ ઉપ વર્ગ
 DocType: Member,Membership Expiry Date,સભ્યપદ સમાપ્તિ તારીખ
@@ -4355,13 +4369,13 @@
 DocType: C-Form Invoice Detail,Territory,પ્રદેશ
 DocType: Pricing Rule,Apply Rule On Item Code,આઇટમ કોડ પર નિયમ લાગુ કરો
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,જરૂરી મુલાકાત કોઈ ઉલ્લેખ કરો
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,સ્ટોક બેલેન્સ રિપોર્ટ
 DocType: Stock Settings,Default Valuation Method,મૂળભૂત મૂલ્યાંકન પદ્ધતિ
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,ફી
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,સંચયિત રકમ બતાવો
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,અપડેટ પ્રગતિમાં છે તેમાં થોડો સમય લાગી શકે છે
 DocType: Production Plan Item,Produced Qty,ઉત્પાદન જથ્થો
 DocType: Vehicle Log,Fuel Qty,ફ્યુઅલ Qty
-DocType: Stock Entry,Target Warehouse Name,ટાર્ગેટ વેરહાઉસ નામ
 DocType: Work Order Operation,Planned Start Time,આયોજિત પ્રારંભ સમય
 DocType: Course,Assessment,આકારણી
 DocType: Payment Entry Reference,Allocated,સોંપાયેલ
@@ -4427,10 +4441,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","સ્ટાન્ડર્ડ નિયમો અને વેચાણ અને ખરીદી માટે ઉમેરી શકાય છે કે શરતો. ઉદાહરણો: આ ઓફર 1. માન્યતા. 1. ચુકવણી શરતો (ક્રેડિટ પર અગાઉથી, ભાગ અગાઉથી વગેરે). 1. વધારાની (અથવા ગ્રાહક દ્વારા ચૂકવવાપાત્ર છે) છે. 1. સુરક્ષા / વપરાશ ચેતવણી. 1. વોરંટી કોઈ હોય તો. 1. નીતિ આપે છે. શીપીંગ 1. શરતો લાગુ પડતું હોય તો. વિવાદો સંબોધન, ક્ષતિપૂર્તિ, જવાબદારી 1. રીતો, વગેરે 1. સરનામું અને તમારી કંપની સંપર્ક."
 DocType: Homepage Section,Section Based On,વિભાગ આધારિત પર
+DocType: Shopping Cart Settings,Show Apply Coupon Code,લાગુ કૂપન કોડ બતાવો
 DocType: Issue,Issue Type,ઇશ્યૂ પ્રકાર
 DocType: Attendance,Leave Type,રજા પ્રકાર
 DocType: Purchase Invoice,Supplier Invoice Details,પુરવઠોકર્તા ઇન્વૉઇસ વિગતો
 DocType: Agriculture Task,Ignore holidays,રજાઓ અવગણો
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,કૂપન શરતો ઉમેરો / સંપાદિત કરો
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,ખર્ચ / તફાવત એકાઉન્ટ ({0}) એક &#39;નફો અથવા નુકસાન ખાતામાં હોવા જ જોઈએ
 DocType: Stock Entry Detail,Stock Entry Child,સ્ટોક એન્ટ્રી ચાઇલ્ડ
 DocType: Project,Copied From,નકલ
@@ -4601,6 +4617,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,આકારણી યોજના માપદંડ
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,વ્યવહારો
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,ખરીદી ઓર્ડર્સ અટકાવો
+DocType: Coupon Code,Coupon Name,કૂપન નામ
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,સંવેદનશીલ
 DocType: Email Campaign,Scheduled,અનુસૂચિત
 DocType: Shift Type,Working Hours Calculation Based On,વર્કિંગ અવર્સ ગણતરી પર આધારિત
@@ -4617,7 +4634,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,ચલો બનાવો
 DocType: Vehicle,Diesel,ડીઝલ
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,ભાવ યાદી કરન્સી પસંદ નહી
+DocType: Quick Stock Balance,Available Quantity,ઉપલબ્ધ જથ્થો
 DocType: Purchase Invoice,Availed ITC Cess,ફાયર્ડ આઇટીસી સેસ
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,કૃપા કરીને શિક્ષણ&gt; શિક્ષણ સેટિંગ્સમાં પ્રશિક્ષક નામકરણ સિસ્ટમ સેટ કરો
 ,Student Monthly Attendance Sheet,વિદ્યાર્થી માસિક હાજરી શીટ
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,શીપીંગ નિયમ ફક્ત વેચાણ માટે લાગુ પડે છે
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,અવમૂલ્યન રો {0}: આગામી અવમૂલ્યન તારીખ ખરીદ તારીખ પહેલાં ન હોઈ શકે
@@ -4685,6 +4704,7 @@
 DocType: Quality Meeting,Quality Meeting,ગુણવત્તા સભા
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,બિન-ગ્રુપ ગ્રુપ
 DocType: Employee,ERPNext User,ERPNext વપરાશકર્તા
+DocType: Coupon Code,Coupon Description,કૂપન વર્ણન
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},બેચ પંક્તિમાં ફરજિયાત છે {0}
 DocType: Company,Default Buying Terms,ડિફોલ્ટ ખરીદવાની શરતો
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,ખરીદી રસીદ વસ્તુ પાડેલ
@@ -4846,6 +4866,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,દસ્તાવેજ વિગતવાર સામે કોઈ
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},દેશ {0} માટે કાઢી નાંખવાની પરવાનગી નથી
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,પાર્ટી પ્રકાર ફરજિયાત છે
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,કૂપન કોડ લાગુ કરો
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","જોબ કાર્ડ {0} માટે, તમે ફક્ત &#39;મટિરિયલ ટ્રાન્સફર ફોર મેન્યુફેક્ચર&#39; ટાઇપ સ્ટોક એન્ટ્રી કરી શકો છો"
 DocType: Quality Inspection,Outgoing,આઉટગોઇંગ
 DocType: Customer Feedback Table,Customer Feedback Table,ગ્રાહક પ્રતિસાદ કોષ્ટક
@@ -4995,7 +5016,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,ઓર્ડર સબમિશન પર ખરીદી
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,બધા સપ્લાયર્સ ઉમેરો
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,રો # {0}: ફાળવેલ રકમ બાકી રકમ કરતાં વધારે ન હોઈ શકે.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,ગ્રાહક&gt; ગ્રાહક જૂથ&gt; ક્ષેત્ર
 DocType: Tally Migration,Parties,પક્ષો
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,બ્રાઉઝ BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,સુરક્ષીત લોન્સ
@@ -5026,7 +5046,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},આઇટમ {0} માટે વૈકલ્પિક આઇટમ સેટ કરવાની મંજૂરી આપશો નહીં
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,તારીખ પુનરાવર્તન કરવામાં આવે છે
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,અધિકૃત હસ્તાક્ષર
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,કૃપા કરીને શિક્ષણ&gt; શિક્ષણ સેટિંગ્સમાં પ્રશિક્ષક નામકરણ સિસ્ટમ સેટ કરો
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),નેટ આઇટીસી ઉપલબ્ધ છે (એ) - (બી)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,ફી બનાવો
 DocType: Project,Total Purchase Cost (via Purchase Invoice),કુલ ખરીદ કિંમત (ખરીદી ભરતિયું મારફતે)
@@ -5050,6 +5069,7 @@
 DocType: Quiz Result,Wrong,ખોટું
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,દર ભાવ યાદી ચલણ ગ્રાહક આધાર ચલણ ફેરવાય છે
 DocType: Purchase Invoice Item,Net Amount (Company Currency),ચોખ્ખી રકમ (કંપની ચલણ)
+DocType: Sales Partner,Referral Code,રેફરલ કોડ
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,કુલ એડવાન્સ રકમ કુલ મંજૂર કરેલી રકમ કરતા વધારે ન હોઈ શકે
 DocType: Salary Slip,Hour Rate,કલાક દર
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Autoટો રી-ઓર્ડરને સક્ષમ કરો
@@ -5177,6 +5197,7 @@
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},આઇટમ {0} સામે BOM પસંદ કરો
 DocType: Shopping Cart Settings,Show Stock Quantity,સ્ટોક જથ્થો બતાવો
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,ઓપરેશન્સ થી ચોખ્ખી રોકડ
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},આઇટમ માટે યુઓએમ કન્વર્ઝન પરિબળ ({0} -&gt; {1}) મળ્યું નથી: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,આઇટમ 4
 DocType: Student Admission,Admission End Date,પ્રવેશ સમાપ્તિ તારીખ
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,પેટા કરાર
@@ -5199,6 +5220,7 @@
 DocType: Travel Request,Fully Sponsored,સંપૂર્ણપણે પ્રાયોજિત
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,રિવર્સ જર્નલ એન્ટ્રી
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,જોબ કાર્ડ બનાવો
+DocType: Quotation,Referral Sales Partner,રેફરલ સેલ્સ પાર્ટનર
 DocType: Quality Procedure Process,Process Description,પ્રક્રિયા વર્ણન
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,ગ્રાહક {0} બનાવવામાં આવેલ છે
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,હાલમાં કોઈ વેરહાઉસમાં કોઈ સ્ટોક ઉપલબ્ધ નથી
@@ -5330,6 +5352,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM દર
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,અપલોડ કરેલી ફાઇલ વાંચવી
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","અટકાવાયેલ કાર્ય ઓર્ડર રદ કરી શકાતો નથી, તેને રદ કરવા માટે પ્રથમ રદ કરો"
+DocType: Coupon Code,Coupon Code,કુપનનૉ ગુપ્ત્તાન્ક
 DocType: Asset,Journal Entry for Scrap,સ્ક્રેપ માટે જર્નલ પ્રવેશ
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,ડ લવર નોંધ વસ્તુઓ ખેંચી કરો
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},રો {0}: ઓપરેશન સામે વર્કસ્ટેશન પસંદ કરો {1}
@@ -5409,6 +5432,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;તારીખ&#39; જરૂરી છે
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},કારણે / સંદર્ભ તારીખ પછી ન હોઈ શકે {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,માહિતી આયાત અને નિકાસ
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","માફ કરશો, કૂપન કોડ માન્યતા સમાપ્ત થઈ ગઈ છે"
 DocType: Bank Account,Account Details,ખાતાની માહિતી
 DocType: Crop,Materials Required,સામગ્રી આવશ્યક છે
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,કોઈ વિદ્યાર્થીઓ મળ્યો
@@ -5446,6 +5470,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,વપરાશકર્તાઓ પર જાઓ
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,ચૂકવેલ રકમ રકમ ગ્રાન્ડ કુલ કરતાં વધારે ન હોઈ શકે માંડવાળ +
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} વસ્તુ માટે માન્ય બેચ નંબર નથી {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,કૃપા કરીને માન્ય કૂપન કોડ દાખલ કરો !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},નોંધ: છોડો પ્રકાર માટે પૂરતી રજા બેલેન્સ નથી {0}
 DocType: Task,Task Description,કાર્ય વર્ણન
 DocType: Training Event,Seminar,સેમિનાર
@@ -5708,6 +5733,7 @@
 ,TDS Payable Monthly,ટીડીએસ ચૂકવવાપાત્ર માસિક
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,બોમની બદલી માટે કતારબદ્ધ. તેમાં થોડો સમય લાગી શકે છે.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',શ્રેણી &#39;મૂલ્યાંકન&#39; અથવા &#39;મૂલ્યાંકન અને કુલ&#39; માટે છે જ્યારે કપાત કરી શકો છો
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,કૃપા કરીને માનવ સંસાધન&gt; એચઆર સેટિંગ્સમાં કર્મચારી નામકરણ સિસ્ટમ સેટ કરો
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,કુલ ચુકવણીઓ
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},શ્રેણીબદ્ધ વસ્તુ માટે સીરીયલ અમે જરૂરી {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,ઇન્વૉઇસેસ સાથે મેળ ચુકવણીઓ
@@ -5795,6 +5821,7 @@
 DocType: Production Plan,Get Raw Materials For Production,ઉત્પાદન માટે કાચો માલ મેળવો
 DocType: Job Opening,Job Title,જોબ શીર્ષક
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,ભાવિ ચુકવણી સંદર્ભ
+DocType: Quotation,Additional Discount and Coupon Code,અતિરિક્ત ડિસ્કાઉન્ટ અને કૂપન કોડ
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} સૂચવે છે કે {1} કોઈ અવતરણ પૂરું પાડશે નહીં, પરંતુ બધી વસ્તુઓનો ઉલ્લેખ કરવામાં આવ્યો છે. RFQ ક્વોટ સ્થિતિ સુધારી રહ્યા છીએ."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,મહત્તમ નમૂનાઓ - બેચ {1} અને વસ્તુ {2} બેચ {3} માં પહેલાથી જ {0} જાળવી રાખવામાં આવ્યા છે.
@@ -6017,6 +6044,7 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,વેબસાઇટ હોમપેજ માટે સેટિંગ્સ
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} સુધી પકડ છે {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},{1} ના સ્કોરકાર્ડ સ્ટેન્ડને કારણે {0} માટે RFQs ને મંજૂરી નથી
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,ખરીદીનું ઇન્વoiceઇસ બનાવો
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,વપરાયેલ પાંદડા
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,શું તમે સામગ્રી વિનંતી સબમિટ કરવા માંગો છો?
 DocType: Job Offer,Awaiting Response,પ્રતિભાવ પ્રતીક્ષામાં
@@ -6031,6 +6059,7 @@
 DocType: Training Event Employee,Optional,વૈકલ્પિક
 DocType: Salary Slip,Earning & Deduction,અર્નિંગ અને કપાત
 DocType: Agriculture Analysis Criteria,Water Analysis,પાણીનું વિશ્લેષણ
+DocType: Sales Order,Skip Delivery Note,ડિલિવરી નોંધ અવગણો
 DocType: Price List,Price Not UOM Dependent,કિંમત યુઓએમ આધારિત નથી
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} ચલો બનાવ્યાં છે
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,ડિફોલ્ટ સેવા સ્તર કરાર પહેલાથી જ અસ્તિત્વમાં છે.
@@ -6234,7 +6263,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,કર અને ખર્ચ ઉમેર્યું
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,અવમૂલ્યન રો {0}: આગલી અવમૂલ્યન તારીખ ઉપલબ્ધ થવાની તારીખ પહેલાં ન હોઈ શકે
 ,Sales Funnel,વેચાણ નાળચું
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,આઇટમ કોડ&gt; આઇટમ જૂથ&gt; બ્રાન્ડ
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,સંક્ષેપનો ફરજિયાત છે
 DocType: Project,Task Progress,ટાસ્ક પ્રગતિ
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,કાર્ટ
@@ -6328,6 +6356,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS પ્રોફાઇલ POS એન્ટ્રી બનાવવા માટે જરૂરી
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",વફાદારીના પોઇંટ્સનો ગણતરી ગણતરીના કારણોના આધારે કરવામાં આવેલા ખર્ચ (સેલ્સ ઇન્વોઇસ દ્વારા) દ્વારા કરવામાં આવશે.
 DocType: Program Enrollment Tool,Enroll Students,વિદ્યાર્થી નોંધણી
+DocType: Pricing Rule,Coupon Code Based,કૂપન કોડ આધારિત
 DocType: Company,HRA Settings,એચઆરએ સેટિંગ્સ
 DocType: Homepage,Hero Section,હિરો વિભાગ
 DocType: Employee Transfer,Transfer Date,તારીખ સ્થાનાંતરિત કરો
@@ -6442,6 +6471,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',કૃપા કરીને કંપની ખાલી ફિલ્ટર સેટ જો ગ્રુપ દ્વારા &#39;કંપની&#39; છે
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,પોસ્ટ તારીખ ભવિષ્યના તારીખ ન હોઈ શકે
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},ROW # {0}: સીરીયલ કોઈ {1} સાથે મેળ ખાતું નથી {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,કૃપા કરીને સેટઅપ&gt; નંબરિંગ સિરીઝ દ્વારા હાજરી માટે સંખ્યા ક્રમાંકન સેટ કરો
 DocType: Stock Entry,Target Warehouse Address,ટાર્ગેટ વેરહાઉસ સરનામું
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,પરચુરણ રજા
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,"શિફ્ટ પ્રારંભ સમયનો સમય, જે દરમિયાન કર્મચારીની ચકાસણી હાજરી માટે માનવામાં આવે છે."
@@ -6476,7 +6506,6 @@
 DocType: Employee Grade,Employee Grade,કર્મચારીનું ગ્રેડ
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,છૂટક કામ
 DocType: GSTR 3B Report,June,જૂન
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,સપ્લાયર&gt; સપ્લાયર પ્રકાર
 DocType: Share Balance,From No,ના ના
 DocType: Shift Type,Early Exit Grace Period,પ્રારંભિક એક્ઝિટ ગ્રેસ પીરિયડ
 DocType: Task,Actual Time (in Hours),(કલાકોમાં) વાસ્તવિક સમય
@@ -6757,7 +6786,6 @@
 DocType: Warehouse,Warehouse Name,વેરહાઉસ નામ
 DocType: Naming Series,Select Transaction,પસંદ ટ્રાન્ઝેક્શન
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,ભૂમિકા એપ્રૂવિંગ અથવા વપરાશકર્તા એપ્રૂવિંગ દાખલ કરો
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},આઇટમ માટે યુઓએમ કન્વર્ઝન પરિબળ ({0} -&gt; {1}) મળ્યું નથી: {2}
 DocType: Journal Entry,Write Off Entry,એન્ટ્રી માંડવાળ
 DocType: BOM,Rate Of Materials Based On,દર સામગ્રી પર આધારિત
 DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","જો સક્ષમ કરેલું હોય, તો ક્ષેત્ર નોંધણી સાધનમાં ફીલ્ડ એકેડેમિક ટર્મ ફરજિયાત રહેશે."
@@ -6893,6 +6921,7 @@
 DocType: Budget,Warn,ચેતવો
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,આ વર્ક ઓર્ડર માટે બધી વસ્તુઓ પહેલેથી જ ટ્રાન્સફર કરવામાં આવી છે.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","કોઈપણ અન્ય ટીકા, રેકોર્ડ જવા જોઈએ કે નોંધપાત્ર પ્રયાસ."
+DocType: Bank Account,Company Account,કંપની ખાતું
 DocType: Asset Maintenance,Manufacturing User,ઉત્પાદન વપરાશકર્તા
 DocType: Purchase Invoice,Raw Materials Supplied,કાચો માલ પાડેલ
 DocType: Subscription Plan,Payment Plan,ચુકવણી યોજના
@@ -6934,6 +6963,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) વર્ક ઓર્ડર {3} માં આયોજિત જથ્થા ({2}) કરતા વધુ ન હોઈ શકે
 DocType: Certification Application,Name of Applicant,અરજદારનુંં નામ
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,ઉત્પાદન માટે સમય શીટ.
+DocType: Quick Stock Balance,Quick Stock Balance,ઝડપી સ્ટોક બેલેન્સ
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,પેટાસરવાળો
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,સ્ટોક ટ્રાન્ઝેક્શન પછી વેરિઅન્ટ પ્રોપર્ટીઝ બદલી શકતા નથી. તમારે આ કરવા માટે એક નવી આઇટમ બનાવવી પડશે.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA આદેશ
@@ -7256,6 +7286,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},સેટ કરો {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} નિષ્ક્રિય વિદ્યાર્થી છે
 DocType: Employee,Health Details,આરોગ્ય વિગતો
+DocType: Coupon Code,Coupon Type,કૂપન પ્રકાર
 DocType: Leave Encashment,Encashable days,એન્કેશબલ ટ્રેડીંગ
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,ચુકવણી વિનંતી સંદર્ભ દસ્તાવેજ જરૂરી છે બનાવવા માટે
 DocType: Soil Texture,Sandy Clay,રેતાળ માટી
@@ -7534,6 +7565,7 @@
 DocType: Hotel Room Package,Amenities,સવલતો
 DocType: Accounts Settings,Automatically Fetch Payment Terms,આપમેળે ચુકવણીની શરતો મેળવો
 DocType: QuickBooks Migrator,Undeposited Funds Account,અનપેક્ષિત ફંડ્સ એકાઉન્ટ
+DocType: Coupon Code,Uses,ઉપયોગ કરે છે
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,ચુકવણીના બહુવિધ ડિફોલ્ટ મોડને મંજૂરી નથી
 DocType: Sales Invoice,Loyalty Points Redemption,લોયલ્ટી પોઇંટ્સ રીડેમ્પશન
 ,Appointment Analytics,નિમણૂંક ઍનલિટિક્સ
@@ -7550,6 +7582,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,કુલ અંદાજપત્ર
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"ખાલી છોડો છો, તો તમે દર વર્ષે વિદ્યાર્થીઓ ગ્રુપ બનાવી"
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","ચકાસાયેલ હોય, તો કુલ નં. દિવસની રજાઓ સમાવેશ થાય છે, અને આ પગાર પ્રતિ દિવસ ની કિંમત ઘટાડશે"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,ડોમેન ઉમેરવામાં નિષ્ફળ
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","રસીદ / વિતરણને મંજૂરી આપવા માટે, સ્ટોક સેટિંગ્સ અથવા આઇટમમાં &quot;ઓવર રસીદ / ડિલિવરી એલાઉન્સ&quot; અપડેટ કરો."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","વર્તમાન કીનો ઉપયોગ કરીને એપ્લિકેશન્સ ઍક્સેસ કરવામાં સમર્થ હશે નહીં, શું તમે ખરેખર છો?"
 DocType: Subscription Settings,Prorate,Prorate
@@ -7562,6 +7595,7 @@
 ,BOM Stock Report,BOM સ્ટોક રિપોર્ટ
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","જો ત્યાં કોઈ સોંપાયેલ ટાઇમસ્લોટ નથી, તો પછી આ જૂથ દ્વારા સંચાર સંચાલિત કરવામાં આવશે"
 DocType: Stock Reconciliation Item,Quantity Difference,જથ્થો તફાવત
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,સપ્લાયર&gt; સપ્લાયર પ્રકાર
 DocType: Opportunity Item,Basic Rate,મૂળ દર
 DocType: GL Entry,Credit Amount,ક્રેડિટ રકમ
 ,Electronic Invoice Register,ઇલેક્ટ્રોનિક ભરતિયું રજિસ્ટર
@@ -7812,6 +7846,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),કર અને ખર્ચ બાદ (કંપની ચલણ)
 DocType: Item Group,General Settings,સામાન્ય સુયોજનો
 DocType: Article,Article,લેખ
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,કૃપા કરીને કૂપન કોડ દાખલ કરો!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,ચલણ અને ચલણ જ ન હોઈ શકે
 DocType: Taxable Salary Slab,Percent Deduction,ટકા કપાત
 DocType: GL Entry,To Rename,નામ બદલવું
diff --git a/erpnext/translations/he.csv b/erpnext/translations/he.csv
index 48e4709..9dbfea4 100644
--- a/erpnext/translations/he.csv
+++ b/erpnext/translations/he.csv
@@ -2111,7 +2111,7 @@
 DocType: Warehouse,Warehouse Detail,פרט מחסן
 DocType: Blanket Order,Order Type,סוג להזמין
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Fiscal Year {0} is required,שנת כספים {0} נדרש
-DocType: Pricing Rule,Pricing Rule,כלל תמחור
+DocType: Coupon Code,Pricing Rule,כלל תמחור
 apps/erpnext/erpnext/controllers/selling_controller.py,To {0} | {1} {2},כדי {0} | {1} {2}
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Set as Lost,קבע כאבוד
 DocType: Student Applicant,Approved,אושר
@@ -3271,6 +3271,7 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Payment against {0} {1} cannot be greater than Outstanding Amount {2},תשלום כנגד {0} {1} לא יכול להיות גדול מהסכום מצטיין {2}
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Ref,"נ""צ"
 apps/erpnext/erpnext/accounts/utils.py,Please set default {0} in Company {1},אנא קבע את ברירת המחדל {0} ב החברה {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,לבצע את רכישת החשבונית
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Direct Income,הכנסה ישירה
 DocType: C-Form,IV,IV
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},שורה לא {0}: הסכום אינו יכול להיות גדול מהסכום ממתין נגד תביעת {1} הוצאות. הסכום בהמתנת {2}
diff --git a/erpnext/translations/hi.csv b/erpnext/translations/hi.csv
index 7ba9ce6..9b5fc41 100644
--- a/erpnext/translations/hi.csv
+++ b/erpnext/translations/hi.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,मेट-डीटी-.YYYY.-
 DocType: Purchase Order,Customer Contact,ग्राहक से संपर्क
 DocType: Shift Type,Enable Auto Attendance,ऑटो अटेंडेंस सक्षम करें
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,कृपया गोदाम और दिनांक दर्ज करें
 DocType: Lost Reason Detail,Opportunity Lost Reason,अवसर खो दिया कारण
 DocType: Patient Appointment,Check availability,उपलब्धता जाँचें
 DocType: Retention Bonus,Bonus Payment Date,बोनस भुगतान दिनांक
@@ -263,6 +264,7 @@
 ,Completed Work Orders,पूर्ण कार्य आदेश
 DocType: Support Settings,Forum Posts,फोरम पोस्ट
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","कार्य को पृष्ठभूमि की नौकरी के रूप में माना गया है। यदि बैकग्राउंड में प्रोसेसिंग पर कोई समस्या है, तो सिस्टम इस स्टॉक रिकंसीलेशन पर त्रुटि के बारे में एक टिप्पणी जोड़ देगा और ड्राफ्ट चरण में वापस आ जाएगा।"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","क्षमा करें, कूपन कोड वैधता शुरू नहीं हुई है"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,कर योग्य राशि
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},इससे पहले कि आप प्रविष्टियों को जोड़ने या अद्यतन करने के लिए अधिकृत नहीं हैं {0}
 DocType: Leave Policy,Leave Policy Details,नीति विवरण छोड़ दें
@@ -328,6 +330,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,उपभोज्य
 DocType: Student,B-,बी
 DocType: Assessment Result,Grade,ग्रेड
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,आइटम कोड&gt; आइटम समूह&gt; ब्रांड
 DocType: Restaurant Table,No of Seats,सीटों की संख्या
 DocType: Sales Invoice,Overdue and Discounted,अतिदेय और रियायती
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,कॉल डिस्कनेक्ट किया गया
@@ -504,6 +507,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,शब्दों में राशि के लिए पंक्ति रिक्ति
 DocType: Vehicle,Additional Details,अतिरिक्त जानकारिया
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,दिया का कोई विवरण नहीं
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,गोदाम से आइटम प्राप्त करें
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,खरीद के लिए अनुरोध.
 DocType: POS Closing Voucher Details,Collected Amount,एकत्रित राशि
 DocType: Lab Test,Submitted Date,सबमिट करने की तिथि
@@ -611,6 +615,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,सीखना
 ,Trial Balance (Simple),परीक्षण शेष (सरल)
 DocType: Purchase Invoice Item,Enable Deferred Expense,डिफरर्ड व्यय सक्षम करें
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,एप्लाइड कूपन कोड
 DocType: Asset,Next Depreciation Date,अगली तिथि मूल्यह्रास
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,कर्मचारी प्रति गतिविधि लागत
 DocType: Accounts Settings,Settings for Accounts,खातों के लिए सेटिंग्स
@@ -846,8 +851,6 @@
 DocType: BOM,Work Order,कार्य आदेश
 DocType: Sales Invoice,Total Qty,कुल मात्रा
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,संरक्षक 2 ईमेल आईडी
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","कृपया इस दस्तावेज़ को रद्द करने के लिए कर्मचारी <a href=""#Form/Employee/{0}"">{0}</a> \ _ हटाएं"
 DocType: Item,Show in Website (Variant),वेबसाइट में दिखाने (variant)
 DocType: Employee,Health Concerns,स्वास्थ्य चिंताएं
 DocType: Payroll Entry,Select Payroll Period,पेरोल की अवधि का चयन करें
@@ -1010,6 +1013,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,कर रोकथाम खाता
 DocType: Pricing Rule,Sales Partner,बिक्री साथी
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,सभी प्रदायक स्कोरकार्ड
+DocType: Coupon Code,To be used to get discount,छूट पाने के लिए इस्तेमाल किया जाना है
 DocType: Buying Settings,Purchase Receipt Required,खरीद रसीद आवश्यक
 DocType: Sales Invoice,Rail,रेल
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,वास्तविक लागत
@@ -1060,6 +1064,7 @@
 DocType: Production Plan,Production Plan,उत्पादन योजना
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,चालान चालान उपकरण खोलना
 DocType: Salary Component,Round to the Nearest Integer,निकटतम इंटेगर का दौर
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,आइटम को कार्ट में नहीं जोड़ने की अनुमति दें
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,बिक्री लौटें
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,सीरियल नो इनपुट के आधार पर लेनदेन में मात्रा निर्धारित करें
 ,Total Stock Summary,कुल स्टॉक सारांश
@@ -1189,6 +1194,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),बेस घंटे की दर (कंपनी मुद्रा)
 ,Qty To Be Billed,बाइट टू बी बिल
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,वितरित राशि
+DocType: Coupon Code,Gift Card,उपहार पत्र
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,उत्पादन के लिए आरक्षित मात्रा: निर्माण सामग्री बनाने के लिए कच्चे माल की मात्रा।
 DocType: Loyalty Point Entry Redemption,Redemption Date,रीडेम्प्शन तिथि
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,यह बैंक लेन-देन पहले से ही पूरी तरह से मेल खाता है
@@ -1276,6 +1282,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Timesheet बनाएं
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,खाता {0} कई बार दर्ज किया गया है
 DocType: Account,Expenses Included In Valuation,व्यय मूल्यांकन में शामिल
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,खरीद चालान
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,यदि केवल 30 दिनों के भीतर आपकी सदस्यता समाप्त होने पर आप केवल नवीनीकृत कर सकते हैं
 DocType: Shopping Cart Settings,Show Stock Availability,स्टॉक उपलब्धता दिखाएं
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},संपत्ति श्रेणी {1} या कंपनी {2} में {0} सेट करें
@@ -1834,6 +1841,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,आयात आइटम और UOMs
 DocType: Repayment Schedule,Balance Loan Amount,शेष ऋण की राशि
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,विवरण में जोड़ा गया
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","क्षमा करें, कूपन कोड समाप्त हो गए हैं"
 DocType: Communication Medium,Catch All,सबको पकड़ो
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,अनुसूची कोर्स
 DocType: Budget,Applicable on Material Request,सामग्री अनुरोध पर लागू
@@ -2001,6 +2009,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,अमान्य विशेषता
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} प्रस्तुत किया जाना चाहिए
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,ईमेल अभियान
+DocType: Sales Partner,To Track inbound purchase,इनबाउंड खरीद को ट्रैक करने के लिए
 DocType: Buying Settings,Default Supplier Group,डिफ़ॉल्ट प्रदायक समूह
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},मात्रा से कम या बराबर होना चाहिए {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},घटक {0} के लिए योग्य अधिकतम राशि {1} से अधिक है
@@ -2156,8 +2165,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,स्टॉक एंट्री करें
 DocType: Hotel Room Reservation,Hotel Reservation User,होटल आरक्षण उपयोगकर्ता
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,स्थिति सेट करें
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,कृपया सेटअप&gt; नंबरिंग श्रृंखला के माध्यम से उपस्थिति के लिए क्रमांकन श्रृंखला की स्थापना करें
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,पहले उपसर्ग का चयन करें
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,कृपया सेटिंग&gt; सेटिंग&gt; नामकरण श्रृंखला के माध्यम से {0} के लिए नामकरण श्रृंखला निर्धारित करें
 DocType: Contract,Fulfilment Deadline,पूर्ति की अंतिम तिथि
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,तुम्हारे पास
 DocType: Student,O-,हे
@@ -2281,6 +2290,7 @@
 DocType: Quality Meeting Table,Under Review,समीक्षाधीन
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,लॉगिन करने में विफल
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,संपत्ति {0} बनाई गई
+DocType: Coupon Code,Promotional,प्रोमोशनल
 DocType: Special Test Items,Special Test Items,विशेष टेस्ट आइटम
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,बाज़ार प्रबंधक पर पंजीकरण करने के लिए आपको सिस्टम मैनेजर और आइटम मैनेजर भूमिकाओं के साथ एक उपयोगकर्ता होने की आवश्यकता है।
 apps/erpnext/erpnext/config/buying.py,Key Reports,मुख्य रिपोर्ट
@@ -2318,6 +2328,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,डॉक्टर के प्रकार
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,बिक्री टीम के लिए कुल आवंटित 100 प्रतिशत होना चाहिए
 DocType: Subscription Plan,Billing Interval Count,बिलिंग अंतराल गणना
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","कृपया इस दस्तावेज़ को रद्द करने के लिए कर्मचारी <a href=""#Form/Employee/{0}"">{0}</a> \ _ हटाएं"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,नियुक्तियों और रोगी Encounters
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,मूल्य गुम है
 DocType: Employee,Department and Grade,विभाग और ग्रेड
@@ -2420,6 +2432,7 @@
 DocType: Project,Start and End Dates,आरंभ और अंत तारीखें
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,अनुबंध टेम्पलेट पूर्ति शर्तें
 ,Delivered Items To Be Billed,बिल के लिए दिया आइटम
+DocType: Coupon Code,Maximum Use,अधिकतम उपयोग
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},ओपन बीओएम {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,वेयरहाउस सीरियल नंबर के लिए बदला नहीं जा सकता
 DocType: Authorization Rule,Average Discount,औसत छूट
@@ -2582,6 +2595,7 @@
 DocType: Item,Inventory,इनवेंटरी
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Json के रूप में डाउनलोड करें
 DocType: Item,Sales Details,बिक्री विवरण
+DocType: Coupon Code,Used,उपयोग किया गया
 DocType: Opportunity,With Items,आइटम के साथ
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',अभियान &#39;{0}&#39; पहले से ही {1} &#39;{2}&#39; के लिए मौजूद है
 DocType: Asset Maintenance,Maintenance Team,रखरखाव टीम
@@ -2711,7 +2725,7 @@
 						Serial No cannot be ensured",आइटम {0} के लिए कोई सक्रिय बीओएम नहीं मिला। \ Serial No द्वारा डिलीवरी सुनिश्चित नहीं किया जा सकता है
 DocType: Sales Partner,Sales Partner Target,बिक्री साथी लक्ष्य
 DocType: Loan Type,Maximum Loan Amount,अधिकतम ऋण राशि
-DocType: Pricing Rule,Pricing Rule,मूल्य निर्धारण नियम
+DocType: Coupon Code,Pricing Rule,मूल्य निर्धारण नियम
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},छात्र के लिए डुप्लिकेट रोल नंबर {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,क्रय आदेश के लिए सामग्री का अनुरोध
 DocType: Company,Default Selling Terms,डिफ़ॉल्ट विक्रय शर्तें
@@ -2790,6 +2804,7 @@
 DocType: Payment Schedule,Payment Amount,भुगतान राशि
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,कार्य दिवस और कार्य समाप्ति तिथि के बीच आधे दिन की तारीख होनी चाहिए
 DocType: Healthcare Settings,Healthcare Service Items,हेल्थकेयर सेवा आइटम
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,अमान्य बारकोड। इस बारकोड से कोई आइटम संलग्न नहीं है।
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,खपत राशि
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,नकद में शुद्ध परिवर्तन
 DocType: Assessment Plan,Grading Scale,ग्रेडिंग पैमाने
@@ -2909,7 +2924,6 @@
 DocType: Share Transfer,Asset Account,संपत्ति खाता
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,नई रिलीज की तारीख भविष्य में होनी चाहिए
 DocType: Purchase Invoice,End date of current invoice's period,वर्तमान चालान की अवधि की समाप्ति की तारीख
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,कृपया मानव संसाधन&gt; HR सेटिंग्स में कर्मचारी नामकरण प्रणाली सेटअप करें
 DocType: Lab Test,Technician Name,तकनीशियन का नाम
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3020,6 +3034,7 @@
 DocType: Products Settings,Hide Variants,वेरिएंट छिपाएँ
 DocType: Lead,Next Contact By,द्वारा अगले संपर्क
 DocType: Compensatory Leave Request,Compensatory Leave Request,मुआवजा छुट्टी अनुरोध
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","पंक्ति {1} से अधिक {2} में आइटम {0} के लिए ओवरबिल नहीं कर सकते। ओवर-बिलिंग की अनुमति देने के लिए, कृपया खाता सेटिंग में भत्ता निर्धारित करें"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},आइटम के लिए आवश्यक मात्रा {0} पंक्ति में {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},मात्रा मद के लिए मौजूद वेयरहाउस {0} मिटाया नहीं जा सकता {1}
 DocType: Blanket Order,Order Type,आदेश प्रकार
@@ -3189,7 +3204,6 @@
 DocType: Student,Student Mobile Number,छात्र मोबाइल नंबर
 DocType: Item,Has Variants,वेरिएंट है
 DocType: Employee Benefit Claim,Claim Benefit For,दावा लाभ के लिए
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","{2} से अधिक पंक्ति {1} में आइटम {0} के लिए अधिकतम नहीं लगाया जा सकता। अधिक-बिलिंग की अनुमति के लिए, कृपया स्टॉक सेटिंग में सेट करें"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,रिस्पांस अपडेट करें
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},आप पहले से ही से आइटम का चयन किया है {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,मासिक वितरण का नाम
@@ -3480,6 +3494,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,कंपनी में मुद्रा निर्दिष्ट करें
 DocType: Workstation,Wages per hour,प्रति घंटे मजदूरी
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},कॉन्फ़िगर करें {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,ग्राहक&gt; ग्राहक समूह&gt; क्षेत्र
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},बैच में स्टॉक संतुलन {0} बन जाएगा नकारात्मक {1} गोदाम में आइटम {2} के लिए {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,सामग्री अनुरोध के बाद मद के फिर से आदेश स्तर के आधार पर स्वचालित रूप से उठाया गया है
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},खाते {0} अमान्य है। खाता मुद्रा होना चाहिए {1}
@@ -3809,6 +3824,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,वेतनपर्ची सबमिट करें
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,होल्ड पर
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,एक qustion में कम से कम एक सही विकल्प होना चाहिए
+apps/erpnext/erpnext/hooks.py,Purchase Orders,क्रय आदेश
 DocType: Account,Inter Company Account,इंटर कंपनी खाता
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,थोक में आयात
 DocType: Sales Partner,Address & Contacts,पता और संपर्क
@@ -3819,6 +3835,7 @@
 DocType: POS Profile,[Select],[ चुनें ]
 DocType: Staffing Plan Detail,Number Of Positions,पदों की संख्या
 DocType: Vital Signs,Blood Pressure (diastolic),रक्तचाप (डायस्टोलिक)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,कृपया ग्राहक चुनें।
 DocType: SMS Log,Sent To,भेजा
 DocType: Agriculture Task,Holiday Management,छुट्टी प्रबंधन
 DocType: Payment Request,Make Sales Invoice,बिक्री चालान बनाएं
@@ -4028,7 +4045,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} प्रस्तुत नहीं किया गया है
 DocType: Subscription,Trialling,trialling
 DocType: Sales Invoice Item,Deferred Revenue,आस्थगित राजस्व
-DocType: Bank Account,GL Account,जीएल खाता
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,बिक्री चालान निर्माण के लिए नकद खाता का उपयोग किया जाएगा
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,छूट उप श्रेणी
 DocType: Member,Membership Expiry Date,सदस्यता समाप्ति तिथि
@@ -4452,13 +4468,13 @@
 DocType: C-Form Invoice Detail,Territory,क्षेत्र
 DocType: Pricing Rule,Apply Rule On Item Code,आइटम कोड पर नियम लागू करें
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,कृपया उल्लेख आवश्यक यात्राओं की कोई
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,स्टॉक बैलेंस रिपोर्ट
 DocType: Stock Settings,Default Valuation Method,डिफ़ॉल्ट मूल्यन विधि
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,शुल्क
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,संचयी राशि दिखाएं
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,अपडेट जारी है। इसमें समय लग सकता है।
 DocType: Production Plan Item,Produced Qty,उत्पादित मात्रा
 DocType: Vehicle Log,Fuel Qty,ईंधन मात्रा
-DocType: Stock Entry,Target Warehouse Name,लक्षित गोदाम का नाम
 DocType: Work Order Operation,Planned Start Time,नियोजित प्रारंभ समय
 DocType: Course,Assessment,मूल्यांकन
 DocType: Payment Entry Reference,Allocated,आवंटित
@@ -4536,10 +4552,12 @@
  1। आदि को संबोधित विवाद, क्षतिपूर्ति, दायित्व, 
  1 के तरीके। पता और अपनी कंपनी के संपर्क।"
 DocType: Homepage Section,Section Based On,अनुभाग के आधार पर
+DocType: Shopping Cart Settings,Show Apply Coupon Code,कूपन कोड लागू करें दिखाएं
 DocType: Issue,Issue Type,समस्या का प्रकार
 DocType: Attendance,Leave Type,प्रकार छोड़ दो
 DocType: Purchase Invoice,Supplier Invoice Details,प्रदायक चालान विवरण
 DocType: Agriculture Task,Ignore holidays,छुट्टियों पर ध्यान न दें
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,कूपन स्थितियां जोड़ें / संपादित करें
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,व्यय / अंतर खाते ({0}) एक 'लाभ या हानि' खाता होना चाहिए
 DocType: Stock Entry Detail,Stock Entry Child,स्टॉक एंट्री चाइल्ड
 DocType: Project,Copied From,से प्रतिलिपि बनाई गई
@@ -4714,6 +4732,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,आकलन योजना मानदंड
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,लेन-देन
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,खरीद ऑर्डर रोकें
+DocType: Coupon Code,Coupon Name,कूपन का नाम
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,ग्रहणक्षम
 DocType: Email Campaign,Scheduled,अनुसूचित
 DocType: Shift Type,Working Hours Calculation Based On,कार्य के घंटे की गणना के आधार पर
@@ -4730,7 +4749,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,वेरिएंट बनाएँ
 DocType: Vehicle,Diesel,डीज़ल
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,मूल्य सूची मुद्रा का चयन नहीं
+DocType: Quick Stock Balance,Available Quantity,उपलब्ध मात्रा
 DocType: Purchase Invoice,Availed ITC Cess,लाभ हुआ आईटीसी सेस
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,कृपया शिक्षा&gt; शिक्षा सेटिंग्स में इंस्ट्रक्टर नामकरण प्रणाली सेटअप करें
 ,Student Monthly Attendance Sheet,छात्र मासिक उपस्थिति पत्रक
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,नौवहन नियम केवल बेचना के लिए लागू है
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,मूल्यह्रास पंक्ति {0}: अगली मूल्यह्रास तिथि खरीद तिथि से पहले नहीं हो सकती है
@@ -4797,8 +4818,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,पंक्ति {0}: ग्राहक के खिलाफ अग्रिम ऋण होना चाहिए
 DocType: Quality Meeting,Quality Meeting,गुणवत्ता की बैठक
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,गैर-समूह समूह को
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,कृपया सेटिंग&gt; सेटिंग&gt; नामकरण श्रृंखला के माध्यम से {0} के लिए नामकरण श्रृंखला निर्धारित करें
 DocType: Employee,ERPNext User,ERPNext उपयोगकर्ता
+DocType: Coupon Code,Coupon Description,कूपन विवरण
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},पंक्ति {0} में बैच अनिवार्य है
 DocType: Company,Default Buying Terms,डिफ़ॉल्ट खरीदना शर्तें
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,खरीद रसीद आइटम की आपूर्ति
@@ -4961,6 +4982,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,दस्तावेज़ विस्तार नहीं के खिलाफ
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},देश के लिए विलोपन की अनुमति नहीं है {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,पार्टी प्रकार अनिवार्य है
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,कूपन कोड लागू करें
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","जॉब कार्ड {0} के लिए, आप केवल &#39;मैटीरियल ट्रांसफर फॉर मैन्युफैक्चर&#39; टाइप स्टॉक एंट्री कर सकते हैं"
 DocType: Quality Inspection,Outgoing,बाहर जाने वाला
 DocType: Customer Feedback Table,Customer Feedback Table,ग्राहक प्रतिक्रिया तालिका
@@ -5110,7 +5132,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,खरीद आदेश प्रस्तुत करने पर
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,सभी आपूर्तिकर्ता जोड़ें
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,पंक्ति # {0}: आवंटित राशि बकाया राशि से अधिक नहीं हो सकती।
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,ग्राहक&gt; ग्राहक समूह&gt; क्षेत्र
 DocType: Tally Migration,Parties,दलों
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,ब्राउज़ बीओएम
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,सुरक्षित कर्जे
@@ -5142,7 +5163,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},आइटम {0} के लिए वैकल्पिक आइटम सेट करने की अनुमति नहीं है
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,तिथि दोहराया है
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,अधिकृत हस्ताक्षरकर्ता
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,कृपया शिक्षा&gt; शिक्षा सेटिंग्स में इंस्ट्रक्टर नामकरण प्रणाली सेटअप करें
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),नेट आईटीसी उपलब्ध (ए) - (बी)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,फीस बनाएं
 DocType: Project,Total Purchase Cost (via Purchase Invoice),कुल खरीद मूल्य (खरीद चालान के माध्यम से)
@@ -5167,6 +5187,7 @@
 DocType: Quiz Result,Wrong,गलत
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,दर जिस पर मूल्य सूची मुद्रा ग्राहक आधार मुद्रा में परिवर्तित किया जाता है
 DocType: Purchase Invoice Item,Net Amount (Company Currency),शुद्ध राशि (कंपनी मुद्रा)
+DocType: Sales Partner,Referral Code,रेफरल कोड
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,कुल अग्रिम राशि कुल स्वीकृत राशि से अधिक नहीं हो सकती
 DocType: Salary Slip,Hour Rate,घंटा दर
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,ऑटो री-ऑर्डर सक्षम करें
@@ -5295,6 +5316,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,स्टॉक मात्रा दिखाएं
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,संचालन से नेट नकद
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},पंक्ति # {0}: चालान छूट {2} के लिए स्थिति {1} होनी चाहिए
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM रूपांतरण कारक ({0} -&gt; {1}) आइटम के लिए नहीं मिला: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,आइटम 4
 DocType: Student Admission,Admission End Date,एडमिशन समाप्ति तिथि
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,उप ठेका
@@ -5317,6 +5339,7 @@
 DocType: Travel Request,Fully Sponsored,पूरी तरह से प्रायोजित
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,रिवर्स जर्नल एंट्री
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,जॉब कार्ड बनाएं
+DocType: Quotation,Referral Sales Partner,रेफरल सेल्स पार्टनर
 DocType: Quality Procedure Process,Process Description,प्रक्रिया वर्णन
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,ग्राहक {0} बनाया गया है
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,वर्तमान में किसी भी गोदाम में कोई स्टॉक उपलब्ध नहीं है
@@ -5451,6 +5474,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,बीओएम दर
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,अपलोड की गई फ़ाइल पढ़ना
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","रुक गए कार्य आदेश को रद्द नहीं किया जा सकता, रद्द करने के लिए इसे पहले से हटा दें"
+DocType: Coupon Code,Coupon Code,कूपन कोड
 DocType: Asset,Journal Entry for Scrap,स्क्रैप के लिए जर्नल प्रविष्टि
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,डिलिवरी नोट से आइटम खींच कृपया
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},पंक्ति {0}: ऑपरेशन के खिलाफ वर्कस्टेशन का चयन करें {1}
@@ -5533,6 +5557,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;दिनांक&#39; की आवश्यकता है
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},कारण / संदर्भ तिथि के बाद नहीं किया जा सकता {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,डाटा आयात और निर्यात
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","क्षमा करें, कूपन कोड वैधता समाप्त हो गई है"
 DocType: Bank Account,Account Details,खाता विवरण
 DocType: Crop,Materials Required,सामग्री की आवश्यकता
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,कोई छात्र नहीं मिले
@@ -5570,6 +5595,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,उपयोगकर्ता पर जाएं
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,भुगतान की गई राशि + राशि से लिखने के कुल योग से बड़ा नहीं हो सकता
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} आइटम के लिए एक वैध बैच नंबर नहीं है {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,कृपया मान्य कूपन कोड दर्ज करें !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},नोट : छोड़ किस्म के लिए पर्याप्त छुट्टी संतुलन नहीं है {0}
 DocType: Task,Task Description,कार्य विवरण
 DocType: Training Event,Seminar,सेमिनार
@@ -5833,6 +5859,7 @@
 ,TDS Payable Monthly,टीडीएस मासिक देय
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,बीओएम की जगह के लिए कतारबद्ध इसमें कुछ मिनट लग सकते हैं।
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',श्रेणी ' मूल्यांकन ' या ' मूल्यांकन और कुल ' के लिए है जब घटा नहीं कर सकते
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,कृपया मानव संसाधन&gt; HR सेटिंग्स में कर्मचारी नामकरण प्रणाली सेटअप करें
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,कुल भुगतान
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},श्रृंखलाबद्ध मद के लिए सीरियल नं आवश्यक {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,चालान के साथ मैच भुगतान
@@ -5922,6 +5949,7 @@
 DocType: Production Plan,Get Raw Materials For Production,कच्चे माल के लिए उत्पादन प्राप्त करें
 DocType: Job Opening,Job Title,कार्य शीर्षक
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,भविष्य का भुगतान रेफरी
+DocType: Quotation,Additional Discount and Coupon Code,अतिरिक्त छूट और कूपन कोड
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} इंगित करता है कि {1} कोई उद्धरण नहीं प्रदान करेगा, लेकिन सभी वस्तुओं को उद्धृत किया गया है। आरएफक्यू कोटेशन स्थिति को अद्यतन करना"
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,अधिकतम नमूनों - {0} बैच {1} और वस्तु {2} बैच {3} में पहले से ही बनाए गए हैं
@@ -6148,7 +6176,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,वेबसाइट मुखपृष्ठ के लिए सेटिंग
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} {1} तक पकड़ पर है
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},{1} के स्कोरकार्ड स्टैंड के कारण आरएफक्यू को {0} के लिए अनुमति नहीं है
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,खरीद चालान बनाएं
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,प्रयुक्त पत्तियां
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} कूपन का उपयोग किया जाता है {1}। अनुमति मात्रा समाप्त हो गई है
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,क्या आप सामग्री अनुरोध सबमिट करना चाहते हैं
 DocType: Job Offer,Awaiting Response,प्रतिक्रिया की प्रतीक्षा
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6162,6 +6192,7 @@
 DocType: Training Event Employee,Optional,ऐच्छिक
 DocType: Salary Slip,Earning & Deduction,अर्जन कटौती
 DocType: Agriculture Analysis Criteria,Water Analysis,जल विश्लेषण
+DocType: Sales Order,Skip Delivery Note,वितरण नोट छोड़ें
 DocType: Price List,Price Not UOM Dependent,मूल्य नहीं UOM आश्रित
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} बनाए गए संस्करण।
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,एक डिफ़ॉल्ट सेवा स्तर समझौता पहले से मौजूद है।
@@ -6266,6 +6297,7 @@
 DocType: Vehicle,Last Carbon Check,अंतिम कार्बन चेक
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,विधि व्यय
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,कृपया पंक्ति पर मात्रा का चयन करें
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},वर्क ऑर्डर {0}: ऑपरेशन के लिए जॉब कार्ड नहीं मिला {1}
 DocType: Purchase Invoice,Posting Time,बार पोस्टिंग
 DocType: Timesheet,% Amount Billed,% बिल की राशि
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,टेलीफोन व्यय
@@ -6368,7 +6400,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,कर और शुल्क जोड़ा
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,मूल्यह्रास पंक्ति {0}: अगली मूल्यह्रास तिथि उपलब्ध उपयोग के लिए पहले नहीं हो सकती है
 ,Sales Funnel,बिक्री कीप
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,आइटम कोड&gt; आइटम समूह&gt; ब्रांड
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,संक्षिप्त अनिवार्य है
 DocType: Project,Task Progress,कार्य प्रगति
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,गाड़ी
@@ -6464,6 +6495,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,पीओएस प्रोफ़ाइल पीओएस एंट्री बनाने के लिए आवश्यक
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",वफादारी अंक का उल्लेख संग्रहित कारक के आधार पर किए गए व्यय (बिक्री चालान के माध्यम से) से किया जाएगा।
 DocType: Program Enrollment Tool,Enroll Students,छात्रों को भर्ती
+DocType: Pricing Rule,Coupon Code Based,कूपन कोड आधारित
 DocType: Company,HRA Settings,एचआरए सेटिंग्स
 DocType: Homepage,Hero Section,हीरो सेक्शन
 DocType: Employee Transfer,Transfer Date,हस्तांतरण की तारीख
@@ -6579,6 +6611,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',अगर ग्रुप बाय &#39;कंपनी&#39; है तो कंपनी को फिल्टर रिक्त करें
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,पोस्ट दिनांक भविष्य की तारीख नहीं किया जा सकता
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},पंक्ति # {0}: सीरियल नहीं {1} के साथ मेल नहीं खाता {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,कृपया सेटअप&gt; नंबरिंग श्रृंखला के माध्यम से उपस्थिति के लिए क्रमांकन श्रृंखला की स्थापना करें
 DocType: Stock Entry,Target Warehouse Address,लक्ष्य वेअरहाउस पता
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,आकस्मिक छुट्टी
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,पारी शुरू होने से पहले का समय जिसके दौरान कर्मचारी चेक-इन उपस्थिति के लिए माना जाता है।
@@ -6613,7 +6646,6 @@
 DocType: Employee Grade,Employee Grade,कर्मचारी ग्रेड
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,ठेका
 DocType: GSTR 3B Report,June,जून
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,आपूर्तिकर्ता&gt; आपूर्तिकर्ता प्रकार
 DocType: Share Balance,From No,नंबर से
 DocType: Shift Type,Early Exit Grace Period,प्रारंभिक निकास अनुग्रह अवधि
 DocType: Task,Actual Time (in Hours),(घंटे में) वास्तविक समय
@@ -6898,7 +6930,6 @@
 DocType: Warehouse,Warehouse Name,वेअरहाउस नाम
 DocType: Naming Series,Select Transaction,लेन - देन का चयन करें
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,रोल अनुमोदन या उपयोगकर्ता स्वीकृति दर्ज करें
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM रूपांतरण कारक ({0} -&gt; {1}) आइटम के लिए नहीं मिला: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,एंटिटी टाइप {0} और एंटिटी {1} सर्विस लेवल एग्रीमेंट पहले से मौजूद है।
 DocType: Journal Entry,Write Off Entry,एंट्री बंद लिखने
 DocType: BOM,Rate Of Materials Based On,सामग्री के आधार पर दर
@@ -7036,6 +7067,7 @@
 DocType: Budget,Warn,चेतावनी देना
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,इस कार्य आदेश के लिए सभी आइटम पहले ही स्थानांतरित कर दिए गए हैं।
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","किसी भी अन्य टिप्पणी, अभिलेखों में जाना चाहिए कि उल्लेखनीय प्रयास।"
+DocType: Bank Account,Company Account,कंपनी खाता
 DocType: Asset Maintenance,Manufacturing User,विनिर्माण प्रयोक्ता
 DocType: Purchase Invoice,Raw Materials Supplied,कच्चे माल की आपूर्ति
 DocType: Subscription Plan,Payment Plan,भुगतान योजना
@@ -7077,6 +7109,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) वर्क ऑर्डर में नियोजित मात्रा ({2}) से अधिक नहीं हो सकता है {3}
 DocType: Certification Application,Name of Applicant,आवेदक का नाम
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,विनिर्माण के लिए समय पत्रक।
+DocType: Quick Stock Balance,Quick Stock Balance,क्विक स्टॉक बैलेंस
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,आधा
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,स्टॉक लेनदेन के बाद वेरिएंट गुणों को बदल नहीं सकते हैं। ऐसा करने के लिए आपको एक नया आइटम बनाना होगा।
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA आदेश
@@ -7402,6 +7435,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},सेट करें {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} निष्क्रिय छात्र है
 DocType: Employee,Health Details,स्वास्थ्य विवरण
+DocType: Coupon Code,Coupon Type,कूपन प्रकार
 DocType: Leave Encashment,Encashable days,Encashable दिन
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,भुगतान अनुरोध संदर्भ दस्तावेज़ बनाने के लिए आवश्यक है
 DocType: Soil Texture,Sandy Clay,सैंडी क्ले
@@ -7685,6 +7719,7 @@
 DocType: Hotel Room Package,Amenities,आराम
 DocType: Accounts Settings,Automatically Fetch Payment Terms,स्वचालित रूप से भुगतान शर्तें प्राप्त करें
 DocType: QuickBooks Migrator,Undeposited Funds Account,Undeposited फंड खाता
+DocType: Coupon Code,Uses,उपयोग
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,भुगतान के कई डिफ़ॉल्ट मोड की अनुमति नहीं है
 DocType: Sales Invoice,Loyalty Points Redemption,वफादारी अंक मोचन
 ,Appointment Analytics,नियुक्ति विश्लेषिकी
@@ -7701,6 +7736,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,कुल बजट
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,अगर आप प्रति वर्ष छात्र समूह बनाते हैं तो रिक्त छोड़ दें
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","जाँच की, तो कुल नहीं. कार्य दिवस की छुट्टियों में शामिल होगा, और यह प्रति दिन वेतन का मूल्य कम हो जाएगा"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,डोमेन जोड़ने में विफल
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","रसीद / वितरण की अनुमति देने के लिए, स्टॉक सेटिंग्स या आइटम में &quot;ओवर रसीद / वितरण भत्ता&quot; अपडेट करें।"
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","वर्तमान कुंजी का उपयोग करने वाले ऐप्स तक पहुंचने में सक्षम नहीं होंगे, क्या आप निश्चित हैं?"
 DocType: Subscription Settings,Prorate,prorate
@@ -7713,6 +7749,7 @@
 ,BOM Stock Report,बीओएम स्टॉक रिपोर्ट
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","यदि कोई निर्धारित समयसीमा नहीं है, तो संचार इस समूह द्वारा नियंत्रित किया जाएगा"
 DocType: Stock Reconciliation Item,Quantity Difference,मात्रा अंतर
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,आपूर्तिकर्ता&gt; आपूर्तिकर्ता प्रकार
 DocType: Opportunity Item,Basic Rate,मूल दर
 DocType: GL Entry,Credit Amount,राशि क्रेडिट करें
 ,Electronic Invoice Register,इलेक्ट्रॉनिक चालान रजिस्टर
@@ -7966,6 +8003,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),कर और शुल्क कटौती (कंपनी मुद्रा)
 DocType: Item Group,General Settings,सामान्य सेटिंग्स
 DocType: Article,Article,लेख
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,कृपया कूपन कोड दर्ज करें !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,मुद्रा से और मुद्रा ही नहीं किया जा सकता है
 DocType: Taxable Salary Slab,Percent Deduction,प्रतिशत कटौती
 DocType: GL Entry,To Rename,का नाम बदला
diff --git a/erpnext/translations/hr.csv b/erpnext/translations/hr.csv
index f590e18..d49b79a 100644
--- a/erpnext/translations/hr.csv
+++ b/erpnext/translations/hr.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Kupac Kontakt
 DocType: Shift Type,Enable Auto Attendance,Omogući automatsku posjetu
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Unesite datum skladišta i datum
 DocType: Lost Reason Detail,Opportunity Lost Reason,Prilika izgubljen razlog
 DocType: Patient Appointment,Check availability,Provjera dostupnosti
 DocType: Retention Bonus,Bonus Payment Date,Datum plaćanja bonusa
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Dovršeni radni nalozi
 DocType: Support Settings,Forum Posts,Forum postova
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Zadatak je zamišljen kao pozadinski posao. U slučaju da dođe do problema s obradom u pozadini, sustav će dodati komentar o pogrešci ovog usklađivanja zaliha i vratit će se u fazu skice."
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Nažalost, valjanost koda kupona nije započela"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Iznos oporezivanja
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Niste ovlašteni dodavati ili ažurirati unose prije {0}
 DocType: Leave Policy,Leave Policy Details,Ostavite pojedinosti o pravilima
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,potrošni
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,Razred
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kod artikla&gt; Grupa artikala&gt; Marka
 DocType: Restaurant Table,No of Seats,Nema sjedala
 DocType: Sales Invoice,Overdue and Discounted,Prepušteni i popusti
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Poziv prekinuti
@@ -506,6 +509,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Prored za iznos u riječima
 DocType: Vehicle,Additional Details,dodatni detalji
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Nema opisa
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Dohvaćanje predmeta iz skladišta
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Zahtjev za kupnju.
 DocType: POS Closing Voucher Details,Collected Amount,Prikupljeni iznos
 DocType: Lab Test,Submitted Date,Poslani datum
@@ -613,6 +617,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Naučiti
 ,Trial Balance (Simple),Probna ravnoteža (jednostavno)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Omogući odgođeno plaćanje
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Primijenjeni kod kupona
 DocType: Asset,Next Depreciation Date,Sljedeći datum Amortizacija
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Aktivnost Cijena po zaposlenom
 DocType: Accounts Settings,Settings for Accounts,Postavke za račune
@@ -848,8 +853,6 @@
 DocType: BOM,Work Order,Radni nalog
 DocType: Sales Invoice,Total Qty,Ukupna količina
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,ID e-pošte Guardian2
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Izbrišite zaposlenika <a href=""#Form/Employee/{0}"">{0}</a> \ da biste otkazali ovaj dokument"
 DocType: Item,Show in Website (Variant),Prikaži u Web (Variant)
 DocType: Employee,Health Concerns,Zdravlje Zabrinutost
 DocType: Payroll Entry,Select Payroll Period,Odaberite Platne razdoblje
@@ -1013,6 +1016,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Račun za zadržavanje poreza
 DocType: Pricing Rule,Sales Partner,Prodajni partner
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Sve ocjene bodova dobavljača.
+DocType: Coupon Code,To be used to get discount,Da se iskoristi za popust
 DocType: Buying Settings,Purchase Receipt Required,Primka je obvezna
 DocType: Sales Invoice,Rail,željeznički
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Stvarna cijena
@@ -1063,6 +1067,7 @@
 DocType: Production Plan,Production Plan,Plan proizvodnje
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Otvaranje alata za izradu računa
 DocType: Salary Component,Round to the Nearest Integer,Zaokružite na najbliži cijeli broj
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Dopustite dodavanje predmeta u košaricu za kupnju
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Povrat robe
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Postavite količinu u transakcijama na temelju serijskog unosa
 ,Total Stock Summary,Ukupni zbroj dionica
@@ -1192,6 +1197,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Baza Sat stopa (Društvo valuta)
 ,Qty To Be Billed,Količina za naplatu
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Isporučeno Iznos
+DocType: Coupon Code,Gift Card,Poklon kartica
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Količina rezervirane za proizvodnju: Količina sirovina za izradu proizvodnih predmeta.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Datum otkupa
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Ova je bankovna transakcija već u potpunosti usklađena
@@ -1279,6 +1285,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Napravite časopis
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Račun {0} unesen više puta
 DocType: Account,Expenses Included In Valuation,Troškovi uključeni u vrednovanje
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Kupnja fakture
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Možete obnoviti pretplatu samo ako vaše članstvo istekne u roku od 30 dana
 DocType: Shopping Cart Settings,Show Stock Availability,Prikaži raspoloživa roba
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Postavite {0} u kategoriji imovine {1} ili tvrtku {2}
@@ -1837,6 +1844,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Uvoz predmeta i UOM-ova
 DocType: Repayment Schedule,Balance Loan Amount,Stanje Iznos kredita
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Dodano detaljima
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Nažalost, kod kupona je iscrpljen"
 DocType: Communication Medium,Catch All,Uhvatiti sve
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Raspored nastave
 DocType: Budget,Applicable on Material Request,Primjenjivo na zahtjev za materijal
@@ -2004,6 +2012,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Pogrešna Osobina
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} mora biti podnesen
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Kampanje e-pošte
+DocType: Sales Partner,To Track inbound purchase,Kako biste pratili ulaznu kupnju
 DocType: Buying Settings,Default Supplier Group,Zadana skupina dobavljača
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Količina mora biti manji ili jednak {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Maksimalni iznos koji ispunjava uvjete za komponentu {0} prelazi {1}
@@ -2159,8 +2168,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Unesite zalihe
 DocType: Hotel Room Reservation,Hotel Reservation User,Korisnik hotela rezervacije
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Postavite status
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Postavite serijsku brojevnu seriju za Attendance putem Postavljanje&gt; Numeriranje serija
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Odaberite prefiks prvi
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Postavite Nameing Series za {0} putem Postavke&gt; Postavke&gt; Imenovanje serija
 DocType: Contract,Fulfilment Deadline,Rok provedbe
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Blizu tebe
 DocType: Student,O-,O-
@@ -2284,6 +2293,7 @@
 DocType: Quality Meeting Table,Under Review,U pregledu
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Prijava nije uspjela
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Izrađen je element {0}
+DocType: Coupon Code,Promotional,reklamni
 DocType: Special Test Items,Special Test Items,Posebne ispitne stavke
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Morate biti korisnik s ulogama upravitelja sustava i upravitelja stavki da biste se registrirali na tržištu.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Ključna izvješća
@@ -2321,6 +2331,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc tip
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Ukupno dodijeljeno postotak za prodajni tim bi trebao biti 100
 DocType: Subscription Plan,Billing Interval Count,Brojač intervala naplate
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Izbrišite zaposlenika <a href=""#Form/Employee/{0}"">{0}</a> \ da biste otkazali ovaj dokument"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Imenovanja i susreta pacijenata
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Nedostaje vrijednost
 DocType: Employee,Department and Grade,Odjel i ocjena
@@ -2423,6 +2435,7 @@
 DocType: Project,Start and End Dates,Datumi početka i završetka
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Uvjeti ispunjenja predloška ugovora
 ,Delivered Items To Be Billed,Isporučeni proizvodi za naplatiti
+DocType: Coupon Code,Maximum Use,Maksimalna upotreba
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Otvoreno BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Skladište se ne može promijeniti za serijskog broja
 DocType: Authorization Rule,Average Discount,Prosječni popust
@@ -2585,6 +2598,7 @@
 DocType: Item,Inventory,Inventar
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Preuzmi kao Json
 DocType: Item,Sales Details,Prodajni detalji
+DocType: Coupon Code,Used,koristi
 DocType: Opportunity,With Items,S Stavke
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Kampanja &quot;{0}&quot; već postoji za {1} &quot;{2}&quot;
 DocType: Asset Maintenance,Maintenance Team,Tim za održavanje
@@ -2714,7 +2728,7 @@
 						Serial No cannot be ensured",Nije pronađena aktivna BOM za stavku {0}. Dostava po \ Serial No ne može se osigurati
 DocType: Sales Partner,Sales Partner Target,Prodajni plan prodajnog partnera
 DocType: Loan Type,Maximum Loan Amount,Maksimalni iznos kredita
-DocType: Pricing Rule,Pricing Rule,Pravila cijena
+DocType: Coupon Code,Pricing Rule,Pravila cijena
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplikat broja valjaka za učenika {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Materijal Zahtjev za Narudžbenica
 DocType: Company,Default Selling Terms,Zadani uvjeti prodaje
@@ -2793,6 +2807,7 @@
 DocType: Payment Schedule,Payment Amount,Iznos za plaćanje
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Poludnevni datum bi trebao biti između rada od datuma i datuma završetka radnog vremena
 DocType: Healthcare Settings,Healthcare Service Items,Zdravstvene usluge
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Nevažeći barkod. Nijedna stavka nije priložena ovom barkodu.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Konzumira Iznos
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Neto promjena u gotovini
 DocType: Assessment Plan,Grading Scale,ljestvici
@@ -2912,7 +2927,6 @@
 DocType: Share Transfer,Asset Account,Asset Account
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Novi datum izlaska trebao bi biti u budućnosti
 DocType: Purchase Invoice,End date of current invoice's period,Kraj datum tekućeg razdoblja dostavnice
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Postavite sustav imenovanja zaposlenika u Ljudski resursi&gt; HR postavke
 DocType: Lab Test,Technician Name,Naziv tehničara
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3023,6 +3037,7 @@
 DocType: Products Settings,Hide Variants,Sakrij varijante
 DocType: Lead,Next Contact By,Sljedeći kontakt od
 DocType: Compensatory Leave Request,Compensatory Leave Request,Zahtjev za kompenzacijski dopust
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Nije moguće preplatiti za stavku {0} u retku {1} više od {2}. Da biste omogućili prekomjerno naplaćivanje, molimo postavite dodatak u Postavkama računa"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Količina potrebna za proizvod {0} u redku {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Skladište {0} ne može biti izbrisano ako na njemu ima proizvod {1}
 DocType: Blanket Order,Order Type,Vrsta narudžbe
@@ -3191,7 +3206,6 @@
 DocType: Student,Student Mobile Number,Studentski broj mobitela
 DocType: Item,Has Variants,Je Varijante
 DocType: Employee Benefit Claim,Claim Benefit For,Zatražite korist od
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Ne može se overbill za stavku {0} u retku {1} više od {2}. Da biste dopustili prekoračenje, postavite Postavke zaliha"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Ažurirajte odgovor
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Već ste odabrali stavke iz {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Naziv mjesečne distribucije
@@ -3482,6 +3496,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Navedite valutu u Društvu
 DocType: Workstation,Wages per hour,Satnice
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Konfigurirajte {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Kupac&gt; Grupa kupaca&gt; Teritorij
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Stock ravnoteža u batch {0} postat negativna {1} za točku {2} na skladištu {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Sljedeći materijal Zahtjevi su automatski podigli na temelju stavke razini ponovno narudžbi
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Račun {0} je nevažeći. Valuta računa mora biti {1}
@@ -3811,6 +3826,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Slanje plaće Slip
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Na čekanju
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Q qurance mora imati barem jednu ispravnu mogućnost
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Narudžbenice
 DocType: Account,Inter Company Account,Inter račun tvrtke
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Uvoz u rasutom stanju
 DocType: Sales Partner,Address & Contacts,Adresa i kontakti
@@ -3821,6 +3837,7 @@
 DocType: POS Profile,[Select],[Odaberi]
 DocType: Staffing Plan Detail,Number Of Positions,Broj mjesta
 DocType: Vital Signs,Blood Pressure (diastolic),Krvni tlak (dijastolički)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Odaberite kupca.
 DocType: SMS Log,Sent To,Poslano Da
 DocType: Agriculture Task,Holiday Management,Upravljanje odmorom
 DocType: Payment Request,Make Sales Invoice,Napravi prodajni račun
@@ -4029,7 +4046,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} nije podnesen
 DocType: Subscription,Trialling,trialling
 DocType: Sales Invoice Item,Deferred Revenue,Odgođeni prihod
-DocType: Bank Account,GL Account,GL račun
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Račun novca upotrebljavat će se za izradu fakture prodaje
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Podkategorija izuzeća
 DocType: Member,Membership Expiry Date,Datum isteka članstva
@@ -4453,13 +4469,13 @@
 DocType: C-Form Invoice Detail,Territory,Teritorij
 DocType: Pricing Rule,Apply Rule On Item Code,Primijenite pravilo na kod predmeta
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Molimo spomenuti nema posjeta potrebnih
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Izvještaj o stanju dionica
 DocType: Stock Settings,Default Valuation Method,Zadana metoda vrednovanja
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Pristojba
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Prikaži kumulativni iznos
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Ažuriranje je u tijeku. Može potrajati neko vrijeme.
 DocType: Production Plan Item,Produced Qty,Proizvedena količina
 DocType: Vehicle Log,Fuel Qty,Gorivo Kol
-DocType: Stock Entry,Target Warehouse Name,Naziv ciljnog skladišta
 DocType: Work Order Operation,Planned Start Time,Planirani početak vremena
 DocType: Course,Assessment,procjena
 DocType: Payment Entry Reference,Allocated,Dodijeljeni
@@ -4537,10 +4553,12 @@
  1. Načini adresiranja sporova, naknade štete, odgovornosti, itd 
  1. Kontakt Vaše tvrtke."
 DocType: Homepage Section,Section Based On,Odjeljak na temelju
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Prikaži Primijeni kod kupona
 DocType: Issue,Issue Type,Vrsta izdanja
 DocType: Attendance,Leave Type,Vrsta odsustva
 DocType: Purchase Invoice,Supplier Invoice Details,Dobavljač Detalji Račun
 DocType: Agriculture Task,Ignore holidays,Zanemari blagdane
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Dodavanje / uređivanje uvjeta kupona
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Rashodi / Razlika računa ({0}) mora biti račun 'dobit ili gubitak'
 DocType: Stock Entry Detail,Stock Entry Child,Dijete za ulazak na zalihe
 DocType: Project,Copied From,Kopiran iz
@@ -4715,6 +4733,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Plan Procjena Kriteriji
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Transakcije
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Spriječiti narudžbenice
+DocType: Coupon Code,Coupon Name,Naziv kupona
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Osjetljiv
 DocType: Email Campaign,Scheduled,Planiran
 DocType: Shift Type,Working Hours Calculation Based On,Proračun radnog vremena na temelju
@@ -4731,7 +4750,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Napravite Varijante
 DocType: Vehicle,Diesel,Dizel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Valuta cjenika nije odabrana
+DocType: Quick Stock Balance,Available Quantity,Dostupna količina
 DocType: Purchase Invoice,Availed ITC Cess,Availed ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Postavite sustav imenovanja instruktora u Obrazovanje&gt; Postavke obrazovanja
 ,Student Monthly Attendance Sheet,Studentski mjesečna posjećenost list
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Pravilo o isporuci primjenjuje se samo za prodaju
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Row amortizacije {0}: Sljedeći datum amortizacije ne može biti prije datuma kupnje
@@ -4798,8 +4819,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Red {0}: Advance protiv Kupac mora biti kreditna
 DocType: Quality Meeting,Quality Meeting,Sastanak kvalitete
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-skupine do skupine
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Postavite Nameing Series za {0} putem Postavke&gt; Postavke&gt; Imenovanje serija
 DocType: Employee,ERPNext User,ERPNext korisnik
+DocType: Coupon Code,Coupon Description,Opis kupona
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Šarža je obavezna u retku {0}
 DocType: Company,Default Buying Terms,Zadani uvjeti kupnje
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Zaprimljena stavka iz primke
@@ -4962,6 +4983,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Protiv dokumenta Detalj No
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Brisanje nije dopušteno za zemlju {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Tip stranka je obvezna
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Primijenite kod kupona
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",Za radnu karticu {0} možete izvršiti samo unos vrste zaliha &quot;Prijenos materijala za proizvodnju&quot;
 DocType: Quality Inspection,Outgoing,Odlazni
 DocType: Customer Feedback Table,Customer Feedback Table,Tablica s povratnim informacijama kupaca
@@ -5111,7 +5133,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Nakon predaje narudžbe
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Dodaj sve dobavljače
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Red # {0}: dodijeljeni iznos ne može biti veći od nepodmirenog iznosa.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Kupac&gt; Grupa kupaca&gt; Teritorij
 DocType: Tally Migration,Parties,Strane
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Pretraživanje BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,osigurani krediti
@@ -5143,7 +5164,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Ne dopusti postavljanje alternativne stavke za stavku {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Datum se ponavlja
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Ovlašteni potpisnik
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Postavite sustav imenovanja instruktora u Obrazovanje&gt; Postavke obrazovanja
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Neto dostupan ITC (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Napravite naknade
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Ukupno troškovi nabave (putem kupnje proizvoda)
@@ -5168,6 +5188,7 @@
 DocType: Quiz Result,Wrong,pogrešno
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Stopa po kojoj Cjenik valute se pretvaraju u kupca osnovne valute
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Neto iznos (Društvo valuta)
+DocType: Sales Partner,Referral Code,referentni kod
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Ukupni iznos predujma ne može biti veći od ukupnog sankcioniranog iznosa
 DocType: Salary Slip,Hour Rate,Cijena sata
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Omogući automatsku ponovnu narudžbu
@@ -5296,6 +5317,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Prikaži količinu proizvoda
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Neto novčani tijek iz operacije
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Redak # {0}: Status mora biti {1} za popust fakture {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Faktor konverzije UOM ({0} -&gt; {1}) nije pronađen za stavku: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Stavka 4
 DocType: Student Admission,Admission End Date,Prijem Datum završetka
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Podugovaranje
@@ -5318,6 +5340,7 @@
 DocType: Travel Request,Fully Sponsored,Potpuno sponzoriran
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Obrnuti unos dnevnika
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Izradite Job Card
+DocType: Quotation,Referral Sales Partner,Preporuka prodajni partner
 DocType: Quality Procedure Process,Process Description,Opis procesa
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Korisnik {0} je stvoren.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Trenutno nema raspoloživih količina u bilo kojem skladištu
@@ -5452,6 +5475,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM stopa
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Čitanje prenesene datoteke
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Zaustavljen radni nalog ne može se otkazati, prvo ga otkazati"
+DocType: Coupon Code,Coupon Code,Kupon kod
 DocType: Asset,Journal Entry for Scrap,Temeljnica za otpad
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Molimo povucite stavke iz Dostavnica
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Red {0}: odaberite radnu stanicu protiv operacije {1}
@@ -5534,6 +5558,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,Obavezan je datum
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Zbog / Referentni datum ne može biti nakon {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Uvoz i izvoz podataka
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Nažalost, valjanost koda kupona je istekla"
 DocType: Bank Account,Account Details,Detalji računa
 DocType: Crop,Materials Required,Potrebni materijali
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Nema učenika Pronađeno
@@ -5571,6 +5596,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Idite na korisnike
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Uplaćeni iznos + otpis iznos ne može biti veći od SVEUKUPNO
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} nije ispravan broj serije za točku {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Unesite važeći kod kupona !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Napomena : Nema dovoljno ravnotežu dopust za dozvolu tipa {0}
 DocType: Task,Task Description,Opis zadatka
 DocType: Training Event,Seminar,Seminar
@@ -5834,6 +5860,7 @@
 ,TDS Payable Monthly,TDS se plaća mjesečno
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,U redu čekanja za zamjenu BOM-a. Može potrajati nekoliko minuta.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Ne mogu odbiti kada kategorija je "" vrednovanje "" ili "" Vrednovanje i Total '"
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Postavite sustav imenovanja zaposlenika u Ljudski resursi&gt; HR postavke
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Ukupna plaćanja
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serijski Nos potrebna za serijaliziranom točke {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Match Plaćanja s faktura
@@ -5923,6 +5950,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Dobiti sirovine za proizvodnju
 DocType: Job Opening,Job Title,Titula
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Buduće plaćanje Ref
+DocType: Quotation,Additional Discount and Coupon Code,Dodatni popust i kod kupona
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} označava da {1} neće ponuditi ponudu, ali su citirane sve stavke \. Ažuriranje statusa licitacije."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maksimalni uzorci - {0} već su zadržani za šaržu {1} i stavku {2} u seriji {3}.
@@ -6150,7 +6178,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Postavke za web stranice početnu stranicu
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} je na čekanju do {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},Zahtjevi za odobrenje nisu dopušteni za {0} zbog položaja {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Napravi račun kupnje
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Koristi lišće
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Kuponi se koriste {1}. Dozvoljena količina se iscrpljuje
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Želite li poslati materijalni zahtjev
 DocType: Job Offer,Awaiting Response,Očekujem odgovor
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6164,6 +6194,7 @@
 DocType: Training Event Employee,Optional,neobavezan
 DocType: Salary Slip,Earning & Deduction,Zarada &amp; Odbitak
 DocType: Agriculture Analysis Criteria,Water Analysis,Analiza vode
+DocType: Sales Order,Skip Delivery Note,Preskočite dostavnicu
 DocType: Price List,Price Not UOM Dependent,Cijena nije UOM ovisna
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,Stvorene su varijante {0}.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Ugovor o razini usluge već postoji.
@@ -6268,6 +6299,7 @@
 DocType: Vehicle,Last Carbon Check,Posljednja Carbon Check
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Pravni troškovi
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Molimo odaberite količinu na red
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Radni nalog {0}: kartica posla nije pronađena za operaciju {1}
 DocType: Purchase Invoice,Posting Time,Vrijeme knjiženja
 DocType: Timesheet,% Amount Billed,% Naplaćeni iznos
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Telefonski troškovi
@@ -6370,7 +6402,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Porezi i naknade Dodano
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Row amortizacije {0}: Sljedeći datum amortizacije ne može biti prije datuma raspoloživog korištenja
 ,Sales Funnel,prodaja dimnjak
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kod artikla&gt; Grupa artikala&gt; Marka
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Naziv je obavezan
 DocType: Project,Task Progress,Zadatak Napredak
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Kolica
@@ -6466,6 +6497,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS Profil potrebna da bi POS unos
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Bodovne bodove izračunat će se iz potrošnje (putem Prodajnog računa), na temelju faktora prikupljanja."
 DocType: Program Enrollment Tool,Enroll Students,upisati studenti
+DocType: Pricing Rule,Coupon Code Based,Na temelju koda kupona
 DocType: Company,HRA Settings,Postavke HRA
 DocType: Homepage,Hero Section,Sekcija heroja
 DocType: Employee Transfer,Transfer Date,Datum prijenosa
@@ -6581,6 +6613,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Postavite prazan filtar Tvrtke ako je Skupna pošta &quot;Tvrtka&quot;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Knjiženja Datum ne može biti datum u budućnosti
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Red # {0}: Serijski br {1} ne odgovara {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Postavite serijsku brojevnu seriju za Attendance putem Postavljanje&gt; Numeriranje serija
 DocType: Stock Entry,Target Warehouse Address,Adresa ciljne skladišta
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Casual dopust
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,Vrijeme prije početka vremena smjene tijekom kojeg se prijava zaposlenika uzima u obzir za prisustvo.
@@ -6615,7 +6648,6 @@
 DocType: Employee Grade,Employee Grade,Grade zaposlenika
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Rad po komadu
 DocType: GSTR 3B Report,June,lipanj
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dobavljač&gt; vrsta dobavljača
 DocType: Share Balance,From No,Od br
 DocType: Shift Type,Early Exit Grace Period,Period prijevremenog izlaska iz milosti
 DocType: Task,Actual Time (in Hours),Stvarno vrijeme (u satima)
@@ -6900,7 +6932,6 @@
 DocType: Warehouse,Warehouse Name,Naziv skladišta
 DocType: Naming Series,Select Transaction,Odaberite transakciju
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Unesite Odobravanje ulogu ili Odobravanje korisnike
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Faktor konverzije UOM ({0} -&gt; {1}) nije pronađen za stavku: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Ugovor o razini usluge s tipom entiteta {0} i entitetom {1} već postoji.
 DocType: Journal Entry,Write Off Entry,Otpis unos
 DocType: BOM,Rate Of Materials Based On,Stopa materijali na temelju
@@ -7038,6 +7069,7 @@
 DocType: Budget,Warn,Upozoriti
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Sve su stavke već prenesene za ovu radnu narudžbu.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Sve ostale primjedbe, značajan napor da bi trebao ići u evidenciji."
+DocType: Bank Account,Company Account,Račun tvrtke
 DocType: Asset Maintenance,Manufacturing User,Proizvodni korisnik
 DocType: Purchase Invoice,Raw Materials Supplied,Sirovine nabavlja
 DocType: Subscription Plan,Payment Plan,Plan plaćanja
@@ -7079,6 +7111,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) ne može biti veći od planirane količine ({2}) u Radnoj nalogu {3}
 DocType: Certification Application,Name of Applicant,Naziv podnositelja zahtjeva
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Vrijeme list za proizvodnju.
+DocType: Quick Stock Balance,Quick Stock Balance,Brzo stanje zaliha
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,suma stavke
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Nije moguće mijenjati svojstva varijanti nakon transakcije zaliha. Morat ćete napraviti novu stavku da to učinite.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA mandat
@@ -7405,6 +7438,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},Molimo postavite {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} je neaktivan učenik
 DocType: Employee,Health Details,Zdravlje Detalji
+DocType: Coupon Code,Coupon Type,Vrsta kupona
 DocType: Leave Encashment,Encashable days,Napadi koji se mogu vezati
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Za izradu referentnog dokumenta zahtjeva za plaćanje potrebno je
 DocType: Soil Texture,Sandy Clay,Sandy Clay
@@ -7688,6 +7722,7 @@
 DocType: Hotel Room Package,Amenities,Sadržaji
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Automatski preuzmi Uvjete plaćanja
 DocType: QuickBooks Migrator,Undeposited Funds Account,Neraspoređeni račun sredstava
+DocType: Coupon Code,Uses,koristi
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Višestruki zadani način plaćanja nije dopušten
 DocType: Sales Invoice,Loyalty Points Redemption,Otkup lojalnih bodova
 ,Appointment Analytics,Imenovanje Google Analytics
@@ -7704,6 +7739,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Ukupni proračun
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Ostavite prazno ako grupe studenata godišnje unesete
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Ako je označeno, Ukupan broj. radnih dana će uključiti odmor, a to će smanjiti vrijednost plaća po danu"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Dodavanje Domene nije uspjelo
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Da biste omogućili primanje / isporuku, ažurirajte &quot;Preplata primanja / Dostava&quot; u Postavkama zaliha ili Stavka."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Aplikacije pomoću trenutnog ključa neće moći pristupiti, jeste li sigurni?"
 DocType: Subscription Settings,Prorate,Proporcionalno podijeliti
@@ -7716,6 +7752,7 @@
 ,BOM Stock Report,BOM Stock Report
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Ako nema dodijeljenog vremenskog intervala, komunikacija će upravljati ovom skupinom"
 DocType: Stock Reconciliation Item,Quantity Difference,Količina razlika
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dobavljač&gt; vrsta dobavljača
 DocType: Opportunity Item,Basic Rate,Osnovna stopa
 DocType: GL Entry,Credit Amount,Kreditni iznos
 ,Electronic Invoice Register,Registar elektroničkih računa
@@ -7969,6 +8006,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Porezi i naknade Umanjenja (Društvo valuta)
 DocType: Item Group,General Settings,Opće postavke
 DocType: Article,Article,Članak
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Unesite kod kupona !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Od valute i valuta ne mogu biti isti
 DocType: Taxable Salary Slab,Percent Deduction,Postotak odbitka
 DocType: GL Entry,To Rename,Za preimenovanje
diff --git a/erpnext/translations/hu.csv b/erpnext/translations/hu.csv
index 3bb5f7d..bd8a6f3 100644
--- a/erpnext/translations/hu.csv
+++ b/erpnext/translations/hu.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Vevő ügyfélkapcsolat
 DocType: Shift Type,Enable Auto Attendance,Automatikus jelenlét engedélyezése
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,"Kérjük, írja be a Raktár és a dátumot"
 DocType: Lost Reason Detail,Opportunity Lost Reason,Lehetséges ok
 DocType: Patient Appointment,Check availability,Ellenőrizd az elérhetőséget
 DocType: Retention Bonus,Bonus Payment Date,Bónusz fizetési dátuma
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Elvégzett munka rendelések
 DocType: Support Settings,Forum Posts,Fórum hozzászólások
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","A feladat hátteret kapott. Ha a háttérben történő feldolgozás kérdése merül fel, a rendszer megjegyzést fűz a készlet-egyeztetés hibájához, és visszatér a Piszkozat szakaszba"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started",Sajnos a kuponkód érvényessége még nem kezdődött meg
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Adóalap
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Nincs engedélye bejegyzés hozzáadására és frissítésére előbb mint: {0}
 DocType: Leave Policy,Leave Policy Details,Távollét szabályok részletei
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Fogyóeszközök
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,Osztály
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Cikkszám&gt; Tételcsoport&gt; Márka
 DocType: Restaurant Table,No of Seats,Ülőhelyek  száma
 DocType: Sales Invoice,Overdue and Discounted,Lejárt és kedvezményes
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Hívás megszakítva
@@ -506,6 +509,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Sor közök az összeg kiírásához
 DocType: Vehicle,Additional Details,További részletek
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Nincs megadott leírás
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Tételek letöltése a raktárból
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Vásárolható rendelés.
 DocType: POS Closing Voucher Details,Collected Amount,Összegyűjtött összeg
 DocType: Lab Test,Submitted Date,Benyújtott dátum
@@ -613,6 +617,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Tanulás
 ,Trial Balance (Simple),Főkönyvi kivonat (Egyszerű)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Engedélyezze a halasztott költségeket
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Alkalmazott kuponkód
 DocType: Asset,Next Depreciation Date,Következő Értékcsökkenés dátuma
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Alkalmazottankénti Tevékenység költség
 DocType: Accounts Settings,Settings for Accounts,Fiókok beállítása
@@ -848,8 +853,6 @@
 DocType: BOM,Work Order,Munka rendelés
 DocType: Sales Invoice,Total Qty,Összesen Mennyiség
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Helyettesítő2 e-mail azonosító
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Kérjük, törölje a (z) <a href=""#Form/Employee/{0}"">{0}</a> alkalmazottat a dokumentum visszavonásához"
 DocType: Item,Show in Website (Variant),Megjelenítés a weboldalon (Változat)
 DocType: Employee,Health Concerns,Egészségügyi problémák
 DocType: Payroll Entry,Select Payroll Period,Válasszon Bérszámfejtési Időszakot
@@ -1013,6 +1016,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Adó visszatartási számla
 DocType: Pricing Rule,Sales Partner,Vevő partner
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Összes Beszállító eredménymutatói.
+DocType: Coupon Code,To be used to get discount,"Ahhoz, hogy kedvezményt kapjunk"
 DocType: Buying Settings,Purchase Receipt Required,Beszerzési megrendelés nyugta kötelező
 DocType: Sales Invoice,Rail,Sín
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Tényleges költség
@@ -1063,6 +1067,7 @@
 DocType: Production Plan,Production Plan,Termelési terv
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Számlát létrehozó eszköz megnyitása
 DocType: Salary Component,Round to the Nearest Integer,Kerek a legközelebbi egész számhoz
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,"Hagyja, hogy a készletben nem lévő tételek kosárba kerüljenek"
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Értékesítés visszaküldése
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Mennyiség megadása a sorozatszámos bemeneten alapuló tranzakciókhoz
 ,Total Stock Summary,Készlet Összefoglaló
@@ -1192,6 +1197,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Alapértelmezett óradíj (Vállalkozás pénznemében)
 ,Qty To Be Billed,Mennyit kell számlázni
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Szállított érték
+DocType: Coupon Code,Gift Card,Ajándékkártya
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Fenntartott termelési mennyiség: alapanyagok mennyisége a gyártáshoz.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Visszaváltási dátum
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Ez a banki tranzakció már teljesen egyezik
@@ -1279,6 +1285,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Időablak létrehozása
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,A {0} számlát már többször bevitték
 DocType: Account,Expenses Included In Valuation,Készletértékelésbe belevitt költségek
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Vásárlási számlák
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,"Csak akkor tudja megújítani, ha tagsága lejár 30 napon belül"
 DocType: Shopping Cart Settings,Show Stock Availability,Raktárkészlet elérhetőségének megjelenítése
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},"Állítsa {0} a vagyontárgy ketegóriát: {1}, vagy a vállalkozást: {2}"
@@ -1818,6 +1825,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Elemek és UOM-ok importálása
 DocType: Repayment Schedule,Balance Loan Amount,Hitel összeg mérlege
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Hozzáadva a részletekhez
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Sajnáljuk, a kuponkód kimerült"
 DocType: Communication Medium,Catch All,Catch All
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Menetrend pálya
 DocType: Budget,Applicable on Material Request,Az anyagkérelemkor alkalmazható
@@ -1985,6 +1993,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Érvénytelen Jellemző
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} be kell nyújtani
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,E-mail kampányok
+DocType: Sales Partner,To Track inbound purchase,A bejövő vásárlás nyomon követése
 DocType: Buying Settings,Default Supplier Group,Alapértelmezett beszállítói csoport
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Mennyiségnek kisebb vagy egyenlő legyen mint {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},A (z) {0} összetevőre jogosult maximális mennyiség meghaladja: {1}
@@ -2140,8 +2149,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Nyilvántartásba vétel
 DocType: Hotel Room Reservation,Hotel Reservation User,Hotel foglalás felhasználó
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Állapot beállítása
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,"Kérjük, állítsa be a számozási sorozatokat a jelenléthez a Beállítás&gt; Számozási sorozat segítségével"
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,"Kérjük, válasszon prefix először"
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,"Kérjük, állítsa a Naming sorozatot a (z) {0} beállításra a Beállítás&gt; Beállítások&gt; Sorozat elnevezése menüpont alatt"
 DocType: Contract,Fulfilment Deadline,Teljesítési határidő
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Közel hozzád
 DocType: Student,O-,ALK-
@@ -2265,6 +2274,7 @@
 DocType: Quality Meeting Table,Under Review,Felülvizsgálat alatt
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Sikertelen bejelentkezés
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,A  {0}  vagyontárgy létrehozva
+DocType: Coupon Code,Promotional,Promóciós
 DocType: Special Test Items,Special Test Items,Különleges vizsgálati tételek
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,"Ahhoz, hogy regisztráljon a Marketplace-re, be kell jelentkeznie a System Manager és a Item Manager szerepekkel."
 apps/erpnext/erpnext/config/buying.py,Key Reports,Főbb jelentések
@@ -2302,6 +2312,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc Type
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Az értékesítési csoport teljes lefoglalt százaléka  100 kell legyen
 DocType: Subscription Plan,Billing Interval Count,Számlázási időtartam számláló
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Kérjük, törölje a (z) <a href=""#Form/Employee/{0}"">{0}</a> alkalmazottat a dokumentum visszavonásához"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Vizitek és a beteg látogatások
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Érték hiányzik
 DocType: Employee,Department and Grade,Osztály és osztály
@@ -2404,6 +2416,7 @@
 DocType: Project,Start and End Dates,Kezdetének és befejezésének időpontjai
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Szerződései sablon teljesítési feltételei
 ,Delivered Items To Be Billed,Számlázandó kiszállított tétel
+DocType: Coupon Code,Maximum Use,Maximális felhasználás
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Anyagj.: {0} megnyitása
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,A sorozatszámhoz tartozó raktárat nem lehet megváltoztatni.
 DocType: Authorization Rule,Average Discount,Átlagos kedvezmény
@@ -2565,6 +2578,7 @@
 DocType: Item,Inventory,Leltár
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Töltse le Json néven
 DocType: Item,Sales Details,Értékesítés részletei
+DocType: Coupon Code,Used,Használt
 DocType: Opportunity,With Items,Tételekkel
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',A (z) {0} kampány már létezik a (z) {1} &#39;{2}&#39; kampányhoz
 DocType: Asset Maintenance,Maintenance Team,Karbantartó csoport
@@ -2694,7 +2708,7 @@
 						Serial No cannot be ensured",A (z) {0} tételhez nem található aktív BOM. Nem biztosítható a \ Serial No \ Delivery
 DocType: Sales Partner,Sales Partner Target,Vevő partner cél
 DocType: Loan Type,Maximum Loan Amount,Maximális hitel összeg
-DocType: Pricing Rule,Pricing Rule,Árképzési szabály
+DocType: Coupon Code,Pricing Rule,Árképzési szabály
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Ismétlődő lajstromszám ehhez a hallgatóhoz: {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Anyagigénylés -&gt; Beszerzési megrendelésre
 DocType: Company,Default Selling Terms,Alapértelmezett eladási feltételek
@@ -2774,6 +2788,7 @@
 DocType: Payment Schedule,Payment Amount,Kifizetés összege
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Félnapos dátumának a munka kezdési és a befejező dátum köztinek kell lennie
 DocType: Healthcare Settings,Healthcare Service Items,Egészségügyi szolgáltatási tételek
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Érvénytelen vonalkód. Ehhez a vonalkódhoz nincs csatolt elem.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Elfogyasztott mennyiség
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Nettó készpénz változás
 DocType: Assessment Plan,Grading Scale,Osztályozás időszak
@@ -2893,7 +2908,6 @@
 DocType: Share Transfer,Asset Account,Vagyontárgy-számla
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Az új kiadási dátumnak a jövőben kell lennie
 DocType: Purchase Invoice,End date of current invoice's period,A befejezés dátuma az aktuális számla időszakra
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Kérjük, állítsa be a Munkavállalók elnevezési rendszerét a Humán erőforrás&gt; HR beállítások menüpontban"
 DocType: Lab Test,Technician Name,Technikus neve
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3005,6 +3019,7 @@
 DocType: Products Settings,Hide Variants,Variánsok elrejtése
 DocType: Lead,Next Contact By,Következő kapcsolat evvel
 DocType: Compensatory Leave Request,Compensatory Leave Request,Kompenzációs távolléti kérelem
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","A (z) {1} sorban a (z) {0} tételnél nem lehet túlterhelni, mint {2}. A túlszámlázás engedélyezéséhez kérjük, állítsa be a kedvezményt a Fiókbeállítások között"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},"Szükséges mennyiség ebből a tételből {0}, ebben a sorban {1}"
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},"{0} Raktárat nem lehet törölni, mint a {1} tételre létezik mennyiség"
 DocType: Blanket Order,Order Type,Rendelés típusa
@@ -3174,7 +3189,6 @@
 DocType: Student,Student Mobile Number,Tanuló mobil szám
 DocType: Item,Has Variants,Rrendelkezik változatokkal
 DocType: Employee Benefit Claim,Claim Benefit For,A kártérítési igény
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","A (z) {1} sorban a (z) {0} tételnél nem lehet túlterhelni, mint {2}. A túlszámlázás engedélyezéséhez kérjük, állítsa be a Készletbeállításokba"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Frissítse a válaszadást
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Már választott ki elemeket innen {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Havi Felbontás neve
@@ -3464,6 +3478,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,"Kérjük, adja meg a vállalkozás pénznemét"
 DocType: Workstation,Wages per hour,Bérek óránként
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Konfigurálás: {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Vevő&gt; Vevőcsoport&gt; Terület
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Készlet egyenleg ebben a kötegben: {0} negatívvá válik {1} erre a tételre: {2} ebben a raktárunkban: {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Következő Anyag igénylések merültek fel  automatikusan a Tétel újra-rendelés szinje alpján
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},A {0} számla érvénytelen. A számla pénzneme legyen {1}
@@ -3793,6 +3808,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Bérpapír küldés
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Feltartva
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,A kérdésnek legalább egy helyes opcióval kell rendelkeznie
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Megrendelések
 DocType: Account,Inter Company Account,Inter vállalkozási számla
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Csoportos importálás
 DocType: Sales Partner,Address & Contacts,Címek és Kapcsolattartók
@@ -3803,6 +3819,7 @@
 DocType: POS Profile,[Select],[Válasszon]
 DocType: Staffing Plan Detail,Number Of Positions,Pozíciók száma
 DocType: Vital Signs,Blood Pressure (diastolic),Vérnyomás (diasztolik)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,"Kérjük, válassza ki az ügyfelet."
 DocType: SMS Log,Sent To,Elküldve
 DocType: Agriculture Task,Holiday Management,Távollétek kezelése
 DocType: Payment Request,Make Sales Invoice,Vevői megrendelésre számla létrehozás
@@ -4012,7 +4029,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} nem nyújtják be
 DocType: Subscription,Trialling,kísérleti
 DocType: Sales Invoice Item,Deferred Revenue,Halasztott bevétel
-DocType: Bank Account,GL Account,GL számla
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Készpénzszámla kerül használatra az értékesítési számla létrehozásakor
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Mentesség alkategóriája
 DocType: Member,Membership Expiry Date,Tagság lejárati idő
@@ -4415,13 +4431,13 @@
 DocType: C-Form Invoice Detail,Territory,Terület
 DocType: Pricing Rule,Apply Rule On Item Code,Alkalmazza a cikk kódját
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Kérjük említse meg a szükséges résztvevők számát
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Készletmérleg-jelentés
 DocType: Stock Settings,Default Valuation Method,Alapértelmezett készletérték számítási mód
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Részvételi díj
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Összesített összeg megjelenítése
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Frissítés folyamatban. Ez eltarthat egy ideig.
 DocType: Production Plan Item,Produced Qty,Termelt mennyiség
 DocType: Vehicle Log,Fuel Qty,Üzemanyag menny.
-DocType: Stock Entry,Target Warehouse Name,Cél raktár neve
 DocType: Work Order Operation,Planned Start Time,Tervezett kezdési idő
 DocType: Course,Assessment,Értékelés
 DocType: Payment Entry Reference,Allocated,Lekötött
@@ -4487,10 +4503,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","Általános Szerződési Feltételek az Ertékesítés- és a Beszerzéshez. Példák: 1. Az ajánlat érvényessége. 1. Fizetési feltételek (Előre, Hitelre, részben előre stb.). 1. Mi az extra (vagy a vevő által fizetendő). 1. Biztonsági / használati figyelmeztetést. 1. Garancia, ha van ilyen. 1. Garancia kezelésének irányelve. 1. Szállítási feltételek, ha van ilyen. 1. Viták kezelése, kártérítés, felelősségvállalás, titoktartás stb. 1. Vállalatának címe és kapcsolattartási elérhetősége."
 DocType: Homepage Section,Section Based On,Szakasz alapján
+DocType: Shopping Cart Settings,Show Apply Coupon Code,A kuponkód alkalmazása
 DocType: Issue,Issue Type,Probléma típus
 DocType: Attendance,Leave Type,Távollét típusa
 DocType: Purchase Invoice,Supplier Invoice Details,Beszállító Számla részletek
 DocType: Agriculture Task,Ignore holidays,Ünnepek figyelmen kívül hagyása
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Kuponfeltételek hozzáadása / szerkesztése
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Költség / Különbség számla ({0}) ,aminek ""Nyereség és Veszteség""  számlának kell lennie"
 DocType: Stock Entry Detail,Stock Entry Child,Stock Entry gyermek
 DocType: Project,Copied From,Innen másolt
@@ -4665,6 +4683,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Értékelési Terv kritériumai
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,tranzakciók
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Vásárlási megrendelések megakadályozása
+DocType: Coupon Code,Coupon Name,Kupon neve
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Fogékony
 DocType: Email Campaign,Scheduled,Ütemezett
 DocType: Shift Type,Working Hours Calculation Based On,Munkaidő számítása alapján
@@ -4681,7 +4700,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Hozzon létre változatok
 DocType: Vehicle,Diesel,Dízel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Árlista pénzneme nincs kiválasztva
+DocType: Quick Stock Balance,Available Quantity,elérhető mennyiség
 DocType: Purchase Invoice,Availed ITC Cess,Hasznosított ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,"Kérjük, állítsa be az Oktató elnevezési rendszert az Oktatás&gt; Oktatási beállítások részben"
 ,Student Monthly Attendance Sheet,Tanuló havi jelenléti ív
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Csak az értékesítésre vonatkozó szállítási szabály
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Értékcsökkenési sor {0}: A következő értékcsökkenési időpont nem lehet a vétel időpontja előtti
@@ -4748,8 +4769,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Sor {0}: A Vevővel szembeni előlegnek követelésnek kell lennie
 DocType: Quality Meeting,Quality Meeting,Minőségi találkozó
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Csoport nélküliek csoportokba
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,"Kérjük, állítsa a Naming sorozatot a (z) {0} beállításra a Beállítás&gt; Beállítások&gt; Sorozat elnevezése menüpont alatt"
 DocType: Employee,ERPNext User,ERPNext felhasználó
+DocType: Coupon Code,Coupon Description,Kupon leírás
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Köteg kötelező ebben a sorban {0}
 DocType: Company,Default Buying Terms,Alapértelmezett vásárlási feltételek
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Beszerzési nyugta tételek beszállítva
@@ -4912,6 +4933,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Ellen Dokument Részlet sz.
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Törlés a (z) {0} országban nincs engedélyezve
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Ügyfél típus kötelező
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Alkalmazza a kuponkódot
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",A (z) {0} álláskártya esetén csak az „Anyagátadás a gyártáshoz” típusú készletbejegyzés lehetséges
 DocType: Quality Inspection,Outgoing,Kimenő
 DocType: Customer Feedback Table,Customer Feedback Table,Ügyfél-visszajelzési táblázat
@@ -5061,7 +5083,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Megrendelés benyújtásakor
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Összes beszállító hozzáadása
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,"# {0} sor: elkülönített összeg nem lehet nagyobb, mint fennálló összeg."
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Vevő&gt; Vevőcsoport&gt; Terület
 DocType: Tally Migration,Parties,A felek
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Keressen anyagjegyzéket
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Záloghitel
@@ -5093,7 +5114,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Nem engedélyezhető az {0} tételre az alternatív tétel változat beállítása
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Dátum megismétlődik
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Hitelesített aláírás
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,"Kérjük, állítsa be az Oktató elnevezési rendszert az Oktatás&gt; Oktatási beállítások menüben"
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Nettó ITC elérhető (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Díjak létrehozása
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Beszerzés teljes költsége (Beszerzési számla alapján)
@@ -5118,6 +5138,7 @@
 DocType: Quiz Result,Wrong,Rossz
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Arány, amelyen az Árlista pénznemét átalakítja az Ügyfél alapértelmezett pénznemére"
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Nettó összeg (Társaság pénznemében)
+DocType: Sales Partner,Referral Code,hivatkozási kód
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,"A teljes előleg összege nem lehet nagyobb, mint a teljes szankcionált összege"
 DocType: Salary Slip,Hour Rate,Óra árértéke
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Engedélyezze az automatikus újrarendelést
@@ -5246,6 +5267,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Készlet mennyiség megjelenítése
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Származó nettó a műveletekből
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},"{0} sor: Az állapotnak {1} kell lennie, ha a számlát diszkontáljuk. {2}"
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM konverziós tényező ({0} -&gt; {1}) nem található az elemre: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,4. tétel
 DocType: Student Admission,Admission End Date,Felvételi Végdátum
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Alvállalkozói
@@ -5268,6 +5290,7 @@
 DocType: Travel Request,Fully Sponsored,Teljesen szponzorált
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Fordított naplóbejegyzés
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Hozzon létre Munkalapot
+DocType: Quotation,Referral Sales Partner,Referral Sales Partner
 DocType: Quality Procedure Process,Process Description,Folyamatleírás
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,A(z)  {0} vevő létrehozva.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Jelenleg nincs raktárkészlet egyik raktárban sem
@@ -5402,6 +5425,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,Anyagjegyzék Díjszabási ár
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Feltöltött fájl olvasása
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","A Megszakított Munka Rendelést nem lehet törölni,  először folytassa a megszüntetéshez"
+DocType: Coupon Code,Coupon Code,Kupon kód
 DocType: Asset,Journal Entry for Scrap,Naplóbejegyzés selejtezéshez
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,"Kérjük, vegye kia a tételeket a szállítólevélből"
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},{0} sor: válassza ki a munkaállomást a művelet ellen {1}
@@ -5484,6 +5508,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,A „dátum” kötelező
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Határidő / referencia dátum nem lehet {0} utáni
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Adatok importálása és exportálása
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired",Sajnos a kuponkód érvényessége lejárt
 DocType: Bank Account,Account Details,Számla adatok
 DocType: Crop,Materials Required,Szükséges anyagok
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Nem talált diákokat
@@ -5521,6 +5546,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Menjen a felhasználókhoz
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,"Fizetett összeg + Leírható összeg nem lehet nagyobb, mint a Teljes összeg"
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} nem érvényes Köteg szám ehhez a tételhez {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,"Kérjük, érvényes kuponkódot írjon be !!"
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Megjegyzés: Nincs elég távollét egyenlege erre a távollét típusra {0}
 DocType: Task,Task Description,Feladatleírás
 DocType: Training Event,Seminar,Szeminárium
@@ -5784,6 +5810,7 @@
 ,TDS Payable Monthly,TDS fizethető havonta
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Queue a BOM cseréjéhez. Néhány percig tarthat.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Nem vonható le, ha a kategória a 'Készletérték' vagy 'Készletérték és Teljes érték'"
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Kérjük, állítsa be a Munkavállalók elnevezési rendszerét a Humán erőforrás&gt; HR beállítások menüpontban"
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Összes kifizetés
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Széria számok szükségesek a sorbarendezett  tételhez: {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Kifizetések és számlák főkönyvi egyeztetése
@@ -5873,6 +5900,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Nyersanyagok beszerzése a termeléshez
 DocType: Job Opening,Job Title,Állás megnevezése
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Jövőbeli fizetés Ref
+DocType: Quotation,Additional Discount and Coupon Code,További kedvezmény és kuponkód
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} azt jelzi, hogy a {1} nem ad meg árajnlatot, de az összes tétel \ már kiajánlott. Az Árajánlatkérés státuszának frissítése."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maximum minták - {0} már tároltak a {1} köteghez és {2} tételhez a  {3} kötegben.
@@ -6100,6 +6128,7 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Beállítások az internetes honlaphoz
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},"{0} tartásban van, eddig {1}"
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},"Árajánlat nem engedélyezett erre: {0}, a mutatószám állás amiatt: {1}"
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Beszerzési számla készítése
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Felhasznált távollétek
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Szeretné benyújtani az anyagkérelmet
 DocType: Job Offer,Awaiting Response,Várakozás válaszra
@@ -6114,6 +6143,7 @@
 DocType: Training Event Employee,Optional,Választható
 DocType: Salary Slip,Earning & Deduction,Jövedelem és levonás
 DocType: Agriculture Analysis Criteria,Water Analysis,Vízelemzés
+DocType: Sales Order,Skip Delivery Note,Átugrani a szállítólevelet
 DocType: Price List,Price Not UOM Dependent,Az ár nem UOM-tól függ
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} változatokat hoztak létre.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Az alapértelmezett szolgáltatási szintű megállapodás már létezik.
@@ -6319,7 +6349,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Adók és költségek hozzáadva
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Értékcsökkenési sor {0}: A következő értékcsökkenési időpont nem lehet a rendelkezésre álló felhasználási dátuma előtt
 ,Sales Funnel,Értékesítési csatorna
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Cikkszám&gt; Tételcsoport&gt; Márka
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Rövidítés kötelező
 DocType: Project,Task Progress,Feladat előrehaladása
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Kosár
@@ -6414,6 +6443,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS profil szükséges a POS bevitelhez
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",A hűségpontokat az elköltött összegből (az értékesítési számlán keresztül) kell kiszámítani az említett begyűjtési tényező alapján.
 DocType: Program Enrollment Tool,Enroll Students,Diákok felvétele
+DocType: Pricing Rule,Coupon Code Based,Kuponkód alapján
 DocType: Company,HRA Settings,HRA beállítások
 DocType: Homepage,Hero Section,Hős szakasz
 DocType: Employee Transfer,Transfer Date,Utalás dátuma
@@ -6529,6 +6559,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',"Kérjük, állítsa Vállakozás szűrését üresre, ha a csoportosítás beállítása 'Vállalkozás'"
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Könyvelési dátum nem lehet jövőbeni időpontban
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Sor # {0}: Sorszám {1} nem egyezik a {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,"Kérjük, állítsa be a számozási sorozatokat a jelenléthez a Beállítás&gt; Számozási sorozat segítségével"
 DocType: Stock Entry,Target Warehouse Address,Cél raktár címe
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Alkalmi távollét
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,"A műszak indulása előtti idő, amely során a munkavállalói bejelentkezést figyelembe veszik a részvételhez."
@@ -6563,7 +6594,6 @@
 DocType: Employee Grade,Employee Grade,Alkalmazott fokozat
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Darabszámra fizetett munka
 DocType: GSTR 3B Report,June,június
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Szállító&gt; Beszállító típusa
 DocType: Share Balance,From No,Ettől
 DocType: Shift Type,Early Exit Grace Period,Korai kilépési türelmi idő
 DocType: Task,Actual Time (in Hours),Tényleges idő (óra)
@@ -6848,7 +6878,6 @@
 DocType: Warehouse,Warehouse Name,Raktár neve
 DocType: Naming Series,Select Transaction,Válasszon Tranzakciót
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,"Kérjük, adja be Beosztás jóváhagyásra vagy Felhasználó jóváhagyásra"
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM konverziós tényező ({0} -&gt; {1}) nem található az elemhez: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Szolgáltatási szintű megállapodás a (z) {0} típusú entitással és a {1} entitással már létezik.
 DocType: Journal Entry,Write Off Entry,Leíró Bejegyzés
 DocType: BOM,Rate Of Materials Based On,Anyagköltség számítás módja
@@ -6986,6 +7015,7 @@
 DocType: Budget,Warn,Figyelmeztet
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Az összes tétel már átkerült ehhez a Munka Rendeléshez.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Bármely egyéb megjegyzések, említésre méltó erőfeszítés, aminek a nyilvántartásba kell kerülnie."
+DocType: Bank Account,Company Account,Vállalati számla
 DocType: Asset Maintenance,Manufacturing User,Gyártás Felhasználó
 DocType: Purchase Invoice,Raw Materials Supplied,Alapanyagok leszállítottak
 DocType: Subscription Plan,Payment Plan,Fizetési ütemterv
@@ -7027,6 +7057,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) nem lehet nagyobb a ({2}) tervezett mennyiségnél  a {3} Munka Rendelésnél
 DocType: Certification Application,Name of Applicant,Jelentkező neve
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Idő nyilvántartó a gyártáshoz.
+DocType: Quick Stock Balance,Quick Stock Balance,Gyors készletmérleg
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Részösszeg
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,A variánsok tulajdonságai nem módosíthatók a készletesítés után. Ehhez új tételt kell készíteni.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA utalási megbízás
@@ -7353,6 +7384,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},"Kérjük, állítsa be {0}"
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} inaktív tanuló
 DocType: Employee,Health Details,Egészségügyi adatok
+DocType: Coupon Code,Coupon Type,Kupon típusa
 DocType: Leave Encashment,Encashable days,Beágyazható napok
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Kifizetés iránti kérelem létrehozásához referencia dokumentum szükséges
 DocType: Soil Texture,Sandy Clay,Homokos agyag
@@ -7635,6 +7667,7 @@
 DocType: Hotel Room Package,Amenities,Felszerelések
 DocType: Accounts Settings,Automatically Fetch Payment Terms,A fizetési feltételek automatikus lehívása
 DocType: QuickBooks Migrator,Undeposited Funds Account,Nem támogatott alapok számlája
+DocType: Coupon Code,Uses,felhasználások
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Több alapértelmezett fizetési mód nem engedélyezett
 DocType: Sales Invoice,Loyalty Points Redemption,Hűségpontok visszaváltása
 ,Appointment Analytics,Vizit időpontok elemzései
@@ -7651,6 +7684,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Teljes költségvetés
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Hagyja üresen, ha diák csoportokat évente hozza létre"
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Ha be van jelölve, a munkanapok száma tartalmazni fogja az ünnepeket, és ez csökkenti a napi bér összegét"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Nem sikerült hozzáadni a tartományt
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.",A túllépés / kézbesítés engedélyezéséhez frissítse a &quot;Túlérvényesítési / szállítási támogatás&quot; elemet a Készletbeállításokban vagy az elemben.
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Az aktuális kulcsot használó alkalmazások nem fognak hozzáférni, biztos ebben?"
 DocType: Subscription Settings,Prorate,Megosztási
@@ -7663,6 +7697,7 @@
 ,BOM Stock Report,Anyagjegyzék készlet jelentés
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Ha nincs hozzárendelt időrés, akkor a kommunikációt ez a csoport kezeli"
 DocType: Stock Reconciliation Item,Quantity Difference,Mennyiség különbség
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Szállító&gt; Beszállító típusa
 DocType: Opportunity Item,Basic Rate,Alapár
 DocType: GL Entry,Credit Amount,Követelés összege
 ,Electronic Invoice Register,Elektronikus számlanyilvántartás
@@ -7916,6 +7951,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Levont adók és költségek (a vállalkozás pénznemében)
 DocType: Item Group,General Settings,Általános beállítások
 DocType: Article,Article,Cikk
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,"Kérjük, írja be a kuponkódot !!"
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Pénznemből és pénznembe nem lehet ugyanaz
 DocType: Taxable Salary Slab,Percent Deduction,Százalékos levonás
 DocType: GL Entry,To Rename,Átnevezni
diff --git a/erpnext/translations/id.csv b/erpnext/translations/id.csv
index 8e29ff6..a49187f 100644
--- a/erpnext/translations/id.csv
+++ b/erpnext/translations/id.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Kontak Pelanggan
 DocType: Shift Type,Enable Auto Attendance,Aktifkan Kehadiran Otomatis
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Silakan masukkan Gudang dan Tanggal
 DocType: Lost Reason Detail,Opportunity Lost Reason,Peluang Hilang Alasan
 DocType: Patient Appointment,Check availability,Cek ketersediaan
 DocType: Retention Bonus,Bonus Payment Date,Tanggal Pembayaran Bonus
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Perintah Kerja Selesai
 DocType: Support Settings,Forum Posts,Kiriman Forum
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Tugas telah ditetapkan sebagai pekerjaan latar belakang. Jika ada masalah pada pemrosesan di latar belakang, sistem akan menambahkan komentar tentang kesalahan Rekonsiliasi Saham ini dan kembali ke tahap Konsep"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Maaf, validitas kode kupon belum dimulai"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Jumlah Kena Pajak
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Anda tidak diizinkan menambah atau memperbarui entri sebelum {0}
 DocType: Leave Policy,Leave Policy Details,Tinggalkan Detail Kebijakan
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Consumable
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,Kelas
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kode Barang&gt; Grup Barang&gt; Merek
 DocType: Restaurant Table,No of Seats,Tidak ada tempat duduk
 DocType: Sales Invoice,Overdue and Discounted,Tunggakan dan Diskon
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Panggilan Terputus
@@ -506,6 +509,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,spasi untuk jumlah kata
 DocType: Vehicle,Additional Details,Rincian Tambahan
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Tidak diberikan deskripsi
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Ambil Item dari Gudang
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Form Permintaan pembelian.
 DocType: POS Closing Voucher Details,Collected Amount,Jumlah yang Dikumpulkan
 DocType: Lab Test,Submitted Date,Tanggal dikirim
@@ -613,6 +617,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Belajar
 ,Trial Balance (Simple),Balance Trial (Sederhana)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Aktifkan Beban Ditangguhkan
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Kode Kupon Terapan
 DocType: Asset,Next Depreciation Date,Berikutnya Penyusutan Tanggal
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Biaya Aktivitas Per Karyawan
 DocType: Accounts Settings,Settings for Accounts,Pengaturan Akun
@@ -848,8 +853,6 @@
 DocType: BOM,Work Order,Perintah kerja
 DocType: Sales Invoice,Total Qty,Jumlah Qty
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,ID Email Guardian2
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Silakan hapus Karyawan <a href=""#Form/Employee/{0}"">{0}</a> \ untuk membatalkan dokumen ini"
 DocType: Item,Show in Website (Variant),Tampilkan Website (Variant)
 DocType: Employee,Health Concerns,Kekhawatiran Kesehatan
 DocType: Payroll Entry,Select Payroll Period,Pilih Payroll Periode
@@ -1013,6 +1016,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Akun Pemotongan Pajak
 DocType: Pricing Rule,Sales Partner,Mitra Penjualan
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Semua kartu pemilih Pemasok.
+DocType: Coupon Code,To be used to get discount,Digunakan untuk mendapatkan diskon
 DocType: Buying Settings,Purchase Receipt Required,Diperlukan Nota Penerimaan
 DocType: Sales Invoice,Rail,Rel
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Harga asli
@@ -1063,6 +1067,7 @@
 DocType: Production Plan,Production Plan,Rencana produksi
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Membuka Invoice Creation Tool
 DocType: Salary Component,Round to the Nearest Integer,Membulatkan ke Integer Terdekat
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Izinkan item yang tidak ada stok ditambahkan ke troli
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Retur Penjualan
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Tentukan Qty dalam Transaksi berdasarkan Serial No Input
 ,Total Stock Summary,Ringkasan Persediaan Total
@@ -1192,6 +1197,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Dasar Tarif Perjam (Mata Uang Perusahaan)
 ,Qty To Be Billed,Qty To Be Billed
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Jumlah Telah Terikirim
+DocType: Coupon Code,Gift Card,Kartu ucapan
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Jumlah Pesanan untuk Produksi: Jumlah bahan baku untuk membuat barang-barang manufaktur.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Tanggal Penebusan
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Transaksi bank ini sudah sepenuhnya direkonsiliasi
@@ -1279,6 +1285,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Buat absen
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Akun {0} telah dimasukkan beberapa kali
 DocType: Account,Expenses Included In Valuation,Biaya Termasuk di Dalam Penilaian Barang
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Beli Faktur
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Anda hanya bisa memperpanjang jika keanggotaan Anda akan berakhir dalam 30 hari
 DocType: Shopping Cart Settings,Show Stock Availability,Tampilkan Ketersediaan Stok
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Setel {0} dalam kategori aset {1} atau perusahaan {2}
@@ -1818,6 +1825,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Mengimpor Item dan UOM
 DocType: Repayment Schedule,Balance Loan Amount,Saldo Jumlah Pinjaman
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Ditambahkan ke detail
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Maaf, kode kupon habis"
 DocType: Communication Medium,Catch All,Tangkap Semua
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Jadwal Kursus
 DocType: Budget,Applicable on Material Request,Berlaku pada Permintaan Material
@@ -1985,6 +1993,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Atribut yang tidak valid
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} harus dikirim
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Kampanye Email
+DocType: Sales Partner,To Track inbound purchase,Untuk Melacak pembelian masuk
 DocType: Buying Settings,Default Supplier Group,Grup Pemasok Default
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Kuantitas harus kurang dari atau sama dengan {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Jumlah maksimum yang memenuhi syarat untuk komponen {0} melebihi {1}
@@ -2140,8 +2149,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Masuk Stock
 DocType: Hotel Room Reservation,Hotel Reservation User,Pengguna Reservasi Hotel
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Setel Status
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Silakan atur seri penomoran untuk Kehadiran melalui Pengaturan&gt; Seri Penomoran
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Silakan pilih awalan terlebih dahulu
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Silakan tentukan Seri Penamaan untuk {0} melalui Pengaturan&gt; Pengaturan&gt; Seri Penamaan
 DocType: Contract,Fulfilment Deadline,Batas Waktu Pemenuhan
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Di dekat Anda
 DocType: Student,O-,HAI-
@@ -2265,6 +2274,7 @@
 DocType: Quality Meeting Table,Under Review,Dalam Ulasan
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Gagal untuk masuk
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Aset {0} dibuat
+DocType: Coupon Code,Promotional,Promosi
 DocType: Special Test Items,Special Test Items,Item Uji Khusus
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Anda harus menjadi pengguna dengan peran Manajer Sistem dan Manajer Item untuk mendaftar di Marketplace.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Laporan Utama
@@ -2302,6 +2312,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc Type
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Persentase total yang dialokasikan untuk tim penjualan harus 100
 DocType: Subscription Plan,Billing Interval Count,Jumlah Interval Penagihan
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Silakan hapus Karyawan <a href=""#Form/Employee/{0}"">{0}</a> \ untuk membatalkan dokumen ini"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Janji dan Pertemuan Pasien
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Nilai hilang
 DocType: Employee,Department and Grade,Departemen dan Grade
@@ -2404,6 +2416,7 @@
 DocType: Project,Start and End Dates,Mulai dan Akhir Tanggal
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Ketentuan Pemenuhan Template Kontrak
 ,Delivered Items To Be Billed,Produk Terkirim untuk Ditagih
+DocType: Coupon Code,Maximum Use,Penggunaan Maksimum
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Terbuka BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Gudang tidak dapat diubah untuk Serial Number
 DocType: Authorization Rule,Average Discount,Rata-rata Diskon
@@ -2566,6 +2579,7 @@
 DocType: Item,Inventory,Inventarisasi
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Unduh sebagai Json
 DocType: Item,Sales Details,Detail Penjualan
+DocType: Coupon Code,Used,Bekas
 DocType: Opportunity,With Items,Dengan Produk
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Kampanye &#39;{0}&#39; sudah ada untuk {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Tim Pemeliharaan
@@ -2695,7 +2709,7 @@
 						Serial No cannot be ensured",Tidak ada BOM aktif yang ditemukan untuk item {0}. Pengiriman oleh \ Serial Tidak dapat dipastikan
 DocType: Sales Partner,Sales Partner Target,Sasaran Mitra Penjualan
 DocType: Loan Type,Maximum Loan Amount,Maksimum Jumlah Pinjaman
-DocType: Pricing Rule,Pricing Rule,Aturan Harga
+DocType: Coupon Code,Pricing Rule,Aturan Harga
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Nomor pengguliran duplikat untuk siswa {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Permintaan Material untuk Order Pembelian
 DocType: Company,Default Selling Terms,Ketentuan Penjualan Default
@@ -2774,6 +2788,7 @@
 DocType: Payment Schedule,Payment Amount,Jumlah pembayaran
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Setengah Hari Tanggal harus di antara Work From Date dan Work End Date
 DocType: Healthcare Settings,Healthcare Service Items,Item Layanan Perawatan Kesehatan
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Kode Batang Tidak Valid. Tidak ada Barang yang terlampir pada barcode ini.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Dikonsumsi Jumlah
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Perubahan bersih dalam kas
 DocType: Assessment Plan,Grading Scale,Skala penilaian
@@ -2893,7 +2908,6 @@
 DocType: Share Transfer,Asset Account,Akun Aset
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Tanggal rilis baru harus di masa depan
 DocType: Purchase Invoice,End date of current invoice's period,Tanggal akhir periode faktur saat ini
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Silakan atur Sistem Penamaan Karyawan di Sumber Daya Manusia&gt; Pengaturan SDM
 DocType: Lab Test,Technician Name,Nama teknisi
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3004,6 +3018,7 @@
 DocType: Products Settings,Hide Variants,Sembunyikan Varian
 DocType: Lead,Next Contact By,Kontak Selanjutnya Oleh
 DocType: Compensatory Leave Request,Compensatory Leave Request,Permintaan Tinggalkan Kompensasi
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Tidak dapat menagih berlebih untuk Item {0} di baris {1} lebih dari {2}. Untuk memungkinkan penagihan berlebih, harap setel kelonggaran di Pengaturan Akun"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Kuantitas yang dibutuhkan untuk Item {0} di baris {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Gudang {0} tidak dapat dihapus karena ada kuantitas untuk Item {1}
 DocType: Blanket Order,Order Type,Tipe Order
@@ -3173,7 +3188,6 @@
 DocType: Student,Student Mobile Number,Mahasiswa Nomor Ponsel
 DocType: Item,Has Variants,Memiliki Varian
 DocType: Employee Benefit Claim,Claim Benefit For,Manfaat Klaim Untuk
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Tidak dapat membebani Item {0} pada baris {1} lebih dari {2}. Untuk mengizinkan over-billing, silahkan atur di Stock Settings"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Perbarui Tanggapan
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Anda sudah memilih item dari {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Nama Distribusi Bulanan
@@ -3464,6 +3478,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Silakan tentukan mata uang di Perusahaan
 DocType: Workstation,Wages per hour,Upah per jam
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Konfigurasikan {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Pelanggan&gt; Grup Pelanggan&gt; Wilayah
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Saldo Persediaan di Batch {0} akan menjadi negatif {1} untuk Barang {2} di Gudang {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Berikut Permintaan Bahan telah dibesarkan secara otomatis berdasarkan tingkat re-order Item
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Akun {0} tidak berlaku. Mata Uang Akun harus {1}
@@ -3793,6 +3808,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Kirim Slip Gaji
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Tertahan
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Qustion harus memiliki setidaknya satu opsi yang benar
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Order pembelian
 DocType: Account,Inter Company Account,Akun Perusahaan Inter
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Impor Secara massal
 DocType: Sales Partner,Address & Contacts,Alamat & Kontak
@@ -3803,6 +3819,7 @@
 DocType: POS Profile,[Select],[Pilih]
 DocType: Staffing Plan Detail,Number Of Positions,Jumlah Posisi
 DocType: Vital Signs,Blood Pressure (diastolic),Tekanan Darah (diastolik)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Silakan pilih pelanggan.
 DocType: SMS Log,Sent To,Dikirim Ke
 DocType: Agriculture Task,Holiday Management,Manajemen liburan
 DocType: Payment Request,Make Sales Invoice,Buat Faktur Penjualan
@@ -4012,7 +4029,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} belum dikirim
 DocType: Subscription,Trialling,Trialling
 DocType: Sales Invoice Item,Deferred Revenue,Pendapatan tangguhan
-DocType: Bank Account,GL Account,Akun GL
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Cash Account akan digunakan untuk kreasi Sales Invoice
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Sub Kategori Pembebasan
 DocType: Member,Membership Expiry Date,Tanggal Kedaluwarsa Keanggotaan
@@ -4436,13 +4452,13 @@
 DocType: C-Form Invoice Detail,Territory,Wilayah
 DocType: Pricing Rule,Apply Rule On Item Code,Terapkan Aturan Pada Item Kode
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Harap menyebutkan tidak ada kunjungan yang diperlukan
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Laporan Neraca Stok
 DocType: Stock Settings,Default Valuation Method,Metode Perhitungan Standar
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Biaya
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Tampilkan Jumlah Kumulatif
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Perbaruan sedang berlangsung. Mungkin perlu beberapa saat.
 DocType: Production Plan Item,Produced Qty,Diproduksi Qty
 DocType: Vehicle Log,Fuel Qty,BBM Qty
-DocType: Stock Entry,Target Warehouse Name,Target Nama Gudang
 DocType: Work Order Operation,Planned Start Time,Rencana Start Time
 DocType: Course,Assessment,Penilaian
 DocType: Payment Entry Reference,Allocated,Dialokasikan
@@ -4508,10 +4524,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","Syarat dan Ketentuan Standar yang dapat ditambahkan ke Penjualan dan Pembelian. Contoh : 1. Validitas tawaran. 1. Termin Pembayaran (Pembayaran Dimuka, Secara Kredit, pembayaran dimuka sebagian, dll). 1. Apa yang ekstra (atau dibayar oleh Pelanggan). 1. Peringatan keamanan / penggunaan. 1. Garansi jika ada. 1. Kebijakan Retur. 1. Syarat pengiriman, jika berlaku. 1. Cara menangani sengketa, ganti rugi, kewajiban, dll. 1. Alamat dan Kontak Perusahaan Anda."
 DocType: Homepage Section,Section Based On,Bagian Berdasarkan
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Tampilkan Terapkan Kode Kupon
 DocType: Issue,Issue Type,Jenis Isu
 DocType: Attendance,Leave Type,Cuti Type
 DocType: Purchase Invoice,Supplier Invoice Details,Pemasok Rincian Faktur
 DocType: Agriculture Task,Ignore holidays,Abaikan hari libur
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Tambah / Edit Ketentuan Kupon
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Beban akun / Difference ({0}) harus akun 'Laba atau Rugi'
 DocType: Stock Entry Detail,Stock Entry Child,Anak Masuk Stock
 DocType: Project,Copied From,Disalin dari
@@ -4686,6 +4704,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Kriteria Rencana Penilaian
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Transaksi
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Cegah Pesanan Pembelian
+DocType: Coupon Code,Coupon Name,Nama Kupon
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Rentan
 DocType: Email Campaign,Scheduled,Dijadwalkan
 DocType: Shift Type,Working Hours Calculation Based On,Perhitungan Jam Kerja Berdasarkan
@@ -4702,7 +4721,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Buat Varian
 DocType: Vehicle,Diesel,disel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Daftar Harga Mata uang tidak dipilih
+DocType: Quick Stock Balance,Available Quantity,Jumlah yang tersedia
 DocType: Purchase Invoice,Availed ITC Cess,Dilengkapi ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Silakan siapkan Sistem Penamaan Instruktur di Pendidikan&gt; Pengaturan Pendidikan
 ,Student Monthly Attendance Sheet,Mahasiswa Lembar Kehadiran Bulanan
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Aturan pengiriman hanya berlaku untuk penjualan
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Depreciation Row {0}: Next Depreciation Date tidak boleh sebelum Tanggal Pembelian
@@ -4769,8 +4790,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Baris {0}: Uang muka dari Pelanggan harus kredit
 DocType: Quality Meeting,Quality Meeting,Rapat Kualitas
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-Group untuk Grup
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Silakan tentukan Seri Penamaan untuk {0} melalui Pengaturan&gt; Pengaturan&gt; Seri Penamaan
 DocType: Employee,ERPNext User,Pengguna ERPNext
+DocType: Coupon Code,Coupon Description,Deskripsi Kupon
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Batch wajib di baris {0}
 DocType: Company,Default Buying Terms,Ketentuan Pembelian Default
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Nota Penerimaan Stok Barang Disediakan
@@ -4933,6 +4954,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Terhadap Detail Dokumen No.
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Penghapusan tidak diizinkan untuk negara {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Partai Type adalah wajib
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Terapkan Kode Kupon
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","Untuk kartu pekerjaan {0}, Anda hanya dapat membuat entri stok jenis &#39;Transfer Bahan untuk Pembuatan&#39;"
 DocType: Quality Inspection,Outgoing,Keluaran
 DocType: Customer Feedback Table,Customer Feedback Table,Tabel Umpan Balik Pelanggan
@@ -5082,7 +5104,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Pengajuan Pesanan Pembelian
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Tambahkan Semua Pemasok
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Baris # {0}: Alokasi Jumlah tidak boleh lebih besar dari jumlah yang terutang.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Pelanggan&gt; Grup Pelanggan&gt; Wilayah
 DocType: Tally Migration,Parties,Pesta
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Telusuri BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Pinjaman Aman
@@ -5114,7 +5135,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Tidak memungkinkan untuk mengatur item alternatif untuk item {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Tanggal diulang
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Penandatangan yang Sah
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Silakan siapkan Sistem Penamaan Instruktur di Pendidikan&gt; Pengaturan Pendidikan
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Tersedia ITC Bersih (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Buat Biaya
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Total Biaya Pembelian (Purchase Invoice via)
@@ -5139,6 +5159,7 @@
 DocType: Quiz Result,Wrong,Salah
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Tingkat di mana mata uang Daftar Harga dikonversi ke mata uang dasar pelanggan
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Jumlah Bersih (Perusahaan Mata Uang)
+DocType: Sales Partner,Referral Code,Kode Rujukan
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Jumlah uang muka tidak boleh lebih besar dari jumlah sanksi
 DocType: Salary Slip,Hour Rate,Nilai per Jam
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Aktifkan Pemesanan Ulang Otomatis
@@ -5267,6 +5288,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Tampilkan Kuantitas Saham
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Kas Bersih dari Operasi
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Baris # {0}: Status harus {1} untuk Diskon Faktur {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Faktor Konversi UOM ({0} -&gt; {1}) tidak ditemukan untuk item: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Item 4
 DocType: Student Admission,Admission End Date,Pendaftaran Tanggal Akhir
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Sub-kontraktor
@@ -5289,6 +5311,7 @@
 DocType: Travel Request,Fully Sponsored,Sepenuhnya Disponsori
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Masuk Balik Jurnal
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Buat Kartu Pekerjaan
+DocType: Quotation,Referral Sales Partner,Rujukan Mitra Penjualan
 DocType: Quality Procedure Process,Process Description,Deskripsi proses
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Pelanggan {0} dibuat
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Saat ini tidak ada persediaan di gudang manapun
@@ -5423,6 +5446,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,Tingkat BOM
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Membaca File yang Diunggah
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Pesanan Kerja yang Berhenti tidak dapat dibatalkan, Hapus terlebih dahulu untuk membatalkan"
+DocType: Coupon Code,Coupon Code,Kode Kupon
 DocType: Asset,Journal Entry for Scrap,Jurnal masuk untuk Scrap
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Silakan tarik item dari Pengiriman Note
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Baris {0}: pilih workstation terhadap operasi {1}
@@ -5505,6 +5529,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;Tanggal&#39; diperlukan
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Karena / Referensi Tanggal tidak boleh setelah {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Data Impor dan Ekspor
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Maaf, validitas kode kupon telah kedaluwarsa"
 DocType: Bank Account,Account Details,Rincian Account
 DocType: Crop,Materials Required,Bahan yang dibutuhkan
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Tidak ada siswa Ditemukan
@@ -5542,6 +5567,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Buka Pengguna
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Jumlah yang dibayarkan + Write Off Jumlah tidak bisa lebih besar dari Grand Total
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} tidak Nomor Batch berlaku untuk Stok Barang {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Silakan masukkan kode kupon yang valid !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Catatan: Tidak ada saldo cuti cukup bagi Leave Type {0}
 DocType: Task,Task Description,Deskripsi Tugas
 DocType: Training Event,Seminar,Seminar
@@ -5805,6 +5831,7 @@
 ,TDS Payable Monthly,TDS Hutang Bulanan
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Antri untuk mengganti BOM. Mungkin perlu beberapa menit.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Tidak bisa mengurangi ketika kategori adalah untuk 'Penilaian' atau 'Penilaian dan Total'
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Silakan atur Sistem Penamaan Karyawan di Sumber Daya Manusia&gt; Pengaturan SDM
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Total Pembayaran
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Nomor Seri Diperlukan untuk Barang Bernomor Seri {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Pembayaran pertandingan dengan Faktur
@@ -5894,6 +5921,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Dapatkan Bahan Baku untuk Produksi
 DocType: Job Opening,Job Title,Jabatan
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Ref Pembayaran di Masa Depan
+DocType: Quotation,Additional Discount and Coupon Code,Diskon Tambahan dan Kode Kupon
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} menunjukkan bahwa {1} tidak akan memberikan kutipan, namun semua item \ telah dikutip. Memperbarui status kutipan RFQ."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Sampel Maksimum - {0} telah disimpan untuk Batch {1} dan Item {2} di Batch {3}.
@@ -6121,7 +6149,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Pengaturan untuk homepage website
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} ditahan sampai {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ tidak diizinkan untuk {0} karena kartu skor berdiri dari {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Membuat Purchase Invoice
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Cuti Yang Telah Digunakan
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Kupon yang digunakan adalah {1}. Kuantitas yang diizinkan habis
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Apakah Anda ingin mengirimkan permintaan materi
 DocType: Job Offer,Awaiting Response,Menunggu Respon
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6135,6 +6165,7 @@
 DocType: Training Event Employee,Optional,Pilihan
 DocType: Salary Slip,Earning & Deduction,Earning & Pengurangan
 DocType: Agriculture Analysis Criteria,Water Analysis,Analisis air
+DocType: Sales Order,Skip Delivery Note,Lewati Catatan Pengiriman
 DocType: Price List,Price Not UOM Dependent,Harga Tidak Tergantung UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} varian dibuat.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Perjanjian Tingkat Layanan Default sudah ada.
@@ -6239,6 +6270,7 @@
 DocType: Vehicle,Last Carbon Check,Terakhir Carbon Periksa
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Beban Legal
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Silakan pilih kuantitas pada baris
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Perintah Kerja {0}: kartu kerja tidak ditemukan untuk operasi {1}
 DocType: Purchase Invoice,Posting Time,Posting Waktu
 DocType: Timesheet,% Amount Billed,% Jumlah Ditagih
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Beban Telepon
@@ -6341,7 +6373,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Pajak dan Biaya Ditambahkan
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Depreciation Row {0}: Next Depreciation Date tidak boleh sebelum Tersedia-untuk-digunakan Tanggal
 ,Sales Funnel,Penjualan Saluran
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kode Barang&gt; Grup Barang&gt; Merek
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Singkatan wajib diisi
 DocType: Project,Task Progress,tugas Kemajuan
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Troli
@@ -6436,6 +6467,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS Profil diperlukan untuk membuat POS Entri
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Poin Loyalitas akan dihitung dari pengeluaran yang dilakukan (melalui Faktur Penjualan), berdasarkan faktor penagihan yang disebutkan."
 DocType: Program Enrollment Tool,Enroll Students,Daftarkan Siswa
+DocType: Pricing Rule,Coupon Code Based,Berbasis Kode Kupon
 DocType: Company,HRA Settings,Pengaturan HRA
 DocType: Homepage,Hero Section,Bagian Pahlawan
 DocType: Employee Transfer,Transfer Date,Tanggal Transfer
@@ -6551,6 +6583,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Harap tentukan filter Perusahaan jika Group By &#39;Company&#39;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Posting Tanggal tidak bisa tanggal di masa depan
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: Serial No {1} tidak sesuai dengan {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Silakan atur seri penomoran untuk Kehadiran melalui Pengaturan&gt; Seri Penomoran
 DocType: Stock Entry,Target Warehouse Address,Target Gudang Alamat
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Santai Cuti
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,Waktu sebelum shift dimulai saat di mana Karyawan Masuk dianggap hadir.
@@ -6585,7 +6618,6 @@
 DocType: Employee Grade,Employee Grade,Kelas Karyawan
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Pekerjaan yg dibayar menurut hasil yg dikerjakan
 DocType: GSTR 3B Report,June,Juni
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Pemasok&gt; Jenis Pemasok
 DocType: Share Balance,From No,Dari No
 DocType: Shift Type,Early Exit Grace Period,Periode Grace Keluar Awal
 DocType: Task,Actual Time (in Hours),Waktu Aktual (dalam Jam)
@@ -6870,7 +6902,6 @@
 DocType: Warehouse,Warehouse Name,Nama Gudang
 DocType: Naming Series,Select Transaction,Pilih Transaksi
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Entrikan Menyetujui Peran atau Menyetujui Pengguna
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Faktor Konversi UOM ({0} -&gt; {1}) tidak ditemukan untuk item: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Perjanjian Tingkat Layanan dengan Jenis Entitas {0} dan Entitas {1} sudah ada.
 DocType: Journal Entry,Write Off Entry,Menulis Off Entri
 DocType: BOM,Rate Of Materials Based On,Laju Bahan Berbasis On
@@ -7008,6 +7039,7 @@
 DocType: Budget,Warn,Peringatan: Cuti aplikasi berisi tanggal blok berikut
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Semua item telah ditransfer untuk Perintah Kerja ini.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Setiap komentar lain, upaya penting yang harus pergi dalam catatan."
+DocType: Bank Account,Company Account,Akun Perusahaan
 DocType: Asset Maintenance,Manufacturing User,Manufaktur Pengguna
 DocType: Purchase Invoice,Raw Materials Supplied,Bahan Baku Disupply
 DocType: Subscription Plan,Payment Plan,Rencana pembayaran
@@ -7049,6 +7081,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) tidak boleh lebih besar dari kuantitas yang direncanakan ({2}) dalam Perintah Kerja {3}
 DocType: Certification Application,Name of Applicant,Nama Pemohon
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Waktu Lembar untuk manufaktur.
+DocType: Quick Stock Balance,Quick Stock Balance,Saldo Stok Cepat
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Subtotal
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Tidak dapat mengubah properti Varian setelah transaksi saham. Anda harus membuat Item baru untuk melakukan ini.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA Mandate
@@ -7375,6 +7408,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},Silakan set {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} adalah siswa tidak aktif
 DocType: Employee,Health Details,Detail Kesehatan
+DocType: Coupon Code,Coupon Type,Jenis Kupon
 DocType: Leave Encashment,Encashable days,Hari-hari yang bisa dikompresi
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Untuk membuat dokumen referensi Request Request diperlukan
 DocType: Soil Texture,Sandy Clay,Sandy Clay
@@ -7658,6 +7692,7 @@
 DocType: Hotel Room Package,Amenities,Fasilitas
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Ambil Ketentuan Pembayaran secara otomatis
 DocType: QuickBooks Migrator,Undeposited Funds Account,Rekening Dana yang Belum Ditentukan
+DocType: Coupon Code,Uses,Penggunaan
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Beberapa modus pembayaran default tidak diperbolehkan
 DocType: Sales Invoice,Loyalty Points Redemption,Penebusan Poin Loyalitas
 ,Appointment Analytics,Penunjukan Analytics
@@ -7674,6 +7709,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Total Anggaran
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Biarkan kosong jika Anda membuat kelompok siswa per tahun
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Jika dicentang, total ada. dari Hari Kerja akan mencakup libur, dan ini akan mengurangi nilai Gaji Per Hari"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Gagal menambahkan Domain
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Untuk memungkinkan penerimaan / pengiriman berlebih, perbarui &quot;Penerimaan Lebih / Tunjangan Pengiriman&quot; di Pengaturan Stok atau Item."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Aplikasi yang menggunakan kunci saat ini tidak dapat diakses, apakah Anda yakin?"
 DocType: Subscription Settings,Prorate,Prorata
@@ -7686,6 +7722,7 @@
 ,BOM Stock Report,Laporan Persediaan BOM
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Jika tidak ada slot waktu yang ditetapkan, maka komunikasi akan ditangani oleh grup ini"
 DocType: Stock Reconciliation Item,Quantity Difference,Perbedaan Kuantitas
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Pemasok&gt; Jenis Pemasok
 DocType: Opportunity Item,Basic Rate,Tarif Dasar
 DocType: GL Entry,Credit Amount,Jumlah kredit
 ,Electronic Invoice Register,Daftar Faktur Elektronik
@@ -7939,6 +7976,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Pajak dan Biaya Dikurangi (Perusahaan Mata Uang)
 DocType: Item Group,General Settings,Pengaturan Umum
 DocType: Article,Article,Artikel
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Silakan masukkan kode kupon !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Dari Mata dan Mata Uang Untuk tidak bisa sama
 DocType: Taxable Salary Slab,Percent Deduction,Pengurangan Persen
 DocType: GL Entry,To Rename,Untuk Mengganti Nama
diff --git a/erpnext/translations/is.csv b/erpnext/translations/is.csv
index e2ce118..8403157 100644
--- a/erpnext/translations/is.csv
+++ b/erpnext/translations/is.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,viðskiptavinur samband við
 DocType: Shift Type,Enable Auto Attendance,Virkja sjálfvirk mæting
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Vinsamlegast sláðu inn vöruhús og dagsetningu
 DocType: Lost Reason Detail,Opportunity Lost Reason,Tækifærið misst ástæða
 DocType: Patient Appointment,Check availability,Athuga framboð
 DocType: Retention Bonus,Bonus Payment Date,Bónus greiðsludagur
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Lokið vinnutilboð
 DocType: Support Settings,Forum Posts,Forum Posts
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage",Verkefnið hefur verið unnið sem bakgrunnsstarf. Ef eitthvað er um vinnslu í bakgrunni mun kerfið bæta við athugasemd um villuna við þessa hlutafjársátt og fara aftur í drög að stigi
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Því miður, gildistími afsláttarmiða hefur ekki byrjað"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Skattskyld fjárhæð
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Þú hefur ekki heimild til að bæta við eða endurnýja færslum áður {0}
 DocType: Leave Policy,Leave Policy Details,Skildu eftir upplýsingum um stefnu
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,einnota
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,bekk
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Atriðakóði&gt; Vöruflokkur&gt; Vörumerki
 DocType: Restaurant Table,No of Seats,Nei sæti
 DocType: Sales Invoice,Overdue and Discounted,Forföll og afsláttur
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Hringt úr sambandi
@@ -506,6 +509,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Línubil fyrir fjárhæð í orðum
 DocType: Vehicle,Additional Details,Önnur Nánar
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Engin lýsing gefin
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Sæktu hluti úr vöruhúsinu
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Beiðni um kaupin.
 DocType: POS Closing Voucher Details,Collected Amount,Söfnuður upphæð
 DocType: Lab Test,Submitted Date,Sendingardagur
@@ -613,6 +617,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Frekari
 ,Trial Balance (Simple),Reynslujafnvægi (einfalt)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Virkja frestaðan kostnað
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Beitt afsláttarmiða kóða
 DocType: Asset,Next Depreciation Date,Næsta Afskriftir Dagsetning
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Virkni Kostnaður á hvern starfsmann
 DocType: Accounts Settings,Settings for Accounts,Stillingar fyrir reikninga
@@ -848,8 +853,6 @@
 DocType: BOM,Work Order,Vinna fyrirmæli
 DocType: Sales Invoice,Total Qty,Total Magn
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 Netfang
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Vinsamlegast eytt starfsmanninum <a href=""#Form/Employee/{0}"">{0}</a> \ til að hætta við þetta skjal"
 DocType: Item,Show in Website (Variant),Sýna í Website (Variant)
 DocType: Employee,Health Concerns,Heilsa Áhyggjuefni
 DocType: Payroll Entry,Select Payroll Period,Veldu Launaskrá Tímabil
@@ -1013,6 +1016,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Skattgreiðslureikningur
 DocType: Pricing Rule,Sales Partner,velta Partner
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Allir birgir skorar.
+DocType: Coupon Code,To be used to get discount,Til að nota til að fá afslátt
 DocType: Buying Settings,Purchase Receipt Required,Kvittun Áskilið
 DocType: Sales Invoice,Rail,Járnbraut
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Raunverulegur kostnaður
@@ -1063,6 +1067,7 @@
 DocType: Production Plan,Production Plan,Framleiðsluáætlun
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Opna reikningsskilatól
 DocType: Salary Component,Round to the Nearest Integer,Hringið að næsta heiltölu
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Leyfa að hlutum sem ekki eru til á lager sé bætt í körfuna
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,velta Return
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Setja magn í viðskiptum sem byggjast á raðnúmeri inntak
 ,Total Stock Summary,Samtals yfirlit yfir lager
@@ -1192,6 +1197,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Base Hour Rate (Company Gjaldmiðill)
 ,Qty To Be Billed,Magn sem þarf að greiða
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Skilað Upphæð
+DocType: Coupon Code,Gift Card,Gjafakort
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Frátekið magn til framleiðslu: Magn hráefna til að framleiða hluti.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Innlausnardagur
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Þessi bankaviðskipti eru nú þegar að fullu sátt
@@ -1279,6 +1285,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Búðu til tímarit
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Reikningur {0} hefur verið slegið mörgum sinnum
 DocType: Account,Expenses Included In Valuation,Kostnaður í Verðmat
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Kaupið innheimtuseðla
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Þú getur aðeins endurnýjað ef aðild þín rennur út innan 30 daga
 DocType: Shopping Cart Settings,Show Stock Availability,Sýna framboð á lager
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Setjið {0} í eignaflokki {1} eða fyrirtæki {2}
@@ -1818,6 +1825,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Flytur inn hluti og UOM
 DocType: Repayment Schedule,Balance Loan Amount,Balance lánsfjárhæð
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Bætt við smáatriði
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Því miður, afsláttarmiða kóða er búinn"
 DocType: Communication Medium,Catch All,Afli allra
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Dagskrá Námskeið
 DocType: Budget,Applicable on Material Request,Gildir á efnisbeiðni
@@ -1985,6 +1993,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Ógilt Attribute
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} Leggja skal fram
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Netfang herferðir
+DocType: Sales Partner,To Track inbound purchase,Til að fylgjast með innkaupum á heimleið
 DocType: Buying Settings,Default Supplier Group,Sjálfgefið Birgir Group
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Magn verður að vera minna en eða jafnt og {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Hámarksupphæð sem hæfur er fyrir hluti {0} fer yfir {1}
@@ -2140,8 +2149,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Gerðu hlutabréfafærslu
 DocType: Hotel Room Reservation,Hotel Reservation User,Hotel Reservation User
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Stilla stöðu
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Vinsamlegast settu upp númeraröð fyrir mætingu með uppsetningu&gt; Númeraröð
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Vinsamlegast veldu forskeyti fyrst
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Vinsamlegast stilltu Naming Series fyrir {0} með Setup&gt; Settings&gt; Naming Series
 DocType: Contract,Fulfilment Deadline,Uppfyllingardagur
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Nálægt þér
 DocType: Student,O-,O-
@@ -2265,6 +2274,7 @@
 DocType: Quality Meeting Table,Under Review,Til athugunar
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Mistókst að skrá þig inn
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Eignin {0} búin til
+DocType: Coupon Code,Promotional,Kynningar
 DocType: Special Test Items,Special Test Items,Sérstakar prófanir
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Þú þarft að vera notandi með kerfisstjóra og hlutverkastjóra hlutverk til að skrá þig á markaðssvæðinu.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Lykilskýrslur
@@ -2302,6 +2312,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc Tegund
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Samtals úthlutað hlutfall fyrir Söluteymi ætti að vera 100
 DocType: Subscription Plan,Billing Interval Count,Greiðslumiðlunartala
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Vinsamlegast eytt starfsmanninum <a href=""#Form/Employee/{0}"">{0}</a> \ til að hætta við þetta skjal"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Tilnefningar og þolinmæði
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Gildi vantar
 DocType: Employee,Department and Grade,Deild og bekk
@@ -2404,6 +2416,7 @@
 DocType: Project,Start and End Dates,Upphafs- og lokadagsetningar
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Samningsskilmál Skilgreining Skilmálar
 ,Delivered Items To Be Billed,Afhent Items verður innheimt
+DocType: Coupon Code,Maximum Use,Hámarksnotkun
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Open BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Warehouse er ekki hægt að breyta fyrir Raðnúmer
 DocType: Authorization Rule,Average Discount,Meðal Afsláttur
@@ -2565,6 +2578,7 @@
 DocType: Item,Inventory,Skrá
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Sæktu sem Json
 DocType: Item,Sales Details,velta Upplýsingar
+DocType: Coupon Code,Used,Notað
 DocType: Opportunity,With Items,með atriði
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Herferðin &#39;{0}&#39; er þegar til fyrir {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Viðhaldsteymi
@@ -2694,7 +2708,7 @@
 						Serial No cannot be ensured",Engin virk BOM fannst fyrir hlut {0}. Ekki er hægt að tryggja afhendingu með \ raðnúmeri
 DocType: Sales Partner,Sales Partner Target,Velta Partner Target
 DocType: Loan Type,Maximum Loan Amount,Hámarkslán
-DocType: Pricing Rule,Pricing Rule,verðlagning Regla
+DocType: Coupon Code,Pricing Rule,verðlagning Regla
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Afrita rúlla númer fyrir nemanda {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Efni Beiðni um Innkaupapöntun
 DocType: Company,Default Selling Terms,Sjálfgefin söluskilmálar
@@ -2773,6 +2787,7 @@
 DocType: Payment Schedule,Payment Amount,Greiðslu upphæð
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Hálft dagur Dagsetning ætti að vera á milli vinnu frá dagsetningu og vinnslutíma
 DocType: Healthcare Settings,Healthcare Service Items,Heilbrigðisþjónustudeildir
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Ógild strikamerki. Það er enginn hlutur festur við þennan strikamerki.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,neytt Upphæð
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Net Breyting á Cash
 DocType: Assessment Plan,Grading Scale,flokkun Scale
@@ -2892,7 +2907,6 @@
 DocType: Share Transfer,Asset Account,Eignareikningur
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Nýr útgáfudagur ætti að vera í framtíðinni
 DocType: Purchase Invoice,End date of current invoice's period,Lokadagur tímabils núverandi reikningi er
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Vinsamlegast settu upp nafnakerfi starfsmanna í mannauði&gt; HR stillingar
 DocType: Lab Test,Technician Name,Nafn tæknimanns
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3003,6 +3017,7 @@
 DocType: Products Settings,Hide Variants,Fela afbrigði
 DocType: Lead,Next Contact By,Næsta Samband með
 DocType: Compensatory Leave Request,Compensatory Leave Request,Bótaábyrgð
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Ekki hægt að of mikið af hlut {0} í röð {1} meira en {2}. Til að leyfa ofinnheimtu, vinsamlegast stilltu vasapeninga í reikningum"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Magn krafist fyrir lið {0} í röð {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Warehouse {0} Ekki er hægt að eyða eins magn er fyrir hendi tl {1}
 DocType: Blanket Order,Order Type,Order Type
@@ -3172,7 +3187,6 @@
 DocType: Student,Student Mobile Number,Student Mobile Number
 DocType: Item,Has Variants,hefur Afbrigði
 DocType: Employee Benefit Claim,Claim Benefit For,Kröfuhagur fyrir
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings",Ekki er hægt að yfirfæra fyrir lið {0} í röð {1} meira en {2}. Til að leyfa ofgreiðslu skaltu setja í lagerstillingar
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Uppfæra svar
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Þú hefur nú þegar valið hluti úr {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Heiti Monthly Distribution
@@ -3462,6 +3476,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Vinsamlegast tilgreinið gjaldmiðil í félaginu
 DocType: Workstation,Wages per hour,Laun á klukkustund
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Stilla {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Viðskiptavinur&gt; viðskiptavinahópur&gt; landsvæði
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Stock jafnvægi í Batch {0} verður neikvætt {1} fyrir lið {2} í Warehouse {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Eftirfarandi efni beiðnir hafa verið hækkaðir sjálfvirkt miðað aftur röð stigi atriðisins
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Reikningur {0} er ógild. Reikningur Gjaldmiðill verður að vera {1}
@@ -3791,6 +3806,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Senda Laun Slip
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Á bið
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Efni þarf að hafa að minnsta kosti einn réttan valkost
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Kaup pantanir
 DocType: Account,Inter Company Account,Innri félagsreikningur
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Innflutningur á lausu
 DocType: Sales Partner,Address & Contacts,Heimilisfang og Tengiliðir
@@ -3801,6 +3817,7 @@
 DocType: POS Profile,[Select],[Veldu]
 DocType: Staffing Plan Detail,Number Of Positions,Fjöldi staða
 DocType: Vital Signs,Blood Pressure (diastolic),Blóðþrýstingur (diastolic)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Vinsamlegast veldu viðskiptavininn.
 DocType: SMS Log,Sent To,send til
 DocType: Agriculture Task,Holiday Management,Holiday Management
 DocType: Payment Request,Make Sales Invoice,Gera sölureikning
@@ -4010,7 +4027,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} er ekki lögð
 DocType: Subscription,Trialling,Skrímsli
 DocType: Sales Invoice Item,Deferred Revenue,Frestað tekjur
-DocType: Bank Account,GL Account,GL reikningur
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Cash reikningur verður notaður fyrir stofnun sölureikninga
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Undanþága undirflokkur
 DocType: Member,Membership Expiry Date,Félagsdagur
@@ -4414,13 +4430,13 @@
 DocType: C-Form Invoice Detail,Territory,Territory
 DocType: Pricing Rule,Apply Rule On Item Code,Notaðu reglu um hlutakóða
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Vinsamlegast nefna engin heimsókna krafist
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Hlutabréfaskýrsla
 DocType: Stock Settings,Default Valuation Method,Sjálfgefið Verðmatsaðferð
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Gjald
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Sýna uppsöfnuð upphæð
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Uppfærsla í gangi. Það gæti tekið smá stund.
 DocType: Production Plan Item,Produced Qty,Framleitt magn
 DocType: Vehicle Log,Fuel Qty,eldsneyti Magn
-DocType: Stock Entry,Target Warehouse Name,Markmið Vörugeymsla
 DocType: Work Order Operation,Planned Start Time,Planned Start Time
 DocType: Course,Assessment,mat
 DocType: Payment Entry Reference,Allocated,úthlutað
@@ -4486,10 +4502,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","Staðlaðar Skilmálar og skilyrði sem hægt er að bæta við sölu og innkaup. Dæmi: 1. Gildi tilboðinu. 1. Greiðsluskilmálar (fyrirfram, á lánsfé, hluti fyrirfram etc). 1. Hvað er aukinn (eða ber að greiða viðskiptamanni). 1. Öryggi / notkun viðvörun. 1. Ábyrgð ef einhver er. 1. Skilareglur. 1. Skilmálar skipum, ef við á. 1. Leiðir sem fjallað deilur bætur, ábyrgð osfrv 1. Heimilisfang og Hafa fyrirtækisins."
 DocType: Homepage Section,Section Based On,Kafli byggður á
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Sýna Nota afsláttarmiða kóða
 DocType: Issue,Issue Type,Útgáfustegund
 DocType: Attendance,Leave Type,Leave Type
 DocType: Purchase Invoice,Supplier Invoice Details,Birgir Reikningsyfirlit
 DocType: Agriculture Task,Ignore holidays,Hunsa frí
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Bæta við / breyta skilyrðum afsláttarmiða
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Kostnað / Mismunur reikning ({0}) verður að vera &#39;rekstrarreikning &quot;reikning a
 DocType: Stock Entry Detail,Stock Entry Child,Barnahlutabréf
 DocType: Project,Copied From,Afritað frá
@@ -4664,6 +4682,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Mat Plan Viðmið
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Viðskipti
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Hindra innkaupapantanir
+DocType: Coupon Code,Coupon Name,Afsláttarmiðaheiti
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Viðkvæm
 DocType: Email Campaign,Scheduled,áætlunarferðir
 DocType: Shift Type,Working Hours Calculation Based On,Útreikningur vinnutíma byggður á
@@ -4680,7 +4699,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Búðu til afbrigði
 DocType: Vehicle,Diesel,Diesel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Verðlisti Gjaldmiðill ekki valinn
+DocType: Quick Stock Balance,Available Quantity,Lauslegt magn
 DocType: Purchase Invoice,Availed ITC Cess,Notaði ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Vinsamlegast settu upp kennslukerfi fyrir kennara í menntun&gt; Menntunarstillingar
 ,Student Monthly Attendance Sheet,Student Monthly Aðsókn Sheet
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Sendingarregla gildir aðeins um sölu
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Afskriftir Róður {0}: Næsta Afskriftir Dagsetning getur ekki verið fyrir Innkaupardagur
@@ -4747,8 +4768,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Row {0}: Advance gegn Viðskiptavinur verður að vera trúnaður
 DocType: Quality Meeting,Quality Meeting,Gæðafundur
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-Group til Group
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Vinsamlegast stilltu Naming Series fyrir {0} með Setup&gt; Settings&gt; Naming Series
 DocType: Employee,ERPNext User,ERPNext User
+DocType: Coupon Code,Coupon Description,Afsláttarmiða lýsing
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Hópur er nauðsynlegur í röð {0}
 DocType: Company,Default Buying Terms,Sjálfgefnir kaupsskilmálar
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Kvittun Item Staðar
@@ -4911,6 +4932,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Gegn Document Detail No
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Eyðing er ekki leyfð fyrir land {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Party Type er nauðsynlegur
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Notaðu afsláttarmiða kóða
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",Að því er varðar starfskort {0} geturðu aðeins slegið inn „Efnisflutning til framleiðslu“
 DocType: Quality Inspection,Outgoing,Outgoing
 DocType: Customer Feedback Table,Customer Feedback Table,Viðbrögð töflu viðskiptavina
@@ -5060,7 +5082,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Við afhendingu innkaupapöntunar
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Bæta við öllum birgjum
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Row # {0}: Úthlutað Magn má ekki vera hærra en útistandandi upphæð.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Viðskiptavinur&gt; viðskiptavinahópur&gt; landsvæði
 DocType: Tally Migration,Parties,Teiti
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Fletta BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Veðlán
@@ -5092,7 +5113,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Ekki leyfa að setja aðra hluti fyrir hlutinn {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Dagsetning er endurtekin
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Leyft Undirritaður
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Vinsamlegast settu upp kennslukerfi fyrir kennara í menntun&gt; Menntunarstillingar
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Net ITC í boði (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Búðu til gjöld
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Total Kaup Kostnaður (í gegnum kaupa Reikningar)
@@ -5117,6 +5137,7 @@
 DocType: Quiz Result,Wrong,Rangt
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Gengi sem Verðskrá mynt er breytt í grunngj.miðil viðskiptavinarins
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Net Magn (Company Gjaldmiðill)
+DocType: Sales Partner,Referral Code,Tilvísunarkóði
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Heildarfjöldi fyrirframgreiðslna má ekki vera hærri en heildarfjárhæðir
 DocType: Salary Slip,Hour Rate,Hour Rate
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Virkja sjálfvirka endurpöntun
@@ -5245,6 +5266,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Sýna lager Magn
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Handbært fé frá rekstri
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Röð # {0}: Staðan verður að vera {1} til að fá reikningaafslátt {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM viðskiptaþáttur ({0} -&gt; {1}) fannst ekki fyrir hlutinn: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Liður 4
 DocType: Student Admission,Admission End Date,Aðgangseyrir Lokadagur
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Sub-samningagerð
@@ -5267,6 +5289,7 @@
 DocType: Travel Request,Fully Sponsored,Fully Sponsored
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Reverse Journal Entry
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Búðu til atvinnukort
+DocType: Quotation,Referral Sales Partner,Tilvísun söluaðila
 DocType: Quality Procedure Process,Process Description,Aðferðalýsing
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Viðskiptavinur {0} er búinn til.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Eins og er ekki birgðir í boði á hvaða vöruhúsi
@@ -5401,6 +5424,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM Rate
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Lestur hlaðið skrá
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel",Stöðvuð vinnuskilyrði er ekki hægt að hætta við. Stöðva það fyrst til að hætta við
+DocType: Coupon Code,Coupon Code,afsláttarkóði
 DocType: Asset,Journal Entry for Scrap,Journal Entry fyrir rusl
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Vinsamlegast draga atriði úr afhendingarseðlinum
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Rú {0}: veldu vinnustöðina gegn aðgerðinni {1}
@@ -5483,6 +5507,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,„Dagsetning“ er krafist
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Vegna / Reference Dagsetning má ekki vera á eftir {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Gögn Innflutningur og útflutningur
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Því miður, gildistími afsláttarmiða er útrunninn"
 DocType: Bank Account,Account Details,Reikningsupplýsingar
 DocType: Crop,Materials Required,Efni sem krafist er
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Engar nemendur Found
@@ -5520,6 +5545,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Fara til notenda
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Greiddur upphæð + afskrifa Upphæð má ekki vera meiri en Grand Total
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} er ekki gild Batch Símanúmer fyrir lið {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Vinsamlegast sláðu inn gildan afsláttarmiða kóða !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Athugið: Það er ekki nóg leyfi jafnvægi um leyfi Tegund {0}
 DocType: Task,Task Description,Verkefnalýsing
 DocType: Training Event,Seminar,Seminar
@@ -5783,6 +5809,7 @@
 ,TDS Payable Monthly,TDS greiðanleg mánaðarlega
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Í biðstöðu fyrir að skipta um BOM. Það getur tekið nokkrar mínútur.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Get ekki draga þegar flokkur er fyrir &#39;Verðmat&#39; eða &#39;Verðmat og heildar&#39;
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Vinsamlegast settu upp nafnakerfi starfsmanna í mannauð&gt; HR stillingar
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Heildargreiðslur
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serial Nos Áskilið fyrir serialized lið {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Passa Greiðslur með Reikningar
@@ -5872,6 +5899,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Fáðu hráefni til framleiðslu
 DocType: Job Opening,Job Title,Starfsheiti
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Framtíðargreiðsla ref
+DocType: Quotation,Additional Discount and Coupon Code,Viðbótarafsláttur og afsláttarmiða kóða
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.",{0} gefur til kynna að {1} muni ekki gefa til kynna en allir hlutir \ hafa verið vitnar í. Uppfæra RFQ vitna stöðu.
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Hámarksýni - {0} hafa þegar verið haldið fyrir lotu {1} og lið {2} í lotu {3}.
@@ -6099,7 +6127,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Stillingar fyrir heimasíðu heimasíðuna
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} er í bið til {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQs eru ekki leyfð fyrir {0} vegna þess að stigatafla sem stendur fyrir {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Gerðu innkaupareikning
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Notaðar blöð
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} afsláttarmiða notaður er {1}. Leyfilegt magn er uppurið
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Viltu leggja fram efnisbeiðnina
 DocType: Job Offer,Awaiting Response,bíður svars
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6113,6 +6143,7 @@
 DocType: Training Event Employee,Optional,Valfrjálst
 DocType: Salary Slip,Earning & Deduction,Launin &amp; Frádráttur
 DocType: Agriculture Analysis Criteria,Water Analysis,Vatnsgreining
+DocType: Sales Order,Skip Delivery Note,Sleppa afhendingu athugasemd
 DocType: Price List,Price Not UOM Dependent,Verð ekki UOM háður
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} afbrigði búin til.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Sjálfgefinn þjónustustigssamningur er þegar til.
@@ -6217,6 +6248,7 @@
 DocType: Vehicle,Last Carbon Check,Síðasta Carbon Athuga
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,málskostnaðar
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Vinsamlegast veljið magn í röð
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Vinnipöntun {0}: starfskort fannst ekki fyrir aðgerðina {1}
 DocType: Purchase Invoice,Posting Time,staða Time
 DocType: Timesheet,% Amount Billed,% Magn Billed
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Sími Útgjöld
@@ -6319,7 +6351,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Skattar og gjöld bætt
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Afskriftir Rauða {0}: Næsta Afskriftir Dagsetning má ekki vera fyrr en hægt er að nota Dagsetning
 ,Sales Funnel,velta trekt
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Atriðakóði&gt; Vöruflokkur&gt; Vörumerki
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Skammstöfun er nauðsynlegur
 DocType: Project,Task Progress,verkefni Progress
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Körfu
@@ -6414,6 +6445,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS Profile þarf að gera POS Entry
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Hollusta stig verður reiknað út frá því sem varið er (með sölureikningi), byggt á söfnunartölu sem getið er um."
 DocType: Program Enrollment Tool,Enroll Students,innritast Nemendur
+DocType: Pricing Rule,Coupon Code Based,Byggt á afsláttarmiða kóða
 DocType: Company,HRA Settings,HRA Stillingar
 DocType: Homepage,Hero Section,Hetja hluti
 DocType: Employee Transfer,Transfer Date,Flutnings Dagsetning
@@ -6529,6 +6561,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Vinsamlegast stilltu Fyrirtæki sía eyða ef Group By er &#39;Company&#39;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Staða Dagsetning má ekki vera liðinn
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: Serial No {1} passar ekki við {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Vinsamlegast settu upp númeraröð fyrir mætingu með uppsetningu&gt; Númeraröð
 DocType: Stock Entry,Target Warehouse Address,Target Warehouse Heimilisfang
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Kjóll Leave
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,Tíminn fyrir upphafstíma vakta þar sem innritun starfsmanna er talin til mætingar.
@@ -6563,7 +6596,6 @@
 DocType: Employee Grade,Employee Grade,Starfsmaður
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,ákvæðisvinnu
 DocType: GSTR 3B Report,June,Júní
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Birgir&gt; Gerð birgis
 DocType: Share Balance,From No,Frá nr
 DocType: Shift Type,Early Exit Grace Period,Náðartímabil snemma útgöngu
 DocType: Task,Actual Time (in Hours),Tíminn (í klst)
@@ -6848,7 +6880,6 @@
 DocType: Warehouse,Warehouse Name,Warehouse Name
 DocType: Naming Series,Select Transaction,Veldu Transaction
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Vinsamlegast sláðu inn Samþykkir hlutverki eða samþykkir notandi
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM viðskiptaþáttur ({0} -&gt; {1}) fannst ekki fyrir hlutinn: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Samningur um þjónustustig með einingategund {0} og eining {1} er þegar til.
 DocType: Journal Entry,Write Off Entry,Skrifaðu Off færslu
 DocType: BOM,Rate Of Materials Based On,Hlutfall af efni byggt á
@@ -6986,6 +7017,7 @@
 DocType: Budget,Warn,Warn
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Öll atriði hafa nú þegar verið flutt fyrir þessa vinnuáætlun.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Allar aðrar athugasemdir, athyglisvert áreynsla sem ætti að fara í skrám."
+DocType: Bank Account,Company Account,Fyrirtækisreikningur
 DocType: Asset Maintenance,Manufacturing User,framleiðsla User
 DocType: Purchase Invoice,Raw Materials Supplied,Raw Materials Staðar
 DocType: Subscription Plan,Payment Plan,Greiðsluáætlun
@@ -7027,6 +7059,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) getur ekki verið meiri en áætlað magn ({2}) í vinnuskilyrðingu {3}
 DocType: Certification Application,Name of Applicant,Nafn umsækjanda
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Tími Sheet fyrir framleiðslu.
+DocType: Quick Stock Balance,Quick Stock Balance,Fljótur hlutafjárjöfnuður
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Samtals
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Ekki er hægt að breyta Variant eignum eftir viðskipti með hlutabréf. Þú verður að búa til nýtt atriði til að gera þetta.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA umboð
@@ -7353,6 +7386,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},Vinsamlegast settu {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} er óvirkur nemandi
 DocType: Employee,Health Details,Heilsa Upplýsingar
+DocType: Coupon Code,Coupon Type,Gerð afsláttarmiða
 DocType: Leave Encashment,Encashable days,Skemmtilegir dagar
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Til að búa til greiðslubeiðni þarf viðmiðunarskjal
 DocType: Soil Texture,Sandy Clay,Sandy Clay
@@ -7635,6 +7669,7 @@
 DocType: Hotel Room Package,Amenities,Aðstaða
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Sæktu sjálfkrafa greiðsluskilmála
 DocType: QuickBooks Migrator,Undeposited Funds Account,Óheimilt sjóðsreikningur
+DocType: Coupon Code,Uses,Notar
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Margfeldi sjálfgefið greiðslumáti er ekki leyfilegt
 DocType: Sales Invoice,Loyalty Points Redemption,Hollusta stig Innlausn
 ,Appointment Analytics,Ráðstefna Analytics
@@ -7651,6 +7686,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Heildaráætlun
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Skildu eftir ef þú gerir nemendur hópa á ári
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Ef hakað Total nr. vinnudaga mun fela frí, og þetta mun draga úr gildi af launum fyrir dag"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Mistókst að bæta við léninu
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Til að leyfa móttöku / afhendingu, skal uppfæra „Yfir móttöku / afhendingu“ í lager stillingum eða hlutnum."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Forrit sem nota núverandi lykil vilja ekki geta nálgast, ertu viss?"
 DocType: Subscription Settings,Prorate,Prorate
@@ -7663,6 +7699,7 @@
 ,BOM Stock Report,BOM Stock Report
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Ef það er enginn úthlutaður tímaröð, þá mun samskipti fara með þennan hóp"
 DocType: Stock Reconciliation Item,Quantity Difference,magn Mismunur
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Birgir&gt; Gerð birgis
 DocType: Opportunity Item,Basic Rate,Basic Rate
 DocType: GL Entry,Credit Amount,Credit Upphæð
 ,Electronic Invoice Register,Rafræn reikningaskrá
@@ -7916,6 +7953,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Skattar og gjöld FrÃ¡ (Company Gjaldmiðill)
 DocType: Item Group,General Settings,Almennar stillingar
 DocType: Article,Article,Grein
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Vinsamlegast sláðu inn afsláttarmiða kóða !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Frá Gjaldmiðill og gjaldmiðla getur ekki verið það sama
 DocType: Taxable Salary Slab,Percent Deduction,Hlutfall frádráttar
 DocType: GL Entry,To Rename,Að endurnefna
diff --git a/erpnext/translations/it.csv b/erpnext/translations/it.csv
index f4ff5ef..5d3f12a 100644
--- a/erpnext/translations/it.csv
+++ b/erpnext/translations/it.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Customer Contact
 DocType: Shift Type,Enable Auto Attendance,Abilita assistenza automatica
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Inserisci il magazzino e la data
 DocType: Lost Reason Detail,Opportunity Lost Reason,Opportunità persa motivo
 DocType: Patient Appointment,Check availability,Verificare la disponibilità
 DocType: Retention Bonus,Bonus Payment Date,Data di pagamento bonus
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Ordini di lavoro completati
 DocType: Support Settings,Forum Posts,Messaggi del forum
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","L&#39;attività è stata accodata come processo in background. Nel caso in cui si verifichino problemi durante l&#39;elaborazione in background, il sistema aggiungerà un commento sull&#39;errore in questa Riconciliazione di magazzino e tornerà alla fase Bozza"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Siamo spiacenti, la validità del codice coupon non è iniziata"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Imponibile
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Non sei autorizzato ad aggiungere o aggiornare le voci prima di {0}
 DocType: Leave Policy,Leave Policy Details,Lasciare i dettagli della politica
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Consumabile
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,Grado
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Codice articolo&gt; Gruppo articoli&gt; Marchio
 DocType: Restaurant Table,No of Seats,No delle sedute
 DocType: Sales Invoice,Overdue and Discounted,Scaduto e scontato
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Chiamata disconnessa
@@ -506,6 +509,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,interlinea per importo in lettere
 DocType: Vehicle,Additional Details,Dettagli aggiuntivi
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Nessuna descrizione fornita
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Recupera articoli dal magazzino
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Richiesta di acquisto.
 DocType: POS Closing Voucher Details,Collected Amount,Importo raccolto
 DocType: Lab Test,Submitted Date,Data di invio
@@ -613,6 +617,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Guide
 ,Trial Balance (Simple),Bilancio di verifica (semplice)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Abilita spese differite
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Codice coupon applicato
 DocType: Asset,Next Depreciation Date,Data ammortamento successivo
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Costo attività per dipendente
 DocType: Accounts Settings,Settings for Accounts,Impostazioni per gli account
@@ -848,8 +853,6 @@
 DocType: BOM,Work Order,Ordine di lavoro
 DocType: Sales Invoice,Total Qty,Totale Quantità
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Email ID Guardian2
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Elimina il dipendente <a href=""#Form/Employee/{0}"">{0}</a> \ per annullare questo documento"
 DocType: Item,Show in Website (Variant),Show di Sito web (Variant)
 DocType: Employee,Health Concerns,Preoccupazioni per la salute
 DocType: Payroll Entry,Select Payroll Period,Seleziona Periodo Busta Paga
@@ -1013,6 +1016,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Conto ritenuta d&#39;acconto
 DocType: Pricing Rule,Sales Partner,Partner vendite
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Tutti i punteggi dei fornitori.
+DocType: Coupon Code,To be used to get discount,Per essere utilizzato per ottenere lo sconto
 DocType: Buying Settings,Purchase Receipt Required,Ricevuta di Acquisto necessaria
 DocType: Sales Invoice,Rail,Rotaia
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Costo attuale
@@ -1063,6 +1067,7 @@
 DocType: Production Plan,Production Plan,Piano di produzione
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Strumento di Creazione di Fattura Tardiva
 DocType: Salary Component,Round to the Nearest Integer,Arrotonda al numero intero più vicino
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Consenti agli articoli non disponibili di essere aggiunti al carrello
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Ritorno di vendite
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Imposta Qtà in Transazioni basate su Nessun input seriale
 ,Total Stock Summary,Sommario totale delle azioni
@@ -1192,6 +1197,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Base Hour Rate (Società di valuta)
 ,Qty To Be Billed,Quantità da fatturare
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Importo Consegnato
+DocType: Coupon Code,Gift Card,Carta regalo
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Qtà riservata per la produzione: quantità di materie prime per la produzione di articoli.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Data di rimborso
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Questa transazione bancaria è già completamente riconciliata
@@ -1279,6 +1285,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Crea scheda attività
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Account {0} è stato inserito più volte
 DocType: Account,Expenses Included In Valuation,Spese incluse nella valorizzazione
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Acquista fatture
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Puoi rinnovare solo se la tua iscrizione scade entro 30 giorni
 DocType: Shopping Cart Settings,Show Stock Availability,Mostra disponibilità di magazzino
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Imposta {0} nella categoria di asset {1} o nella società {2}
@@ -1837,6 +1844,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Importazione di articoli e UOM
 DocType: Repayment Schedule,Balance Loan Amount,Importo del prestito di bilancio
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Aggiunto ai dettagli
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Siamo spiacenti, il codice coupon è esaurito"
 DocType: Communication Medium,Catch All,Prendi tutto
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Programma del corso
 DocType: Budget,Applicable on Material Request,Applicabile su richiesta materiale
@@ -2004,6 +2012,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,attributo non valido
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} deve essere confermato
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Campagne e-mail
+DocType: Sales Partner,To Track inbound purchase,Per tenere traccia dell&#39;acquisto in entrata
 DocType: Buying Settings,Default Supplier Group,Gruppo di fornitori predefinito
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},La quantità deve essere minore o uguale a {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},L&#39;importo massimo ammissibile per il componente {0} supera {1}
@@ -2159,8 +2168,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Effettuare una registrazione di magazzino
 DocType: Hotel Room Reservation,Hotel Reservation User,Utente prenotazione hotel
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Imposta stato
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Impostare le serie di numerazione per la partecipazione tramite Impostazione&gt; Serie di numerazione
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Si prega di selezionare il prefisso prima
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Impostare Naming Series per {0} tramite Setup&gt; Impostazioni&gt; Naming Series
 DocType: Contract,Fulfilment Deadline,Scadenza di adempimento
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Vicino a te
 DocType: Student,O-,O-
@@ -2284,6 +2293,7 @@
 DocType: Quality Meeting Table,Under Review,In fase di revisione
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Impossibile accedere
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Asset {0} creato
+DocType: Coupon Code,Promotional,promozionale
 DocType: Special Test Items,Special Test Items,Articoli speciali di prova
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Devi essere un utente con i ruoli di System Manager e Item Manager da registrare sul Marketplace.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Rapporti chiave
@@ -2321,6 +2331,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Tipo Doc
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Totale percentuale assegnato per il team di vendita dovrebbe essere di 100
 DocType: Subscription Plan,Billing Interval Count,Conteggio intervalli di fatturazione
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Elimina il dipendente <a href=""#Form/Employee/{0}"">{0}</a> \ per annullare questo documento"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Appuntamenti e incontri con il paziente
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Valore mancante
 DocType: Employee,Department and Grade,Dipartimento e grado
@@ -2423,6 +2435,7 @@
 DocType: Project,Start and End Dates,Date di inizio e fine
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Termini di adempimento del modello di contratto
 ,Delivered Items To Be Billed,Gli Articoli consegnati da Fatturare
+DocType: Coupon Code,Maximum Use,Massimo utilizzo
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Apri la Distinta Base {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Magazzino non può essere modificato per Serial No.
 DocType: Authorization Rule,Average Discount,Sconto Medio
@@ -2585,6 +2598,7 @@
 DocType: Item,Inventory,Inventario
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Scarica come Json
 DocType: Item,Sales Details,Dettagli di vendita
+DocType: Coupon Code,Used,Usato
 DocType: Opportunity,With Items,Con gli articoli
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',La campagna &quot;{0}&quot; esiste già per {1} &quot;{2}&quot;
 DocType: Asset Maintenance,Maintenance Team,Squadra di manutenzione
@@ -2714,7 +2728,7 @@
 						Serial No cannot be ensured",Nessun BOM attivo trovato per l&#39;articolo {0}. La consegna per \ Numero di serie non può essere garantita
 DocType: Sales Partner,Sales Partner Target,Vendite Partner di destinazione
 DocType: Loan Type,Maximum Loan Amount,Importo massimo del prestito
-DocType: Pricing Rule,Pricing Rule,Regola Prezzi
+DocType: Coupon Code,Pricing Rule,Regola Prezzi
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplica il numero di rotolo per lo studente {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Richiesta materiale per ordine d&#39;acquisto
 DocType: Company,Default Selling Terms,Termini di vendita predefiniti
@@ -2793,6 +2807,7 @@
 DocType: Payment Schedule,Payment Amount,Pagamento Importo
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,La data di mezza giornata deve essere compresa tra la data di fine lavoro e la data di fine lavoro
 DocType: Healthcare Settings,Healthcare Service Items,Articoli per servizi sanitari
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Codice a barre non valido. Non ci sono articoli collegati a questo codice a barre.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Quantità consumata
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Variazione netta delle disponibilità
 DocType: Assessment Plan,Grading Scale,Scala di classificazione
@@ -2912,7 +2927,6 @@
 DocType: Share Transfer,Asset Account,Conto cespiti
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,La nuova data di uscita dovrebbe essere in futuro
 DocType: Purchase Invoice,End date of current invoice's period,Data di fine del periodo di fatturazione corrente
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Si prega di impostare il sistema di denominazione dei dipendenti in Risorse umane&gt; Impostazioni risorse umane
 DocType: Lab Test,Technician Name,Nome tecnico
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3023,6 +3037,7 @@
 DocType: Products Settings,Hide Variants,Nascondi varianti
 DocType: Lead,Next Contact By,Contatto Successivo Con
 DocType: Compensatory Leave Request,Compensatory Leave Request,Richiesta di congedo compensativo
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Impossibile eseguire l&#39;overbilling per l&#39;articolo {0} nella riga {1} più di {2}. Per consentire l&#39;eccessiva fatturazione, imposta l&#39;indennità in Impostazioni account"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Quantità necessaria per la voce {0} in riga {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Magazzino {0} non può essere cancellato in quanto esiste la quantità per l' articolo {1}
 DocType: Blanket Order,Order Type,Tipo di ordine
@@ -3192,7 +3207,6 @@
 DocType: Student,Student Mobile Number,Student Mobile Number
 DocType: Item,Has Variants,Ha varianti
 DocType: Employee Benefit Claim,Claim Benefit For,Reclamo Beneficio per
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Impossibile eseguire lo overbill per l&#39;articolo {0} nella riga {1} più di {2}. Per consentire la fatturazione eccessiva, si prega di impostare in Impostazioni di magazzino"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Aggiorna risposta
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Hai già selezionato elementi da {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Nome della distribuzione mensile
@@ -3483,6 +3497,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Si prega di specificare la valuta in azienda
 DocType: Workstation,Wages per hour,Salari all'ora
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Configura {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Cliente&gt; Gruppo di clienti&gt; Territorio
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Equilibrio Stock in Lotto {0} sarà negativo {1} per la voce {2} a Warehouse {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,A seguito di richieste di materiale sono state sollevate automaticamente in base al livello di riordino della Voce
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Account {0} non valido. La valuta del conto deve essere {1}
@@ -3812,6 +3827,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Presenta Busta Paga
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,In attesa
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Una qustion deve avere almeno un&#39;opzione corretta
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Ordini di acquisto
 DocType: Account,Inter Company Account,Conto Inter Inter
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Importazione Collettiva
 DocType: Sales Partner,Address & Contacts,Indirizzi & Contatti
@@ -3822,6 +3838,7 @@
 DocType: POS Profile,[Select],[Seleziona]
 DocType: Staffing Plan Detail,Number Of Positions,Numero di posizioni
 DocType: Vital Signs,Blood Pressure (diastolic),Pressione sanguigna (diastolica)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Seleziona il cliente
 DocType: SMS Log,Sent To,Inviato A
 DocType: Agriculture Task,Holiday Management,Gestione Ferie
 DocType: Payment Request,Make Sales Invoice,Crea Fattura di vendita
@@ -4031,7 +4048,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} non è confermato
 DocType: Subscription,Trialling,sperimentazione
 DocType: Sales Invoice Item,Deferred Revenue,Ricavo differito
-DocType: Bank Account,GL Account,Conto GL
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Conto in contanti verrà utilizzato per la creazione di fattura di vendita
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Sottocategoria di esenzione
 DocType: Member,Membership Expiry Date,Data di scadenza dell&#39;appartenenza
@@ -4455,13 +4471,13 @@
 DocType: C-Form Invoice Detail,Territory,Territorio
 DocType: Pricing Rule,Apply Rule On Item Code,Applica regola sul codice articolo
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Si prega di citare nessuna delle visite richieste
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Rapporto sul bilancio azionario
 DocType: Stock Settings,Default Valuation Method,Metodo di valorizzazione predefinito
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,tassa
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Mostra quantità cumulativa
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Aggiornamento in corso. Potrebbe volerci un po &#39;.
 DocType: Production Plan Item,Produced Qty,Qtà prodotta
 DocType: Vehicle Log,Fuel Qty,Quantità di carburante
-DocType: Stock Entry,Target Warehouse Name,Nome del magazzino di destinazione
 DocType: Work Order Operation,Planned Start Time,Ora di inizio prevista
 DocType: Course,Assessment,Valutazione
 DocType: Payment Entry Reference,Allocated,Assegnati
@@ -4539,10 +4555,12 @@
  1. Modi di controversie indirizzamento, indennità, responsabilità, ecc 
  1. Indirizzo e contatti della vostra azienda."
 DocType: Homepage Section,Section Based On,Sezione basata su
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Mostra Applica codice coupon
 DocType: Issue,Issue Type,Tipo di Problema
 DocType: Attendance,Leave Type,Tipo di Permesso
 DocType: Purchase Invoice,Supplier Invoice Details,Dettagli Fattura Fornitore
 DocType: Agriculture Task,Ignore holidays,Ignora le vacanze
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Aggiungi / Modifica condizioni coupon
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Expense / account Differenza ({0}) deve essere un 'utile o perdita' conto
 DocType: Stock Entry Detail,Stock Entry Child,Stock di entrata figlio
 DocType: Project,Copied From,Copiato da
@@ -4717,6 +4735,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Criteri piano di valutazione
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Le transazioni
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Impedire gli ordini di acquisto
+DocType: Coupon Code,Coupon Name,Nome del coupon
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,suscettibile
 DocType: Email Campaign,Scheduled,Pianificate
 DocType: Shift Type,Working Hours Calculation Based On,Calcolo dell&#39;orario di lavoro basato su
@@ -4733,7 +4752,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Crea Varianti
 DocType: Vehicle,Diesel,diesel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Listino Prezzi Valuta non selezionati
+DocType: Quick Stock Balance,Available Quantity,quantità disponibile
 DocType: Purchase Invoice,Availed ITC Cess,Disponibile ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Installa il sistema di denominazione dell&#39;istruttore in Istruzione&gt; Impostazioni istruzione
 ,Student Monthly Attendance Sheet,Presenze mensile Scheda
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Regola di spedizione applicabile solo per la vendita
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Riga di ammortamento {0}: la successiva data di ammortamento non può essere anteriore alla data di acquisto
@@ -4800,8 +4821,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Riga {0}: Advance contro il Cliente deve essere di credito
 DocType: Quality Meeting,Quality Meeting,Riunione di qualità
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-gruppo a gruppo
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Impostare Naming Series per {0} tramite Setup&gt; Impostazioni&gt; Naming Series
 DocType: Employee,ERPNext User,ERPNext Utente
+DocType: Coupon Code,Coupon Description,Descrizione del coupon
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Il lotto è obbligatorio nella riga {0}
 DocType: Company,Default Buying Terms,Termini di acquisto predefiniti
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Ricevuta di Acquisto Articolo Fornito
@@ -4964,6 +4985,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Per Dettagli Documento N
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},La cancellazione non è consentita per il Paese {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Tipo Partner è obbligatorio
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Applica il codice coupon
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","Per la scheda lavoro {0}, è possibile effettuare solo l&#39;immissione di magazzino del tipo &quot;Trasferimento materiale per produzione&quot;"
 DocType: Quality Inspection,Outgoing,In partenza
 DocType: Customer Feedback Table,Customer Feedback Table,Tabella di feedback dei clienti
@@ -5113,7 +5135,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Alla presentazione dell&#39;ordine d&#39;acquisto
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Aggiungi tutti i fornitori
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Riga # {0}: L'Importo assegnato non può essere superiore all'importo dovuto.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Cliente&gt; Gruppo di clienti&gt; Territorio
 DocType: Tally Migration,Parties,parti
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Sfoglia Distinta Base
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Prestiti garantiti
@@ -5145,7 +5166,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Non consentire di impostare articoli alternativi per l&#39;articolo {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,La Data si Ripete
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Firma autorizzata
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Configura il sistema di denominazione dell&#39;istruttore in Istruzione&gt; Impostazioni istruzione
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Net ITC disponibile (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Crea tariffe
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Costo totale di acquisto (tramite acquisto fattura)
@@ -5170,6 +5190,7 @@
 DocType: Quiz Result,Wrong,Sbagliato
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Tasso al quale Listino valuta viene convertita in valuta di base del cliente
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Importo netto (Valuta Azienda)
+DocType: Sales Partner,Referral Code,Codice di riferimento
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,L&#39;importo totale anticipato non può essere maggiore dell&#39;importo sanzionato totale
 DocType: Salary Slip,Hour Rate,Rapporto Orario
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Abilita il riordino automatico
@@ -5298,6 +5319,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Mostra quantità di magazzino
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Cassa netto da attività
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Riga # {0}: lo stato deve essere {1} per lo sconto fattura {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Fattore di conversione UOM ({0} -&gt; {1}) non trovato per l&#39;articolo: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Articolo 4
 DocType: Student Admission,Admission End Date,Data Fine Ammissione
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Subappalto
@@ -5320,6 +5342,7 @@
 DocType: Travel Request,Fully Sponsored,Completamente sponsorizzato
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Entrata di giornale inversa
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Crea Job Card
+DocType: Quotation,Referral Sales Partner,Partner commerciale di riferimento
 DocType: Quality Procedure Process,Process Description,Descrizione del processo
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Cliente {0} creato.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Articolo attualmente non presente in nessun magazzino
@@ -5455,6 +5478,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM Tasso
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Lettura del file caricato
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","L&#39;ordine di lavoro interrotto non può essere annullato, fermalo prima per annullare"
+DocType: Coupon Code,Coupon Code,codice coupon
 DocType: Asset,Journal Entry for Scrap,Diario di rottami
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Si prega di tirare oggetti da DDT
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Riga {0}: seleziona la workstation rispetto all&#39;operazione {1}
@@ -5537,6 +5561,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,È richiesta la &quot;data&quot;
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Data / Reference Data non può essere successiva {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Importazione ed esportazione dati
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Siamo spiacenti, la validità del codice coupon è scaduta"
 DocType: Bank Account,Account Details,Dettagli Account
 DocType: Crop,Materials Required,Materiali richiesti
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Nessun studenti hanno trovato
@@ -5574,6 +5599,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Vai agli Utenti
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Importo pagato + Importo svalutazione non può essere superiore a Totale generale
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} non è un numero di lotto valido per la voce {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Inserisci un codice coupon valido !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Nota : Non hai giorni sufficienti per il permesso {0}
 DocType: Task,Task Description,Descrizione del compito
 DocType: Training Event,Seminar,Seminario
@@ -5837,6 +5863,7 @@
 ,TDS Payable Monthly,TDS mensile pagabile
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,In coda per la sostituzione della BOM. Potrebbero essere necessari alcuni minuti.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Non può dedurre quando categoria è di ' valutazione ' o ' Valutazione e Total '
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Si prega di impostare il sistema di denominazione dei dipendenti in Risorse umane&gt; Impostazioni risorse umane
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Pagamenti totali
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serial Nos Obbligatorio per la voce Serialized {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Partita pagamenti con fatture
@@ -5926,6 +5953,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Ottieni materie prime per la produzione
 DocType: Job Opening,Job Title,Titolo Posizione
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Rif. Pagamento futuro
+DocType: Quotation,Additional Discount and Coupon Code,Codice sconto e coupon aggiuntivi
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} indica che {1} non fornirà una quotazione, ma tutti gli elementi \ sono stati quotati. Aggiornamento dello stato delle quotazione."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Numero massimo di campioni: {0} sono già stati conservati per il batch {1} e l&#39;articolo {2} nel batch {3}.
@@ -6153,7 +6181,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Impostazioni per homepage del sito
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} è in attesa fino a {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ non sono consentite per {0} a causa del valutazione {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Crea Fattura d'Acquisto
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Ferie Usate
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} I coupon utilizzati sono {1}. La quantità consentita è esaurita
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Vuoi inviare la richiesta materiale
 DocType: Job Offer,Awaiting Response,In attesa di risposta
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6167,6 +6197,7 @@
 DocType: Training Event Employee,Optional,Opzionale
 DocType: Salary Slip,Earning & Deduction,Rendimento & Detrazione
 DocType: Agriculture Analysis Criteria,Water Analysis,Analisi dell&#39;acqua
+DocType: Sales Order,Skip Delivery Note,Salta bolla di consegna
 DocType: Price List,Price Not UOM Dependent,Prezzo non dipendente dall&#39;UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} varianti create.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Esiste già un accordo sul livello di servizio predefinito.
@@ -6271,6 +6302,7 @@
 DocType: Vehicle,Last Carbon Check,Ultima verifica carbon
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Spese legali
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Seleziona la quantità in fila
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Ordine di lavoro {0}: scheda lavoro non trovata per l&#39;operazione {1}
 DocType: Purchase Invoice,Posting Time,Ora di Registrazione
 DocType: Timesheet,% Amount Billed,% Importo Fatturato
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Spese telefoniche
@@ -6373,7 +6405,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Tasse e spese aggiuntive
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Riga di ammortamento {0}: la successiva Data di ammortamento non può essere precedente alla Data disponibile per l&#39;uso
 ,Sales Funnel,imbuto di vendita
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Codice articolo&gt; Gruppo articoli&gt; Marchio
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,L'abbreviazione è obbligatoria
 DocType: Project,Task Progress,Avanzamento attività
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Carrello
@@ -6468,6 +6499,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS Profilo tenuto a POS Entry
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","I Punti Fedeltà saranno calcolati a partire dal totale speso (tramite la Fattura di vendita), in base al fattore di raccolta menzionato."
 DocType: Program Enrollment Tool,Enroll Students,iscrivere gli studenti
+DocType: Pricing Rule,Coupon Code Based,Basato su codice coupon
 DocType: Company,HRA Settings,Impostazioni HRA
 DocType: Homepage,Hero Section,Sezione degli eroi
 DocType: Employee Transfer,Transfer Date,Data di trasferimento
@@ -6583,6 +6615,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Impostare il filtro aziendale vuoto se Group By è &#39;Azienda&#39;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,La Data di Registrazione non può essere una data futura
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Fila # {0}: N. di serie {1} non corrisponde con {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Impostare le serie di numerazione per la partecipazione tramite Impostazione&gt; Serie di numerazione
 DocType: Stock Entry,Target Warehouse Address,Indirizzo del magazzino di destinazione
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Permesso retribuito
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,Il tempo prima dell&#39;orario di inizio turno durante il quale il check-in dei dipendenti viene preso in considerazione per la partecipazione.
@@ -6617,7 +6650,6 @@
 DocType: Employee Grade,Employee Grade,Grado del dipendente
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,lavoro a cottimo
 DocType: GSTR 3B Report,June,giugno
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Fornitore&gt; Tipo di fornitore
 DocType: Share Balance,From No,Dal n
 DocType: Shift Type,Early Exit Grace Period,Periodo di tolleranza dell&#39;uscita anticipata
 DocType: Task,Actual Time (in Hours),Tempo reale (in ore)
@@ -6902,7 +6934,6 @@
 DocType: Warehouse,Warehouse Name,Nome Magazzino
 DocType: Naming Series,Select Transaction,Selezionare Transaction
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Inserisci Approvazione ruolo o Approvazione utente
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Fattore di conversione UOM ({0} -&gt; {1}) non trovato per l&#39;articolo: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Accordo sul livello di servizio con il tipo di entità {0} e l&#39;entità {1} esiste già.
 DocType: Journal Entry,Write Off Entry,Entry di Svalutazione
 DocType: BOM,Rate Of Materials Based On,Tasso di materiali a base di
@@ -7040,6 +7071,7 @@
 DocType: Budget,Warn,Avvisa
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Tutti gli articoli sono già stati trasferiti per questo ordine di lavoro.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Eventuali altre osservazioni, sforzo degno di nota che dovrebbe andare nelle registrazioni."
+DocType: Bank Account,Company Account,Conto aziendale
 DocType: Asset Maintenance,Manufacturing User,Utente Produzione
 DocType: Purchase Invoice,Raw Materials Supplied,Materie prime fornite
 DocType: Subscription Plan,Payment Plan,Piano di pagamento
@@ -7081,6 +7113,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) non può essere maggiore della quantità pianificata ({2}) nell'ordine di lavoro {3}
 DocType: Certification Application,Name of Applicant,Nome del candidato
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Scheda attività per la produzione.
+DocType: Quick Stock Balance,Quick Stock Balance,Bilancio rapido delle scorte
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Sub Totale
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Impossibile modificare le proprietà Variant dopo la transazione stock. Dovrai creare un nuovo oggetto per farlo.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,Mandato GoCardless SEPA
@@ -7407,6 +7440,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},Impostare {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} è uno studente inattivo
 DocType: Employee,Health Details,Dettagli Salute
+DocType: Coupon Code,Coupon Type,Tipo di coupon
 DocType: Leave Encashment,Encashable days,Giorni incastrili
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Per creare un Riferimento di Richiesta di Pagamento è necessario un Documento
 DocType: Soil Texture,Sandy Clay,Sandy Clay
@@ -7689,6 +7723,7 @@
 DocType: Hotel Room Package,Amenities,Servizi
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Recupera automaticamente i termini di pagamento
 DocType: QuickBooks Migrator,Undeposited Funds Account,Conto fondi non trasferiti
+DocType: Coupon Code,Uses,usi
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Non è consentito il modo di pagamento multiplo predefinito
 DocType: Sales Invoice,Loyalty Points Redemption,Punti fedeltà Punti di riscatto
 ,Appointment Analytics,Statistiche Appuntamento
@@ -7705,6 +7740,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Budget totale
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Lasciare vuoto se fai gruppi di studenti all&#39;anno
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Se selezionato, non totale. di giorni lavorativi includerà vacanze, e questo ridurrà il valore di salario per ogni giorno"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Impossibile aggiungere il dominio
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Per consentire l&#39;eccesso di scontrino / consegna, aggiorna &quot;Sovracontrollo / assegno di consegna&quot; in Impostazioni magazzino o Articolo."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Le app che utilizzano la chiave corrente non saranno in grado di accedere, sei sicuro?"
 DocType: Subscription Settings,Prorate,dividere proporzionalmente
@@ -7717,6 +7753,7 @@
 ,BOM Stock Report,Report Giacenza Distinta Base
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Se non è stata assegnata alcuna fascia oraria, la comunicazione verrà gestita da questo gruppo"
 DocType: Stock Reconciliation Item,Quantity Difference,Quantità Differenza
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Fornitore&gt; Tipo di fornitore
 DocType: Opportunity Item,Basic Rate,Tasso Base
 DocType: GL Entry,Credit Amount,Ammontare del credito
 ,Electronic Invoice Register,Registro delle fatture elettroniche
@@ -7970,6 +8007,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Tasse e oneri dedotti (Azienda valuta)
 DocType: Item Group,General Settings,Impostazioni Generali
 DocType: Article,Article,Articolo
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Inserisci il codice coupon !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Da Valuta e A Valuta non possono essere gli stessi
 DocType: Taxable Salary Slab,Percent Deduction,Detrazione percentuale
 DocType: GL Entry,To Rename,Rinominare
diff --git a/erpnext/translations/ja.csv b/erpnext/translations/ja.csv
index 795129d..166d4ef 100644
--- a/erpnext/translations/ja.csv
+++ b/erpnext/translations/ja.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT- .YYYY.-
 DocType: Purchase Order,Customer Contact,顧客連絡先
 DocType: Shift Type,Enable Auto Attendance,自動参加を有効にする
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,倉庫と日付を入力してください
 DocType: Lost Reason Detail,Opportunity Lost Reason,機会を失った理由
 DocType: Patient Appointment,Check availability,空室をチェック
 DocType: Retention Bonus,Bonus Payment Date,ボーナス支払日
@@ -265,6 +266,7 @@
 ,Completed Work Orders,完了した作業オーダー
 DocType: Support Settings,Forum Posts,フォーラム投稿
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage",タスクはバックグラウンドジョブとしてエンキューされました。バックグラウンドでの処理に問題がある場合は、この在庫調整にエラーに関するコメントが追加され、ドラフト段階に戻ります。
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started",申し訳ありませんが、クーポンコードの有効性は開始されていません
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,課税額
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},{0}以前のエントリーを追加または更新する権限がありません
 DocType: Leave Policy,Leave Policy Details,ポリシーの詳細を残す
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,消耗品
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,グレード
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,商品コード&gt;商品グループ&gt;ブランド
 DocType: Restaurant Table,No of Seats,席数
 DocType: Sales Invoice,Overdue and Discounted,期限切れおよび割引
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,切断された通話
@@ -506,6 +509,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,言葉の金額の行間隔
 DocType: Vehicle,Additional Details,さらなる詳細
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,説明がありません
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,倉庫からアイテムを取得する
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,仕入要求
 DocType: POS Closing Voucher Details,Collected Amount,回収額
 DocType: Lab Test,Submitted Date,提出日
@@ -613,6 +617,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,学ぶ
 ,Trial Balance (Simple),試算表（シンプル）
 DocType: Purchase Invoice Item,Enable Deferred Expense,繰延経費を有効にする
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,適用されたクーポンコード
 DocType: Asset,Next Depreciation Date,次の減価償却日
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,従業員一人あたりの活動費用
 DocType: Accounts Settings,Settings for Accounts,アカウント設定
@@ -849,8 +854,6 @@
 DocType: BOM,Work Order,作業命令
 DocType: Sales Invoice,Total Qty,合計数量
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,保護者2 メールID
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","このドキュメントをキャンセルするには、従業員<a href=""#Form/Employee/{0}"">{0}</a> \を削除してください"
 DocType: Item,Show in Website (Variant),ウェブサイトに表示（バリエーション）
 DocType: Employee,Health Concerns,健康への懸念
 DocType: Payroll Entry,Select Payroll Period,給与計算期間を選択
@@ -1014,6 +1017,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,源泉徴収勘定
 DocType: Pricing Rule,Sales Partner,販売パートナー
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,すべてのサプライヤスコアカード。
+DocType: Coupon Code,To be used to get discount,割引を受けるために使用する
 DocType: Buying Settings,Purchase Receipt Required,領収書が必要です
 DocType: Sales Invoice,Rail,レール
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,実費
@@ -1064,6 +1068,7 @@
 DocType: Production Plan,Production Plan,生産計画
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,インボイス作成ツールを開く
 DocType: Salary Component,Round to the Nearest Integer,最も近い整数に丸める
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,在庫のない商品をカートに追加できるようにする
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,販売返品
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,シリアルナンバーに基づいて取引で数量を設定する
 ,Total Stock Summary,総株式サマリー
@@ -1193,6 +1198,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),基本時間単価（会社通貨）
 ,Qty To Be Billed,請求される数量
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,納品済額
+DocType: Coupon Code,Gift Card,ギフトカード
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,生産予約数量：製造品目を製造するための原料数量。
 DocType: Loyalty Point Entry Redemption,Redemption Date,償還日
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,この銀行取引はすでに完全に調整されています
@@ -1280,6 +1286,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,タイムシートを作成する
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,アカウント {0} が複数回入力されました
 DocType: Account,Expenses Included In Valuation,評価中経費
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,請求書を購入する
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,30日以内に会員の有効期限が切れる場合にのみ更新することができます
 DocType: Shopping Cart Settings,Show Stock Availability,在庫を表示する
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},資産カテゴリ{1}または会社{2}に{0}を設定してください
@@ -1845,6 +1852,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,アイテムと単位のインポート
 DocType: Repayment Schedule,Balance Loan Amount,残高貸付額
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,詳細に追加
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted",申し訳ありませんが、クーポンコードは使い尽くされています
 DocType: Communication Medium,Catch All,すべてキャッチ
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,スケジュールコース
 DocType: Budget,Applicable on Material Request,品目依頼に適用
@@ -2012,6 +2020,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,無効な属性
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1}は提出しなければなりません
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,メールキャンペーン
+DocType: Sales Partner,To Track inbound purchase,インバウンド購入を追跡するには
 DocType: Buying Settings,Default Supplier Group,デフォルトサプライヤグループ
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},数量は以下でなければなりません{0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},{0}のコンポーネントの対象となる最大金額が{1}を超えています
@@ -2167,8 +2176,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,在庫登録
 DocType: Hotel Room Reservation,Hotel Reservation User,ホテル予約ユーザー
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,ステータス設定
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,[設定]&gt; [ナンバリングシリーズ]から出席のナンバリングシリーズを設定してください
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,接頭辞を選択してください
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,[設定]&gt; [設定]&gt; [命名シリーズ]で{0}の命名シリーズを設定してください
 DocType: Contract,Fulfilment Deadline,フルフィルメントの締め切り
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,あなたの近く
 DocType: Student,O-,O-
@@ -2292,6 +2301,7 @@
 DocType: Quality Meeting Table,Under Review,レビュー中
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,ログインに失敗しました
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,アセット{0}が作成されました
+DocType: Coupon Code,Promotional,プロモーション
 DocType: Special Test Items,Special Test Items,特別試験項目
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Marketplaceに登録するには、System ManagerおよびItem Managerの役割を持つユーザーである必要があります。
 apps/erpnext/erpnext/config/buying.py,Key Reports,主なレポート
@@ -2329,6 +2339,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,文書タイプ
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,営業チームの割当率の合計は100でなければなりません
 DocType: Subscription Plan,Billing Interval Count,請求間隔のカウント
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","このドキュメントをキャンセルするには、従業員<a href=""#Form/Employee/{0}"">{0}</a> \を削除してください"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,予定と患者の出会い
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,値がありません
 DocType: Employee,Department and Grade,学科と学年
@@ -2431,6 +2443,7 @@
 DocType: Project,Start and End Dates,開始・終了日
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,契約テンプレートの履行条件
 ,Delivered Items To Be Billed,未入金の納品済アイテム
+DocType: Coupon Code,Maximum Use,最大使用
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},BOM {0} を開く
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,倉庫は製造番号によって変更することはできません。
 DocType: Authorization Rule,Average Discount,平均割引
@@ -2593,6 +2606,7 @@
 DocType: Item,Inventory,在庫
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Jsonとしてダウンロード
 DocType: Item,Sales Details,販売明細
+DocType: Coupon Code,Used,中古
 DocType: Opportunity,With Items,関連アイテム
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',キャンペーン &#39;{0}&#39;は既に{1} &#39;{2}&#39;に存在します
 DocType: Asset Maintenance,Maintenance Team,保守チーム
@@ -2723,7 +2737,7 @@
 						Serial No cannot be ensured",アイテム{0}の有効なBOMが見つかりませんでした。 \ Serial Noによる配送は保証されません
 DocType: Sales Partner,Sales Partner Target,販売パートナー目標
 DocType: Loan Type,Maximum Loan Amount,最大融資額
-DocType: Pricing Rule,Pricing Rule,価格設定ルール
+DocType: Coupon Code,Pricing Rule,価格設定ルール
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},生徒{0}のロール番号が重複しています
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,仕入注文のための資材要求
 DocType: Company,Default Selling Terms,デフォルトの販売条件
@@ -2802,6 +2816,7 @@
 DocType: Payment Schedule,Payment Amount,支払金額
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,半日の日付は、作業日と作業終了日の間にある必要があります
 DocType: Healthcare Settings,Healthcare Service Items,医療サービス項目
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,無効なバーコード。このバーコードに添付されたアイテムはありません。
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,消費額
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,現金の純変更
 DocType: Assessment Plan,Grading Scale,評価尺度
@@ -2921,7 +2936,6 @@
 DocType: Share Transfer,Asset Account,アセットアカウント
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,新しいリリース日は将来になるはずです
 DocType: Purchase Invoice,End date of current invoice's period,現在の請求書の期間の終了日
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,人事管理&gt; HR設定で従業員命名システムを設定してください
 DocType: Lab Test,Technician Name,技術者名
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3033,6 +3047,7 @@
 DocType: Products Settings,Hide Variants,バリアントを隠す
 DocType: Lead,Next Contact By,次回連絡
 DocType: Compensatory Leave Request,Compensatory Leave Request,補償休暇申請
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings",行{1}のアイテム{0}に対して{2}を超えて超過請求することはできません。超過請求を許可するには、アカウント設定で許可を設定してください
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},行{1}のアイテム{0}に必要な数量
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},アイテム{1}が存在するため倉庫{0}を削除することができません
 DocType: Blanket Order,Order Type,注文タイプ
@@ -3202,7 +3217,6 @@
 DocType: Student,Student Mobile Number,生徒携帯電話番号
 DocType: Item,Has Variants,バリエーションあり
 DocType: Employee Benefit Claim,Claim Benefit For,のための請求の利益
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings",行{1}のアイテム{0}を{2}以上にオーバレイすることはできません。超過請求を許可するには、在庫設定で設定してください
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,レスポンスの更新
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},項目を選択済みです {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,月次配分の名前
@@ -3492,6 +3506,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,会社に通貨を指定してください
 DocType: Workstation,Wages per hour,時間あたり賃金
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},{0}を設定
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,顧客&gt;顧客グループ&gt;テリトリー
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},倉庫 {3} のアイテム {2} ではバッチ {0} の在庫残高がマイナス {1} になります
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,以下の資材要求は、アイテムの再注文レベルに基づいて自動的に提出されています
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},アカウント{0}は無効です。アカウントの通貨は{1}でなければなりません
@@ -3821,6 +3836,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,給与伝票を提出
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,保留
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,qustionには少なくとも1つの正しいオプションが必要です
+apps/erpnext/erpnext/hooks.py,Purchase Orders,発注書
 DocType: Account,Inter Company Account,インターカンパニーアカウント
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,一括でインポート
 DocType: Sales Partner,Address & Contacts,住所・連絡先
@@ -3831,6 +3847,7 @@
 DocType: POS Profile,[Select],[選択]
 DocType: Staffing Plan Detail,Number Of Positions,ポジション数
 DocType: Vital Signs,Blood Pressure (diastolic),血圧（下）
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,顧客を選択してください。
 DocType: SMS Log,Sent To,送信先
 DocType: Agriculture Task,Holiday Management,休暇管理
 DocType: Payment Request,Make Sales Invoice,納品書を作成
@@ -4041,7 +4058,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1}は提出されていません
 DocType: Subscription,Trialling,トライアル
 DocType: Sales Invoice Item,Deferred Revenue,繰延収益
-DocType: Bank Account,GL Account,GLアカウント
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,請求書作成に使用される現金勘定
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,免除サブカテゴリ
 DocType: Member,Membership Expiry Date,会員有効期限
@@ -4470,13 +4486,13 @@
 DocType: C-Form Invoice Detail,Territory,地域
 DocType: Pricing Rule,Apply Rule On Item Code,商品コードにルールを適用
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,必要な訪問の数を記述してください
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,在庫残高レポート
 DocType: Stock Settings,Default Valuation Method,デフォルト評価方法
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,費用
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,累積金額を表示する
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,更新中です。しばらくお待ちください。
 DocType: Production Plan Item,Produced Qty,生産数量
 DocType: Vehicle Log,Fuel Qty,燃料数量
-DocType: Stock Entry,Target Warehouse Name,ターゲット倉庫名
 DocType: Work Order Operation,Planned Start Time,計画開始時間
 DocType: Course,Assessment,評価
 DocType: Payment Entry Reference,Allocated,割り当て済み
@@ -4553,10 +4569,12 @@
  1.紛争に対処する方法、賠償、責任など
  1.住所とあなたの会社の連絡先"
 DocType: Homepage Section,Section Based On,に基づくセクション
+DocType: Shopping Cart Settings,Show Apply Coupon Code,クーポンコードの適用を表示
 DocType: Issue,Issue Type,課題タイプ
 DocType: Attendance,Leave Type,休暇タイプ
 DocType: Purchase Invoice,Supplier Invoice Details,サプライヤの請求書の詳細
 DocType: Agriculture Task,Ignore holidays,休暇を無視する
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,クーポン条件の追加/編集
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,費用／差損益（{0}）は「損益」アカウントである必要があります
 DocType: Stock Entry Detail,Stock Entry Child,株式エントリーチャイルド
 DocType: Project,Copied From,コピー元
@@ -4731,6 +4749,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,評価計画基準
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,トランザクション
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,注文停止
+DocType: Coupon Code,Coupon Name,クーポン名
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,影響を受けやすいです
 DocType: Email Campaign,Scheduled,スケジュール設定済
 DocType: Shift Type,Working Hours Calculation Based On,に基づく労働時間の計算
@@ -4747,7 +4766,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,バリエーションを作成
 DocType: Vehicle,Diesel,ディーゼル
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,価格表の通貨が選択されていません
+DocType: Quick Stock Balance,Available Quantity,利用可能な数量
 DocType: Purchase Invoice,Availed ITC Cess,入手可能なITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,教育&gt;教育の設定でインストラクターの命名システムを設定してください
 ,Student Monthly Attendance Sheet,生徒月次出席シート
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,配送ルールは販売にのみ適用されます
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,減価償却行{0}：次の減価償却日は購入日より前にすることはできません
@@ -4814,8 +4835,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,行{0}：お客様に対する事前クレジットでなければなりません
 DocType: Quality Meeting,Quality Meeting,質の高い会議
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,グループに非グループ
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,[設定]&gt; [設定]&gt; [命名シリーズ]で{0}の命名シリーズを設定してください
 DocType: Employee,ERPNext User,ERPNextユーザー
+DocType: Coupon Code,Coupon Description,クーポンの説明
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},行{0}にバッチが必須です
 DocType: Company,Default Buying Terms,デフォルトの購入条件
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,領収書アイテム供給済
@@ -4978,6 +4999,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,文書詳細番号に対して
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},国{0}の削除は許可されていません
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,当事者タイプは必須です
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,クーポンコードを適用
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",ジョブカード{0}の場合は、 &#39;製造のための品目転送&#39;タイプの在庫エントリしか作成できません。
 DocType: Quality Inspection,Outgoing,支出
 DocType: Customer Feedback Table,Customer Feedback Table,顧客フィードバック表
@@ -5127,7 +5149,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,発注書提出時
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,すべてのサプライヤーを追加
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,行番号{0}：割り当て金額は未払い金額より大きくすることはできません。
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,顧客&gt;顧客グループ&gt;テリトリー
 DocType: Tally Migration,Parties,締約国
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,部品表（BOM）を表示
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,担保ローン
@@ -5159,7 +5180,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},アイテム{0}の代替アイテムを設定できません
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,日付が繰り返されます
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,決裁者
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,[教育]&gt; [教育設定]でインストラクターの命名システムを設定してください
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),利用可能な純ITC（A） - （B）
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,料金の作成
 DocType: Project,Total Purchase Cost (via Purchase Invoice),総仕入費用（仕入請求書経由）
@@ -5184,6 +5204,7 @@
 DocType: Quiz Result,Wrong,違う
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,価格表の通貨が顧客の基本通貨に換算されるレート
 DocType: Purchase Invoice Item,Net Amount (Company Currency),正味金額（会社通貨）
+DocType: Sales Partner,Referral Code,紹介コード
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,総引き渡し額は、総額を超えてはならない
 DocType: Salary Slip,Hour Rate,時給
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,自動並べ替えを有効にする
@@ -5312,6 +5333,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,在庫数を表示する
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,事業からの純キャッシュ・フロー
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},行＃{0}：請求書割引{2}のステータスは{1}でなければなりません
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},アイテムのUOM換算係数（{0}-&gt; {1}）が見つかりません：{2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,アイテム4
 DocType: Student Admission,Admission End Date,入場終了日
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,サブ契約
@@ -5334,6 +5356,7 @@
 DocType: Travel Request,Fully Sponsored,完全にスポンサーされた
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,逆仕訳入力
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,求人カードを作成する
+DocType: Quotation,Referral Sales Partner,紹介販売パートナー
 DocType: Quality Procedure Process,Process Description,過程説明
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,顧客 {0} が作成されました。
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,現在どの倉庫にも在庫がありません
@@ -5468,6 +5491,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,部品表通貨レート
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,アップロードされたファイルを読む
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel",停止した作業指示を取り消すことはできません。取り消すには最初に取り消してください
+DocType: Coupon Code,Coupon Code,クーポンコード
 DocType: Asset,Journal Entry for Scrap,スクラップ用の仕訳
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,納品書からアイテムを抽出してください
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},行{0}：操作{1}に対するワークステーションを選択します。
@@ -5550,6 +5574,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,「日付」は必須です
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},期限／基準日は{0}より後にすることはできません
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,データインポート・エクスポート
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired",申し訳ありませんが、クーポンコードの有効期限が切れています
 DocType: Bank Account,Account Details,口座詳細
 DocType: Crop,Materials Required,必要な材料
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,生徒が存在しません
@@ -5587,6 +5612,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,ユーザーに移動
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,支払額＋償却額は総計を超えることはできません
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0}はアイテム{1}に対して有効なバッチ番号ではありません
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,有効なクーポンコードを入力してください!!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},注：休暇タイプ{0}のための休暇残高が足りません
 DocType: Task,Task Description,タスク説明
 DocType: Training Event,Seminar,セミナー
@@ -5850,6 +5876,7 @@
 ,TDS Payable Monthly,毎月TDS支払可能
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,BOMを置き換えるために待機します。数分かかることがあります。
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',カテゴリーが「評価」や「評価と合計」である場合は控除することができません
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,人事管理&gt; HR設定で従業員命名システムを設定してください
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,総支払い
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},アイテム{0}には複数のシリアル番号が必要です
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,請求書と一致支払い
@@ -5939,6 +5966,7 @@
 DocType: Production Plan,Get Raw Materials For Production,生産のための原材料を入手する
 DocType: Job Opening,Job Title,職業名
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,将来の支払い参照
+DocType: Quotation,Additional Discount and Coupon Code,追加割引とクーポンコード
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.",{0}は{1}が見積提出されないことを示していますが、全てのアイテムは見積もられています。 見積依頼の状況を更新しています。
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,最大サンプル - {0} はバッチ {1} およびバッチ {3} 内のアイテム {2} として既に保管されています。
@@ -6166,7 +6194,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,ウェブサイトのホームページの設定
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0}は{1}まで保留中です
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},スコアカードが{1}のためRFQは{0}には許可されていません
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,仕入請求書を作成
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,中古の葉
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0}使用されるクーポンは{1}です。許容量を使い果たしました
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,資料請求を提出しますか
 DocType: Job Offer,Awaiting Response,応答を待っています
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6180,6 +6210,7 @@
 DocType: Training Event Employee,Optional,任意
 DocType: Salary Slip,Earning & Deduction,収益と控除
 DocType: Agriculture Analysis Criteria,Water Analysis,水質分析
+DocType: Sales Order,Skip Delivery Note,納品書をスキップ
 DocType: Price List,Price Not UOM Dependent,UOMに依存しない価格
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0}バリアントが作成されました。
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,デフォルトのサービスレベル契約がすでに存在します。
@@ -6284,6 +6315,7 @@
 DocType: Vehicle,Last Carbon Check,最後のカーボンチェック
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,訴訟費用
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,行数量を選択してください
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},作業指示{0}：操作{1}のジョブカードが見つかりません
 DocType: Purchase Invoice,Posting Time,投稿時間
 DocType: Timesheet,% Amount Billed,％請求
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,電話代
@@ -6386,7 +6418,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,租税公課が追加されました。
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,減価償却行{0}：次の減価償却日は、使用可能日前にすることはできません
 ,Sales Funnel,セールスファネル
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,商品コード&gt;商品グループ&gt;ブランド
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,略称は必須です
 DocType: Project,Task Progress,タスクの進捗状況
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,カート
@@ -6481,6 +6512,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POSエントリを作成するためにはPOSプロフィールが必要です
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",ロイヤリティポイントは、記載されている回収率に基づいて、（販売請求書によって）完了した使用額から計算されます。
 DocType: Program Enrollment Tool,Enroll Students,生徒を登録
+DocType: Pricing Rule,Coupon Code Based,クーポンコードベース
 DocType: Company,HRA Settings,HRAの設定
 DocType: Homepage,Hero Section,ヒーローセクション
 DocType: Employee Transfer,Transfer Date,転送日
@@ -6597,6 +6629,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Group Byが &#39;Company&#39;の場合、Companyフィルターを空白に設定してください
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,転記日付は将来の日付にすることはできません
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},行＃{0}：シリアル番号 {1} が {2} {3}と一致しません
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,[設定]&gt; [ナンバリングシリーズ]から出席のナンバリングシリーズを設定してください
 DocType: Stock Entry,Target Warehouse Address,ターゲット倉庫の住所
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,臨時休暇
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,従業員チェックインが出席のために考慮される間のシフト開始時間の前の時間。
@@ -6631,7 +6664,6 @@
 DocType: Employee Grade,Employee Grade,従業員グレード
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,出来高制
 DocType: GSTR 3B Report,June,六月
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,サプライヤ&gt;サプライヤタイプ
 DocType: Share Balance,From No,〜から
 DocType: Shift Type,Early Exit Grace Period,早期終了猶予期間
 DocType: Task,Actual Time (in Hours),実際の時間（時）
@@ -6914,7 +6946,6 @@
 DocType: Warehouse,Warehouse Name,倉庫名
 DocType: Naming Series,Select Transaction,取引を選択
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,「役割承認」または「ユーザー承認」を入力してください
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},アイテムのUOM換算係数（{0}-&gt; {1}）が見つかりません：{2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,エンティティタイプ{0}とエンティティ{1}のサービスレベル契約が既に存在します。
 DocType: Journal Entry,Write Off Entry,償却エントリ
 DocType: BOM,Rate Of Materials Based On,資材単価基準
@@ -7052,6 +7083,7 @@
 DocType: Budget,Warn,警告する
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,すべてのアイテムは、この作業オーダーのために既に転送されています。
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.",記録内で注目に値する特記事項
+DocType: Bank Account,Company Account,企業アカウント
 DocType: Asset Maintenance,Manufacturing User,製造ユーザー
 DocType: Purchase Invoice,Raw Materials Supplied,原材料供給
 DocType: Subscription Plan,Payment Plan,支払計画
@@ -7093,6 +7125,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},作業オーダー{3}で{0}（{1}）は計画数量（{2}）を上回ることはできません
 DocType: Certification Application,Name of Applicant,応募者の氏名
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,製造のための勤務表。
+DocType: Quick Stock Balance,Quick Stock Balance,クイックストックバランス
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,小計
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,株式取引後にバリアントプロパティを変更することはできません。これを行うには、新しいアイテムを作成する必要があります。
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPAマンデート
@@ -7419,6 +7452,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},{0}を設定してください
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0}  -  {1}は非アクティブな生徒です
 DocType: Employee,Health Details,健康の詳細
+DocType: Coupon Code,Coupon Type,クーポンの種類
 DocType: Leave Encashment,Encashable days,Encashable days
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,支払依頼を作成するには参照書類が必要です
 DocType: Soil Texture,Sandy Clay,砂質粘土
@@ -7703,6 +7737,7 @@
 DocType: Hotel Room Package,Amenities,アメニティ
 DocType: Accounts Settings,Automatically Fetch Payment Terms,支払い条件を自動的に取得する
 DocType: QuickBooks Migrator,Undeposited Funds Account,未払い資金口座
+DocType: Coupon Code,Uses,用途
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,複数のデフォルトの支払い方法は許可されていません
 DocType: Sales Invoice,Loyalty Points Redemption,ロイヤリティポイント償還
 ,Appointment Analytics,予約分析
@@ -7719,6 +7754,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,総予算
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,年ごとに生徒グループを作る場合は空欄にしてください
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day",チェックした場合、営業日数は全て祝日を含みますが、これにより1日あたりの給与の値は小さくなります
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,ドメインを追加できませんでした
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.",入庫/配送の超過を許可するには、在庫設定またはアイテムの「入庫/配送許可超過」を更新します。
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?",現在の鍵を使用しているアプリケーションはアクセスできません。本当ですか？
 DocType: Subscription Settings,Prorate,比喩
@@ -7731,6 +7767,7 @@
 ,BOM Stock Report,BOM在庫レポート
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group",割り当てられたタイムスロットがない場合、通信はこのグループによって処理されます。
 DocType: Stock Reconciliation Item,Quantity Difference,数量違い
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,サプライヤ&gt;サプライヤタイプ
 DocType: Opportunity Item,Basic Rate,基本料金
 DocType: GL Entry,Credit Amount,貸方金額
 ,Electronic Invoice Register,電子請求書レジスタ
@@ -7984,6 +8021,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),租税公課控除（会社通貨）
 DocType: Item Group,General Settings,一般設定
 DocType: Article,Article,記事
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,クーポンコードを入力してください!!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,同じ通貨には変更できません
 DocType: Taxable Salary Slab,Percent Deduction,減額率
 DocType: GL Entry,To Rename,名前を変更する
diff --git a/erpnext/translations/km.csv b/erpnext/translations/km.csv
index ca381fd..812f6ba 100644
--- a/erpnext/translations/km.csv
+++ b/erpnext/translations/km.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT -YYYY.-
 DocType: Purchase Order,Customer Contact,ទំនាក់ទំនងអតិថិជន
 DocType: Shift Type,Enable Auto Attendance,បើកការចូលរួមដោយស្វ័យប្រវត្តិ។
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,សូមបញ្ចូលឃ្លាំងនិងកាលបរិច្ឆេទ
 DocType: Lost Reason Detail,Opportunity Lost Reason,ឱកាសបាត់បង់ហេតុផល។
 DocType: Patient Appointment,Check availability,ពិនិត្យភាពអាចរកបាន
 DocType: Retention Bonus,Bonus Payment Date,ថ្ងៃបង់ប្រាក់រង្វាន់
@@ -264,6 +265,7 @@
 ,Completed Work Orders,បានបញ្ចប់ការបញ្ជាទិញការងារ
 DocType: Support Settings,Forum Posts,ប្រកាសវេទិកា
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage",ភារកិច្ចត្រូវបានគេប្រមូលជាការងារផ្ទៃខាងក្រោយ។ ក្នុងករណីមានបញ្ហាណាមួយទាក់ទងនឹងដំណើរការក្នុងប្រព័ន្ធផ្ទៃខាងក្រោយប្រព័ន្ធនឹងបន្ថែមមតិយោបល់អំពីកំហុសលើការផ្សះផ្សាភាគហ៊ុននេះហើយត្រលប់ទៅដំណាក់កាលព្រាង
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started",សូមទោសលេខកូដប័ណ្ណមានសុពលភាពមិនបានចាប់ផ្តើមទេ
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,ចំនួនទឹកប្រាក់ដែលត្រូវជាប់ពន្ធ
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},អ្នកមិនត្រូវបានអនុញ្ញាតឱ្យបន្ថែមឬធ្វើឱ្យទាន់សម័យធាតុមុន {0}
 DocType: Leave Policy,Leave Policy Details,ចាកចេញពីព័ត៌មានលម្អិតអំពីគោលនយោបាយ
@@ -328,6 +330,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,ប្រើប្រាស់
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,ថ្នាក់ទី
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,លេខកូដរបស់ក្រុម&gt; ក្រុមក្រុម&gt; ម៉ាក
 DocType: Restaurant Table,No of Seats,ចំនួនកៅអី
 DocType: Sales Invoice,Overdue and Discounted,ហួសកាលកំណត់និងបញ្ចុះតំលៃ។
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,ការហៅត្រូវបានផ្តាច់។
@@ -504,6 +507,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,គម្លាតបន្ទាត់សម្រាប់ចំនួននៅក្នុងពាក្យ
 DocType: Vehicle,Additional Details,សេចក្ដីលម្អិតបន្ថែម
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,ការពិពណ៌នាដែលបានផ្ដល់ឱ្យមិនមាន
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,ទាញយកធាតុពីឃ្លាំង
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,ស្នើសុំសម្រាប់ការទិញ។
 DocType: POS Closing Voucher Details,Collected Amount,ចំនួនសរុបដែលបានប្រមូល
 DocType: Lab Test,Submitted Date,កាលបរិច្ឆេទដែលបានដាក់ស្នើ
@@ -611,6 +615,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,រៀន
 ,Trial Balance (Simple),តុល្យភាពនៃការសាកល្បង (សាមញ្ញ)
 DocType: Purchase Invoice Item,Enable Deferred Expense,បើកដំណើរការការពន្យារពេល
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,អនុវត្តលេខកូដគូប៉ុង
 DocType: Asset,Next Depreciation Date,រំលស់បន្ទាប់កាលបរិច្ឆេទ
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,តម្លៃសកម្មភាពដោយបុគ្គលិក
 DocType: Accounts Settings,Settings for Accounts,ការកំណត់សម្រាប់គណនី
@@ -845,8 +850,6 @@
 DocType: BOM,Work Order,លំដាប់ការងារ
 DocType: Sales Invoice,Total Qty,សរុប Qty
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,លេខសម្គាល់អ៊ីមែល Guardian2
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","សូមលុបនិយោជិក <a href=""#Form/Employee/{0}"">{0}</a> \ ដើម្បីលុបចោលឯកសារនេះ។"
 DocType: Item,Show in Website (Variant),បង្ហាញក្នុងវេបសាយ (វ៉ារ្យង់)
 DocType: Employee,Health Concerns,ការព្រួយបារម្ភសុខភាព
 DocType: Payroll Entry,Select Payroll Period,ជ្រើសរយៈពេលបើកប្រាក់បៀវត្ស
@@ -1007,6 +1010,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,គណនីបង់ពន្ធ
 DocType: Pricing Rule,Sales Partner,ដៃគូការលក់
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,កាតពិន្ទុទាំងអស់របស់អ្នកផ្គត់ផ្គង់។
+DocType: Coupon Code,To be used to get discount,ត្រូវបានប្រើដើម្បីទទួលបានការបញ្ចុះតម្លៃ
 DocType: Buying Settings,Purchase Receipt Required,បង្កាន់ដៃត្រូវការទិញ
 DocType: Sales Invoice,Rail,រថភ្លើង
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,ការចំណាយជាក់ស្តែង។
@@ -1056,6 +1060,7 @@
 DocType: Production Plan,Production Plan,ផែនការផលិតកម្ម
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,បើកឧបករណ៍បង្កើតវិក្កយបត្រ
 DocType: Salary Component,Round to the Nearest Integer,បង្គត់ទៅចំនួនគត់ជិតបំផុត។
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,អនុញ្ញាតឱ្យវត្ថុដែលមិនមាននៅក្នុងស្តុកត្រូវបានបន្ថែមទៅរទេះ
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,ត្រឡប់មកវិញការលក់
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,កំណត់ Qty នៅក្នុងប្រតិបត្តិការដែលមានមូលដ្ឋានលើលេខស៊េរី
 ,Total Stock Summary,សង្ខេបហ៊ុនសរុប
@@ -1185,6 +1190,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),អត្រាហួរមូលដ្ឋាន (ក្រុមហ៊ុនរូបិយប័ណ្ណ)
 ,Qty To Be Billed,Qty ត្រូវបានចេញវិក្កយបត្រ។
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,ចំនួនទឹកប្រាក់ដែលបានបញ្ជូន
+DocType: Coupon Code,Gift Card,កាតអំណោយ
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Qty ដែលបានបម្រុងទុកសម្រាប់ផលិតកម្ម៖ បរិមាណវត្ថុធាតុដើមដើម្បីផលិតរបស់របរ។
 DocType: Loyalty Point Entry Redemption,Redemption Date,កាលបរិច្ឆេទការប្រោសលោះ
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,ប្រតិបត្តិការធនាគារនេះត្រូវបានផ្សះផ្សារួចហើយ។
@@ -1271,6 +1277,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,បង្កើត Timesheet ។
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,គណនី {0} ត្រូវបានបញ្ចូលច្រើនដង
 DocType: Account,Expenses Included In Valuation,ការចំណាយដែលបានរួមបញ្ចូលនៅក្នុងការវាយតម្លៃ
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,វិក័យប័ត្រទិញ
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,អ្នកអាចបន្តបានលុះត្រាតែសមាជិកភាពរបស់អ្នកផុតកំណត់ក្នុងរយៈពេល 30 ថ្ងៃ
 DocType: Shopping Cart Settings,Show Stock Availability,បង្ហាញស្តង់ដារដែលអាចរកបាន
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},កំណត់ {0} នៅក្នុងប្រភេទទ្រព្យសម្បត្តិ {1} ឬក្រុមហ៊ុន {2}
@@ -1809,6 +1816,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,ការនាំចូលទំនិញនិង UOMs ។
 DocType: Repayment Schedule,Balance Loan Amount,តុល្យភាពប្រាក់កម្ចីចំនួនទឹកប្រាក់
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,បានបន្ថែមទៅព័ត៌មានលម្អិត
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted",សូមទោសលេខកូដប័ណ្ណបានអស់ហើយ
 DocType: Communication Medium,Catch All,ចាប់ទាំងអស់។
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,វគ្គកាលវិភាគ
 DocType: Budget,Applicable on Material Request,អនុវត្តលើសំណើសុំសម្ភារៈ
@@ -1976,6 +1984,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Attribute មិនត្រឹមត្រូវ
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} ត្រូវតែបានដាក់ស្នើ
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,យុទ្ធនាការអ៊ីមែល។
+DocType: Sales Partner,To Track inbound purchase,ដើម្បីតាមដានការទិញពីខាងក្រៅ
 DocType: Buying Settings,Default Supplier Group,ក្រុមអ្នកផ្គត់ផ្គង់លំនាំដើម
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},បរិមាណដែលត្រូវទទួលទានត្រូវតែតិចជាងឬស្មើទៅនឹង {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},ចំនួនទឹកប្រាក់អតិបរមាមានសិទ្ធិទទួលបានសមាសភាគ {0} លើសពី {1}
@@ -2130,8 +2139,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,ធ្វើឱ្យធាតុចូល។
 DocType: Hotel Room Reservation,Hotel Reservation User,អ្នកប្រើប្រាស់កក់សណ្ឋាគារ
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,កំណត់ស្ថានភាព។
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,សូមរៀបចំស៊េរីលេខរៀងសម្រាប់ការចូលរួមតាមរយៈតំឡើង&gt; លេខរៀង។
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,សូមជ្រើសបុព្វបទជាលើកដំបូង
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,សូមកំណត់ឈ្មោះដាក់ឈ្មោះសំរាប់ {0} តាមរយៈតំឡើង&gt; ការកំណត់&gt; តំរុយឈ្មោះ
 DocType: Contract,Fulfilment Deadline,ថ្ងៃផុតកំណត់
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,នៅក្បែរអ្នក។
 DocType: Student,O-,O-
@@ -2255,6 +2264,7 @@
 DocType: Quality Meeting Table,Under Review,កំពុងពិនិត្យ។
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,បានបរាជ័យក្នុងការចូល
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,ទ្រព្យសម្បត្តិ {0} បានបង្កើត
+DocType: Coupon Code,Promotional,ផ្សព្វផ្សាយ
 DocType: Special Test Items,Special Test Items,ធាតុសាកល្បងពិសេស
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,អ្នកត្រូវតែជាអ្នកប្រើដែលមានកម្មវិធីគ្រប់គ្រងប្រព័ន្ធនិងធាតុកម្មវិធីគ្រប់គ្រងធាតុដើម្បីចុះឈ្មោះនៅលើទីផ្សារ។
 apps/erpnext/erpnext/config/buying.py,Key Reports,របាយការណ៍សំខាន់ៗ។
@@ -2292,6 +2302,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,ប្រភេទឯកសារ
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,ចំនួនភាគរយត្រៀមបម្រុងទុកសរុបសម្រាប់លក់ក្រុមគួរមាន 100 នាក់
 DocType: Subscription Plan,Billing Interval Count,រាប់ចន្លោះពេលចេញវិក្កយបត្រ
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","សូមលុបនិយោជិក <a href=""#Form/Employee/{0}"">{0}</a> \ ដើម្បីលុបចោលឯកសារនេះ"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,ការណាត់ជួបនិងជួបអ្នកជម្ងឺ
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,បាត់តម្លៃ
 DocType: Employee,Department and Grade,នាយកដ្ឋាននិងថ្នាក់
@@ -2394,6 +2406,7 @@
 DocType: Project,Start and End Dates,ចាប់ផ្តើមនិងបញ្ចប់កាលបរិច្ឆេទ
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,លក្ខខណ្ឌកិច្ចព្រមព្រៀងគំរូកិច្ចសន្យា
 ,Delivered Items To Be Billed,មុខទំនិញទៅដល់ត្រូវបង់លុយ
+DocType: Coupon Code,Maximum Use,ការប្រើប្រាស់អតិបរមា
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},ការបើកចំហ Bom {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,ឃ្លាំងមិនអាចត្រូវបានផ្លាស់ប្តូរសម្រាប់លេខស៊េរី
 DocType: Authorization Rule,Average Discount,ការបញ្ចុះតម្លៃជាមធ្យម
@@ -2553,6 +2566,7 @@
 DocType: Item,Inventory,សារពើភ័ណ្ឌ
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,ទាញយកជា Json ។
 DocType: Item,Sales Details,ពត៌មានលំអិតការលក់
+DocType: Coupon Code,Used,បានប្រើ
 DocType: Opportunity,With Items,ជាមួយនឹងការធាតុ
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',យុទ្ធនាការ &#39;{0}&#39; មានរួចហើយសម្រាប់ {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,ក្រុមថែទាំ
@@ -2681,7 +2695,7 @@
 						Serial No cannot be ensured",រកមិនឃើញ BOM សកម្មសម្រាប់ធាតុ {0} ទេ។ ការចែកចាយដោយ \ Serial No មិនអាចធានាបានទេ
 DocType: Sales Partner,Sales Partner Target,ដៃគូគោលដៅការលក់
 DocType: Loan Type,Maximum Loan Amount,ចំនួនទឹកប្រាក់កម្ចីអតិបរមា
-DocType: Pricing Rule,Pricing Rule,វិធានការកំណត់តម្លៃ
+DocType: Coupon Code,Pricing Rule,វិធានការកំណត់តម្លៃ
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},ចំនួនសិស្សស្ទួនរមៀល {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,សម្ភារៈសំណើទិញសណ្តាប់ធ្នាប់
 DocType: Company,Default Selling Terms,លក្ខខណ្ឌលក់លំនាំដើម។
@@ -2760,6 +2774,7 @@
 DocType: Payment Schedule,Payment Amount,ចំនួនទឹកប្រាក់ការទូទាត់
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,ថ្ងៃពាក់កណ្តាលថ្ងៃគួរស្ថិតនៅចន្លោះរវាងការងារពីកាលបរិច្ឆេទបញ្ចប់និងកាលបរិច្ឆេទការងារ
 DocType: Healthcare Settings,Healthcare Service Items,សេវាកម្មថែទាំសុខភាព
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,លេខកូដមិនត្រឹមត្រូវ។ មិនមានធាតុភ្ជាប់ជាមួយលេខកូដនេះទេ។
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,ចំនួនទឹកប្រាក់ដែលគេប្រើប្រាស់
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,ការផ្លាស់ប្តូរសាច់ប្រាក់សុទ្ធ
 DocType: Assessment Plan,Grading Scale,ធ្វើមាត្រដ្ឋានពិន្ទុ
@@ -2879,7 +2894,6 @@
 DocType: Share Transfer,Asset Account,គណនីទ្រព្យសកម្ម
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,កាលបរិច្ឆេទចេញផ្សាយថ្មីគួរតែមាននៅពេលអនាគត។
 DocType: Purchase Invoice,End date of current invoice's period,កាលបរិច្ឆេទបញ្ចប់នៃរយៈពេលបច្ចុប្បន្នរបស់វិក័យប័ត្រ
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,សូមរៀបចំប្រព័ន្ធដាក់ឈ្មោះបុគ្គលិកនៅក្នុងធនធានមនុស្ស&gt; ធនធានមនុស្ស។
 DocType: Lab Test,Technician Name,ឈ្មោះអ្នកបច្ចេកទេស
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -2989,6 +3003,7 @@
 DocType: Products Settings,Hide Variants,លាក់វ៉ារ្យ៉ង់។
 DocType: Lead,Next Contact By,ទំនាក់ទំនងបន្ទាប់ដោយ
 DocType: Compensatory Leave Request,Compensatory Leave Request,សំណើសុំប្រាក់សំណង
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings",មិនអាចលើសថ្លៃសម្រាប់ធាតុ {0} ក្នុងជួរ {1} លើសពី {2} ។ ដើម្បីអនុញ្ញាតវិក័យប័ត្រលើសសូមកំណត់ប្រាក់ឧបត្ថម្ភនៅក្នុងការកំណត់គណនី
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},បរិមាណដែលទាមទារសម្រាប់ធាតុ {0} នៅក្នុងជួរដេក {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},ឃ្លាំង {0} មិនអាចត្រូវបានលុបជាបរិមាណមានសម្រាប់ធាតុ {1}
 DocType: Blanket Order,Order Type,ប្រភេទលំដាប់
@@ -3157,7 +3172,6 @@
 DocType: Student,Student Mobile Number,លេខទូរស័ព្ទរបស់សិស្ស
 DocType: Item,Has Variants,មានវ៉ារ្យ៉ង់
 DocType: Employee Benefit Claim,Claim Benefit For,ទាមទារអត្ថប្រយោជន៍សម្រាប់
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings",មិនអាចវាយតម្លៃធាតុ {0} ក្នុងជួរដេក {1} ច្រើនជាង {2} ។ ដើម្បីអនុញ្ញាតឱ្យចេញវិក័យប័ត្រសូមកំណត់នៅក្នុងការកំណត់ស្តុក
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,ធ្វើបច្ចុប្បន្នភាពចម្លើយ
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},អ្នកបានជ្រើសរួចហើយចេញពីធាតុ {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,ឈ្មោះរបស់ចែកចាយប្រចាំខែ
@@ -3443,6 +3457,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,សូមបញ្ជាក់រូបិយប័ណ្ណនៅក្នុងក្រុមហ៊ុន
 DocType: Workstation,Wages per hour,ប្រាក់ឈ្នួលក្នុងមួយម៉ោង
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},តំឡើង {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,អតិថិជន&gt; ក្រុមអតិថិជន&gt; ទឹកដី
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},ភាគហ៊ុននៅក្នុងជំនាន់ទីតុល្យភាព {0} នឹងក្លាយទៅជាអវិជ្ជមាន {1} សម្រាប់ធាតុ {2} នៅឃ្លាំង {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,បន្ទាប់ពីការសម្ភារៈសំណើត្រូវបានលើកឡើងដោយស្វ័យប្រវត្តិដោយផ្អែកលើកម្រិតឡើងវិញដើម្បីធាតុរបស់
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},គណនី {0} មិនត្រឹមត្រូវ។ រូបិយប័ណ្ណគណនីត្រូវតែ {1}
@@ -3771,6 +3786,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,ដាក់ស្នើប្រាក់ខែគ្រូពេទ្យប្រហែលជា
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,រង់ចាំ
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,យ៉ាងហោចណាស់សត្វព្រៃត្រូវតែមានជម្រើសត្រឹមត្រូវយ៉ាងហោចណាស់មួយ។
+apps/erpnext/erpnext/hooks.py,Purchase Orders,បញ្ជាទិញ
 DocType: Account,Inter Company Account,គណនីក្រុមហ៊ុនអន្ដរជាតិ
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,នាំចូលក្នុងក្រុម
 DocType: Sales Partner,Address & Contacts,អាសយដ្ឋាន &amp; ទំនាក់ទំនង
@@ -3781,6 +3797,7 @@
 DocType: POS Profile,[Select],[ជ្រើសរើស]
 DocType: Staffing Plan Detail,Number Of Positions,ចំនួនតំណែង
 DocType: Vital Signs,Blood Pressure (diastolic),សម្ពាធឈាម (Diastolic)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,សូមជ្រើសរើសអតិថិជន។
 DocType: SMS Log,Sent To,ដែលបានផ្ញើទៅ
 DocType: Agriculture Task,Holiday Management,ការគ្រប់គ្រងថ្ងៃឈប់សម្រាក
 DocType: Payment Request,Make Sales Invoice,ធ្វើឱ្យការលក់វិក័យប័ត្រ
@@ -3989,7 +4006,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} មិនត្រូវបានដាក់ស្នើ
 DocType: Subscription,Trialling,Trialling
 DocType: Sales Invoice Item,Deferred Revenue,ចំណូលដែលពន្យាពេល
-DocType: Bank Account,GL Account,ហ្គ្រេនគណនី។
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,គណនីសាច់ប្រាក់នឹងត្រូវបានប្រើសម្រាប់ការបង្កើតវិក័យប័ត្រលក់
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,ការលើកលែងប្រភេទរង
 DocType: Member,Membership Expiry Date,ថ្ងៃផុតកំណត់សមាជិក
@@ -4387,13 +4403,13 @@
 DocType: C-Form Invoice Detail,Territory,សណ្ធានដី
 DocType: Pricing Rule,Apply Rule On Item Code,អនុវត្តវិធានលើលេខកូដធាតុ។
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,សូមនិយាយពីមិនមាននៃការមើលដែលបានទាមទារ
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,របាយការណ៍សមតុល្យភាគហ៊ុន
 DocType: Stock Settings,Default Valuation Method,វិធីសាស្រ្តវាយតម្លៃលំនាំដើម
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,ថ្លៃសេវា
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,បង្ហាញចំនួនទឹកប្រាក់កើនឡើង
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,កំពុងធ្វើបច្ចុប្បន្នភាព។ វាអាចចំណាយពេលបន្តិច។
 DocType: Production Plan Item,Produced Qty,ផលិត Qty
 DocType: Vehicle Log,Fuel Qty,ប្រេងឥន្ធនៈ Qty
-DocType: Stock Entry,Target Warehouse Name,ឈ្មោះឃ្លាំងគោលដៅ
 DocType: Work Order Operation,Planned Start Time,ពេលវេលាចាប់ផ្ដើមគ្រោងទុក
 DocType: Course,Assessment,ការវាយតំលៃ
 DocType: Payment Entry Reference,Allocated,ត្រៀមបម្រុងទុក
@@ -4459,10 +4475,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","លក្ខខណ្ឌក្នុងស្ដង់ដារនិងលក្ខខណ្ឌដែលអាចត្រូវបានបន្ថែមទៅការលក់និងការទិញ។ ឧទាហរណ៏: 1. សុពលភាពនៃការផ្តល់ជូននេះ។ 1. លក្ខខណ្ឌក្នុងការទូទាត់ (មុន, នៅលើឥណទានដែលជាផ្នែកមួយមុនល) ។ 1. តើអ្វីជាការបន្ថែម (ឬបង់ដោយអតិថិជន) ។ 1. សុវត្ថិភាពការព្រមាន / ការប្រើប្រាស់។ 1. ការធានាប្រសិនបើមាន។ 1. ត្រឡប់គោលនយោបាយ។ 1. ល័ក្ខខ័ណ្ឌលើការដឹកជញ្ជូន, បើអនុវត្តបាន។ 1. វិធីនៃការដោះស្រាយវិវាទសំណងការទទួលខុសត្រូវជាដើម 1. អាសយដ្ឋាននិងទំនាក់ទំនងរបស់ក្រុមហ៊ុនរបស់អ្នក។"
 DocType: Homepage Section,Section Based On,ផ្នែកផ្អែកលើ។
+DocType: Shopping Cart Settings,Show Apply Coupon Code,បង្ហាញអនុវត្តលេខកូដគូប៉ុង
 DocType: Issue,Issue Type,ប្រភេទបញ្ហា
 DocType: Attendance,Leave Type,ប្រភេទការឈប់សម្រាក
 DocType: Purchase Invoice,Supplier Invoice Details,ក្រុមហ៊ុនផ្គត់ផ្គង់វិក័យប័ត្រលំអិត
 DocType: Agriculture Task,Ignore holidays,មិនអើពើថ្ងៃបុណ្យ
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,បន្ថែម / កែលក្ខខណ្ឌគូប៉ុង
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,គណនីក្នុងការចំណាយ / ភាពខុសគ្នា ({0}) ត្រូវតែជា &quot;ចំណញឬខាត &#39;គណនី
 DocType: Stock Entry Detail,Stock Entry Child,កូនក្មេងចូលស្តុក។
 DocType: Project,Copied From,ចម្លងពី
@@ -4636,6 +4654,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,លក្ខណៈវិនិច្ឆ័យការវាយតំលៃផែនការ
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,ប្រតិបត្តិការ
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,ទប់ស្កាត់ការបញ្ជាទិញ
+DocType: Coupon Code,Coupon Name,ឈ្មោះគូប៉ុង
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,ងាយយល់
 DocType: Email Campaign,Scheduled,កំណត់ពេលវេលា
 DocType: Shift Type,Working Hours Calculation Based On,ការគណនាម៉ោងធ្វើការផ្អែកលើ។
@@ -4652,7 +4671,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,បង្កើតវ៉ារ្យ៉ង់
 DocType: Vehicle,Diesel,ម៉ាស៊ូត
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,រូបិយប័ណ្ណបញ្ជីតម្លៃមិនបានជ្រើសរើស
+DocType: Quick Stock Balance,Available Quantity,បរិមាណដែលអាចប្រើបាន
 DocType: Purchase Invoice,Availed ITC Cess,ផ្តល់ជូនដោយ ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,សូមតំឡើងប្រព័ន្ធដាក់ឈ្មោះគ្រូនៅក្នុងការអប់រំ&gt; ការកំណត់ការអប់រំ
 ,Student Monthly Attendance Sheet,សិស្សសន្លឹកអវត្តមានប្រចាំខែ
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,ច្បាប់នៃការដឹកជញ្ជូនអាចអនុវត្តបានតែសម្រាប់លក់ប៉ុណ្ណោះ
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,រំលស់ជួរដេក {0}: កាលបរិច្ឆេទរំលោះបន្ទាប់មិនអាចនៅមុនកាលបរិច្ឆេទទិញបានទេ
@@ -4719,8 +4740,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,ជួរដេក {0}: ជាមុនប្រឆាំងនឹងការអតិថិជនត្រូវតែមានការឥណទាន
 DocType: Quality Meeting,Quality Meeting,ការប្រជុំគុណភាព។
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,ដែលមិនមែនជាក្រុមដែលជាក្រុម
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,សូមកំណត់ឈ្មោះដាក់ឈ្មោះសំរាប់ {0} តាមរយៈតំឡើង&gt; ការកំណត់&gt; តំរុយឈ្មោះ។
 DocType: Employee,ERPNext User,អ្នកប្រើ ERPNext
+DocType: Coupon Code,Coupon Description,ការពិពណ៌នាគូប៉ុង
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},បាច់គឺជាការចាំបាច់ក្នុងជួរ {0}
 DocType: Company,Default Buying Terms,ល័ក្ខខ័ណ្ឌនៃការទិញលំនាំដើម។
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,ធាតុបង្កាន់ដៃទិញសហការី
@@ -4882,6 +4903,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,ពត៌មានលំអិតរបស់ឯកសារគ្មានការប្រឆាំងនឹងការ
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},ការលុបមិនត្រូវបានអនុញ្ញាតសម្រាប់ប្រទេស {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,គណបក្សជាការចាំបាច់ប្រភេទ
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,អនុវត្តលេខកូដគូប៉ុង
 DocType: Quality Inspection,Outgoing,ចេញ
 DocType: Customer Feedback Table,Customer Feedback Table,តារាងមតិអតិថិជន។
 apps/erpnext/erpnext/config/support.py,Service Level Agreement.,កិច្ចព្រមព្រៀងកម្រិតសេវាកម្ម។
@@ -5031,7 +5053,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,នៅលើការដាក់ស្នើការបញ្ជាទិញ។
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,បន្ថែមអ្នកផ្គត់ផ្គង់ទាំងអស់
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,ជួរដេក # {0}: ចំនួនទឹកប្រាក់ដែលបានបម្រុងទុកមិនអាចច្រើនជាងចំនួនពូកែ។
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,អតិថិជន&gt; ក្រុមអតិថិជន&gt; ទឹកដី។
 DocType: Tally Migration,Parties,ពិធីជប់លៀង។
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,រកមើល Bom
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,ការផ្តល់កម្ចីដែលមានសុវត្ថិភាព
@@ -5063,7 +5084,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},មិនអនុញ្ញាតឱ្យកំណត់ធាតុជំនួសសម្រាប់ធាតុ {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,កាលបរិច្ឆេទគឺត្រូវបានធ្វើម្តងទៀត
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,ហត្ថលេខីដែលបានអនុញ្ញាត
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,សូមតំឡើងប្រព័ន្ធដាក់ឈ្មោះគ្រូនៅក្នុងការអប់រំ&gt; ការកំណត់ការអប់រំ។
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),មានអាយ។ ស៊ី។ ធី។ ស៊ីដែលមាន (ក) - (ខ)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,បង្កើតកម្រៃ
 DocType: Project,Total Purchase Cost (via Purchase Invoice),ការចំណាយទិញសរុប (តាមរយៈការទិញវិក័យប័ត្រ)
@@ -5088,6 +5108,7 @@
 DocType: Quiz Result,Wrong,ខុស។
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,អត្រាដែលតារាងតំលៃរូបិយប័ណ្ណត្រូវបានបម្លែងទៅជារូបិយប័ណ្ណមូលដ្ឋានរបស់អតិថិជន
 DocType: Purchase Invoice Item,Net Amount (Company Currency),ចំនួនទឹកប្រាក់សុទ្ធ (ក្រុមហ៊ុនរូបិយវត្ថុ)
+DocType: Sales Partner,Referral Code,លេខកូដបង្អែក
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,ចំនួនទឹកប្រាក់សរុបជាមុនមិនអាចច្រើនជាងចំនួនសរុបដែលបានអនុញ្ញាត
 DocType: Salary Slip,Hour Rate,ហួរអត្រា
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,បើកការបញ្ជាទិញដោយស្វ័យប្រវត្តិ។
@@ -5239,6 +5260,7 @@
 DocType: Travel Request,Fully Sponsored,ឧបត្ថម្ភយ៉ាងពេញទំហឹង
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,បញ្ច្រាសធាតុទិនានុប្បវត្តិ
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,បង្កើតកាតការងារ។
+DocType: Quotation,Referral Sales Partner,ដៃគូលក់ការបញ្ជូន
 DocType: Quality Procedure Process,Process Description,ការពិពណ៌នាអំពីដំណើរការ។
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,អតិថិជន {0} ត្រូវបានបង្កើត។
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,បច្ចុប្បន្នពុំមានស្តុកនៅក្នុងឃ្លាំងណាមួយឡើយ
@@ -5373,6 +5395,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,អត្រា Bom
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,កំពុងអានឯកសារដែលបានផ្ទុកឡើង។
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","បញ្ឈប់ការងារមិនអាចលុបចោលបានទេ, សូមបញ្ឈប់វាសិនមុននឹងលុបចោល"
+DocType: Coupon Code,Coupon Code,លេខកូដគូប៉ុង
 DocType: Asset,Journal Entry for Scrap,ទិនានុប្បវត្តិធាតុសម្រាប់សំណល់អេតចាយ
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,សូមទាញធាតុពីការដឹកជញ្ជូនចំណាំ
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},ជួរដេក {0}: ជ្រើសកន្លែងធ្វើការប្រឆាំងនឹងប្រតិបត្តិការ {1}
@@ -5456,6 +5479,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;កាលបរិច្ឆេទ&#39; ត្រូវបានទាមទារ។
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},ដោយសារ / សេចក្តីយោងកាលបរិច្ឆេទមិនអាចបន្ទាប់ពី {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,នាំចូលទិន្នន័យនិងការនាំចេញ
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired",សូមទោសលេខកូដប័ណ្ណមានសុពលភាពផុតកំណត់
 DocType: Bank Account,Account Details,ព័ត៌មានអំពីគណនី
 DocType: Crop,Materials Required,សម្ភារៈដែលត្រូវការ
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,គ្មានសិស្សនិស្សិតបានរកឃើញ
@@ -5493,6 +5517,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,ទៅកាន់អ្នកប្រើប្រាស់
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,ចំនួនទឹកប្រាក់ដែលបង់ + + បិទសរសេរចំនួនទឹកប្រាក់ដែលមិនអាចត្រូវបានធំជាងសម្ពោធសរុប
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} គឺមិនមែនជាលេខបាច់ត្រឹមត្រូវសម្រាប់ធាតុ {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,សូមបញ្ចូលលេខកូដប័ណ្ណត្រឹមត្រូវ !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},ចំណាំ: មិនមានតុល្យភាពឈប់សម្រាកឱ្យបានគ្រប់គ្រាន់សម្រាប់ទុកឱ្យប្រភេទ {0}
 DocType: Task,Task Description,ការពិពណ៌នាអំពីភារកិច្ច។
 DocType: Training Event,Seminar,សិក្ខាសាលា
@@ -5760,6 +5785,7 @@
 ,TDS Payable Monthly,TDS ត្រូវបង់ប្រចាំខែ
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,ដាក់ជួរសម្រាប់ជំនួស BOM ។ វាអាចចំណាយពេលពីរបីនាទី។
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',មិនអាចធ្វើការកាត់កងនៅពេលដែលប្រភេទគឺសម្រាប់ &#39;វាយតម្លៃ&#39; ឬ &#39;វាយតម្លៃនិងសរុប
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,សូមរៀបចំប្រព័ន្ធដាក់ឈ្មោះបុគ្គលិកនៅក្នុងធនធានមនុស្ស&gt; ធនធានមនុស្ស
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,ការទូទាត់សរុប។
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Nos ដែលត្រូវការសម្រាប់ធាតុសៀរៀលសៀរៀល {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,វិកិយប័ត្រទូទាត់ប្រកួតជាមួយ
@@ -5850,6 +5876,7 @@
 DocType: Production Plan,Get Raw Materials For Production,ទទួលបានវត្ថុធាតុដើមសម្រាប់ផលិតកម្ម
 DocType: Job Opening,Job Title,ចំណងជើងការងារ
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,ការទូទាត់សំណងអនាគត។
+DocType: Quotation,Additional Discount and Coupon Code,ការបញ្ចុះតម្លៃបន្ថែមនិងលេខកូដគូប៉ុង
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.",{0} បង្ហាញថា {1} នឹងមិនផ្តល់សម្រង់ទេប៉ុន្តែធាតុទាំងអស់ត្រូវបានដកស្រង់។ ធ្វើបច្ចុប្បន្នភាពស្ថានភាពសម្រង់ RFQ ។
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,គំរូអតិបរមា - {0} ត្រូវបានរក្សាទុករួចហើយសម្រាប់បំណះ {1} និងធាតុ {2} នៅក្នុងបាច់ {3} ។
@@ -6076,7 +6103,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,ការកំណត់សម្រាប់គេហទំព័រគេហទំព័រ
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} បានផ្អាករហូតដល់ {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQs មិនត្រូវបានអនុញ្ញាតសម្រាប់ {0} ដោយសារតែពិន្ទុនៃពិន្ទុនៃ {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,ធ្វើឱ្យការទិញវិក័យប័ត្រ
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,ប្រើស្លឹក
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} គូប៉ុងដែលបានប្រើគឺ {1} ។ បរិមាណដែលបានអនុញ្ញាតគឺអស់ហើយ
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,តើអ្នកចង់ដាក់សំណើសម្ភារៈទេ។
 DocType: Job Offer,Awaiting Response,រង់ចាំការឆ្លើយតប
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-yYYYY.-
@@ -6090,6 +6119,7 @@
 DocType: Training Event Employee,Optional,ស្រេចចិត្ត
 DocType: Salary Slip,Earning & Deduction,ការរកប្រាក់ចំណូលនិងការកាត់បនថយ
 DocType: Agriculture Analysis Criteria,Water Analysis,ការវិភាគទឹក
+DocType: Sales Order,Skip Delivery Note,រំលងចំណាំដឹកជញ្ជូន
 DocType: Price List,Price Not UOM Dependent,តម្លៃមិនមែនយូអ៊ឹមពឹងផ្អែក។
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} បានបង្កើតវ៉ារ្យ៉ង់។
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,កិច្ចព្រមព្រៀងកម្រិតសេវាកម្មលំនាំដើមមានរួចហើយ។
@@ -6300,7 +6330,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,ពន្ធនិងការចោទប្រកាន់បន្ថែម
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,រំលស់ជួរដេក {0}: កាលបរិច្ឆេទរំលោះបន្ទាប់មិនអាចនៅមុនកាលបរិច្ឆេទដែលអាចប្រើបាន
 ,Sales Funnel,ការប្រមូលផ្តុំការលក់
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,លេខកូដរបស់ក្រុម&gt; ក្រុមក្រុម&gt; ម៉ាក។
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,អក្សរកាត់គឺជាការចាំបាច់
 DocType: Project,Task Progress,វឌ្ឍនភាពភារកិច្ច
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,រទេះ
@@ -6396,6 +6425,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,ម៉ាស៊ីនឆូតកាតពត៌មានផ្ទាល់ខ្លួនត្រូវបានទាមទារដើម្បីធ្វើឱ្យធាតុរបស់ម៉ាស៊ីនឆូតកាត
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",ពិន្ទុស្មោះត្រង់នឹងត្រូវបានគណនាពីការចំណាយដែលបានចំណាយ (តាមរយៈវិក័យប័ត្រលក់) ផ្អែកលើកត្តាប្រមូលដែលបានលើកឡើង។
 DocType: Program Enrollment Tool,Enroll Students,ចុះឈ្មោះសិស្ស
+DocType: Pricing Rule,Coupon Code Based,លេខកូដប័ណ្ណ
 DocType: Company,HRA Settings,ការកំណត់ HRA
 DocType: Homepage,Hero Section,ផ្នែកវីរៈបុរស។
 DocType: Employee Transfer,Transfer Date,កាលបរិច្ឆេទផ្ទេរ
@@ -6512,6 +6542,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',សូមកំណត់ក្រុមហ៊ុនត្រងនៅទទេប្រសិនបើក្រុមតាមគឺ &#39;ក្រុមហ៊ុន&#39;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,ការប្រកាសកាលបរិច្ឆេទមិនអាចបរិច្ឆេទនាពេលអនាគត
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},ជួរដេក # {0}: សៀរៀលគ្មាន {1} មិនផ្គូផ្គងនឹង {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,សូមរៀបចំស៊េរីលេខរៀងសម្រាប់ការចូលរួមតាមរយៈតំឡើង&gt; លេខរៀង
 DocType: Stock Entry,Target Warehouse Address,អាស័យដ្ឋានឃ្លាំង
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,ចាកចេញធម្មតា
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,ពេលវេលាមុនពេលវេនចាប់ផ្តើមផ្លាស់ប្តូរកំឡុងពេលដែលបុគ្គលិកចុះឈ្មោះចូលត្រូវបានពិចារណាសម្រាប់ការចូលរួម។
@@ -6546,7 +6577,6 @@
 DocType: Employee Grade,Employee Grade,ថ្នាក់និយោជិក
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,ម៉ៅការ
 DocType: GSTR 3B Report,June,មិថុនា។
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,អ្នកផ្គត់ផ្គង់&gt; ប្រភេទអ្នកផ្គត់ផ្គង់។
 DocType: Share Balance,From No,ពីលេខ
 DocType: Shift Type,Early Exit Grace Period,រយៈពេលនៃការចាកចេញពីព្រះគុណមុនកាលកំណត់។
 DocType: Task,Actual Time (in Hours),ពេលវេលាពិតប្រាកដ (នៅក្នុងម៉ោងធ្វើការ)
@@ -6969,6 +6999,7 @@
 DocType: Budget,Warn,ព្រមាន
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,មុខទំនិញអស់ត្រូវបានផ្ទេររួចហើយសម្រាប់ការកម្ម៉ង់នេះ។
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","ការកត់សម្គាល់ណាមួយផ្សេងទៀត, ការខិតខំប្រឹងប្រែងគួរឱ្យកត់សម្គាល់ដែលគួរតែចូលទៅក្នុងរបាយការណ៍។"
+DocType: Bank Account,Company Account,គណនីក្រុមហ៊ុន
 DocType: Asset Maintenance,Manufacturing User,អ្នកប្រើប្រាស់កម្មន្តសាល
 DocType: Purchase Invoice,Raw Materials Supplied,វត្ថុធាតុដើមដែលសហការី
 DocType: Subscription Plan,Payment Plan,ផែនការទូទាត់
@@ -7010,6 +7041,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) មិនអាចធំជាងបរិមាណដែលបានគ្រោងទុក ({2}) ក្នុងលំដាប់ការងារ {3}
 DocType: Certification Application,Name of Applicant,ឈ្មោះរបស់បេក្ខជន
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,ពេលវេលាសម្រាប់ការផលិតសន្លឹក។
+DocType: Quick Stock Balance,Quick Stock Balance,សមតុល្យស្តុករហ័ស
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,សរុបរង
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,មិនអាចផ្លាស់ប្តូរលក្ខណសម្បត្តិវ៉ារ្យ៉ង់បន្ទាប់ពីប្រតិបត្តិការភាគហ៊ុន។ អ្នកនឹងត្រូវបង្កើតធាតុថ្មីដើម្បីធ្វើវា។
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,អាណត្តិ SEPC របស់ GoCardless
@@ -7337,6 +7369,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} ជានិស្សិតអសកម្ម
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} ជានិស្សិតអសកម្ម
 DocType: Employee,Health Details,ពត៌មានលំអិតសុខភាព
+DocType: Coupon Code,Coupon Type,ប្រភេទគូប៉ុង
 DocType: Leave Encashment,Encashable days,ថ្ងៃជាប់គ្នា
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,ដើម្បីបង្កើតសំណើទូទាត់ឯកសារសេចក្ដីយោងគឺត្រូវបានទាមទារ
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,ដើម្បីបង្កើតសំណើទូទាត់ឯកសារសេចក្ដីយោងគឺត្រូវបានទាមទារ
@@ -7625,6 +7658,7 @@
 DocType: Hotel Room Package,Amenities,គ្រឿងបរិក្ខារ
 DocType: Accounts Settings,Automatically Fetch Payment Terms,ប្រមូលយកលក្ខខណ្ឌទូទាត់ដោយស្វ័យប្រវត្តិ។
 DocType: QuickBooks Migrator,Undeposited Funds Account,គណនីមូលនិធិដែលមិនបានរឹបអូស
+DocType: Coupon Code,Uses,ការប្រើប្រាស់
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,របៀបបង់ប្រាក់លំនាំដើមច្រើនមិនត្រូវបានអនុញ្ញាតទេ
 DocType: Sales Invoice,Loyalty Points Redemption,ពិន្ទុស្មោះត្រង់នឹងការប្រោសលោះ
 ,Appointment Analytics,វិភាគណាត់ជួប
@@ -7642,6 +7676,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,ទុកឱ្យនៅទទេប្រសិនបើអ្នកបានធ្វើឱ្យក្រុមសិស្សក្នុងមួយឆ្នាំ
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,ទុកឱ្យនៅទទេប្រសិនបើអ្នកបានធ្វើឱ្យក្រុមសិស្សក្នុងមួយឆ្នាំ
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","ប្រសិនបើបានធីកនោះទេសរុប។ នៃថ្ងៃធ្វើការនឹងរួមបញ្ចូលទាំងថ្ងៃឈប់សម្រាក, ហើយនេះនឹងកាត់បន្ថយតម្លៃនៃប្រាក់ខែក្នុងមួយថ្ងៃនោះ"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,បានបរាជ័យក្នុងការបន្ថែមដែន
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.",ដើម្បីអនុញ្ញាតិអោយទទួលវិក័យប័ត្រ / ដឹកជញ្ជូនលើសកំណត់ធ្វើបច្ចុប្បន្នភាព“ លើវិក័យប័ត្រទទួលប្រាក់ឧបត្ថម្ភ / ការដឹកជញ្ជូន” នៅក្នុងការកំណត់ស្តុកឬធាតុ។
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?",កម្មវិធីដែលប្រើពាក្យគន្លឹះបច្ចុប្បន្ននឹងមិនអាចចូលដំណើរការបានទេតើអ្នកប្រាកដទេ?
 DocType: Subscription Settings,Prorate,Prorate
@@ -7655,6 +7690,7 @@
 ,BOM Stock Report,របាយការណ៍ស្តុករបស់ BOM
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group",ប្រសិនបើមិនមានពេលវេលាកំណត់ទេនោះការទំនាក់ទំនងនឹងត្រូវបានដោះស្រាយដោយក្រុមនេះ។
 DocType: Stock Reconciliation Item,Quantity Difference,ភាពខុសគ្នាបរិមាណ
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,អ្នកផ្គត់ផ្គង់&gt; ប្រភេទអ្នកផ្គត់ផ្គង់
 DocType: Opportunity Item,Basic Rate,អត្រាជាមូលដ្ឋាន
 DocType: GL Entry,Credit Amount,ចំនួនឥណទាន
 ,Electronic Invoice Register,ចុះឈ្មោះវិក្កយបត្រអេឡិចត្រូនិក។
@@ -7909,6 +7945,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),ពន្ធនិងការចោទប្រកាន់កាត់ (ក្រុមហ៊ុនរូបិយវត្ថុ)
 DocType: Item Group,General Settings,ការកំណត់ទូទៅ
 DocType: Article,Article,មាត្រា
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,សូមបញ្ចូលលេខកូដប័ណ្ណ !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,ចាប់ពីរូបិយវត្ថុនិងដើម្បីរូបិយវត្ថុមិនអាចជាដូចគ្នា
 DocType: Taxable Salary Slab,Percent Deduction,ការកាត់បន្ថយភាគរយ
 DocType: GL Entry,To Rename,ដើម្បីប្តូរឈ្មោះ។
diff --git a/erpnext/translations/kn.csv b/erpnext/translations/kn.csv
index b68eb65..471bd74 100644
--- a/erpnext/translations/kn.csv
+++ b/erpnext/translations/kn.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT -YYYY.-
 DocType: Purchase Order,Customer Contact,ಗ್ರಾಹಕ ಸಂಪರ್ಕ
 DocType: Shift Type,Enable Auto Attendance,ಸ್ವಯಂ ಹಾಜರಾತಿಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,ದಯವಿಟ್ಟು ಗೋದಾಮು ಮತ್ತು ದಿನಾಂಕವನ್ನು ನಮೂದಿಸಿ
 DocType: Lost Reason Detail,Opportunity Lost Reason,ಅವಕಾಶ ಕಳೆದುಹೋದ ಕಾರಣ
 DocType: Patient Appointment,Check availability,ಲಭ್ಯವಿದೆಯೇ
 DocType: Retention Bonus,Bonus Payment Date,ಬೋನಸ್ ಪಾವತಿ ದಿನಾಂಕ
@@ -260,6 +261,7 @@
 ,Completed Work Orders,ಕೆಲಸ ಆದೇಶಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸಲಾಗಿದೆ
 DocType: Support Settings,Forum Posts,ವೇದಿಕೆ ಪೋಸ್ಟ್ಗಳು
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","ಕಾರ್ಯವನ್ನು ಹಿನ್ನೆಲೆ ಕೆಲಸವೆಂದು ಎನ್ಕ್ಯೂ ಮಾಡಲಾಗಿದೆ. ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವಲ್ಲಿ ಯಾವುದೇ ಸಮಸ್ಯೆ ಇದ್ದಲ್ಲಿ, ಸಿಸ್ಟಮ್ ಈ ಸ್ಟಾಕ್ ಸಾಮರಸ್ಯದಲ್ಲಿನ ದೋಷದ ಬಗ್ಗೆ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಸೇರಿಸುತ್ತದೆ ಮತ್ತು ಡ್ರಾಫ್ಟ್ ಹಂತಕ್ಕೆ ಹಿಂತಿರುಗುತ್ತದೆ"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","ಕ್ಷಮಿಸಿ, ಕೂಪನ್ ಕೋಡ್ ಸಿಂಧುತ್ವ ಪ್ರಾರಂಭವಾಗಿಲ್ಲ"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,ತೆರಿಗೆ ಪ್ರಮಾಣ
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},ನೀವು ಮೊದಲು ನಮೂದುಗಳನ್ನು ಸೇರಿಸಲು ಅಥವ ಅಪ್ಡೇಟ್ ಅಧಿಕಾರ {0}
 DocType: Leave Policy,Leave Policy Details,ಪಾಲಿಸಿ ವಿವರಗಳನ್ನು ಬಿಡಿ
@@ -324,6 +326,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,ಉಪಭೋಗ್ಯ
 DocType: Student,B-,ಬಿ
 DocType: Assessment Result,Grade,ಗ್ರೇಡ್
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,ಐಟಂ ಕೋಡ್&gt; ಐಟಂ ಗುಂಪು&gt; ಬ್ರಾಂಡ್
 DocType: Restaurant Table,No of Seats,ಆಸನಗಳ ಸಂಖ್ಯೆ
 DocType: Sales Invoice,Overdue and Discounted,ಮಿತಿಮೀರಿದ ಮತ್ತು ರಿಯಾಯಿತಿ
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,ಕರೆ ಸಂಪರ್ಕ ಕಡಿತಗೊಂಡಿದೆ
@@ -500,6 +503,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,ಪದಗಳಲ್ಲಿ ಪ್ರಮಾಣದ ಸಾಲಿನ ಅಂತರ
 DocType: Vehicle,Additional Details,ಹೆಚ್ಚುವರಿ ವಿವರಗಳು
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,ಯಾವುದೇ ವಿವರಣೆ givenName
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,ಗೋದಾಮಿನಿಂದ ವಸ್ತುಗಳನ್ನು ಪಡೆಯಿರಿ
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,ಖರೀದಿ ವಿನಂತಿ .
 DocType: POS Closing Voucher Details,Collected Amount,ಸಂಗ್ರಹಿಸಿದ ಮೊತ್ತ
 DocType: Lab Test,Submitted Date,ಸಲ್ಲಿಸಿದ ದಿನಾಂಕ
@@ -607,6 +611,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,ಕಲಿಯಿರಿ
 ,Trial Balance (Simple),ಪ್ರಯೋಗ ಸಮತೋಲನ (ಸರಳ)
 DocType: Purchase Invoice Item,Enable Deferred Expense,ಮುಂದೂಡಲ್ಪಟ್ಟ ಖರ್ಚು ಸಕ್ರಿಯಗೊಳಿಸಿ
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,ಅನ್ವಯಿಕ ಕೂಪನ್ ಕೋಡ್
 DocType: Asset,Next Depreciation Date,ಮುಂದಿನ ಸವಕಳಿ ದಿನಾಂಕ
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,ನೌಕರರ ಚಟುವಟಿಕೆಗಳನ್ನು ವೆಚ್ಚ
 DocType: Accounts Settings,Settings for Accounts,ಖಾತೆಗಳಿಗೆ ಸೆಟ್ಟಿಂಗ್ಗಳು
@@ -842,8 +847,6 @@
 DocType: Sales Invoice,Total Qty,ಒಟ್ಟು ಪ್ರಮಾಣ
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 ಮೇಲ್
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 ಮೇಲ್
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","ಈ ಡಾಕ್ಯುಮೆಂಟ್ ರದ್ದುಗೊಳಿಸಲು ದಯವಿಟ್ಟು ನೌಕರ <a href=""#Form/Employee/{0}"">{0}</a> delete ಅನ್ನು ಅಳಿಸಿ"
 DocType: Item,Show in Website (Variant),ವೆಬ್ಸೈಟ್ ತೋರಿಸಿ (variant)
 DocType: Employee,Health Concerns,ಆರೋಗ್ಯ ಕಾಳಜಿ
 DocType: Payroll Entry,Select Payroll Period,ವೇತನದಾರರ ಅವಧಿಯ ಆಯ್ಕೆ
@@ -1006,6 +1009,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,ತೆರಿಗೆ ತಡೆಹಿಡಿಯುವ ಖಾತೆ
 DocType: Pricing Rule,Sales Partner,ಮಾರಾಟದ ಸಂಗಾತಿ
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,ಎಲ್ಲಾ ಪೂರೈಕೆದಾರ ಸ್ಕೋರ್ಕಾರ್ಡ್ಗಳು.
+DocType: Coupon Code,To be used to get discount,ರಿಯಾಯಿತಿ ಪಡೆಯಲು ಬಳಸಲಾಗುತ್ತದೆ
 DocType: Buying Settings,Purchase Receipt Required,ಅಗತ್ಯ ಖರೀದಿ ರಸೀತಿ
 DocType: Sales Invoice,Rail,ರೈಲು
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,ವಾಸ್ತವಿಕ ವೆಚ್ಚ
@@ -1053,6 +1057,7 @@
 DocType: Production Plan,Production Plan,ಉತ್ಪಾದನಾ ಯೋಜನೆ
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,ಸರಕುಪಟ್ಟಿ ಸೃಷ್ಟಿ ಉಪಕರಣವನ್ನು ತೆರೆಯಲಾಗುತ್ತಿದೆ
 DocType: Salary Component,Round to the Nearest Integer,ಹತ್ತಿರದ ಪೂರ್ಣಾಂಕಕ್ಕೆ ಸುತ್ತಿಕೊಳ್ಳಿ
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,ಸ್ಟಾಕ್‌ನಲ್ಲಿರದ ವಸ್ತುಗಳನ್ನು ಕಾರ್ಟ್‌ಗೆ ಸೇರಿಸಲು ಅನುಮತಿಸಿ
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,ಮಾರಾಟದ ರಿಟರ್ನ್
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,ಸೀರಿಯಲ್ ನೋ ಇನ್ಪುಟ್ ಆಧರಿಸಿ ಟ್ರಾನ್ಸಾಕ್ಷನ್ಸ್ನಲ್ಲಿ ಹೊಂದಿಸಿ
 ,Total Stock Summary,ಒಟ್ಟು ಸ್ಟಾಕ್ ಸಾರಾಂಶ
@@ -1182,6 +1187,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),ಬೇಸ್ ಅವರ್ ದರ (ಕಂಪನಿ ಕರೆನ್ಸಿ)
 ,Qty To Be Billed,ಬಿಲ್ ಮಾಡಲು ಬಿಟಿ
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,ತಲುಪಿಸಲಾಗಿದೆ ಪ್ರಮಾಣ
+DocType: Coupon Code,Gift Card,ಉಡುಗೊರೆ ಪತ್ರ
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,ಉತ್ಪಾದನೆಗೆ ಕಾಯ್ದಿರಿಸಲಾಗಿದೆ: ಉತ್ಪಾದನಾ ವಸ್ತುಗಳನ್ನು ತಯಾರಿಸಲು ಕಚ್ಚಾ ವಸ್ತುಗಳ ಪ್ರಮಾಣ.
 DocType: Loyalty Point Entry Redemption,Redemption Date,ರಿಡೆಂಪ್ಶನ್ ದಿನಾಂಕ
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,ಈ ಬ್ಯಾಂಕ್ ವ್ಯವಹಾರವು ಈಗಾಗಲೇ ಸಂಪೂರ್ಣವಾಗಿ ಹೊಂದಾಣಿಕೆ ಆಗಿದೆ
@@ -1270,6 +1276,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,ಟೈಮ್‌ಶೀಟ್ ರಚಿಸಿ
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,ಖಾತೆ {0} ಅನೇಕ ಬಾರಿ ನಮೂದಿಸಲಾದ
 DocType: Account,Expenses Included In Valuation,ವೆಚ್ಚಗಳು ಮೌಲ್ಯಾಂಕನ ಸೇರಿಸಲಾಗಿದೆ
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,ಇನ್ವಾಯ್ಸ್ಗಳನ್ನು ಖರೀದಿಸಿ
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,ನಿಮ್ಮ ಸದಸ್ಯತ್ವ 30 ದಿನಗಳಲ್ಲಿ ಅವಧಿ ಮೀರಿದರೆ ಮಾತ್ರ ನೀವು ನವೀಕರಿಸಬಹುದು
 DocType: Shopping Cart Settings,Show Stock Availability,ಸ್ಟಾಕ್ ಲಭ್ಯತೆ ತೋರಿಸಿ
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},ಆಸ್ತಿ ವರ್ಗದ {1} ಅಥವಾ ಕಂಪನಿಯಲ್ಲಿ {0} ಹೊಂದಿಸಿ {2}
@@ -1827,6 +1834,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,ಐಟಂಗಳು ಮತ್ತು UOM ಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳಲಾಗುತ್ತಿದೆ
 DocType: Repayment Schedule,Balance Loan Amount,ಬ್ಯಾಲೆನ್ಸ್ ಸಾಲದ ಪ್ರಮಾಣ
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,ವಿವರಗಳಿಗೆ ಸೇರಿಸಲಾಗಿದೆ
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","ಕ್ಷಮಿಸಿ, ಕೂಪನ್ ಕೋಡ್ ಖಾಲಿಯಾಗಿದೆ"
 DocType: Communication Medium,Catch All,ಎಲ್ಲವನ್ನೂ ಕ್ಯಾಚ್ ಮಾಡಿ
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,ವೇಳಾಪಟ್ಟಿ ಕೋರ್ಸ್
 DocType: Budget,Applicable on Material Request,ಮೆಟೀರಿಯಲ್ ವಿನಂತಿಗೆ ಅನ್ವಯಿಸುತ್ತದೆ
@@ -1974,6 +1982,7 @@
 DocType: Company,Parent Company,ಮೂಲ ಕಂಪನಿ
 apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py,Hotel Rooms of type {0} are unavailable on {1},ಹೋಟೆಲ್ ಕೊಠಡಿಗಳು {0} {1} ನಲ್ಲಿ ಲಭ್ಯವಿಲ್ಲ
 apps/erpnext/erpnext/config/manufacturing.py,Compare BOMs for changes in Raw Materials and Operations,ಕಚ್ಚಾ ವಸ್ತುಗಳು ಮತ್ತು ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿನ ಬದಲಾವಣೆಗಳಿಗಾಗಿ BOM ಗಳನ್ನು ಹೋಲಿಕೆ ಮಾಡಿ
+apps/erpnext/erpnext/accounts/doctype/bank_transaction/bank_transaction.js,Document {0} successfully uncleared,ಡಾಕ್ಯುಮೆಂಟ್ {0} ಯಶಸ್ವಿಯಾಗಿ ಅಸ್ಪಷ್ಟವಾಗಿದೆ
 DocType: Healthcare Practitioner,Default Currency,ಡೀಫಾಲ್ಟ್ ಕರೆನ್ಸಿ
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.js,Reconcile this account,ಈ ಖಾತೆಯನ್ನು ಮರುಸಂಗ್ರಹಿಸಿ
 apps/erpnext/erpnext/controllers/selling_controller.py,Maximum discount for Item {0} is {1}%,ಐಟಂ {0} ಗೆ ಗರಿಷ್ಠ ರಿಯಾಯಿತಿ {1}%
@@ -1993,6 +2002,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,ಅಮಾನ್ಯ ಲಕ್ಷಣ
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} ಸಲ್ಲಿಸಬೇಕು
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,ಇಮೇಲ್ ಪ್ರಚಾರಗಳು
+DocType: Sales Partner,To Track inbound purchase,ಒಳಬರುವ ಖರೀದಿಯನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು
 DocType: Buying Settings,Default Supplier Group,ಡೀಫಾಲ್ಟ್ ಪೂರೈಕೆದಾರ ಗುಂಪು
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},ಪ್ರಮಾಣ ಕಡಿಮೆ ಅಥವಾ ಸಮನಾಗಿರಬೇಕು {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},{0} ಅಂಶಕ್ಕೆ ಅರ್ಹವಾದ ಗರಿಷ್ಠ ಮೊತ್ತವು {1} ಮೀರಿದೆ
@@ -2146,7 +2156,6 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,ಸ್ಟಾಕ್ ಎಂಟ್ರಿ ಮಾಡಿ
 DocType: Hotel Room Reservation,Hotel Reservation User,ಹೋಟೆಲ್ ಮೀಸಲಾತಿ ಬಳಕೆದಾರ
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,ಸ್ಥಿತಿಯನ್ನು ಹೊಂದಿಸಿ
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,ಸೆಟಪ್&gt; ಸಂಖ್ಯೆಯ ಸರಣಿಯ ಮೂಲಕ ಹಾಜರಾತಿಗಾಗಿ ದಯವಿಟ್ಟು ಸಂಖ್ಯೆಯ ಸರಣಿಯನ್ನು ಹೊಂದಿಸಿ
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,ಮೊದಲ ಪೂರ್ವಪ್ರತ್ಯಯ ಆಯ್ಕೆ ಮಾಡಿ
 DocType: Contract,Fulfilment Deadline,ಪೂರೈಸುವ ಗಡುವು
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,ನಿನ್ನ ಹತ್ತಿರ
@@ -2270,6 +2279,7 @@
 DocType: Quality Meeting Table,Under Review,ಪರಿಶೀಲನೆಯಲ್ಲಿದೆ
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,ಲಾಗಿನ್ ಮಾಡಲು ವಿಫಲವಾಗಿದೆ
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,ಆಸ್ತಿ {0} ರಚಿಸಲಾಗಿದೆ
+DocType: Coupon Code,Promotional,ಪ್ರಚಾರ
 DocType: Special Test Items,Special Test Items,ವಿಶೇಷ ಪರೀಕ್ಷಾ ಐಟಂಗಳು
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Marketplace ನಲ್ಲಿ ನೋಂದಾಯಿಸಲು ನೀವು ಸಿಸ್ಟಮ್ ಮ್ಯಾನೇಜರ್ ಮತ್ತು ಐಟಂ ಮ್ಯಾನೇಜರ್ ರೋಲ್ಗಳೊಂದಿಗೆ ಬಳಕೆದಾರರಾಗಿರಬೇಕಾಗುತ್ತದೆ.
 apps/erpnext/erpnext/config/buying.py,Key Reports,ಪ್ರಮುಖ ವರದಿಗಳು
@@ -2307,6 +2317,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,ಡಾಕ್ ಪ್ರಕಾರ
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,ಮಾರಾಟದ ತಂಡಕ್ಕೆ ಹಂಚಿಕೆ ಶೇಕಡಾವಾರು ಒಟ್ಟು 100 ಶುಡ್
 DocType: Subscription Plan,Billing Interval Count,ಬಿಲ್ಲಿಂಗ್ ಇಂಟರ್ವಲ್ ಕೌಂಟ್
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","ಈ ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು ರದ್ದುಗೊಳಿಸಲು ದಯವಿಟ್ಟು ನೌಕರ <a href=""#Form/Employee/{0}"">{0}</a> delete ಅನ್ನು ಅಳಿಸಿ"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,ನೇಮಕಾತಿಗಳು ಮತ್ತು ರೋಗಿಯ ಎನ್ಕೌಂಟರ್ಸ್
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,ಮೌಲ್ಯವು ಕಾಣೆಯಾಗಿದೆ
 DocType: Employee,Department and Grade,ಇಲಾಖೆ ಮತ್ತು ಗ್ರೇಡ್
@@ -2407,6 +2419,7 @@
 DocType: Project,Start and End Dates,ಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ದಿನಾಂಕ ಎಂಡ್
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,ಕಾಂಟ್ರಾಕ್ಟ್ ಟೆಂಪ್ಲೇಟು ಪೂರೈಸುವ ನಿಯಮಗಳು
 ,Delivered Items To Be Billed,ಪಾವತಿಸಬೇಕಾಗುತ್ತದೆ ವಿತರಿಸಲಾಯಿತು ಐಟಂಗಳು
+DocType: Coupon Code,Maximum Use,ಗರಿಷ್ಠ ಬಳಕೆ
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},ಓಪನ್ ಬಿಒಎಮ್ {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,ವೇರ್ಹೌಸ್ ನೆಯ ಬದಲಾಗಿದೆ ಸಾಧ್ಯವಿಲ್ಲ .
 DocType: Authorization Rule,Average Discount,ಸರಾಸರಿ ರಿಯಾಯಿತಿ
@@ -2567,6 +2580,7 @@
 DocType: Item,Inventory,ತಪಶೀಲು ಪಟ್ಟಿ
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Json ಆಗಿ ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ
 DocType: Item,Sales Details,ಮಾರಾಟದ ವಿವರಗಳು
+DocType: Coupon Code,Used,ಬಳಸಲಾಗುತ್ತದೆ
 DocType: Opportunity,With Items,ವಸ್ತುಗಳು
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',&#39;{0}&#39; ಅಭಿಯಾನವು ಈಗಾಗಲೇ {1} &#39;{2}&#39; ಗೆ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ
 DocType: Asset Maintenance,Maintenance Team,ನಿರ್ವಹಣೆ ತಂಡ
@@ -2694,7 +2708,7 @@
 						Serial No cannot be ensured",ಐಟಂ {0} ಗಾಗಿ ಸಕ್ರಿಯ BOM ಕಂಡುಬಂದಿಲ್ಲ. \ ಸೀರಿಯಲ್ ನ ಮೂಲಕ ವಿತರಣೆ ಖಾತ್ರಿಪಡಿಸಲಾಗುವುದಿಲ್ಲ
 DocType: Sales Partner,Sales Partner Target,ಮಾರಾಟದ ಸಂಗಾತಿ ಟಾರ್ಗೆಟ್
 DocType: Loan Type,Maximum Loan Amount,ಗರಿಷ್ಠ ಸಾಲದ
-DocType: Pricing Rule,Pricing Rule,ಬೆಲೆ ರೂಲ್
+DocType: Coupon Code,Pricing Rule,ಬೆಲೆ ರೂಲ್
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},ವಿದ್ಯಾರ್ಥಿ ನಕಲು ರೋಲ್ ಸಂಖ್ಯೆ {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},ವಿದ್ಯಾರ್ಥಿ ನಕಲು ರೋಲ್ ಸಂಖ್ಯೆ {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,ಆರ್ಡರ್ ಖರೀದಿಸಿ ಮೆಟೀರಿಯಲ್ ವಿನಂತಿ
@@ -2772,6 +2786,7 @@
 DocType: Payment Schedule,Payment Amount,ಪಾವತಿ ಪ್ರಮಾಣವನ್ನು
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,ಹಾಫ್ ಡೇ ದಿನಾಂಕವು ದಿನಾಂಕ ಮತ್ತು ಕೆಲಸದ ಕೊನೆಯ ದಿನಾಂಕದಿಂದ ಕೆಲಸದ ನಡುವೆ ಇರಬೇಕು
 DocType: Healthcare Settings,Healthcare Service Items,ಆರೋಗ್ಯ ಸೇವೆ ವಸ್ತುಗಳು
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,ಅಮಾನ್ಯ ಬಾರ್‌ಕೋಡ್. ಈ ಬಾರ್‌ಕೋಡ್‌ಗೆ ಯಾವುದೇ ಐಟಂ ಲಗತ್ತಿಸಲಾಗಿಲ್ಲ.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,ಸೇವಿಸುವ ಪ್ರಮಾಣವನ್ನು
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,ನಗದು ನಿವ್ವಳ ವ್ಯತ್ಯಾಸದ
 DocType: Assessment Plan,Grading Scale,ಗ್ರೇಡಿಂಗ್ ಸ್ಕೇಲ್
@@ -2891,7 +2906,6 @@
 DocType: Share Transfer,Asset Account,ಆಸ್ತಿ ಖಾತೆ
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,ಹೊಸ ಬಿಡುಗಡೆ ದಿನಾಂಕ ಭವಿಷ್ಯದಲ್ಲಿರಬೇಕು
 DocType: Purchase Invoice,End date of current invoice's period,ಪ್ರಸ್ತುತ ಅವಧಿಯ ಸರಕುಪಟ್ಟಿ ಅಂತಿಮ ದಿನಾಂಕ
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,ದಯವಿಟ್ಟು ಮಾನವ ಸಂಪನ್ಮೂಲ&gt; ಮಾನವ ಸಂಪನ್ಮೂಲ ಸೆಟ್ಟಿಂಗ್‌ಗಳಲ್ಲಿ ನೌಕರರ ಹೆಸರಿಸುವ ವ್ಯವಸ್ಥೆಯನ್ನು ಹೊಂದಿಸಿ
 DocType: Lab Test,Technician Name,ತಂತ್ರಜ್ಞ ಹೆಸರು
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3172,7 +3186,6 @@
 DocType: Student,Student Mobile Number,ವಿದ್ಯಾರ್ಥಿ ಮೊಬೈಲ್ ಸಂಖ್ಯೆ
 DocType: Item,Has Variants,ವೇರಿಯಂಟ್
 DocType: Employee Benefit Claim,Claim Benefit For,ಕ್ಲೈಮ್ ಲಾಭ
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","{2} ಕ್ಕಿಂತ ಹೆಚ್ಚು {1} ಸಾಲಿನಲ್ಲಿ ಐಟಂ {0} ಗಾಗಿ ಓವರ್ಬಲ್ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ. ಅಧಿಕ ಬಿಲ್ಲಿಂಗ್ ಅನ್ನು ಅನುಮತಿಸಲು, ದಯವಿಟ್ಟು ಸ್ಟಾಕ್ ಸೆಟ್ಟಿಂಗ್ಗಳಲ್ಲಿ ಹೊಂದಿಸಿ"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,ಅಪ್ಡೇಟ್ ಪ್ರತಿಕ್ರಿಯೆ
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},ನೀವು ಈಗಾಗಲೇ ಆಯ್ಕೆ ಐಟಂಗಳನ್ನು ಎಂದು {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,ಮಾಸಿಕ ವಿತರಣೆ ಹೆಸರು
@@ -3460,6 +3473,7 @@
 DocType: Vehicle,Fuel Type,ಇಂಧನ ಕೌಟುಂಬಿಕತೆ
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,ಕಂಪನಿ ಕರೆನ್ಸಿ ಸೂಚಿಸಿ
 DocType: Workstation,Wages per hour,ಗಂಟೆಗೆ ವೇತನ
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,ಗ್ರಾಹಕ&gt; ಗ್ರಾಹಕ ಗುಂಪು&gt; ಪ್ರದೇಶ
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},ಬ್ಯಾಚ್ ಸ್ಟಾಕ್ ಸಮತೋಲನ {0} ಪರಿಣಮಿಸುತ್ತದೆ ಋಣಾತ್ಮಕ {1} ಕೋಠಿಯಲ್ಲಿ ಐಟಂ {2} ಫಾರ್ {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,ಮೆಟೀರಿಯಲ್ ವಿನಂತಿಗಳು ಕೆಳಗಿನ ಐಟಂ ಮರು ಆದೇಶ ಮಟ್ಟವನ್ನು ಆಧರಿಸಿ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಎದ್ದಿವೆ
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},ಖಾತೆ {0} ಅಮಾನ್ಯವಾಗಿದೆ. ಖಾತೆ ಕರೆನ್ಸಿ ಇರಬೇಕು {1}
@@ -3793,6 +3807,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,ಸಂಬಳ ಸ್ಲಿಪ್ ಸಲ್ಲಿಸಿ
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,ಹೋಲ್ಡ್ ಆನ್
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,ಒಂದು ಕ್ವಾಶನ್ ಕನಿಷ್ಠ ಒಂದು ಸರಿಯಾದ ಆಯ್ಕೆಗಳನ್ನು ಹೊಂದಿರಬೇಕು
+apps/erpnext/erpnext/hooks.py,Purchase Orders,ಖರೀದಿ ಆದೇಶ
 DocType: Account,Inter Company Account,ಇಂಟರ್ ಕಂಪನಿ ಖಾತೆ
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,ದೊಡ್ಡ ಆಮದು
 DocType: Sales Partner,Address & Contacts,ವಿಳಾಸ ಮತ್ತು ಸಂಪರ್ಕಗಳು
@@ -3803,6 +3818,7 @@
 DocType: POS Profile,[Select],[ ಆರಿಸಿರಿ ]
 DocType: Staffing Plan Detail,Number Of Positions,ಸ್ಥಾನಗಳ ಸಂಖ್ಯೆ
 DocType: Vital Signs,Blood Pressure (diastolic),ರಕ್ತದೊತ್ತಡ (ಡಯಾಸ್ಟೊಲಿಕ್)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,ದಯವಿಟ್ಟು ಗ್ರಾಹಕರನ್ನು ಆಯ್ಕೆ ಮಾಡಿ.
 DocType: SMS Log,Sent To,ಕಳುಹಿಸಲಾಗುತ್ತದೆ
 DocType: Agriculture Task,Holiday Management,ರಜಾದಿನದ ನಿರ್ವಹಣೆ
 DocType: Payment Request,Make Sales Invoice,ಮಾರಾಟದ ಸರಕುಪಟ್ಟಿ ಮಾಡಿ
@@ -4009,7 +4025,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} ಸಲ್ಲಿಸದಿದ್ದರೆ
 DocType: Subscription,Trialling,ಟ್ರಯಲಿಂಗ್
 DocType: Sales Invoice Item,Deferred Revenue,ಮುಂದೂಡಲ್ಪಟ್ಟ ಆದಾಯ
-DocType: Bank Account,GL Account,ಜಿಎಲ್ ಖಾತೆ
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,ಸೇಲ್ಸ್ ಸರಕುಪಟ್ಟಿ ರಚನೆಗೆ ನಗದು ಖಾತೆಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,ವಿನಾಯಿತಿ ಉಪ ವರ್ಗ
 DocType: Member,Membership Expiry Date,ಸದಸ್ಯತ್ವ ಮುಕ್ತಾಯ ದಿನಾಂಕ
@@ -4429,13 +4444,13 @@
 DocType: C-Form Invoice Detail,Territory,ಕ್ಷೇತ್ರ
 DocType: Pricing Rule,Apply Rule On Item Code,ಐಟಂ ಕೋಡ್‌ನಲ್ಲಿ ನಿಯಮವನ್ನು ಅನ್ವಯಿಸಿ
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,ನಮೂದಿಸಿ ಅಗತ್ಯವಿದೆ ಭೇಟಿ ಯಾವುದೇ
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,ಸ್ಟಾಕ್ ಬ್ಯಾಲೆನ್ಸ್ ವರದಿ
 DocType: Stock Settings,Default Valuation Method,ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಮಾಪನ ವಿಧಾನ
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,ಶುಲ್ಕ
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,ಸಂಚಿತ ಮೊತ್ತವನ್ನು ತೋರಿಸಿ
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,ನವೀಕರಣ ಪ್ರಗತಿಯಲ್ಲಿದೆ. ಸ್ವಲ್ಪ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳಬಹುದು.
 DocType: Production Plan Item,Produced Qty,ನಿರ್ಮಾಣದ ಕ್ಯೂಟಿ
 DocType: Vehicle Log,Fuel Qty,ಇಂಧನ ಪ್ರಮಾಣ
-DocType: Stock Entry,Target Warehouse Name,ಟಾರ್ಗೆಟ್ ವೇರ್ಹೌಸ್ ಹೆಸರು
 DocType: Work Order Operation,Planned Start Time,ಯೋಜಿತ ಆರಂಭಿಸಲು ಸಮಯ
 DocType: Course,Assessment,ಅಸೆಸ್ಮೆಂಟ್
 DocType: Payment Entry Reference,Allocated,ಹಂಚಿಕೆ
@@ -4513,10 +4528,12 @@
  1. ಇತ್ಯಾದಿ ವಿಳಾಸ ವಿವಾದಗಳು, ನಷ್ಟ, ಹೊಣೆಗಾರಿಕೆ, 
  1 ಮಾರ್ಗಗಳು. ವಿಳಾಸ ಮತ್ತು ನಿಮ್ಮ ಕಂಪನಿ ಸಂಪರ್ಕಿಸಿ."
 DocType: Homepage Section,Section Based On,ವಿಭಾಗ ಆಧಾರಿತ
+DocType: Shopping Cart Settings,Show Apply Coupon Code,ಅನ್ವಯಿಸು ಕೂಪನ್ ಕೋಡ್ ತೋರಿಸಿ
 DocType: Issue,Issue Type,ಸಂಚಿಕೆ ಪ್ರಕಾರ
 DocType: Attendance,Leave Type,ಪ್ರಕಾರ ಬಿಡಿ
 DocType: Purchase Invoice,Supplier Invoice Details,ಸರಬರಾಜುದಾರ ಇನ್ವಾಯ್ಸ್ ವಿವರಗಳು
 DocType: Agriculture Task,Ignore holidays,ರಜಾದಿನಗಳನ್ನು ನಿರ್ಲಕ್ಷಿಸಿ
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,ಕೂಪನ್ ಷರತ್ತುಗಳನ್ನು ಸೇರಿಸಿ / ಸಂಪಾದಿಸಿ
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,ಖರ್ಚು / ವ್ಯತ್ಯಾಸ ಖಾತೆ ({0}) ಒಂದು 'ಲಾಭ ಅಥವಾ ನಷ್ಟ' ಖಾತೆ ಇರಬೇಕು
 DocType: Stock Entry Detail,Stock Entry Child,ಸ್ಟಾಕ್ ಎಂಟ್ರಿ ಚೈಲ್ಡ್
 DocType: Project,Copied From,ನಕಲು
@@ -4687,6 +4704,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,ಅಸೆಸ್ಮೆಂಟ್ ಯೋಜನೆ ಮಾನದಂಡ
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,ಟ್ರಾನ್ಸಾಕ್ಷನ್ಸ್
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,ಖರೀದಿ ಆದೇಶಗಳನ್ನು ತಡೆಯಿರಿ
+DocType: Coupon Code,Coupon Name,ಕೂಪನ್ ಹೆಸರು
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,ಒಳಗಾಗಬಹುದು
 DocType: Email Campaign,Scheduled,ಪರಿಶಿಷ್ಟ
 DocType: Shift Type,Working Hours Calculation Based On,ಕೆಲಸದ ಸಮಯದ ಲೆಕ್ಕಾಚಾರವನ್ನು ಆಧರಿಸಿದೆ
@@ -4703,7 +4721,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,ಮಾರ್ಪಾಟುಗಳು ರಚಿಸಿ
 DocType: Vehicle,Diesel,ಡೀಸೆಲ್
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,ಬೆಲೆ ಪಟ್ಟಿ ಕರೆನ್ಸಿ ಆಯ್ಕೆ ಇಲ್ಲ
+DocType: Quick Stock Balance,Available Quantity,ಲಭ್ಯವಿರುವ ಪ್ರಮಾಣ
 DocType: Purchase Invoice,Availed ITC Cess,ಐಟಿಸಿ ಸೆಸ್ ಪಡೆದುಕೊಂಡಿದೆ
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,ಶಿಕ್ಷಣ&gt; ಶಿಕ್ಷಣ ಸೆಟ್ಟಿಂಗ್‌ಗಳಲ್ಲಿ ಬೋಧಕ ಹೆಸರಿಸುವ ವ್ಯವಸ್ಥೆಯನ್ನು ದಯವಿಟ್ಟು ಹೊಂದಿಸಿ
 ,Student Monthly Attendance Sheet,ವಿದ್ಯಾರ್ಥಿ ಮಾಸಿಕ ಅಟೆಂಡೆನ್ಸ್ ಶೀಟ್
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,ಶಿಪ್ಪಿಂಗ್ ನಿಯಮವು ಮಾರಾಟಕ್ಕೆ ಮಾತ್ರ ಅನ್ವಯಿಸುತ್ತದೆ
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,ಸವಕಳಿ ಸಾಲು {0}: ಮುಂದಿನ ಸವಕಳಿ ದಿನಾಂಕ ಖರೀದಿಯ ದಿನಾಂಕಕ್ಕಿಂತ ಮೊದಲು ಇರುವಂತಿಲ್ಲ
@@ -4772,6 +4792,7 @@
 DocType: Quality Meeting,Quality Meeting,ಗುಣಮಟ್ಟದ ಸಭೆ
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,ಗ್ರೂಪ್ ಅಲ್ಲದ ಗ್ರೂಪ್
 DocType: Employee,ERPNext User,ERPNext ಬಳಕೆದಾರ
+DocType: Coupon Code,Coupon Description,ಕೂಪನ್ ವಿವರಣೆ
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},ಬ್ಯಾಚ್ ಸತತವಾಗಿ ಕಡ್ಡಾಯ {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},ಬ್ಯಾಚ್ ಸತತವಾಗಿ ಕಡ್ಡಾಯ {0}
 DocType: Company,Default Buying Terms,ಡೀಫಾಲ್ಟ್ ಖರೀದಿ ನಿಯಮಗಳು
@@ -4933,6 +4954,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,ಡಾಕ್ಯುಮೆಂಟ್ ವಿವರ ವಿರುದ್ಧ ನಂ
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},ದೇಶಕ್ಕಾಗಿ {0} ಅಳಿಸುವಿಕೆಗೆ ಅನುಮತಿ ಇಲ್ಲ
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,ಪಕ್ಷದ ಕೌಟುಂಬಿಕತೆ ಕಡ್ಡಾಯ
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,ಕೂಪನ್ ಕೋಡ್ ಅನ್ನು ಅನ್ವಯಿಸಿ
 DocType: Quality Inspection,Outgoing,ನಿರ್ಗಮಿಸುವ
 DocType: Customer Feedback Table,Customer Feedback Table,ಗ್ರಾಹಕ ಪ್ರತಿಕ್ರಿಯೆ ಕೋಷ್ಟಕ
 apps/erpnext/erpnext/config/support.py,Service Level Agreement.,ಸೇವೆ ಮಟ್ಟದ ಒಪ್ಪಂದ.
@@ -5083,7 +5105,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,ಖರೀದಿ ಆದೇಶ ಸಲ್ಲಿಕೆಗೆ
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,ಎಲ್ಲಾ ಪೂರೈಕೆದಾರರನ್ನು ಸೇರಿಸಿ
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,ರೋ # {0}: ನಿಗದಿ ಪ್ರಮಾಣ ಬಾಕಿ ಮೊತ್ತದ ಹೆಚ್ಚು ಹೆಚ್ಚಿರಬಾರದು.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,ಗ್ರಾಹಕ&gt; ಗ್ರಾಹಕ ಗುಂಪು&gt; ಪ್ರದೇಶ
 DocType: Tally Migration,Parties,ಪಕ್ಷಗಳು
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,ಬ್ರೌಸ್ BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,ಸುರಕ್ಷಿತ ಸಾಲ
@@ -5114,7 +5135,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},ಐಟಂ {0} ಗಾಗಿ ಪರ್ಯಾಯ ಐಟಂ ಅನ್ನು ಹೊಂದಿಸಲು ಅನುಮತಿಸುವುದಿಲ್ಲ
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,ದಿನಾಂಕ ಪುನರಾವರ್ತಿಸುತ್ತದೆ
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,ಅಧಿಕೃತ ಸಹಿ
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,ಶಿಕ್ಷಣ&gt; ಶಿಕ್ಷಣ ಸೆಟ್ಟಿಂಗ್‌ಗಳಲ್ಲಿ ಬೋಧಕ ಹೆಸರಿಸುವ ವ್ಯವಸ್ಥೆಯನ್ನು ದಯವಿಟ್ಟು ಹೊಂದಿಸಿ
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),ನೆಟ್ ಐಟಿಸಿ ಲಭ್ಯವಿದೆ (ಎ) - (ಬಿ)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,ಶುಲ್ಕಗಳು ರಚಿಸಿ
 DocType: Project,Total Purchase Cost (via Purchase Invoice),ಒಟ್ಟು ಖರೀದಿ ವೆಚ್ಚ (ಖರೀದಿ ಸರಕುಪಟ್ಟಿ ಮೂಲಕ)
@@ -5138,6 +5158,7 @@
 DocType: Quiz Result,Wrong,ತಪ್ಪಾಗಿದೆ
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,ಬೆಲೆ ಪಟ್ಟಿ ಕರೆನ್ಸಿ ದರ ಗ್ರಾಹಕ ಬೇಸ್ ಕರೆನ್ಸಿ ಪರಿವರ್ತನೆ
 DocType: Purchase Invoice Item,Net Amount (Company Currency),ನೆಟ್ ಪ್ರಮಾಣ (ಕಂಪನಿ ಕರೆನ್ಸಿ)
+DocType: Sales Partner,Referral Code,ರೆಫರಲ್ ಕೋಡ್
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,ಒಟ್ಟು ಮುಂಗಡ ಮೊತ್ತವು ಒಟ್ಟು ಮಂಜೂರು ಮೊತ್ತಕ್ಕಿಂತ ಹೆಚ್ಚಿನದಾಗಿರುವುದಿಲ್ಲ
 DocType: Salary Slip,Hour Rate,ಅವರ್ ದರ
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,ಸ್ವಯಂ ಮರು-ಆದೇಶವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ
@@ -5266,6 +5287,7 @@
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},ದಯವಿಟ್ಟು ಐಟಂನ ವಿರುದ್ಧ BOM ಅನ್ನು ಆಯ್ಕೆಮಾಡಿ {0}
 DocType: Shopping Cart Settings,Show Stock Quantity,ಸ್ಟಾಕ್ ಪ್ರಮಾಣವನ್ನು ತೋರಿಸಿ
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,ಕಾರ್ಯಾಚರಣೆ ನಿವ್ವಳ ನಗದು
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},ಐಟಂಗೆ UOM ಪರಿವರ್ತನೆ ಅಂಶ ({0} -&gt; {1}) ಕಂಡುಬಂದಿಲ್ಲ: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,ಐಟಂ 4
 DocType: Student Admission,Admission End Date,ಪ್ರವೇಶ ಮುಕ್ತಾಯ ದಿನಾಂಕ
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,ಒಳ-ಒಪ್ಪಂದ
@@ -5288,6 +5310,7 @@
 DocType: Travel Request,Fully Sponsored,ಸಂಪೂರ್ಣವಾಗಿ ಪ್ರಾಯೋಜಿತ
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,ರಿವರ್ಸ್ ಜರ್ನಲ್ ಎಂಟ್ರಿ
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,ಜಾಬ್ ಕಾರ್ಡ್ ರಚಿಸಿ
+DocType: Quotation,Referral Sales Partner,ರೆಫರಲ್ ಮಾರಾಟ ಪಾಲುದಾರ
 DocType: Quality Procedure Process,Process Description,ಪ್ರಕ್ರಿಯೆಯ ವಿವರಣೆ
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,ಗ್ರಾಹಕ {0} ರಚಿಸಲಾಗಿದೆ.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,ಪ್ರಸ್ತುತ ಯಾವುದೇ ವೇರಾಹೌಸ್‌ನಲ್ಲಿ ಸ್ಟಾಕ್ ಲಭ್ಯವಿಲ್ಲ
@@ -5419,6 +5442,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,ಬಿಒಎಮ್ ದರ
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,ಅಪ್‌ಲೋಡ್ ಮಾಡಿದ ಫೈಲ್ ಅನ್ನು ಓದುವುದು
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","ನಿಲ್ಲಿಸಿರುವ ಕೆಲಸ ಆದೇಶವನ್ನು ರದ್ದುಗೊಳಿಸಲಾಗುವುದಿಲ್ಲ, ಅನ್ಸ್ಟಪ್ ಅದನ್ನು ಮೊದಲು ರದ್ದುಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ"
+DocType: Coupon Code,Coupon Code,ಕೂಪನ್ ಕೋಡ್
 DocType: Asset,Journal Entry for Scrap,ಸ್ಕ್ರ್ಯಾಪ್ ಜರ್ನಲ್ ಎಂಟ್ರಿ
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,ಡೆಲಿವರಿ ಗಮನಿಸಿ ಐಟಂಗಳನ್ನು ಪುಲ್ ದಯವಿಟ್ಟು
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},ಸಾಲು {0}: ಕಾರ್ಯಾಚರಣೆ ವಿರುದ್ಧ ಕಾರ್ಯಕ್ಷೇತ್ರವನ್ನು ಆಯ್ಕೆಮಾಡಿ {1}
@@ -5502,6 +5526,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;ದಿನಾಂಕ&#39; ಅಗತ್ಯವಿದೆ
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},ಕಾರಣ / ಉಲ್ಲೇಖ ದಿನಾಂಕ ನಂತರ ಇರುವಂತಿಲ್ಲ {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,ಡೇಟಾ ಆಮದು ಮತ್ತು ರಫ್ತು
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","ಕ್ಷಮಿಸಿ, ಕೂಪನ್ ಕೋಡ್ ಸಿಂಧುತ್ವ ಅವಧಿ ಮೀರಿದೆ"
 DocType: Bank Account,Account Details,ಖಾತೆ ವಿವರಗಳು
 DocType: Crop,Materials Required,ಸಾಮಗ್ರಿಗಳು ಅಗತ್ಯವಿದೆ
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,ಯಾವುದೇ ವಿದ್ಯಾರ್ಥಿಗಳು ಕಂಡುಬಂದಿಲ್ಲ
@@ -5539,6 +5564,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,ಬಳಕೆದಾರರಿಗೆ ಹೋಗಿ
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,ಪಾವತಿಸಿದ ಪ್ರಮಾಣದ + ಆಫ್ ಬರೆಯಿರಿ ಪ್ರಮಾಣ ಹೆಚ್ಚಿನ ಗ್ರ್ಯಾಂಡ್ ಒಟ್ಟು ಸಾಧ್ಯವಿಲ್ಲ
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} ಐಟಂ ಮಾನ್ಯ ಬ್ಯಾಚ್ ಸಂಖ್ಯೆ ಅಲ್ಲ {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,ದಯವಿಟ್ಟು ಮಾನ್ಯ ಕೂಪನ್ ಕೋಡ್ ನಮೂದಿಸಿ !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},ಗಮನಿಸಿ : ಲೀವ್ ಪ್ರಕಾರ ಸಾಕಷ್ಟು ರಜೆ ಸಮತೋಲನ ಇಲ್ಲ {0}
 DocType: Task,Task Description,ಕಾರ್ಯ ವಿವರಣೆ
 DocType: Training Event,Seminar,ಸೆಮಿನಾರ್
@@ -5805,6 +5831,7 @@
 ,TDS Payable Monthly,ಟಿಡಿಎಸ್ ಪಾವತಿಸಬಹುದಾದ ಮಾಸಿಕ
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,BOM ಅನ್ನು ಬದಲಿಸಲು ಸರದಿಯಲ್ಲಿದೆ. ಇದು ಕೆಲವು ನಿಮಿಷಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',ವರ್ಗದಲ್ಲಿ ' ಮೌಲ್ಯಾಂಕನ ' ಅಥವಾ ' ಮೌಲ್ಯಾಂಕನ ಮತ್ತು ಒಟ್ಟು ' ಫಾರ್ ಯಾವಾಗ ಕಡಿತಗೊಳಿಸದಿರುವುದರ ಸಾಧ್ಯವಿಲ್ಲ
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,ದಯವಿಟ್ಟು ಮಾನವ ಸಂಪನ್ಮೂಲ&gt; ಮಾನವ ಸಂಪನ್ಮೂಲ ಸೆಟ್ಟಿಂಗ್‌ಗಳಲ್ಲಿ ನೌಕರರ ಹೆಸರಿಸುವ ವ್ಯವಸ್ಥೆಯನ್ನು ಹೊಂದಿಸಿ
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,ಒಟ್ಟು ಪಾವತಿಗಳು
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},ಧಾರಾವಾಹಿಯಾಗಿ ಐಟಂ ಸೀರಿಯಲ್ ಸೂಲ ಅಗತ್ಯವಿದೆ {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,ಇನ್ವಾಯ್ಸ್ಗಳು ಜೊತೆ ಪಾವತಿಗಳು ಹೊಂದಿಕೆ
@@ -5892,6 +5919,7 @@
 DocType: Production Plan,Get Raw Materials For Production,ಉತ್ಪಾದನೆಗೆ ರಾ ಮೆಟೀರಿಯಲ್ಸ್ ಪಡೆಯಿರಿ
 DocType: Job Opening,Job Title,ಕೆಲಸದ ಶೀರ್ಷಿಕೆ
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,ಭವಿಷ್ಯದ ಪಾವತಿ ರೆಫ್
+DocType: Quotation,Additional Discount and Coupon Code,ಹೆಚ್ಚುವರಿ ರಿಯಾಯಿತಿ ಮತ್ತು ಕೂಪನ್ ಕೋಡ್
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} {1} ಉದ್ಧರಣವನ್ನು ಒದಗಿಸುವುದಿಲ್ಲ ಎಂದು ಸೂಚಿಸುತ್ತದೆ, ಆದರೆ ಎಲ್ಲಾ ಐಟಂಗಳನ್ನು ಉಲ್ಲೇಖಿಸಲಾಗಿದೆ. RFQ ಉಲ್ಲೇಖ ಸ್ಥಿತಿಯನ್ನು ನವೀಕರಿಸಲಾಗುತ್ತಿದೆ."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,ಗರಿಷ್ಠ ಸ್ಯಾಂಪಲ್ಸ್ - ಬ್ಯಾಚ್ {3} ನಲ್ಲಿ ಬ್ಯಾಚ್ {1} ಮತ್ತು ಐಟಂ {2} ಗಾಗಿ {0} ಈಗಾಗಲೇ ಉಳಿಸಿಕೊಂಡಿವೆ.
@@ -6118,6 +6146,7 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,ವೆಬ್ಸೈಟ್ ಮುಖಪುಟ ಸೆಟ್ಟಿಂಗ್ಗಳು
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} {1} ವರೆಗೆ ಹಿಡಿದಿರುತ್ತದೆ
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},{1} ರ ಸ್ಕೋರ್ಕಾರ್ಡ್ ನಿಂತಿರುವ ಕಾರಣದಿಂದ {0} RFQ ಗಳನ್ನು ಅನುಮತಿಸಲಾಗುವುದಿಲ್ಲ.
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,ಖರೀದಿ ಸರಕುಪಟ್ಟಿ ಮಾಡಿ
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,ಉಪಯೋಗಿಸಿದ ಎಲೆಗಳು
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,ವಸ್ತು ವಿನಂತಿಯನ್ನು ಸಲ್ಲಿಸಲು ನೀವು ಬಯಸುವಿರಾ
 DocType: Job Offer,Awaiting Response,ಪ್ರತಿಕ್ರಿಯೆ ಕಾಯುತ್ತಿದ್ದ
@@ -6132,6 +6161,7 @@
 DocType: Training Event Employee,Optional,ಐಚ್ಛಿಕ
 DocType: Salary Slip,Earning & Deduction,ದುಡಿಯುತ್ತಿದ್ದ & ಡಿಡಕ್ಷನ್
 DocType: Agriculture Analysis Criteria,Water Analysis,ನೀರಿನ ವಿಶ್ಲೇಷಣೆ
+DocType: Sales Order,Skip Delivery Note,ವಿತರಣಾ ಟಿಪ್ಪಣಿ ಬಿಟ್ಟುಬಿಡಿ
 DocType: Price List,Price Not UOM Dependent,ಬೆಲೆ UOM ಅವಲಂಬಿತವಲ್ಲ
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} ರೂಪಾಂತರಗಳು ರಚಿಸಲಾಗಿದೆ.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,ಡೀಫಾಲ್ಟ್ ಸೇವಾ ಮಟ್ಟದ ಒಪ್ಪಂದವು ಈಗಾಗಲೇ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.
@@ -6339,7 +6369,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,ಸೇರಿಸಲಾಗಿದೆ ತೆರಿಗೆಗಳು ಮತ್ತು ಶುಲ್ಕಗಳು
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,ಸವಕಳಿ ಸಾಲು {0}: ಮುಂದಿನ ಸವಕಳಿ ದಿನಾಂಕ ಲಭ್ಯವಾಗುವ ದಿನಾಂಕದ ಮೊದಲು ಇರಬಾರದು
 ,Sales Funnel,ಮಾರಾಟ ಕೊಳವೆಯನ್ನು
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,ಐಟಂ ಕೋಡ್&gt; ಐಟಂ ಗುಂಪು&gt; ಬ್ರಾಂಡ್
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,ಸಂಕ್ಷೇಪಣ ಕಡ್ಡಾಯ
 DocType: Project,Task Progress,ಟಾಸ್ಕ್ ಪ್ರೋಗ್ರೆಸ್
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,ಕಾರ್ಟ್
@@ -6435,6 +6464,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,ಪಿಓಎಸ್ ಪ್ರೊಫೈಲ್ ಪಿಓಎಸ್ ಎಂಟ್ರಿ ಮಾಡಲು ಅಗತ್ಯವಿದೆ
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",ಪ್ರಸ್ತಾಪಿಸಲಾದ ಸಂಗ್ರಹ ಅಂಶದ ಆಧಾರದ ಮೇಲೆ ಖರ್ಚು ಮಾಡಿದ (ಮಾರಾಟದ ಸರಕುಪಟ್ಟಿ ಮೂಲಕ) ನಿಷ್ಠೆ ಪಾಯಿಂಟುಗಳನ್ನು ಲೆಕ್ಕಹಾಕಲಾಗುತ್ತದೆ.
 DocType: Program Enrollment Tool,Enroll Students,ವಿದ್ಯಾರ್ಥಿಗಳು ದಾಖಲು
+DocType: Pricing Rule,Coupon Code Based,ಕೂಪನ್ ಕೋಡ್ ಆಧಾರಿತ
 DocType: Company,HRA Settings,HRA ಸೆಟ್ಟಿಂಗ್ಗಳು
 DocType: Homepage,Hero Section,ಹೀರೋ ವಿಭಾಗ
 DocType: Employee Transfer,Transfer Date,ವರ್ಗಾವಣೆ ದಿನಾಂಕ
@@ -6549,6 +6579,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',ಕಂಪನಿ ಖಾಲಿ ಫಿಲ್ಟರ್ ಸೆಟ್ ದಯವಿಟ್ಟು ಗುಂಪಿನ ಕಂಪೆನಿ &#39;ಆಗಿದೆ
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,ಪೋಸ್ಟಿಂಗ್ ದಿನಾಂಕ ಮುಂದಿನ ದಿನಾಂಕದಂದು ಸಾಧ್ಯವಿಲ್ಲ
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},ರೋ # {0}: ಸೀರಿಯಲ್ ಯಾವುದೇ {1} ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,ಸೆಟಪ್&gt; ಸಂಖ್ಯೆಯ ಸರಣಿಯ ಮೂಲಕ ಹಾಜರಾತಿಗಾಗಿ ದಯವಿಟ್ಟು ಸಂಖ್ಯೆಯ ಸರಣಿಯನ್ನು ಹೊಂದಿಸಿ
 DocType: Stock Entry,Target Warehouse Address,ಟಾರ್ಗೆಟ್ ವೇರ್ಹೌಸ್ ವಿಳಾಸ
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,ರಜೆ
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,ಶಿಫ್ಟ್ ಪ್ರಾರಂಭದ ಸಮಯದ ಮೊದಲು ನೌಕರರ ಚೆಕ್-ಇನ್ ಅನ್ನು ಹಾಜರಾತಿಗಾಗಿ ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ.
@@ -6583,7 +6614,6 @@
 DocType: Employee Grade,Employee Grade,ಉದ್ಯೋಗಿ ಗ್ರೇಡ್
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Piecework
 DocType: GSTR 3B Report,June,ಜೂನ್
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,ಸರಬರಾಜುದಾರ&gt; ಪೂರೈಕೆದಾರ ಪ್ರಕಾರ
 DocType: Share Balance,From No,ಇಲ್ಲ
 DocType: Shift Type,Early Exit Grace Period,ಆರಂಭಿಕ ನಿರ್ಗಮನ ಗ್ರೇಸ್ ಅವಧಿ
 DocType: Task,Actual Time (in Hours),(ಘಂಟೆಗಳಲ್ಲಿ) ವಾಸ್ತವ ಟೈಮ್
@@ -6866,7 +6896,6 @@
 DocType: Warehouse,Warehouse Name,ವೇರ್ಹೌಸ್ ಹೆಸರು
 DocType: Naming Series,Select Transaction,ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಆಯ್ಕೆ
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,ಪಾತ್ರ ಅನುಮೋದಿಸಲಾಗುತ್ತಿದೆ ಅಥವಾ ಬಳಕೆದಾರ ಅನುಮೋದಿಸಲಾಗುತ್ತಿದೆ ನಮೂದಿಸಿ
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},ಐಟಂಗೆ UOM ಪರಿವರ್ತನೆ ಅಂಶ ({0} -&gt; {1}) ಕಂಡುಬಂದಿಲ್ಲ: {2}
 DocType: Journal Entry,Write Off Entry,ಎಂಟ್ರಿ ಆಫ್ ಬರೆಯಿರಿ
 DocType: BOM,Rate Of Materials Based On,ಮೆಟೀರಿಯಲ್ಸ್ ಆಧರಿಸಿದ ದರ
 DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","ಸಕ್ರಿಯಗೊಳಿಸಿದಲ್ಲಿ, ಫೀಲ್ಡ್ ಅಕಾಡೆಮಿಕ್ ಟರ್ಮ್ ಪ್ರೋಗ್ರಾಂ ದಾಖಲಾತಿ ಪರಿಕರದಲ್ಲಿ ಕಡ್ಡಾಯವಾಗಿರುತ್ತದೆ."
@@ -7003,6 +7032,7 @@
 DocType: Budget,Warn,ಎಚ್ಚರಿಕೆ
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,ಈ ಕೆಲಸದ ಆದೇಶಕ್ಕಾಗಿ ಈಗಾಗಲೇ ಎಲ್ಲಾ ಐಟಂಗಳನ್ನು ವರ್ಗಾಯಿಸಲಾಗಿದೆ.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","ಯಾವುದೇ ಟೀಕೆಗಳನ್ನು, ದಾಖಲೆಗಳಲ್ಲಿ ಹೋಗಬೇಕು ಎಂದು ವಿವರಣೆಯಾಗಿದೆ ಪ್ರಯತ್ನ."
+DocType: Bank Account,Company Account,ಕಂಪನಿ ಖಾತೆ
 DocType: Asset Maintenance,Manufacturing User,ಉತ್ಪಾದನಾ ಬಳಕೆದಾರ
 DocType: Purchase Invoice,Raw Materials Supplied,ವಿತರಿಸುತ್ತಾರೆ ರಾ ಮೆಟೀರಿಯಲ್ಸ್
 DocType: Subscription Plan,Payment Plan,ಪಾವತಿ ಯೋಜನೆ
@@ -7044,6 +7074,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) ಕೆಲಸದ ಆದೇಶದಲ್ಲಿ {2} ಯೋಜಿತ ಪ್ರಮಾಣಕ್ಕಿಂತ ಹೆಚ್ಚಿನದಾಗಿರಬಾರದು {3}
 DocType: Certification Application,Name of Applicant,ಅರ್ಜಿದಾರರ ಹೆಸರು
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,ಉತ್ಪಾದನೆ ಟೈಮ್ ಶೀಟ್.
+DocType: Quick Stock Balance,Quick Stock Balance,ತ್ವರಿತ ಸ್ಟಾಕ್ ಬ್ಯಾಲೆನ್ಸ್
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,ಉಪಮೊತ್ತ
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,ಸ್ಟಾಕ್ ವ್ಯವಹಾರದ ನಂತರ ರೂಪಾಂತರ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಬದಲಾಯಿಸಲಾಗುವುದಿಲ್ಲ. ಇದನ್ನು ಮಾಡಲು ನೀವು ಹೊಸ ಐಟಂ ಅನ್ನು ಮಾಡಬೇಕಾಗುತ್ತದೆ.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,ಗೋಕಾರ್ಡರ್ಲೆಸ್ SEPA ಮ್ಯಾಂಡೇಟ್
@@ -7367,6 +7398,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} ನಿಷ್ಕ್ರಿಯ ವಿದ್ಯಾರ್ಥಿ
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} ನಿಷ್ಕ್ರಿಯ ವಿದ್ಯಾರ್ಥಿ
 DocType: Employee,Health Details,ಆರೋಗ್ಯ ವಿವರಗಳು
+DocType: Coupon Code,Coupon Type,ಕೂಪನ್ ಪ್ರಕಾರ
 DocType: Leave Encashment,Encashable days,ಎನ್ಕ್ಯಾಷಬಲ್ ದಿನಗಳು
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,ಒಂದು ಪಾವತಿ ವಿನಂತಿ ಉಲ್ಲೇಖ ಡಾಕ್ಯುಮೆಂಟ್ ಅಗತ್ಯವಿದೆ ರಚಿಸಲು
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,ಒಂದು ಪಾವತಿ ವಿನಂತಿ ಉಲ್ಲೇಖ ಡಾಕ್ಯುಮೆಂಟ್ ಅಗತ್ಯವಿದೆ ರಚಿಸಲು
@@ -7651,6 +7683,7 @@
 DocType: Hotel Room Package,Amenities,ಸೌಕರ್ಯಗಳು
 DocType: Accounts Settings,Automatically Fetch Payment Terms,ಪಾವತಿ ನಿಯಮಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪಡೆದುಕೊಳ್ಳಿ
 DocType: QuickBooks Migrator,Undeposited Funds Account,ಗುರುತಿಸಲಾಗದ ಫಂಡ್ಸ್ ಖಾತೆ
+DocType: Coupon Code,Uses,ಉಪಯೋಗಗಳು
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,ಬಹುಪಾಲು ಡೀಫಾಲ್ಟ್ ಮೋಡ್ ಅನ್ನು ಅನುಮತಿಸಲಾಗುವುದಿಲ್ಲ
 DocType: Sales Invoice,Loyalty Points Redemption,ಲಾಯಲ್ಟಿ ಪಾಯಿಂಟುಗಳು ರಿಡೆಂಪ್ಶನ್
 ,Appointment Analytics,ನೇಮಕಾತಿ ಅನಾಲಿಟಿಕ್ಸ್
@@ -7668,6 +7701,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,ನೀವು ವರ್ಷಕ್ಕೆ ವಿದ್ಯಾರ್ಥಿಗಳು ಗುಂಪುಗಳು ಮಾಡಿದರೆ ಖಾಲಿ ಬಿಡಿ
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,ನೀವು ವರ್ಷಕ್ಕೆ ವಿದ್ಯಾರ್ಥಿಗಳು ಗುಂಪುಗಳು ಮಾಡಿದರೆ ಖಾಲಿ ಬಿಡಿ
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","ಪರಿಶೀಲಿಸಿದರೆ, ಕೆಲಸ ದಿನಗಳ ಒಟ್ಟು ಯಾವುದೇ ರಜಾದಿನಗಳು ಸೇರಿವೆ , ಮತ್ತು ಈ ಸಂಬಳ ದಿನಕ್ಕೆ ಮೌಲ್ಯವನ್ನು ಕಡಿಮೆಗೊಳಿಸುತ್ತದೆ"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,ಡೊಮೇನ್ ಸೇರಿಸಲು ವಿಫಲವಾಗಿದೆ
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","ಓವರ್ ರಶೀದಿ / ವಿತರಣೆಯನ್ನು ಅನುಮತಿಸಲು, ಸ್ಟಾಕ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳು ಅಥವಾ ಐಟಂನಲ್ಲಿ &quot;ಓವರ್ ರಶೀದಿ / ವಿತರಣಾ ಭತ್ಯೆ&quot; ಅನ್ನು ನವೀಕರಿಸಿ."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","ಪ್ರಸ್ತುತ ಕೀಲಿಯನ್ನು ಬಳಸುವ ಅಪ್ಲಿಕೇಶನ್ಗಳು ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ, ನೀವು ಖಚಿತವಾಗಿರುವಿರಾ?"
 DocType: Subscription Settings,Prorate,ಪ್ರಾರ್ಥಿಸು
@@ -7681,6 +7715,7 @@
 ,BOM Stock Report,ಬಿಒಎಮ್ ಸ್ಟಾಕ್ ವರದಿ
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","ನಿಗದಿಪಡಿಸಿದ ಟೈಮ್‌ಸ್ಲಾಟ್ ಇಲ್ಲದಿದ್ದರೆ, ಈ ಗುಂಪಿನಿಂದ ಸಂವಹನವನ್ನು ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ"
 DocType: Stock Reconciliation Item,Quantity Difference,ಪ್ರಮಾಣ ವ್ಯತ್ಯಾಸ
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,ಸರಬರಾಜುದಾರ&gt; ಪೂರೈಕೆದಾರ ಪ್ರಕಾರ
 DocType: Opportunity Item,Basic Rate,ಮೂಲ ದರದ
 DocType: GL Entry,Credit Amount,ಕ್ರೆಡಿಟ್ ಪ್ರಮಾಣ
 ,Electronic Invoice Register,ಎಲೆಕ್ಟ್ರಾನಿಕ್ ಸರಕುಪಟ್ಟಿ ನೋಂದಣಿ
@@ -7934,6 +7969,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),ಕಡಿತಗೊಳಿಸಲಾಗುತ್ತದೆ ತೆರಿಗೆಗಳು ಮತ್ತು ಶುಲ್ಕಗಳು ( ಕಂಪನಿ ಕರೆನ್ಸಿ )
 DocType: Item Group,General Settings,ಸಾಮಾನ್ಯ ಸೆಟ್ಟಿಂಗ್ಗಳು
 DocType: Article,Article,ಲೇಖನ
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,ದಯವಿಟ್ಟು ಕೂಪನ್ ಕೋಡ್ ನಮೂದಿಸಿ !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,ಚಲಾವಣೆಯ ಮತ್ತು ಕರೆನ್ಸಿ ಇರಲಾಗುವುದಿಲ್ಲ
 DocType: Taxable Salary Slab,Percent Deduction,ಪರ್ಸೆಂಟ್ ಡಿಡಕ್ಷನ್
 DocType: GL Entry,To Rename,ಮರುಹೆಸರಿಸಲು
diff --git a/erpnext/translations/ko.csv b/erpnext/translations/ko.csv
index 1ff9873..ab079ea 100644
--- a/erpnext/translations/ko.csv
+++ b/erpnext/translations/ko.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT- .YYYY.-
 DocType: Purchase Order,Customer Contact,고객 연락처
 DocType: Shift Type,Enable Auto Attendance,자동 출석 사용
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,창고 및 날짜를 입력하십시오
 DocType: Lost Reason Detail,Opportunity Lost Reason,기회 손실 원인
 DocType: Patient Appointment,Check availability,이용 가능 여부 확인
 DocType: Retention Bonus,Bonus Payment Date,보너스 지급일
@@ -265,6 +266,7 @@
 ,Completed Work Orders,완료된 작업 주문
 DocType: Support Settings,Forum Posts,포럼 게시물
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage",작업이 백그라운드 작업으로 대기열에 포함되었습니다. 백그라운드에서 처리하는 데 문제가있는 경우 시스템에서이 주식 조정의 오류에 대한 설명을 추가하고 초안 단계로 되돌립니다.
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started",쿠폰 코드 유효성이 시작되지 않았습니다.
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,과세 대상 금액
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},당신은 전에 항목을 추가하거나 업데이트 할 수있는 권한이 없습니다 {0}
 DocType: Leave Policy,Leave Policy Details,정책 세부 정보 남김
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,소모품
 DocType: Student,B-,비-
 DocType: Assessment Result,Grade,학년
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,상품 코드&gt; 상품 그룹&gt; 브랜드
 DocType: Restaurant Table,No of Seats,좌석 수
 DocType: Sales Invoice,Overdue and Discounted,연체 및 할인
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,통화 끊김
@@ -507,6 +510,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,즉 양에 대한 줄 간격
 DocType: Vehicle,Additional Details,추가 세부 사항
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,주어진 설명이 없습니다
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,창고에서 물품 반입
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,구입 요청합니다.
 DocType: POS Closing Voucher Details,Collected Amount,징수 금액
 DocType: Lab Test,Submitted Date,제출 날짜
@@ -614,6 +618,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,배우다
 ,Trial Balance (Simple),시산표 (단순)
 DocType: Purchase Invoice Item,Enable Deferred Expense,지연 지출 활성화
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,적용 쿠폰 코드
 DocType: Asset,Next Depreciation Date,다음 감가 상각 날짜
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,직원 당 활동 비용
 DocType: Accounts Settings,Settings for Accounts,계정에 대한 설정
@@ -854,8 +859,6 @@
 DocType: Sales Invoice,Total Qty,총 수량
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 이메일 ID
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 이메일 ID
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","이 문서를 취소하려면 직원 <a href=""#Form/Employee/{0}"">{0}을 (를)</a> 삭제하십시오"
 DocType: Item,Show in Website (Variant),웹 사이트에 표시 (변형)
 DocType: Employee,Health Concerns,건강 문제
 DocType: Payroll Entry,Select Payroll Period,급여 기간을 선택
@@ -1021,6 +1024,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,세금 원천 징수 계정
 DocType: Pricing Rule,Sales Partner,영업 파트너
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,모든 공급자 스코어 카드.
+DocType: Coupon Code,To be used to get discount,할인을받는 데 사용
 DocType: Buying Settings,Purchase Receipt Required,필수 구입 영수증
 DocType: Sales Invoice,Rail,레일
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,실제 비용
@@ -1071,6 +1075,7 @@
 DocType: Production Plan,Production Plan,생산 계획
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,개설 송장 생성 도구
 DocType: Salary Component,Round to the Nearest Integer,가장 가까운 정수로 반올림
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,재고가없는 품목을 장바구니에 추가 할 수 있도록 허용
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,판매로 돌아 가기
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,일련 번호가없는 입력을 기준으로 트랜잭션의 수량 설정
 ,Total Stock Summary,총 주식 요약
@@ -1202,6 +1207,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),자료 시간 비율 (회사 통화)
 ,Qty To Be Billed,청구될 수량
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,납품 금액
+DocType: Coupon Code,Gift Card,기프트 카드
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,생산을위한 예비 수량 : 제조 품목을 만들기위한 원자재 수량.
 DocType: Loyalty Point Entry Redemption,Redemption Date,사용 날짜
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,이 은행 거래가 이미 완전히 조정되었습니다.
@@ -1290,6 +1296,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,작업 표 만들기
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,계정 {0} 여러 번 입력 된
 DocType: Account,Expenses Included In Valuation,비용은 평가에 포함
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,구매 송장
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,회원 자격이 30 일 이내에 만료되는 경우에만 갱신 할 수 있습니다.
 DocType: Shopping Cart Settings,Show Stock Availability,재고 상태 표시
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},자산 카테고리 {1} 또는 회사 {2}에서 {0}을 (를)
@@ -1852,6 +1859,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,항목 및 UOM 가져 오기
 DocType: Repayment Schedule,Balance Loan Amount,잔액 대출 금액
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,세부 정보에 추가됨
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted",쿠폰 코드가 소진되었습니다.
 DocType: Communication Medium,Catch All,모두 잡아라.
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,일정 코스
 DocType: Budget,Applicable on Material Request,자재 요청에 적용 가능
@@ -2022,6 +2030,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,잘못된 속성
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} 제출해야합니다
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,이메일 캠페인
+DocType: Sales Partner,To Track inbound purchase,인바운드 구매를 추적하려면
 DocType: Buying Settings,Default Supplier Group,기본 공급 업체 그룹
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},수량보다 작거나 같아야합니다 {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},{0} 구성 요소에 적합한 최대 금액이 {1}을 초과합니다.
@@ -2179,8 +2188,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,재고 항목 만들기
 DocType: Hotel Room Reservation,Hotel Reservation User,호텔 예약 사용자
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,상태 설정
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,설정&gt; 넘버링 시리즈를 통해 출석 용 넘버링 시리즈를 설정하십시오
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,첫 번째 접두사를 선택하세요
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,설정&gt; 설정&gt; 이름 지정 시리즈를 통해 이름 지정 시리즈를 {0}으로 설정하십시오.
 DocType: Contract,Fulfilment Deadline,이행 마감
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,가까운
 DocType: Student,O-,영형-
@@ -2304,6 +2313,7 @@
 DocType: Quality Meeting Table,Under Review,검토 중
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,로그인 실패
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,저작물 {0}이 생성되었습니다.
+DocType: Coupon Code,Promotional,프로모션
 DocType: Special Test Items,Special Test Items,특별 시험 항목
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,마켓 플레이스에 등록하려면 System Manager 및 Item Manager 역할이있는 사용자 여야합니다.
 apps/erpnext/erpnext/config/buying.py,Key Reports,주요 보고서
@@ -2342,6 +2352,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,문서 유형
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,영업 팀의 총 할당 비율은 100해야한다
 DocType: Subscription Plan,Billing Interval Count,청구 간격
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","이 문서를 취소하려면 직원 <a href=""#Form/Employee/{0}"">{0}을 (를)</a> 삭제하십시오"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,임명 및 환자 조우
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,가치 누락
 DocType: Employee,Department and Grade,학과 및 학년
@@ -2445,6 +2457,7 @@
 DocType: Project,Start and End Dates,시작 날짜를 종료
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,계약 템플릿 이행 조건
 ,Delivered Items To Be Billed,청구에 전달 항목
+DocType: Coupon Code,Maximum Use,최대 사용
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},열기 BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,웨어 하우스는 일련 번호 변경할 수 없습니다
 DocType: Authorization Rule,Average Discount,평균 할인
@@ -2607,6 +2620,7 @@
 DocType: Item,Inventory,재고
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Json으로 다운로드
 DocType: Item,Sales Details,판매 세부 사항
+DocType: Coupon Code,Used,익숙한
 DocType: Opportunity,With Items,항목
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',{1}의 {2} 캠페인에 대한 캠페인 &#39;{0}&#39;이 (가) 이미 있습니다.
 DocType: Asset Maintenance,Maintenance Team,유지 보수 팀
@@ -2736,7 +2750,7 @@
 						Serial No cannot be ensured",{0} 항목에 활성 BOM이 없습니다. \ Serial No 로의 배송은 보장 할 수 없습니다.
 DocType: Sales Partner,Sales Partner Target,영업 파트너 대상
 DocType: Loan Type,Maximum Loan Amount,최대 대출 금액
-DocType: Pricing Rule,Pricing Rule,가격 규칙
+DocType: Coupon Code,Pricing Rule,가격 규칙
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},학생 {0}의 중복 롤 번호
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},학생 {0}의 중복 롤 번호
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,주문을 (를) 구매하려면 자료 요청
@@ -2816,6 +2830,7 @@
 DocType: Payment Schedule,Payment Amount,결제 금액
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,반나절 날짜는 작업 시작 날짜와 종료 날짜 사이에 있어야합니다.
 DocType: Healthcare Settings,Healthcare Service Items,의료 서비스 품목
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,잘못된 바코드입니다. 이 바코드에 부착 된 품목이 없습니다.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,소비 금액
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,현금의 순 변화
 DocType: Assessment Plan,Grading Scale,등급 규모
@@ -2937,7 +2952,6 @@
 DocType: Share Transfer,Asset Account,자산 계좌
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,새로운 출시 날짜가 미래에 있어야합니다.
 DocType: Purchase Invoice,End date of current invoice's period,현재 송장의 기간의 종료 날짜
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,인사 관리&gt; HR 설정에서 직원 이름 지정 시스템을 설정하십시오
 DocType: Lab Test,Technician Name,기술자 이름
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3049,6 +3063,7 @@
 DocType: Products Settings,Hide Variants,변형 숨기기
 DocType: Lead,Next Contact By,다음 접촉
 DocType: Compensatory Leave Request,Compensatory Leave Request,보상 휴가 요청
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings",{1} 행의 {0} 항목에 {2}보다 많은 비용을 청구 할 수 없습니다. 초과 청구를 허용하려면 계정 설정에서 허용 한도를 설정하십시오.
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},상품에 필요한 수량 {0} 행에서 {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},수량이 항목에 대한 존재하는 창고 {0} 삭제할 수 없습니다 {1}
 DocType: Blanket Order,Order Type,주문 유형
@@ -3221,7 +3236,6 @@
 DocType: Student,Student Mobile Number,학생 휴대 전화 번호
 DocType: Item,Has Variants,변형을 가지고
 DocType: Employee Benefit Claim,Claim Benefit For,에 대한 보상 혜택
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings",{1} 행의 {0} 항목이 {2} 이상으로 과다 보급 될 수 없습니다. 초과 청구를 허용하려면 재고 설정에서 설정하십시오.
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,응답 업데이트
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},이미에서 항목을 선택한 {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,월별 분포의 이름
@@ -3515,6 +3529,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,회사에 통화를 지정하십시오
 DocType: Workstation,Wages per hour,시간당 임금
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},{0} 구성
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,고객&gt; 고객 그룹&gt; 지역
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},일괄 재고 잔액은 {0}이 될 것이다 부정적인 {1}의 창고에서 상품 {2}에 대한 {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,자료 요청에 이어 항목의 재 주문 레벨에 따라 자동으로 제기되고있다
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},계정 {0} 유효하지 않습니다. 계정 통화가 있어야합니다 {1}
@@ -3847,6 +3862,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,급여 슬립 제출
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,보류 중
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,퀘스트는 적어도 하나의 올바른 옵션을 가져야합니다.
+apps/erpnext/erpnext/hooks.py,Purchase Orders,구매 주문
 DocType: Account,Inter Company Account,회사 간 계정
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,대량 수입
 DocType: Sales Partner,Address & Contacts,주소 및 연락처
@@ -3857,6 +3873,7 @@
 DocType: POS Profile,[Select],[선택]
 DocType: Staffing Plan Detail,Number Of Positions,직위 수
 DocType: Vital Signs,Blood Pressure (diastolic),혈압 (확장기)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,고객을 선택하십시오.
 DocType: SMS Log,Sent To,전송
 DocType: Agriculture Task,Holiday Management,휴일 관리
 DocType: Payment Request,Make Sales Invoice,견적서에게 확인
@@ -4067,7 +4084,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} 제출되지 않았습니다.
 DocType: Subscription,Trialling,Trialling
 DocType: Sales Invoice Item,Deferred Revenue,지연된 수익
-DocType: Bank Account,GL Account,GL 계정
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,현금 계정은 판매 송장 생성에 사용됩니다.
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,면제 하위 카테고리
 DocType: Member,Membership Expiry Date,회원 자격 만료일
@@ -4493,13 +4509,13 @@
 DocType: C-Form Invoice Detail,Territory,국가
 DocType: Pricing Rule,Apply Rule On Item Code,항목 코드에 규칙 적용
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,언급 해주십시오 필요한 방문 없음
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,재고 잔고 보고서
 DocType: Stock Settings,Default Valuation Method,기본 평가 방법
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,보수
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,누적 금액 표시
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,진행중인 업데이트. 시간이 좀 걸릴 수 있습니다.
 DocType: Production Plan Item,Produced Qty,생산 수량
 DocType: Vehicle Log,Fuel Qty,연료 수량
-DocType: Stock Entry,Target Warehouse Name,대상 창고 이름
 DocType: Work Order Operation,Planned Start Time,계획 시작 시간
 DocType: Course,Assessment,평가
 DocType: Payment Entry Reference,Allocated,할당
@@ -4577,10 +4593,12 @@
  1.등 주소 분쟁, 손해 배상, 책임, 
  하나의 방법.주소 및 회사의 연락."
 DocType: Homepage Section,Section Based On,섹션 기반
+DocType: Shopping Cart Settings,Show Apply Coupon Code,쿠폰 코드 적용 표시
 DocType: Issue,Issue Type,이슈 유형
 DocType: Attendance,Leave Type,휴가 유형
 DocType: Purchase Invoice,Supplier Invoice Details,공급 업체 인보이스 세부 사항
 DocType: Agriculture Task,Ignore holidays,휴일을 무시하십시오.
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,쿠폰 조건 추가 / 편집
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,비용 / 차이 계정 ({0})의 이익 또는 손실 '계정이어야합니다
 DocType: Stock Entry Detail,Stock Entry Child,입국 어린이
 DocType: Project,Copied From,에서 복사 됨
@@ -4756,6 +4774,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,평가 계획 기준
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,업무
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,구매 주문 방지
+DocType: Coupon Code,Coupon Name,쿠폰 이름
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,느끼기 쉬운
 DocType: Email Campaign,Scheduled,예약된
 DocType: Shift Type,Working Hours Calculation Based On,근무 시간 계산에 근거
@@ -4772,7 +4791,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,변형 만들기
 DocType: Vehicle,Diesel,디젤
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,가격리스트 통화 선택하지
+DocType: Quick Stock Balance,Available Quantity,주문 가능 수량
 DocType: Purchase Invoice,Availed ITC Cess,제공되는 ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,교육&gt; 교육 설정에서 강사 명명 시스템을 설정하십시오
 ,Student Monthly Attendance Sheet,학생 월별 출석 시트
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,판매에만 적용되는 배송 규칙
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,감가 상각 행 {0} : 다음 감가 상각 날짜는 구입일 이전 일 수 없습니다.
@@ -4840,8 +4861,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,행 {0} : 고객에 대한 사전 신용해야합니다
 DocType: Quality Meeting,Quality Meeting,품질 회의
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,그룹에 비 그룹
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,설정&gt; 설정&gt; 이름 지정 시리즈를 통해 이름 지정 시리즈를 {0}으로 설정하십시오.
 DocType: Employee,ERPNext User,ERPNext 사용자
+DocType: Coupon Code,Coupon Description,쿠폰 설명
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},배치는 {0} 행에서 필수 항목입니다.
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},배치는 {0} 행에서 필수 항목입니다.
 DocType: Company,Default Buying Terms,기본 구매 조건
@@ -5006,6 +5027,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,문서의 세부 사항에 대한 없음
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},{0} 국가에서는 삭제할 수 없습니다.
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,파티의 종류는 필수입니다
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,쿠폰 코드 적용
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",구직 카드 {0}의 경우 &#39;제조를위한 자재 이전&#39;유형 재고 입력 만 할 수 있습니다
 DocType: Quality Inspection,Outgoing,발신
 DocType: Customer Feedback Table,Customer Feedback Table,고객 피드백 표
@@ -5158,7 +5180,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,구매 주문서 제출
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,모든 공급 업체 추가
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,행 번호 {0} : 할당 된 금액은 미납 금액을 초과 할 수 없습니다.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,고객&gt; 고객 그룹&gt; 지역
 DocType: Tally Migration,Parties,당사국들
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,찾아 BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,보안 대출
@@ -5190,7 +5211,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},항목 {0}에 대해 대체 항목을 설정할 수 없습니다.
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,날짜는 반복된다
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,공인 서명자
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,교육&gt; 교육 설정에서 강사 명명 시스템을 설정하십시오
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),순 ITC 가능 (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,수수료 생성
 DocType: Project,Total Purchase Cost (via Purchase Invoice),총 구매 비용 (구매 송장을 통해)
@@ -5215,6 +5235,7 @@
 DocType: Quiz Result,Wrong,잘못된
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,가격 목록의 통화는 고객의 기본 통화로 변환하는 속도에
 DocType: Purchase Invoice Item,Net Amount (Company Currency),순 금액 (회사 통화)
+DocType: Sales Partner,Referral Code,추천 코드
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,총 선불 금액은 총 승인 금액보다 클 수 없습니다.
 DocType: Salary Slip,Hour Rate,시간 비율
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,자동 재주문 사용
@@ -5345,6 +5366,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,재고 수량 표시
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,조작에서 순 현금
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},행 번호 {0} : 인보이스 할인 {2}의 상태는 {1}이어야합니다.
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},항목 {2}에 대한 UOM 변환 계수 ({0}-&gt; {1})를 찾을 수 없습니다
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,항목 4
 DocType: Student Admission,Admission End Date,입학 종료 날짜
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,하위 계약
@@ -5367,6 +5389,7 @@
 DocType: Travel Request,Fully Sponsored,후원사
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,역 분개 항목
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,작업 카드 생성
+DocType: Quotation,Referral Sales Partner,추천 영업 파트너
 DocType: Quality Procedure Process,Process Description,프로세스 설명
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,고객 {0}이 (가) 생성되었습니다.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,현재 어떤 창고에서도 재고가 없습니다.
@@ -5501,6 +5524,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM 평가
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,업로드 된 파일 읽기
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel",작업 지시 중단을 취소 할 수 없습니다. 취소하려면 먼저 취소하십시오.
+DocType: Coupon Code,Coupon Code,쿠폰 코드
 DocType: Asset,Journal Entry for Scrap,스크랩에 대한 분개
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,배달 주에서 항목을 뽑아주세요
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},행 {0} : 작업 {1}에 대한 워크 스테이션을 선택하십시오.
@@ -5585,6 +5609,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;날짜&#39;필요
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},때문에 / 참조 날짜 이후 수 없습니다 {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,데이터 가져 오기 및 내보내기
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired",쿠폰 코드 유효 기간이 만료되었습니다.
 DocType: Bank Account,Account Details,합계좌 세부사항
 DocType: Crop,Materials Required,필요한 자료
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,어떤 학생들은 찾을 수 없음
@@ -5622,6 +5647,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,사용자 이동
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,지불 금액 + 금액 오프 쓰기 총합보다 클 수 없습니다
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} 항목에 대한 유효한 배치 번호없는 {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,유효한 쿠폰 코드를 입력하십시오!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},참고 : 허가 유형에 대한 충분한 휴가 밸런스가 없습니다 {0}
 DocType: Task,Task Description,과업 설명
 DocType: Training Event,Seminar,세미나
@@ -5889,6 +5915,7 @@
 ,TDS Payable Monthly,매월 TDS 지급
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,BOM 대체 대기. 몇 분이 걸릴 수 있습니다.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',카테고리는 '평가'또는 '평가 및 전체'에 대한 때 공제 할 수 없습니다
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,인사 관리&gt; HR 설정에서 직원 이름 지정 시스템을 설정하십시오
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,총 지불액
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},직렬화 된 항목에 대한 일련 NOS 필수 {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,송장과 일치 결제
@@ -5979,6 +6006,7 @@
 DocType: Production Plan,Get Raw Materials For Production,생산 원료 확보
 DocType: Job Opening,Job Title,직책
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,향후 결제 참조
+DocType: Quotation,Additional Discount and Coupon Code,추가 할인 및 쿠폰 코드
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.",{0}은 {1}이 따옴표를 제공하지 않지만 모든 항목은 인용 된 것을 나타냅니다. RFQ 견적 상태 갱신.
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,최대 샘플 - {0}은 배치 {1}의 배치 {1} 및 항목 {2}에 대해 이미 보유되었습니다.
@@ -6208,7 +6236,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,웹 사이트 홈페이지에 대한 설정
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0}은 (는) {1}까지 보류 중입니다.
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},{1}의 스코어 카드로 인해 RFQ가 {0}에 허용되지 않습니다.
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,구매 송장 생성
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,중고 잎
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} 사용 된 쿠폰은 {1}입니다. 허용 수량이 소진되었습니다
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,자료 요청을 제출 하시겠습니까
 DocType: Job Offer,Awaiting Response,응답을 기다리는 중
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6222,6 +6252,7 @@
 DocType: Training Event Employee,Optional,선택 과목
 DocType: Salary Slip,Earning & Deduction,당기순이익/손실
 DocType: Agriculture Analysis Criteria,Water Analysis,수질 분석
+DocType: Sales Order,Skip Delivery Note,납품서 건너 뛰기
 DocType: Price List,Price Not UOM Dependent,UOM에 의존하지 않는 가격
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,변형 {0}이 생성되었습니다.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,기본 서비스 수준 계약이 이미 있습니다.
@@ -6330,6 +6361,7 @@
 DocType: Vehicle,Last Carbon Check,마지막으로 탄소 확인
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,법률 비용
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,행의 수량을 선택하십시오.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},작업 지시 {0} : 작업 {1}에 대한 작업 카드를 찾을 수 없습니다
 DocType: Purchase Invoice,Posting Time,등록시간
 DocType: Timesheet,% Amount Billed,청구 % 금액
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,전화 비용
@@ -6432,7 +6464,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,추가 세금 및 수수료
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,감가 상각 행 {0} : 다음 감가 상각 날짜는 사용 가능일 이전 일 수 없습니다.
 ,Sales Funnel,판매 퍼넬
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,상품 코드&gt; 상품 그룹&gt; 브랜드
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,약자는 필수입니다
 DocType: Project,Task Progress,작업 진행
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,카트
@@ -6528,6 +6559,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS 프로필 POS 항목을 만드는 데 필요한
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",로열티 포인트는 언급 된 징수 요인에 근거하여 완료된 지출액 (판매 송장을 통해)에서 계산됩니다.
 DocType: Program Enrollment Tool,Enroll Students,학생 등록
+DocType: Pricing Rule,Coupon Code Based,쿠폰 코드 기반
 DocType: Company,HRA Settings,HRA 설정
 DocType: Homepage,Hero Section,영웅 섹션
 DocType: Employee Transfer,Transfer Date,이전 날짜
@@ -6644,6 +6676,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',그룹화 기준이 &#39;회사&#39;인 경우 회사 필터를 비워 두십시오.
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,게시 날짜는 미래의 날짜 수 없습니다
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},행 번호 {0} : 일련 번호 {1}과 일치하지 않는 {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,설정&gt; 넘버링 시리즈를 통해 출석 용 넘버링 시리즈를 설정하십시오
 DocType: Stock Entry,Target Warehouse Address,대상 창고 주소
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,캐주얼 허가
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,직원 수표가 출석으로 간주되는 근무 시작 시간 전의 시간.
@@ -6678,7 +6711,6 @@
 DocType: Employee Grade,Employee Grade,직원 급료
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,일한 분량에 따라 공임을 지급받는 일
 DocType: GSTR 3B Report,June,유월
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,공급 업체&gt; 공급 업체 유형
 DocType: Share Balance,From No,~부터
 DocType: Shift Type,Early Exit Grace Period,조기 퇴거 유예 기간
 DocType: Task,Actual Time (in Hours),(시간) 실제 시간
@@ -6965,7 +6997,6 @@
 DocType: Warehouse,Warehouse Name,창고의 이름
 DocType: Naming Series,Select Transaction,거래 선택
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,역할을 승인 또는 사용을 승인 입력하십시오
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},항목 {2}에 대한 UOM 변환 계수 ({0}-&gt; {1})를 찾을 수 없습니다
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,엔티티 유형 {0} 및 엔티티 {1}을 (를) 사용하는 서비스 수준 계약이 이미 존재합니다.
 DocType: Journal Entry,Write Off Entry,항목 오프 쓰기
 DocType: BOM,Rate Of Materials Based On,자료에 의거 한 속도
@@ -7104,6 +7135,7 @@
 DocType: Budget,Warn,경고
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,이 작업 주문을 위해 모든 항목이 이미 전송되었습니다.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","다른 발언, 기록에 가야한다 주목할만한 노력."
+DocType: Bank Account,Company Account,회사 계정
 DocType: Asset Maintenance,Manufacturing User,제조 사용자
 DocType: Purchase Invoice,Raw Materials Supplied,공급 원료
 DocType: Subscription Plan,Payment Plan,지불 계획
@@ -7145,6 +7177,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},작업 공정 {3}에서 {0} ({1})은 계획 수량 ({2})보다 클 수 없습니다.
 DocType: Certification Application,Name of Applicant,신청자 성명
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,제조 시간 시트.
+DocType: Quick Stock Balance,Quick Stock Balance,빠른 재고 잔고
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,소계
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,주식 거래 후 Variant 속성을 변경할 수 없습니다. 이 작업을 수행하려면 새 항목을 만들어야합니다.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA 위임장
@@ -7473,6 +7506,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1}은 (는) 비활성 학생입니다.
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1}은 (는) 비활성 학생입니다.
 DocType: Employee,Health Details,건강의 자세한 사항
+DocType: Coupon Code,Coupon Type,쿠폰 종류
 DocType: Leave Encashment,Encashable days,어려운 날
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,지불 요청 참조 문서를 작성하려면 필수 항목입니다.
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,지불 요청 참조 문서를 작성하려면 필수 항목입니다.
@@ -7762,6 +7796,7 @@
 DocType: Hotel Room Package,Amenities,예의
 DocType: Accounts Settings,Automatically Fetch Payment Terms,지불 조건 자동 가져 오기
 DocType: QuickBooks Migrator,Undeposited Funds Account,Undeposited Funds Account
+DocType: Coupon Code,Uses,용도
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,여러 기본 결제 방법이 허용되지 않습니다.
 DocType: Sales Invoice,Loyalty Points Redemption,충성도 포인트 사용
 ,Appointment Analytics,약속 분석
@@ -7779,6 +7814,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,1 년에 학생 그룹을 만들면 비워 둡니다.
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,1 년에 학생 그룹을 만들면 비워 둡니다.
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","이 옵션을 선택하면 총 없음. 작업 일의 휴일을 포함하며,이 급여 당 일의 가치를 감소시킬 것이다"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,도메인을 추가하지 못했습니다
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.",수령 / 배송을 허용하려면 재고 설정 또는 품목에서 &quot;초과 수령 / 인도 수당&quot;을 업데이트하십시오.
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?",현재 키를 사용하는 앱은 액세스 할 수 없습니다. 확실합니까?
 DocType: Subscription Settings,Prorate,비례 배당
@@ -7792,6 +7828,7 @@
 ,BOM Stock Report,BOM 재고 보고서
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","할당 된 타임 슬롯이 없다면, 통신은이 그룹에 의해 처리 될 것이다"
 DocType: Stock Reconciliation Item,Quantity Difference,수량 차이
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,공급 업체&gt; 공급 업체 유형
 DocType: Opportunity Item,Basic Rate,기본 요금
 DocType: GL Entry,Credit Amount,신용 금액
 ,Electronic Invoice Register,전자 인보이스 등록
@@ -8046,6 +8083,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),차감 세금 및 수수료 (회사 통화)
 DocType: Item Group,General Settings,일반 설정
 DocType: Article,Article,조
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,쿠폰 코드를 입력하십시오 !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,통화와 통화하는 방법은 동일 할 수 없습니다
 DocType: Taxable Salary Slab,Percent Deduction,비율 공제
 DocType: GL Entry,To Rename,이름 바꾸기
diff --git a/erpnext/translations/ku.csv b/erpnext/translations/ku.csv
index 7d3f27b..af961b1 100644
--- a/erpnext/translations/ku.csv
+++ b/erpnext/translations/ku.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-YYYY-
 DocType: Purchase Order,Customer Contact,mişterî Contact
 DocType: Shift Type,Enable Auto Attendance,Beşdariya Otomatîkî çalak bike
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Ji kerema xwe Warehouse û Dîrokê binivîsin
 DocType: Lost Reason Detail,Opportunity Lost Reason,Sedema winda ya Derfet
 DocType: Patient Appointment,Check availability,Peyda bikin
 DocType: Retention Bonus,Bonus Payment Date,Daxistina Bonus Bonus
@@ -258,6 +259,7 @@
 ,Completed Work Orders,Birêvebirina Kar
 DocType: Support Settings,Forum Posts,Forum Mesaj
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Peywir wekî karekî paşverû tête peyda kirin. Digel vê yekê pirsgirêkek heye ku di paşpirtikê de pirsgirêk çêbibe, dê pergalê li ser xeletiyek li ser vê Lihevkirina Stock-ê şîroveyek zêde bike û vegere qonaxa Drav"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Bibore, derbasbûna kodê ya kodon dest pê nekiriye"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Şêwaz ber bacê
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Destûra te tune ku lê zêde bike an update entries berî {0}
 DocType: Leave Policy,Leave Policy Details,Dîtina Dîtina Bilind
@@ -322,6 +324,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,bikaranînê
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,Sinif
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Koda Babetê&gt; Koma Rêzan&gt; Brand
 DocType: Restaurant Table,No of Seats,No Seats
 DocType: Sales Invoice,Overdue and Discounted,Zêde û bêhêz kirin
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Gazî veqetandin
@@ -498,6 +501,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,spacing Line ji bo mîktarê li gotinên
 DocType: Vehicle,Additional Details,Details Additional
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,No description dayîn
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Tiştên ji Warehouse bigirin
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,ji bo kirînê bixwaze.
 DocType: POS Closing Voucher Details,Collected Amount,Amûdê Collect Collect
 DocType: Lab Test,Submitted Date,Dîroka Submitted
@@ -604,6 +608,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Fêrbûn
 ,Trial Balance (Simple),Balansek Trial (Simple)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Expansed Deferred Enabled
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Koda kodê ya sepandî
 DocType: Asset,Next Depreciation Date,Next Date Farhad.
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Cost Activity per Employee
 DocType: Accounts Settings,Settings for Accounts,Mîhengên ji bo Accounts
@@ -1003,6 +1008,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Hesabê Bacê
 DocType: Pricing Rule,Sales Partner,Partner Sales
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,All Supplier Scorecards.
+DocType: Coupon Code,To be used to get discount,Ji bo ku bikar anîn dakêşin
 DocType: Buying Settings,Purchase Receipt Required,Meqbûz kirînê pêwîst
 DocType: Sales Invoice,Rail,Hesinê tirêne
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Mesrefa rastîn
@@ -1050,6 +1056,7 @@
 DocType: Production Plan,Production Plan,Plana hilberînê
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Di Vebijandina Destûra Rêkeftinê de vekin
 DocType: Salary Component,Round to the Nearest Integer,Rêze Li Ser Niqaşê Nêzik
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Destûr bidin tiştên ku ne di stûyê xwe de ne ku bi zorê werin zêdekirin
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Return Sales
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Li Qanûna Qanûna Saziyê Hilbijêre Li ser Serial No Serial
 ,Total Stock Summary,Stock Nasname Total
@@ -1178,6 +1185,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Saet Rate Base (Company Exchange)
 ,Qty To Be Billed,Qty To Bills
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Şêwaz teslîmî
+DocType: Coupon Code,Gift Card,Diyariya Karta
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Qty Ji bo Hilberînê Qedandî: Kêmasiya madeyên xav ji bo çêkirina tiştên çêker.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Dîroka Veweşandinê
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Ev danûstendina bankê bi tevahî lihevhatî ye
@@ -1267,6 +1275,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Timesheet biafirînin
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Account {0} hatiye bicihkirin çend caran
 DocType: Account,Expenses Included In Valuation,Mesrefên di nav Valuation
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Pêşniyarên Kirînê bikirin
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Hûn dikarin tenê nûve bikin ku endametiya we di nav 30 rojan de derbas dibe
 DocType: Shopping Cart Settings,Show Stock Availability,Hilbijêre Stock Stock
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Set in {0} li kategoriya {1} de an şîrket {2}
@@ -1805,6 +1814,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Itemsêkirina Tişt û UOM-ê
 DocType: Repayment Schedule,Balance Loan Amount,Balance Loan Mîqdar
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Add to details
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Bibore, kodên kodonê pêça"
 DocType: Communication Medium,Catch All,Tev bigirtin
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Kurs de Cedwela
 DocType: Budget,Applicable on Material Request,Li ser daxwaznameya materyalê bicîh kirin
@@ -1974,6 +1984,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Pêşbîr Invalid
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} de divê bê şandin
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Kampanyayên E-nameyê
+DocType: Sales Partner,To Track inbound purchase,Ji bo şopandina kirîna hundurîn
 DocType: Buying Settings,Default Supplier Group,Default Supplier Group
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Quantity gerek kêmtir an jî wekhev be {0}
 DocType: Department Approver,Department Approver,Dezgeha nêzî
@@ -2127,8 +2138,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Navbera Stock Bikin
 DocType: Hotel Room Reservation,Hotel Reservation User,User Reservation
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Rewşa Set
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Ji kerema xwe ji hêla Tevlêbûnê&gt; Pêjeya Hejmarbûnê ve ji bo Pêvekêşandinê hejmarên hejmarê saz bikin
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Ji kerema xwe ve yekem prefix hilbijêre
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Ji kerema xwe Sêwirandina Navên foran ji bo {0} bi hêla Setup&gt; Mîhengên&gt; Navên Navnîşan saz bikin
 DocType: Contract,Fulfilment Deadline,Pêdengiya Dawî
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Li nêzê te
 DocType: Student,O-,öó
@@ -2250,6 +2261,7 @@
 DocType: Quality Meeting Table,Under Review,Di bin Review
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Têketin têkevin
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Asset {0} hat afirandin
+DocType: Coupon Code,Promotional,Pêşkêşker
 DocType: Special Test Items,Special Test Items,Tîmên Taybet
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Pêdivî ye ku hûn bikar bîne ku bikarhênerên Rêveberê Gerînendeyê û Rêveberê Rêveberê Şîfre bikin ku li ser bazarê Marketplace bikin.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Raporên sereke
@@ -2388,6 +2400,7 @@
 DocType: Project,Start and End Dates,Destpêk û dawiya Kurdî Nexşe
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Şertên Peymana Fulfillasyonê
 ,Delivered Items To Be Billed,Nawy teslîmî ye- Be
+DocType: Coupon Code,Maximum Use,Bikaranîna Maximum
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Open BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Warehouse dikarin ji bo No. Serial ne bê guhertin
 DocType: Authorization Rule,Average Discount,Average Discount
@@ -2547,6 +2560,7 @@
 DocType: Item,Inventory,Inventory
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Wekî Json dakêşin
 DocType: Item,Sales Details,Details Sales
+DocType: Coupon Code,Used,Bikaranîn
 DocType: Opportunity,With Items,bi babetî
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Kampanya &#39;{0}&#39; jixwe ji bo {1} &#39;{2}&#39; heye
 DocType: Asset Maintenance,Maintenance Team,Tîmên Parastinê
@@ -2672,7 +2686,7 @@
 						Serial No cannot be ensured",BOM-ê çalak nabe BİXWÎNE {0}. Beriya \ \ Serial Na Nabe ku misoger nekin
 DocType: Sales Partner,Sales Partner Target,Sales Partner Target
 DocType: Loan Type,Maximum Loan Amount,Maximum Mîqdar Loan
-DocType: Pricing Rule,Pricing Rule,Rule Pricing
+DocType: Coupon Code,Pricing Rule,Rule Pricing
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},hejmara roll Pekana ji bo xwendekarê {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},hejmara roll Pekana ji bo xwendekarê {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Daxwaza madî ji bo Buy Order
@@ -2750,6 +2764,7 @@
 DocType: Payment Schedule,Payment Amount,Amûrdayê
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Dîroka Dîroka Dîroka Dîroka Dîroka Dîroka Navend û Dîroka Dawî be
 DocType: Healthcare Settings,Healthcare Service Items,Xizmetên tendurustî yên tenduristî
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Barcode xelet e. Li ser vê barcode ve ti tişt girêdayî ne.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Şêwaz telef
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Change Net di Cash
 DocType: Assessment Plan,Grading Scale,pîvanê de
@@ -2867,7 +2882,6 @@
 DocType: Share Transfer,Asset Account,Hesabê Assist
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Dîroka berdana nû divê di pêşerojê de be
 DocType: Purchase Invoice,End date of current invoice's period,roja dawî ji dema fatûra niha ya
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Ji kerema xwe di Resavkaniya Mirovan de&gt; Sîstema Nomisyonkirina Karmendan saz bikin&gt; Mîhengên HR
 DocType: Lab Test,Technician Name,Nûnerê Teknîkî
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3146,7 +3160,6 @@
 DocType: Student,Student Mobile Number,Xwendekarên Hejmara Mobile
 DocType: Item,Has Variants,has Variants
 DocType: Employee Benefit Claim,Claim Benefit For,Ji bo Mafê Mirovan
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Ji hêla {2} di rêza {1} de ji hêla {2} ve tête navnîşan nabe. Ji bo destûrkirina barkirinê, kerema xwe li Stock Settings"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Response Update
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Jixwe te tomar ji hilbijartî {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Name ji Belavkariya Ayda
@@ -3435,6 +3448,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Ji kerema xwe ve pereyan li Company diyar
 DocType: Workstation,Wages per hour,"Mûçe, di saetekê de"
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Configure {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Mişterî&gt; Koma Xerîdar&gt; Herêm
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},balance Stock li Batch {0} dê bibe neyînî {1} ji bo babet {2} li Warehouse {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Piştî Requests Material hatine automatically li ser asta re-da babete rabûye
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Account {0} ne derbasdar e. Account Exchange divê {1}
@@ -3766,6 +3780,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Submit Slip Salary
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Li Hold
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Qusyonek divê bi kêmanî yek vebijarkên rast be
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Ordanên Kirînê
 DocType: Account,Inter Company Account,Kompaniya Inter Inter
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Import li Gir
 DocType: Sales Partner,Address & Contacts,Navnîşana &amp; Têkilî
@@ -3776,6 +3791,7 @@
 DocType: POS Profile,[Select],[Neqandin]
 DocType: Staffing Plan Detail,Number Of Positions,Hejmarên Pirtûka
 DocType: Vital Signs,Blood Pressure (diastolic),Pressure Pressure (diastolic)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Ji kerema xwe xerîdar hilbijêrin.
 DocType: SMS Log,Sent To,şandin To
 DocType: Agriculture Task,Holiday Management,Management Management
 DocType: Payment Request,Make Sales Invoice,Make Sales bi fatûreyên
@@ -3982,7 +3998,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} ji pêşkêşkirî ne
 DocType: Subscription,Trialling,Tîma
 DocType: Sales Invoice Item,Deferred Revenue,Revenue Deferred
-DocType: Bank Account,GL Account,Hesabê GL
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Hesabê kredê dê ji bo afirandina afirandina Înfiroşa Sales Sales
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Kategorî Sub Submission
 DocType: Member,Membership Expiry Date,Endamê Dîroka Dawîbûnê
@@ -4380,13 +4395,13 @@
 DocType: C-Form Invoice Detail,Territory,Herêm
 DocType: Pricing Rule,Apply Rule On Item Code,Li ser Koda Koda Rêzikê bicîh bikin
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Ji kerema xwe re tu ji serdanên pêwîst behsa
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Raporta Bilindiya Stock
 DocType: Stock Settings,Default Valuation Method,Default Method Valuation
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Xerc
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Amûdê Amûdê bide
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Pêşkeftina pêşveçûnê. Ew dibe ku demekê bigirin.
 DocType: Production Plan Item,Produced Qty,Qutkirî Qty
 DocType: Vehicle Log,Fuel Qty,Qty mazotê
-DocType: Stock Entry,Target Warehouse Name,Navê Navnîşa Navnîşana Navnîşan
 DocType: Work Order Operation,Planned Start Time,Bi plan Time Start
 DocType: Course,Assessment,Bellîkirinî
 DocType: Payment Entry Reference,Allocated,veqetandin
@@ -4452,10 +4467,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","Termên Standard û mercan ku dikare ji bo Sales û kirîna added. Nimûne: 1. Validity ji pêşniyarê. 1. Mercên Payment (Di Advance, Li ser Credit, part pêşwext û hwd.). 1. çi extra (an sûdî ji aliyê Mişterî) e. 1. Safety warning / Bikaranîna. 1. Warranty, eger. 1. Policy Þexsî. 1. Mercên shipping, eger hebin. 1. Riyên çareserkirina nakokiyan, hêlekê, berpirsiyarî, hwd 1. Address û Contact ji Company xwe."
 DocType: Homepage Section,Section Based On,Beş li ser bingeha
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Afirandin Koda Coupon
 DocType: Issue,Issue Type,Tîpa Nimûne
 DocType: Attendance,Leave Type,Type Leave
 DocType: Purchase Invoice,Supplier Invoice Details,Supplier Details bi fatûreyên
 DocType: Agriculture Task,Ignore holidays,Betlaneyê bibînin
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Addertên Kuponê zêde bikin / biguherînin
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"account Expense / Cudahiya ({0}), divê hesabekî &#39;Profit an Loss&#39; be"
 DocType: Stock Entry Detail,Stock Entry Child,Zarok ketina Stock
 DocType: Project,Copied From,Kopiyek ji From
@@ -4626,6 +4643,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Şertên Plan Nirxandina
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Transactions
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Pêşniyarên kirînê bikujin
+DocType: Coupon Code,Coupon Name,Navê kodikê
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Neheq
 DocType: Email Campaign,Scheduled,scheduled
 DocType: Shift Type,Working Hours Calculation Based On,Demjimêrên Karkirina Hêlîna Bingehîn
@@ -4642,7 +4660,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Variantan biafirînin
 DocType: Vehicle,Diesel,Diesel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,List Price Exchange hilbijartî ne
+DocType: Quick Stock Balance,Available Quantity,Hêjmarek peyda dike
 DocType: Purchase Invoice,Availed ITC Cess,ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Ji kerema xwe Li Perwerde&gt; Mîhengên Perwerdehiyê Sîstema Navnekirina Sêwiran saz bikin
 ,Student Monthly Attendance Sheet,Xwendekarên mihasebeya Beşdariyê Ayda
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Qanûna Rêvebirin tenê tenê ji bo firotina kirînê
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Berê Nerazîbûnê Rûber {0}: Piştre Dîroka Nirxandina Dîroka Berî Berê kirîna Dîroka
@@ -4710,8 +4730,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,"Row {0}: Advance dijî Mişterî, divê credit be"
 DocType: Quality Meeting,Quality Meeting,Civîna Quality
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-Pol to Group
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Ji kerema xwe Sêwirandina Navên foran ji bo {0} bi hêla Setup&gt; Mîhengên&gt; Navên Navnîşan bikin
 DocType: Employee,ERPNext User,ERPNext Bikarhêner
+DocType: Coupon Code,Coupon Description,Danasîna Cupon
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Batch li row wêneke e {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Batch li row wêneke e {0}
 DocType: Company,Default Buying Terms,Mercên Kirînê yên Default
@@ -4873,6 +4893,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Li dijî Detail dokumênt No
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Deletion ji bo welatekî destûr nabe {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Type Partiya wêneke e
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Koda kodê bicîh bikin
 DocType: Quality Inspection,Outgoing,nikarbe
 DocType: Customer Feedback Table,Customer Feedback Table,Tabloya Bersivê Xerîdar
 apps/erpnext/erpnext/config/support.py,Service Level Agreement.,Peymana asta karûbarê karûbarê.
@@ -5022,7 +5043,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Li ser radestkirina Fermana Kirînê
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,All Suppliers
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Row # {0}: butçe ne dikarin bibin mezintir mayî bidin.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Mişterî&gt; Koma Xerîdar&gt; Herêm
 DocType: Tally Migration,Parties,Partî
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Browse BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,"Loans temînatê,"
@@ -5043,6 +5063,7 @@
 DocType: Appraisal,Appraisal,Qinetbirrînî
 DocType: Loan,Loan Account,Account
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Valid from and valid upto fields are mandatory for the cumulative,Qanûnên derbasdar û derbasdar ji bo akumulkirinê mecbûrî ne
+apps/erpnext/erpnext/stock/doctype/pick_list/pick_list.py,"For item {0} at row {1}, count of serial numbers does not match with the picked quantity","Ji bo tiştên {0} di rêza {1} de, jimara hejmarên serial bi hêjeya bijartî re nayê hev"
 DocType: Purchase Invoice,GST Details,GST Dîtin
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,This is based on transactions against this Healthcare Practitioner.,Ev li ser tedbîrên li dijî Pratîsyona Tenduristiyê ya bingehîn e.
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Email sent to supplier {0},"Email şandin, da ku dabînkerê {0}"
@@ -5053,7 +5074,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Ne destûrê ji bo tiştek alternatîf hilbijêre {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Date tê dubarekirin
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,mafdar
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Ji kerema xwe Li Perwerde&gt; Mîhengên Perwerdehiyê Sîstema Nomisandina Sêwiran saz bikin
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Net ITC ITapkirî (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Pêvek çêbikin
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Total Cost Purchase (via Purchase bi fatûreyên)
@@ -5078,6 +5098,7 @@
 DocType: Quiz Result,Wrong,Qelp
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Rate li ku currency list Price ji bo pereyan base mişterî bîya
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Şêwaz Net (Company Exchange)
+DocType: Sales Partner,Referral Code,Koda referansê
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Hêjeya pêşniyarê heya hema ji hejmarê vekirî ya bêtir mezintirîn
 DocType: Salary Slip,Hour Rate,Saet Rate
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Re-Fermandariya Otomatê çalak bikin
@@ -5227,6 +5248,7 @@
 DocType: Travel Request,Fully Sponsored,Fully Sponsored
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Navnîşana rojnamevanê veguhestin
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Karta Xebatê biafirînin
+DocType: Quotation,Referral Sales Partner,Partner Firotan Referral
 DocType: Quality Procedure Process,Process Description,Danasîna pêvajoyê
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Têkilî {0} hatiye afirandin.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Niha tu firotek li her wareyê heye
@@ -5357,6 +5379,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM Rate
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Pelê Uploaded-ê xwendin
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Karta Karûbarê Rawestandin Tête qedexekirin, yekemîn betal bike ku ji bo betal bike"
+DocType: Coupon Code,Coupon Code,Koda kodê
 DocType: Asset,Journal Entry for Scrap,Peyam di Journal ji bo Scrap
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Ji kerema xwe tomar ji Delivery Têbînî vekişîne
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Row {0}: Li dijî xebatê {1}
@@ -5437,6 +5460,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;Dîrok&#39; pêdivî ye
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Date ji ber / Çavkanî ne dikarin piştî be {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Data Import û Export
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Bibore, derbasbûna kodê ya kodonê qedandiye"
 DocType: Bank Account,Account Details,Agahdariyên Hesab
 DocType: Crop,Materials Required,Materyalên pêwîst
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,No xwendekarên dîtin.Di
@@ -5474,6 +5498,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Herin Bikarhênerên
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,pereyan + hewe Off Mîqdar ne dikarin bibin mezintir Grand Total
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} e a Number Batch derbasdar e ji bo vî babetî bi {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Ji kerema xwe kodê kodê ya derbasdar derbas bikin !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Têbînî: e balance îzna bes ji bo Leave Type tune ne {0}
 DocType: Task,Task Description,Danasîna Task
 DocType: Training Event,Seminar,Semîner
@@ -5739,6 +5764,7 @@
 ,TDS Payable Monthly,TDS Tenê Monthly
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Ji bo guhertina BOM. Ew dikare çend deqeyan bistînin.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',ne dikarin dadixînin dema kategoriyê e ji bo &#39;Valuation&#39; an jî &#39;Valuation û Total&#39;
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Ji kerema xwe di Resavkaniya Mirovan de&gt; Sîstema Nomisyonkirina Karmendan saz bikin
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Tezmînat Total
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serial Nos pêwîst ji bo vî babetî weşandin {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Payments Match bi fatûreyên
@@ -5827,6 +5853,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Ji bo hilberîna hilberan
 DocType: Job Opening,Job Title,Manşeta şolê
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Dravê Pêşerojê Ref
+DocType: Quotation,Additional Discount and Coupon Code,Daxuyaniya Zêdetir û Koda Coupon
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} nîşan dide ku {1} dê nirxandin nekirî, lê hemî tiştan \ nirxandin. Guherandinên RFQê radigihîne."
 DocType: Manufacturing Settings,Update BOM Cost Automatically,Bom Costa xwe bixweber bike
@@ -6050,6 +6077,7 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Mîhengên ji bo homepage malpera
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} heta ku li {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ ji bo {1} ji bila {0} ji bo karmendek ji
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Pêşnûmeya Kirînê Bikin
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Leaves Used
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Ma hûn dixwazin daxwaziya materyalê bişînin
 DocType: Job Offer,Awaiting Response,li benda Response
@@ -6064,6 +6092,7 @@
 DocType: Training Event Employee,Optional,Bixwe
 DocType: Salary Slip,Earning & Deduction,Maaş &amp; dabirîna
 DocType: Agriculture Analysis Criteria,Water Analysis,Analysis
+DocType: Sales Order,Skip Delivery Note,Derketinê Têbînî
 DocType: Price List,Price Not UOM Dependent,Buhayê Ne girêdayî UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,Guhertin {0}.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Berê Peymana Asta Xizmeta Berê heye.
@@ -6269,7 +6298,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Bac û tawana Ev babete ji layê
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Berê Nerazîbûnê Rûber {0}: Piştre Dîroka Nirxandina Berî Berî Berî Berî Bikaranîna Dîrok-pey-be
 ,Sales Funnel,govekeke Sales
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Koda Babetê&gt; Koma Rêzan&gt; Brand
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Abbreviation wêneke e
 DocType: Project,Task Progress,Task Progress
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Ereboka destan
@@ -6364,6 +6392,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS Profile pêwîst ji bo Peyam POS
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Points of loyalty will be calculated ((via via Sales Invoice), ji hêla faktora kolektîfê re behsa kirê ye."
 DocType: Program Enrollment Tool,Enroll Students,kul Xwendekarên
+DocType: Pricing Rule,Coupon Code Based,Li gorî Koda Kuponê
 DocType: Company,HRA Settings,HRA Settings
 DocType: Homepage,Hero Section,Beşa Hero
 DocType: Employee Transfer,Transfer Date,Transfer Date
@@ -6478,6 +6507,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Xêra xwe Company wêr&#39;a vala eger Pol By e &#39;Company&#39;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Deaktîv bike Date nikare bibe dîroka pêşerojê de
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: Serial No {1} nayê bi hev nagirin {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Ji kerema xwe ji hêla Tevlêbûnê&gt; Pêjeya Hejmarbûnê ve ji bo Pêvekêşandinê hejmarên hejmarê saz bikin
 DocType: Stock Entry,Target Warehouse Address,Navnîşana Navnîşana Warehouse
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Leave Casual
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,Wexta dema destpêkê ya guhartinê de dema ku Navnîşa Karmendê ji bo beşdarbûnê tête hesibandin.
@@ -6512,7 +6542,6 @@
 DocType: Employee Grade,Employee Grade,Dibistana
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Piecework
 DocType: GSTR 3B Report,June,Pûşper
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Hilberîner&gt; Tîpa pêşkêşkar
 DocType: Share Balance,From No,Ji Na
 DocType: Shift Type,Early Exit Grace Period,Serdema Grace Exit zû
 DocType: Task,Actual Time (in Hours),Time rastî (di Hours)
@@ -6778,6 +6807,7 @@
 DocType: Item Price,Item Price,Babetê Price
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Soap & Detergent,Sabûn &amp; Detergent
 DocType: BOM,Show Items,Show babetî
+apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.py,Duplicate Tax Declaration of {0} for period {1},Daxuyaniya Daxuyaniya Bacê ya {0} ji bo {1}
 apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py,From Time cannot be greater than To Time.,Ji Time ne dikarin bibin mezintir To Time.
 apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Do you want to notify all the customers by email?,Ma hûn dixwazin ku hemî mişteriyan bi e-nameyê agahdar bikin?
 DocType: Subscription Plan,Billing Interval,Navendiya Navîn
@@ -6932,6 +6962,7 @@
 DocType: Budget,Warn,Gazîgîhandin
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Hemû tiştên ku ji ber vê yekê ji bo Karê Karker ve hatibû veguhestin.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Bęjeyek ji axaftinên din jî, hewldana wê xalê de, ku divê di qeydên here."
+DocType: Bank Account,Company Account,Hesabê şîrketê
 DocType: Asset Maintenance,Manufacturing User,manufacturing Bikarhêner
 DocType: Purchase Invoice,Raw Materials Supplied,Madeyên xav Supplied
 DocType: Subscription Plan,Payment Plan,Plana Payan
@@ -6973,6 +7004,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) ji hêla plana plankirî ({2}) ji hêla Karê Karker {3}
 DocType: Certification Application,Name of Applicant,Navekî Serêdanê
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Bîlançoya Time ji bo febrîkayan.
+DocType: Quick Stock Balance,Quick Stock Balance,Balyozxaneya Bilez Zû
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Subtotal
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Ji ber veguhastina veberhênanên variant veguherînin nikare guhertin. Divê hûn nifşek nû çêbikin ku ev bikin.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,Rêveberiya SEPA GoCardless
@@ -7295,6 +7327,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} Xwendekarê neçalak e
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} Xwendekarê neçalak e
 DocType: Employee,Health Details,Details Health
+DocType: Coupon Code,Coupon Type,Tîpa Cupon
 DocType: Leave Encashment,Encashable days,Rojan nabe
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Ji bo afirandina daxwaza Payment belge referansa pêwîst e
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Ji bo afirandina daxwaza Payment belge referansa pêwîst e
@@ -7576,6 +7609,7 @@
 DocType: Hotel Room Package,Amenities,Amenities
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Allyertên Dravê bixweber Bawer bikin
 DocType: QuickBooks Migrator,Undeposited Funds Account,Hesabê Hesabê Bêguman
+DocType: Coupon Code,Uses,Uses
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Modeya piralî ya pêdivî ye ku pêdivî ye
 DocType: Sales Invoice,Loyalty Points Redemption,Redemption Points
 ,Appointment Analytics,Analytics
@@ -7593,6 +7627,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Vala bihêlin eger tu şaşiyekê komên xwendekarên her salê
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Vala bihêlin eger tu şaşiyekê komên xwendekarên her salê
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Eger kontrolkirin, Total tune. ji Xebatê Rojan wê de betlaneyên xwe, û em ê bi nirxê Salary Per Day kêm"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Domain nekêşand
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Ji bo destûrdayîn / teslîmkirina bihêlin, Di &quot;Settings Stock&quot; an &quot;Tiştê&quot; de &quot;Over Receipt / Allowance Delivery&quot; nûve bikin."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Vebijêrkên key-ê bikar bînin ku dê nikaribin gihîştin destûr, ma hûn rast bin?"
 DocType: Subscription Settings,Prorate,Prorate
@@ -7606,6 +7641,7 @@
 ,BOM Stock Report,BOM Stock Report
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Ger demsalek nehatibe diyarkirin, wê hingê ragihandinê ji hêla vê komê ve were rêve birin"
 DocType: Stock Reconciliation Item,Quantity Difference,Cudahiya di Diravan
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Hilberîner&gt; Tîpa pêşkêşkar
 DocType: Opportunity Item,Basic Rate,Rate bingehîn
 DocType: GL Entry,Credit Amount,Şêwaz Credit
 ,Electronic Invoice Register,Xeydêkerê Belavkirina Elektronîkî
@@ -7858,6 +7894,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Bac û doz li dabirîn (Company Exchange)
 DocType: Item Group,General Settings,Mîhengên giştî
 DocType: Article,Article,Tişt
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Ji kerema xwe kodê kodê binivîse !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Ji Exchange û To Exchange ne dikarin heman
 DocType: Taxable Salary Slab,Percent Deduction,Perçûna Perê
 DocType: GL Entry,To Rename,Navnav kirin
diff --git a/erpnext/translations/lo.csv b/erpnext/translations/lo.csv
index 960ef15..e7349a4 100644
--- a/erpnext/translations/lo.csv
+++ b/erpnext/translations/lo.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-YYYY.-
 DocType: Purchase Order,Customer Contact,ຕິດຕໍ່ລູກຄ້າ
 DocType: Shift Type,Enable Auto Attendance,ເປີດໃຊ້ງານອັດຕະໂນມັດການເຂົ້າຮ່ວມ
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,ກະລຸນາໃສ່ສາງແລະວັນທີ
 DocType: Lost Reason Detail,Opportunity Lost Reason,ໂອກາດ ໝົດ ເຫດຜົນ
 DocType: Patient Appointment,Check availability,ກວດເບິ່ງທີ່ມີຢູ່
 DocType: Retention Bonus,Bonus Payment Date,ວັນຈ່າຍເງິນໂບນັດ
@@ -265,6 +266,7 @@
 ,Completed Work Orders,ຄໍາສັ່ງເຮັດວຽກສໍາເລັດແລ້ວ
 DocType: Support Settings,Forum Posts,Forum Posts
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","ວຽກງານດັ່ງກ່າວໄດ້ຖືກຮວບຮວມເປັນວຽກພື້ນຖານ. ໃນກໍລະນີມີບັນຫາກ່ຽວກັບການປະມວນຜົນໃນພື້ນຫລັງ, ລະບົບຈະເພີ່ມ ຄຳ ເຫັນກ່ຽວກັບຂໍ້ຜິດພາດກ່ຽວກັບຫຼັກຊັບຫຸ້ນຄືນນີ້ແລະກັບຄືນສູ່ຂັ້ນຕອນຮ່າງ"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","ຂໍໂທດ, ລະຫັດຄູປອງຍັງບໍ່ໄດ້ເລີ່ມຕົ້ນ"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,ຈໍານວນພາສີ
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},ເຈົ້າຍັງບໍ່ໄດ້ອະນຸຍາດໃຫ້ເພີ່ມຫຼືການປັບປຸງການອອກສຽງກ່ອນ {0}
 DocType: Leave Policy,Leave Policy Details,ອອກຈາກລາຍລະອຽດຂອງນະໂຍບາຍ
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,ຜູ້ບໍລິໂພກ
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,Grade
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,ລະຫັດສິນຄ້າ&gt; ກຸ່ມລາຍການ&gt; ຍີ່ຫໍ້
 DocType: Restaurant Table,No of Seats,ບໍ່ມີບ່ອນນັ່ງ
 DocType: Sales Invoice,Overdue and Discounted,ເກີນ ກຳ ນົດແລະຫຼຸດລາຄາ
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,ໂທຕັດການເຊື່ອມຕໍ່
@@ -507,6 +510,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,ສະຖານທີ່ອອນໄລນ໌ສໍາລັບການຈໍານວນເງິນໃນຄໍາສັບຕ່າງໆ
 DocType: Vehicle,Additional Details,ລາຍລະອຽດເພີ່ມເຕີມ
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,ບໍ່ໄດ້ຮັບການອະທິບາຍ
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,ເກັບເອົາສິ່ງຂອງຈາກສາງ
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,ຮ້ອງຂໍໃຫ້ມີສໍາລັບການຊື້.
 DocType: POS Closing Voucher Details,Collected Amount,ຈໍານວນເງິນທີ່ໄດ້ເກັບກໍາ
 DocType: Lab Test,Submitted Date,Submitted Date
@@ -614,6 +618,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,ຮຽນຮູ້
 ,Trial Balance (Simple),ການດຸ່ນດ່ຽງການທົດລອງ (ງ່າຍດາຍ)
 DocType: Purchase Invoice Item,Enable Deferred Expense,ເປີດໃຊ້ງານຄ່າໃຊ້ຈ່າຍໄລຍະຍາວ
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,ໃຊ້ລະຫັດຄູປອງ
 DocType: Asset,Next Depreciation Date,ຕໍ່ໄປວັນທີ່ຄ່າເສື່ອມລາຄາ
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,ຄ່າໃຊ້ຈ່າຍຂອງກິດຈະກໍາຕໍ່ພະນັກງານ
 DocType: Accounts Settings,Settings for Accounts,ການຕັ້ງຄ່າສໍາລັບການບັນຊີ
@@ -854,8 +859,6 @@
 DocType: Sales Invoice,Total Qty,ທັງຫມົດຈໍານວນ
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,ລະຫັດອີເມວ Guardian2
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,ລະຫັດອີເມວ Guardian2
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","ກະລຸນາລຶບພະນັກງານ <a href=""#Form/Employee/{0}"">{0}</a> \ ເພື່ອຍົກເລີກເອກະສານນີ້"
 DocType: Item,Show in Website (Variant),ສະແດງໃຫ້ເຫັນໃນເວັບໄຊທ໌ (Variant)
 DocType: Employee,Health Concerns,ຄວາມກັງວົນສຸຂະພາບ
 DocType: Payroll Entry,Select Payroll Period,ເລືອກ Payroll ໄລຍະເວລາ
@@ -1021,6 +1024,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,ບັນຊີອອມຊັບພາສີ
 DocType: Pricing Rule,Sales Partner,Partner ຂາຍ
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,ທັງຫມົດ scorecards Supplier.
+DocType: Coupon Code,To be used to get discount,ເພື່ອໃຊ້ໃນການຮັບສ່ວນຫຼຸດ
 DocType: Buying Settings,Purchase Receipt Required,ຊື້ຮັບທີ່ກໍານົດໄວ້
 DocType: Sales Invoice,Rail,ລົດໄຟ
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,ຄ່າໃຊ້ຈ່າຍຕົວຈິງ
@@ -1071,6 +1075,7 @@
 DocType: Production Plan,Production Plan,ແຜນການຜະລິດ
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,ເປີດເຄື່ອງມືການສ້າງໃບເກັບເງິນ
 DocType: Salary Component,Round to the Nearest Integer,ມົນກັບການເຊື່ອມໂຍງໃກ້ທີ່ສຸດ
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,ອະນຸຍາດໃຫ້ເອົາສິນຄ້າທີ່ບໍ່ຢູ່ໃນສິນຄ້າເຂົ້າໄປໃນກະຕ່າ
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Return ຂາຍ
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,ຕັ້ງຄ່າ Qty ໃນການປະຕິບັດການໂດຍອີງໃສ່ການນໍາເຂົ້າບໍ່ມີ Serial
 ,Total Stock Summary,ທັງຫມົດສະຫຼຸບ Stock
@@ -1202,6 +1207,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),ຖານອັດຕາຊົ່ວໂມງ (ບໍລິສັດສະກຸນເງິນ)
 ,Qty To Be Billed,Qty ທີ່ຈະຖືກເກັບເງິນ
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,ຈໍານວນເງິນສົ່ງ
+DocType: Coupon Code,Gift Card,ບັດຂອງຂວັນ
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Qty ສຳ ລັບການຜະລິດ: ຈຳ ນວນວັດຖຸດິບເພື່ອຜະລິດເປັນສິນຄ້າ.
 DocType: Loyalty Point Entry Redemption,Redemption Date,ວັນທີ່ຖືກໄຖ່
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,ການເຮັດທຸລະ ກຳ ຂອງທະນາຄານນີ້ແມ່ນມີການຄືນດີກັນແລ້ວ
@@ -1291,6 +1297,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,ສ້າງ Timesheet
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,ບັນຊີ {0} ໄດ້ຮັບການປ້ອນເວລາຫຼາຍ
 DocType: Account,Expenses Included In Valuation,ຄ່າໃຊ້ຈ່າຍລວມຢູ່ໃນການປະເມີນຄ່າ
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,ໃບຮັບເງິນຊື້
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,ທ່ານພຽງແຕ່ສາມາດຕໍ່ອາຍຸຖ້າວ່າສະມາຊິກຂອງທ່ານຫມົດອາຍຸພາຍໃນ 30 ວັນ
 DocType: Shopping Cart Settings,Show Stock Availability,Show Availability Availability
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},ຕັ້ງ {0} ໃນຫມວດສິນຊັບ {1} ຫຼືບໍລິສັດ {2}
@@ -1834,6 +1841,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,ການ ນຳ ເຂົ້າສິນຄ້າແລະ UOMs
 DocType: Repayment Schedule,Balance Loan Amount,ການດຸ່ນດ່ຽງຈໍານວນເງິນກູ້
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,ເພີ່ມເຂົ້າໃນລາຍລະອຽດ
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","ຂໍໂທດ, ລະຫັດຄູປອງ ໝົດ ແລ້ວ"
 DocType: Communication Medium,Catch All,ຈັບທັງ ໝົດ
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,ຂອງລາຍວິຊາກໍານົດເວລາ
 DocType: Budget,Applicable on Material Request,ສາມາດໃຊ້ໄດ້ກັບການຮ້ອງຂໍວັດສະດຸ
@@ -2004,6 +2012,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,ຄຸນລັກສະນະທີ່ບໍ່ຖືກຕ້ອງ
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} ຕ້ອງໄດ້ຮັບການສົ່ງ
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,ການໂຄສະນາທາງອີເມວ
+DocType: Sales Partner,To Track inbound purchase,ເພື່ອຕິດຕາມການຊື້ຂາເຂົ້າ
 DocType: Buying Settings,Default Supplier Group,Default Supplier Group
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},ປະລິມານຈະຕ້ອງຫນ້ອຍກ່ວາຫຼືເທົ່າກັບ {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},ຈໍານວນເງິນທີ່ສູງສຸດມີເງື່ອນໄຂສໍາລັບອົງປະກອບ {0} ເກີນ {1}
@@ -2161,8 +2170,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,ເຮັດໃຫ້ການເຂົ້າຫຸ້ນ
 DocType: Hotel Room Reservation,Hotel Reservation User,Hotel Reservation User
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,ຕັ້ງສະຖານະພາບ
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,ກະລຸນາຕິດຕັ້ງຊຸດ ໝາຍ ເລກ ສຳ ລັບການເຂົ້າຮຽນຜ່ານການຕັ້ງຄ່າ&gt; ເລກ ລຳ ດັບ
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,ກະລຸນາເລືອກຄໍານໍາຫນ້າທໍາອິດ
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,ກະລຸນາຕັ້ງຊຸດການໃສ່ຊື່ ສຳ ລັບ {0} ຜ່ານການຕັ້ງຄ່າ&gt; ການຕັ້ງຄ່າ&gt; ຊຸດການຕັ້ງຊື່
 DocType: Contract,Fulfilment Deadline,Fulfillment Deadline
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,ໃກ້ທ່ານ
 DocType: Student,O-,O-
@@ -2286,6 +2295,7 @@
 DocType: Quality Meeting Table,Under Review,ພາຍໃຕ້ການທົບທວນ
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,ບໍ່ສາມາດເຂົ້າສູ່ລະບົບໄດ້
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Asset {0} ສ້າງ
+DocType: Coupon Code,Promotional,ການໂຄສະນາ
 DocType: Special Test Items,Special Test Items,Special Test Items
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,ທ່ານຈໍາເປັນຕ້ອງເປັນຜູ້ໃຊ້ທີ່ມີລະບົບຈັດການລະບົບແລະການຈັດການ Item Manager ເພື່ອລົງທະບຽນໃນ Marketplace.
 apps/erpnext/erpnext/config/buying.py,Key Reports,ບົດລາຍງານທີ່ ສຳ ຄັນ
@@ -2324,6 +2334,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,ປະເພດ Doc
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,ອັດຕາສ່ວນການຈັດສັນທັງຫມົດສໍາລັບທີມງານການຂາຍຄວນຈະເປັນ 100
 DocType: Subscription Plan,Billing Interval Count,ໄລຍະເວລາການເອີ້ນເກັບເງິນ
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","ກະລຸນາລຶບພະນັກງານ <a href=""#Form/Employee/{0}"">{0}</a> \ ເພື່ອຍົກເລີກເອກະສານນີ້"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,ການນັດຫມາຍແລະການພົບກັບຜູ້ເຈັບ
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,ມູນຄ່າທີ່ຂາດຫາຍໄປ
 DocType: Employee,Department and Grade,ກົມແລະຊັ້ນຮຽນ
@@ -2427,6 +2439,7 @@
 DocType: Project,Start and End Dates,ເລີ່ມຕົ້ນແລະສິ້ນສຸດວັນທີ່
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,ຂໍ້ກໍານົດການປະຕິບັດຕາມແບບຟອມສັນຍາ
 ,Delivered Items To Be Billed,ການສົ່ງຈະ billed
+DocType: Coupon Code,Maximum Use,ການ ນຳ ໃຊ້ສູງສຸດ
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},ເປີດ BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Warehouse ບໍ່ສາມາດມີການປ່ຽນແປງສໍາລັບການສະບັບເລກທີ Serial
 DocType: Authorization Rule,Average Discount,ສ່ວນລົດສະເລ່ຍປະຈໍາ
@@ -2588,6 +2601,7 @@
 DocType: Item,Inventory,ສິນຄ້າຄົງຄັງ
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,ດາວໂຫລດເປັນ Json
 DocType: Item,Sales Details,ລາຍລະອຽດການຂາຍ
+DocType: Coupon Code,Used,ໃຊ້ແລ້ວ
 DocType: Opportunity,With Items,ມີລາຍການ
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',ແຄມເປນ &#39;{0}&#39; ມີແລ້ວ ສຳ ລັບ {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,ທີມບໍາລຸງຮັກສາ
@@ -2717,7 +2731,7 @@
 						Serial No cannot be ensured",ບໍ່ພົບ BOM ທີ່ມີການເຄື່ອນໄຫວສໍາລັບລາຍການ {0}. ການຈັດສົ່ງໂດຍ \ Serial No ບໍ່ສາມາດຮັບປະກັນໄດ້
 DocType: Sales Partner,Sales Partner Target,Sales Partner ເປົ້າຫມາຍ
 DocType: Loan Type,Maximum Loan Amount,ຈໍານວນເງິນກູ້ສູງສຸດ
-DocType: Pricing Rule,Pricing Rule,ກົດລະບຽບການຕັ້ງລາຄາ
+DocType: Coupon Code,Pricing Rule,ກົດລະບຽບການຕັ້ງລາຄາ
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},ຈໍານວນມ້ວນຊ້ໍາກັນສໍາລັບນັກຮຽນ {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},ຈໍານວນມ້ວນຊ້ໍາກັນສໍາລັບນັກຮຽນ {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,ຂໍອຸປະກອນການການສັ່ງຊື້
@@ -2797,6 +2811,7 @@
 DocType: Payment Schedule,Payment Amount,ຈໍານວນການຊໍາລະເງິນ
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,ວັນທີເຄິ່ງວັນຄວນຢູ່ໃນລະຫວ່າງວັນທີເຮັດວຽກແລະວັນທີເຮັດວຽກ
 DocType: Healthcare Settings,Healthcare Service Items,Health Care Service Items
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,ລະຫັດບາໂຄດບໍ່ຖືກຕ້ອງ. ມັນບໍ່ມີລາຍການທີ່ຕິດກັບລະຫັດນີ້.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,ຈໍານວນການບໍລິໂພກ
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,ການປ່ຽນແປງສຸດທິໃນເງິນສົດ
 DocType: Assessment Plan,Grading Scale,ຂະຫນາດການຈັດລໍາດັບ
@@ -2918,7 +2933,6 @@
 DocType: Share Transfer,Asset Account,ບັນຊີຊັບສິນ
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,ວັນປ່ອຍລຸ້ນ ໃໝ່ ຄວນຈະເປັນໃນອະນາຄົດ
 DocType: Purchase Invoice,End date of current invoice's period,ວັນທີໃນຕອນທ້າຍຂອງໄລຍະເວລາໃບເກັບເງິນໃນປັດຈຸບັນ
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,ກະລຸນາຕິດຕັ້ງລະບົບການຕັ້ງຊື່ພະນັກງານໃນຊັບພະຍາກອນມະນຸດ&gt; ການຕັ້ງຄ່າ HR
 DocType: Lab Test,Technician Name,ຊື່ Technician
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3030,6 +3044,7 @@
 DocType: Products Settings,Hide Variants,ເຊື່ອງ Variants
 DocType: Lead,Next Contact By,ຕິດຕໍ່ຕໍ່ໄປໂດຍ
 DocType: Compensatory Leave Request,Compensatory Leave Request,ຄໍາຮ້ອງຂໍການສະເຫນີຄ່າຊົດເຊີຍ
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","ບໍ່ສາມາດ overbill ສຳ ລັບລາຍການ {0} ໃນແຖວ {1} ເກີນ {2}. ເພື່ອອະນຸຍາດການເອີ້ນເກັບເງິນເກີນ, ກະລຸນາ ກຳ ນົດເງິນອຸດ ໜູນ ໃນການຕັ້ງຄ່າບັນຊີ"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},ປະລິມານທີ່ກໍານົດໄວ້ສໍາລັບລາຍການ {0} ຕິດຕໍ່ກັນ {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Warehouse {0} ບໍ່ສາມາດໄດ້ຮັບການລຶບເປັນປະລິມານທີ່ມີຢູ່ສໍາລັບລາຍການ {1}
 DocType: Blanket Order,Order Type,ປະເພດຄໍາສັ່ງ
@@ -3202,7 +3217,6 @@
 DocType: Student,Student Mobile Number,ຈໍານວນໂທລະສັບມືຖືນັກສຶກສາ
 DocType: Item,Has Variants,ມີ Variants
 DocType: Employee Benefit Claim,Claim Benefit For,Claim Benefit For
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","ບໍ່ສາມາດ overbill ສໍາລັບລາຍການ {0} ໃນແຖວ {1} ຫຼາຍກວ່າ {2}. ເພື່ອອະນຸຍາດໃຫ້ການອອກໃບຢັ້ງຢືນໃນໄລຍະຍາວ, ກະລຸນາຕັ້ງຄ່າ Stock Settings"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,ການປັບປຸງການຕອບສະຫນອງ
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},ທ່ານໄດ້ຄັດເລືອກເອົາແລ້ວລາຍການຈາກ {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,ຊື່ຂອງການແຜ່ກະຈາຍລາຍເດືອນ
@@ -3495,6 +3509,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,ກະລຸນາລະບຸສະກຸນເງິນໃນບໍລິສັດ
 DocType: Workstation,Wages per hour,ຄ່າແຮງງານຕໍ່ຊົ່ວໂມງ
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},ຕັ້ງຄ່າ {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,ລູກຄ້າ&gt; ກຸ່ມລູກຄ້າ&gt; ອານາເຂດ
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Stock ຄວາມສົມດູນໃນ Batch {0} ຈະກາຍເປັນກະທົບທາງລົບ {1} ສໍາລັບລາຍການ {2} ທີ່ Warehouse {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,ປະຕິບັດຕາມການຮ້ອງຂໍການວັດສະດຸໄດ້ຮັບການຍົກຂຶ້ນມາອັດຕະໂນມັດອີງຕາມລະດັບ Re: ສັ່ງຊື້ສິນຄ້າຂອງ
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},ບັນຊີ {0} ບໍ່ຖືກຕ້ອງ. ບັນຊີສະກຸນເງິນຈະຕ້ອງ {1}
@@ -3828,6 +3843,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,ຍື່ນສະເຫນີການ Slip ເງິນເດືອນ
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,On Hold
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,ອາລົມດີຕ້ອງມີຢ່າງ ໜ້ອຍ ໜຶ່ງ ຕົວເລືອກທີ່ຖືກຕ້ອງ
+apps/erpnext/erpnext/hooks.py,Purchase Orders,ສັ່ງຊື້
 DocType: Account,Inter Company Account,Inter Company Account
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,ການນໍາເຂົ້າໃນການເປັນກຸ່ມ
 DocType: Sales Partner,Address & Contacts,ທີ່ຢູ່ແລະຕິດຕໍ່ພົວພັນ
@@ -3838,6 +3854,7 @@
 DocType: POS Profile,[Select],[ເລືອກ]
 DocType: Staffing Plan Detail,Number Of Positions,ຈໍານວນຕໍາແຫນ່ງ
 DocType: Vital Signs,Blood Pressure (diastolic),ຄວາມດັນເລືອດ (Diastolic)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,ກະລຸນາເລືອກລູກຄ້າ.
 DocType: SMS Log,Sent To,ຖືກສົ່ງໄປ
 DocType: Agriculture Task,Holiday Management,ການຄຸ້ມຄອງພັກຜ່ອນ
 DocType: Payment Request,Make Sales Invoice,ເຮັດໃຫ້ຍອດຂາຍ Invoice
@@ -4048,7 +4065,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} ບໍ່ໄດ້ສົ່ງ
 DocType: Subscription,Trialling,Trialling
 DocType: Sales Invoice Item,Deferred Revenue,ລາຍໄດ້ທີ່ຄ້າງຊໍາລະ
-DocType: Bank Account,GL Account,ບັນຊີ GL
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,ບັນຊີເງິນສົດຈະນໍາໃຊ້ສໍາລັບການສ້າງໃບເກັບເງິນຂາຍ
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,ຫມວດສິນຄ້າຍ່ອຍຍົກເວັ້ນ
 DocType: Member,Membership Expiry Date,ສະມາຊິກເວລາຫມົດອາຍຸ
@@ -4455,13 +4471,13 @@
 DocType: C-Form Invoice Detail,Territory,ອານາເຂດຂອງ
 DocType: Pricing Rule,Apply Rule On Item Code,ນຳ ໃຊ້ກົດລະບຽບໃນລາຍການ
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,ກະລຸນາທີ່ບໍ່ມີການໄປຢ້ຽມຢາມທີ່ຕ້ອງການ
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,ລາຍງານຍອດຫຸ້ນ
 DocType: Stock Settings,Default Valuation Method,ວິທີການປະເມີນມູນຄ່າໃນຕອນຕົ້ນ
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,ຄ່າບໍລິການ
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,ສະແດງຈໍານວນສະສົມ
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,ປັບປຸງໃນຄວາມຄືບຫນ້າ. ມັນອາດຈະໃຊ້ເວລາໃນຂະນະທີ່.
 DocType: Production Plan Item,Produced Qty,ຜະລິດ Qty
 DocType: Vehicle Log,Fuel Qty,ນໍ້າມັນເຊື້ອໄຟຈໍານວນ
-DocType: Stock Entry,Target Warehouse Name,Target Warehouse Name
 DocType: Work Order Operation,Planned Start Time,ເວລາການວາງແຜນ
 DocType: Course,Assessment,ການປະເມີນຜົນ
 DocType: Payment Entry Reference,Allocated,ການຈັດສັນ
@@ -4527,10 +4543,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","ເງື່ອນໄຂມາດຕະຖານແລະເງື່ອນໄຂທີ່ສາມາດໄດ້ຮັບການເພີ່ມການຂາຍແລະການຊື້. ຕົວຢ່າງ: 1. ຄວາມຖືກຕ້ອງຂອງການສະເຫນີຂອງ. 1 ເງື່ອນໄຂການຊໍາລະເງິນ (ລ່ວງຫນ້າ, ກ່ຽວກັບການປ່ອຍສິນເຊື່ອ, ສ່ວນລ່ວງຫນ້າແລະອື່ນໆ). 1. ມີຫຍັງແດ່ເປັນພິເສດ (ຫຼືຈ່າຍໂດຍການລູກຄ້າ). 1 ຄວາມປອດໄພການເຕືອນໄພ / ການນໍາໃຊ້. 1 ຮັບປະກັນຖ້າມີ. 1 ຜົນໄດ້ຮັບນະໂຍບາຍ. 1 ເງື່ອນໄຂຂອງການຂົນສົ່ງ, ຖ້າຫາກວ່າສາມາດນໍາໃຊ້. 1 ວິທີການແກ້ໄຂຂໍ້ຂັດແຍ່ງ, ຕິຕົກລົງ, ຄວາມຮັບຜິດຊອບ, ແລະອື່ນໆ 1 ທີ່ຢູ່ແລະຕິດຕໍ່ບໍລິສັດຂອງທ່ານ."
 DocType: Homepage Section,Section Based On,ພາກສ່ວນອີງໃສ່
+DocType: Shopping Cart Settings,Show Apply Coupon Code,ສະແດງລະຫັດຄູປອງ
 DocType: Issue,Issue Type,ປະເພດບັນຫາ
 DocType: Attendance,Leave Type,ປະເພດອອກຈາກ
 DocType: Purchase Invoice,Supplier Invoice Details,Supplier ລາຍລະອຽດໃບເກັບເງິນ
 DocType: Agriculture Task,Ignore holidays,Ignore holidays
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,ເພີ່ມ / ແກ້ໄຂເງື່ອນໄຂຄູປອງ
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,ບັນຊີຄ່າໃຊ້ຈ່າຍ / ຄວາມແຕກຕ່າງ ({0}) ຈະຕ້ອງບັນຊີກໍາໄຮຫລືຂາດທຶນ &#39;
 DocType: Stock Entry Detail,Stock Entry Child,ເດັກເຂົ້າ
 DocType: Project,Copied From,ຄັດລອກຈາກ
@@ -4706,6 +4724,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,ເງື່ອນໄຂການປະເມີນຜົນ
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Transactions
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,ປ້ອງກັນບໍ່ໃຫ້ໃບສັ່ງຊື້
+DocType: Coupon Code,Coupon Name,ຊື່ຄູປອງ
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,ຫນ້າຢ້ານ
 DocType: Email Campaign,Scheduled,ກໍານົດ
 DocType: Shift Type,Working Hours Calculation Based On,ການຄິດໄລ່ຊົ່ວໂມງເຮັດວຽກໂດຍອີງໃສ່
@@ -4722,7 +4741,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,ສ້າງ Variants
 DocType: Vehicle,Diesel,Diesel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,ລາຄາສະກຸນເງິນບໍ່ໄດ້ເລືອກ
+DocType: Quick Stock Balance,Available Quantity,ຈຳ ນວນທີ່ມີ
 DocType: Purchase Invoice,Availed ITC Cess,ໄດ້ຮັບສິນຄ້າ ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,ກະລຸນາຕິດຕັ້ງລະບົບການຕັ້ງຊື່ຜູ້ສອນໃນການສຶກສາ&gt; ການຕັ້ງຄ່າການສຶກສາ
 ,Student Monthly Attendance Sheet,ນັກສຶກສາ Sheet ເຂົ້າຮ່ວມລາຍເດືອນ
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,ກົດລະບຽບການສົ່ງສິນຄ້າໃຊ້ໄດ້ສໍາລັບການຂາຍ
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,ໄລຍະຫັກຄ່າທໍານຽມ {0}: ວັນທີເສຍຄ່າໃຊ້ຈ່າຍຕໍ່ໄປບໍ່ສາມາດກ່ອນວັນຊື້
@@ -4790,8 +4811,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,ຕິດຕໍ່ກັນ {0}: Advance ຕໍ່ລູກຄ້າຈະຕ້ອງເປັນການປ່ອຍສິນເຊື່ອ
 DocType: Quality Meeting,Quality Meeting,ກອງປະຊຸມຄຸນນະພາບ
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,ທີ່ບໍ່ແມ່ນກຸ່ມ Group
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,ກະລຸນາຕັ້ງຊຸດການໃສ່ຊື່ ສຳ ລັບ {0} ຜ່ານການຕັ້ງຄ່າ&gt; ການຕັ້ງຄ່າ&gt; ຊຸດການຕັ້ງຊື່
 DocType: Employee,ERPNext User,ERPNext User
+DocType: Coupon Code,Coupon Description,ລາຍລະອຽດຄູປອງ
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},batch ເປັນຂໍ້ບັງຄັບໃນການຕິດຕໍ່ກັນ {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},batch ເປັນຂໍ້ບັງຄັບໃນການຕິດຕໍ່ກັນ {0}
 DocType: Company,Default Buying Terms,ເງື່ອນໄຂການຊື້ແບບເລີ່ມຕົ້ນ
@@ -4956,6 +4977,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,ຕໍ່ຂໍ້ມູນເອກະສານທີ່ບໍ່ມີ
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},ການຍົກເລີກບໍ່ໄດ້ຮັບອະນຸຍາດສໍາລັບປະເທດ {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,ປະເພດບຸກຄົນທີ່ບັງຄັບ
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,ສະ ໝັກ ລະຫັດຄູປອງ
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","ສຳ ລັບບັດວຽກ {0}, ທ່ານພຽງແຕ່ສາມາດເຮັດຫຸ້ນປະເພດ &#39;ການໂອນຍ້າຍເອກະສານ ສຳ ລັບການຜະລິດ&#39;"
 DocType: Quality Inspection,Outgoing,ລາຍຈ່າຍ
 DocType: Customer Feedback Table,Customer Feedback Table,ຕາຕະລາງ ຄຳ ຕິຊົມຂອງລູກຄ້າ
@@ -5108,7 +5130,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,ກ່ຽວກັບການຍື່ນສະ ເໜີ ການສັ່ງຊື້
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,ຕື່ມການສະຫນອງທັງຫມົດ
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,ແຖວ # {0}: ຈັດສັນຈໍານວນບໍ່ສາມາດຈະມີຫຼາຍຂຶ້ນກ່ວາປະລິມານທີ່ຍັງຄ້າງຄາ.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,ລູກຄ້າ&gt; ກຸ່ມລູກຄ້າ&gt; ອານາເຂດ
 DocType: Tally Migration,Parties,ພາກສ່ວນຕ່າງໆ
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Browse BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,ກູ້ໄພ
@@ -5140,7 +5161,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},ບໍ່ອະນຸຍາດໃຫ້ຕັ້ງຄ່າລາຍການທາງເລືອກສໍາລັບລາຍການ {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,ວັນທີ່ຖືກຊ້ໍາ
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,ລົງນາມອະນຸຍາດ
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,ກະລຸນາຕັ້ງລະບົບການຕັ້ງຊື່ຜູ້ສອນໃນການສຶກສາ&gt; ການຕັ້ງຄ່າການສຶກສາ
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),ມີ ITC ສຸດທິ (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,ສ້າງຄ່າທໍານຽມ
 DocType: Project,Total Purchase Cost (via Purchase Invoice),ມູນຄ່າທັງຫມົດຊື້ (ຜ່ານຊື້ Invoice)
@@ -5165,6 +5185,7 @@
 DocType: Quiz Result,Wrong,ຜິດ
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,ອັດຕາການທີ່ສະເຫນີລາຄາສະກຸນເງິນຈະປ່ຽນເປັນສະກຸນເງິນຂອງລູກຄ້າຂອງພື້ນຖານ
 DocType: Purchase Invoice Item,Net Amount (Company Currency),ຈໍານວນສຸດທິ (ບໍລິສັດສະກຸນເງິນ)
+DocType: Sales Partner,Referral Code,ລະຫັດການສົ່ງຕໍ່
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,ຈໍານວນເງິນລ່ວງຫນ້າທັງຫມົດບໍ່ສາມາດຈະສູງກວ່າຈໍານວນເງິນທີ່ຖືກລົງໂທດທັງຫມົດ
 DocType: Salary Slip,Hour Rate,ອັດຕາຊົ່ວໂມງ
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,ເປີດໃຊ້ການສັ່ງຊື້ຄືນອັດຕະໂນມັດ
@@ -5295,6 +5316,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Show Quantity Quantity
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,ເງິນສົດສຸດທິຈາກການດໍາເນີນວຽກ
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},ແຖວ # {0}: ສະຖານະພາບຕ້ອງເປັນ {1} ສຳ ລັບການຫຼຸດຄ່າໃບແຈ້ງຫນີ້ {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},ປັດໄຈການປ່ຽນ UOM ({0} -&gt; {1}) ບໍ່ພົບ ສຳ ລັບລາຍການ: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,ຂໍ້ 4
 DocType: Student Admission,Admission End Date,ເປີດປະຕູຮັບວັນທີ່ສິ້ນສຸດ
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,ອະນຸສັນຍາ
@@ -5317,6 +5339,7 @@
 DocType: Travel Request,Fully Sponsored,Fully Sponsored
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Reverse Journal Entry
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,ສ້າງບັດວຽກ
+DocType: Quotation,Referral Sales Partner,ຄູ່ຄ້າການສົ່ງຕໍ່
 DocType: Quality Procedure Process,Process Description,ລາຍລະອຽດຂອງຂະບວນການ
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,ລູກຄ້າ {0} ຖືກສ້າງຂຶ້ນ.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,ໃນປະຈຸບັນບໍ່ມີຫຼັກຊັບໃນຄັງສິນຄ້າໃດໆ
@@ -5451,6 +5474,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM ອັດຕາ
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,ອ່ານໄຟລ໌ທີ່ຖືກອັບໂຫລດ
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","ບໍ່ສາມາດຍົກເລີກການຍົກເລີກການສັ່ງວຽກໄດ້, ຍົກເລີກທໍາອິດໃຫ້ຍົກເລີກ"
+DocType: Coupon Code,Coupon Code,ລະຫັດຄູປອງ
 DocType: Asset,Journal Entry for Scrap,ວາລະສານການອອກສຽງ Scrap
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,ກະລຸນາດຶງລາຍການຈາກການສົ່ງເງິນ
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},ແຖວ {0}: ເລືອກເອົາສະຖານທີ່ເຮັດວຽກຕໍ່ການດໍາເນີນງານ {1}
@@ -5535,6 +5559,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;ວັນທີ&#39; ແມ່ນ ຈຳ ເປັນ
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},ກໍາຫນົດ / Reference ບໍ່ສາມາດໄດ້ຮັບຫຼັງຈາກ {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,ນໍາເຂົ້າຂໍ້ມູນແລະສົ່ງອອກ
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","ຂໍໂທດ, ລະຫັດຄູປອງໄດ້ ໝົດ ອາຍຸແລ້ວ"
 DocType: Bank Account,Account Details,ລາຍລະອຽດບັນຊີ
 DocType: Crop,Materials Required,ວັດສະດຸທີ່ຕ້ອງການ
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,ບໍ່ພົບຂໍ້ມູນນັກສຶກສາ
@@ -5572,6 +5597,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,ໄປທີ່ຜູ້ໃຊ້
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,ຈໍານວນເງິນທີ່ຊໍາລະເງິນ + ຂຽນ Off ຈໍານວນເງິນບໍ່ສາມາດຈະຫຼາຍກ່ວາຈໍານວນທັງຫມົດ
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} ບໍ່ແມ່ນຈໍານວນ Batch ຖືກຕ້ອງສໍາລັບສິນຄ້າ {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,ກະລຸນາໃສ່ລະຫັດຄູປອງທີ່ຖືກຕ້ອງ !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},ຫມາຍເຫດ: ຍັງບໍ່ທັນມີຄວາມສົມດູນອອກພຽງພໍສໍາລັບການອອກຈາກປະເພດ {0}
 DocType: Task,Task Description,ລາຍລະອຽດວຽກງານ
 DocType: Training Event,Seminar,ການສໍາມະນາ
@@ -5839,6 +5865,7 @@
 ,TDS Payable Monthly,TDS ຕ້ອງຈ່າຍລາຍເດືອນ
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,ວາງສາຍສໍາລັບການທົດແທນ BOM. ມັນອາດຈະໃຊ້ເວລາສອງສາມນາທີ.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',ບໍ່ສາມາດຫັກໃນເວລາທີ່ປະເພດແມ່ນສໍາລັບການ &#39;ປະເມີນມູນຄ່າ&#39; ຫຼື &#39;ການປະເມີນຄ່າແລະທັງຫມົດ&#39;
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,ກະລຸນາຕິດຕັ້ງລະບົບການຕັ້ງຊື່ພະນັກງານໃນຊັບພະຍາກອນມະນຸດ&gt; ການຕັ້ງຄ່າ HR
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,ຈ່າຍລວມ
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serial Nos ຕ້ອງການສໍາລັບລາຍການຕໍ່ເນື່ອງ {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,ການຊໍາລະເງິນກົງກັບໃບແຈ້ງຫນີ້
@@ -5929,6 +5956,7 @@
 DocType: Production Plan,Get Raw Materials For Production,ເອົາວັດຖຸດິບສໍາລັບການຜະລິດ
 DocType: Job Opening,Job Title,ຕໍາແຫນ່ງ
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,ການ ຊຳ ລະເງິນໃນອະນາຄົດ
+DocType: Quotation,Additional Discount and Coupon Code,ຫຼຸດລາຄາແລະລະຫັດຄູປອງເພີ່ມເຕີມ
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} ຊີ້ໃຫ້ເຫັນວ່າ {1} ຈະບໍ່ໃຫ້ຢືມ, ແຕ່ລາຍການທັງຫມົດ \ ໄດ້ຖືກບາຍດີທຸກ. ການປັບປຸງສະຖານະພາບ RFQ quote ໄດ້."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,ຕົວຢ່າງທີ່ສູງສຸດ - {0} ໄດ້ຖືກເກັບຮັກສາໄວ້ສໍາລັບຊຸດ {1} ແລະລາຍການ {2} ໃນຈໍານວນ {3}.
@@ -6158,7 +6186,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,ການຕັ້ງຄ່າສໍາລັບຫນ້າທໍາອິດຂອງເວັບໄຊທ໌
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} ແມ່ນລໍຖ້າຈົນກວ່າ {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQs ຍັງບໍ່ໄດ້ອະນຸຍາດໃຫ້ສໍາລັບການ {0} ເນື່ອງຈາກການນຸ່ງປະຈໍາດັດນີຊີ້ວັດຂອງ {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,ເຮັດໃບເກັບເງິນຊື້
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Used Leaves
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} ຄູປອງທີ່ໃຊ້ແມ່ນ {1}. ປະລິມານທີ່ອະນຸຍາດ ໝົດ ແລ້ວ
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,ທ່ານຕ້ອງການສົ່ງ ຄຳ ຮ້ອງຂໍເອກະສານ
 DocType: Job Offer,Awaiting Response,ລັງລໍຖ້າການຕອບໂຕ້
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-yYYY.-
@@ -6172,6 +6202,7 @@
 DocType: Training Event Employee,Optional,ທາງເລືອກ
 DocType: Salary Slip,Earning & Deduction,ທີ່ໄດ້ຮັບແລະການຫັກ
 DocType: Agriculture Analysis Criteria,Water Analysis,ການວິເຄາະນ້ໍາ
+DocType: Sales Order,Skip Delivery Note,ຂ້າມຫມາຍເຫດສົ່ງ
 DocType: Price List,Price Not UOM Dependent,ລາຄາບໍ່ແມ່ນຂຶ້ນກັບ UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} variants ສ້າງ.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,ຂໍ້ຕົກລົງລະດັບການບໍລິການໃນຕອນຕົ້ນມີຢູ່ແລ້ວ.
@@ -6280,6 +6311,7 @@
 DocType: Vehicle,Last Carbon Check,Check Carbon ຫຼ້າສຸດ
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,ຄ່າໃຊ້ຈ່າຍດ້ານກົດຫມາຍ
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,ກະລຸນາເລືອກປະລິມານກ່ຽວກັບການຕິດຕໍ່ກັນ
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},ໃບສັ່ງການເຮັດວຽກ {0}: ບັດວຽກບໍ່ພົບ ສຳ ລັບການ ດຳ ເນີນງານ {1}
 DocType: Purchase Invoice,Posting Time,ເວລາທີ່ປະກາດ
 DocType: Timesheet,% Amount Billed,% ຈໍານວນເງິນບິນ
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,ຄ່າໃຊ້ຈ່າຍທາງໂທລະສັບ
@@ -6382,7 +6414,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,ພາສີອາກອນແລະຄ່າບໍລິການເພີ່ມ
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,ໄລຍະຫັກຄ່າທໍານຽມ {0}: ວັນທີຄ່າເສື່ອມລາຄາຕໍ່ໄປບໍ່ສາມາດຢູ່ໃນວັນທີ່ມີຢູ່
 ,Sales Funnel,ຊ່ອງທາງການຂາຍ
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,ລະຫັດສິນຄ້າ&gt; ກຸ່ມລາຍການ&gt; ຍີ່ຫໍ້
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,ຊື່ຫຍໍ້ເປັນການບັງຄັບ
 DocType: Project,Task Progress,ຄວາມຄືບຫນ້າວຽກງານ
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,ໂຄງຮ່າງການ
@@ -6478,6 +6509,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS ຂໍ້ມູນທີ່ຕ້ອງການເພື່ອເຮັດໃຫ້ POS Entry
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","ຈຸດເຄົາລົບຈະຖືກຄໍານວນຈາກການໃຊ້ຈ່າຍ (ຜ່ານໃບເກັບເງິນການຂາຍ), ອີງໃສ່ປັດໄຈການເກັບກໍາທີ່ໄດ້ກ່າວມາ."
 DocType: Program Enrollment Tool,Enroll Students,ລົງທະບຽນນັກສຶກສາ
+DocType: Pricing Rule,Coupon Code Based,ລະຫັດຄູປອງອີງ
 DocType: Company,HRA Settings,ການຕັ້ງຄ່າ HRA
 DocType: Homepage,Hero Section,ສ່ວນພະເອກ
 DocType: Employee Transfer,Transfer Date,ວັນທີໂອນ
@@ -6594,6 +6626,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',ກະລຸນາຕັ້ງບໍລິສັດກັ່ນຕອງ blank ຖ້າ Group By ແມ່ນ &#39;Company&#39;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,ວັນທີ່ບໍ່ສາມາດເປັນວັນໃນອະນາຄົດ
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},"ຕິດຕໍ່ກັນ, {0}: ບໍ່ມີ Serial {1} ບໍ່ກົງກັບ {2} {3}"
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,ກະລຸນາຕິດຕັ້ງຊຸດ ໝາຍ ເລກ ສຳ ລັບການເຂົ້າຮຽນຜ່ານການຕັ້ງຄ່າ&gt; ເລກ ລຳ ດັບ
 DocType: Stock Entry,Target Warehouse Address,Target Warehouse Address
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,ອອກຈາກການບາດເຈັບແລະ
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,ເວລາກ່ອນເວລາການປ່ຽນວຽກຈະເລີ່ມໃນໄລຍະທີ່ການເຂົ້າເຮັດວຽກຂອງພະນັກງານຈະຖືກພິຈາລະນາເຂົ້າຮ່ວມ.
@@ -6628,7 +6661,6 @@
 DocType: Employee Grade,Employee Grade,ລະດັບພະນັກງານ
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,ເຫມົາ
 DocType: GSTR 3B Report,June,ມິຖຸນາ
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,ຜູ້ສະ ໜອງ ສິນຄ້າ&gt; ປະເພດຜູ້ສະ ໜອງ ສິນຄ້າ
 DocType: Share Balance,From No,ຈາກ No
 DocType: Shift Type,Early Exit Grace Period,ໄລຍະເວລາ Grace ອອກກ່ອນໄວອັນຄວນ
 DocType: Task,Actual Time (in Hours),ທີ່ໃຊ້ເວລາຕົວຈິງ (ໃນຊົ່ວໂມງ)
@@ -6915,7 +6947,6 @@
 DocType: Warehouse,Warehouse Name,ຊື່ Warehouse
 DocType: Naming Series,Select Transaction,ເລືອກເຮັດທຸລະກໍາ
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,ກະລຸນາໃສ່ອະນຸມັດການພາລະບົດບາດຫຼືອະນຸມັດຜູ້ໃຊ້
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},ປັດໄຈການປ່ຽນ UOM ({0} -&gt; {1}) ບໍ່ພົບ ສຳ ລັບລາຍການ: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,ຂໍ້ຕົກລົງລະດັບການບໍລິການກັບປະເພດຫົວ ໜ່ວຍ {0} ແລະ ໜ່ວຍ ງານ {1} ມີຢູ່ແລ້ວ.
 DocType: Journal Entry,Write Off Entry,ຂຽນ Off Entry
 DocType: BOM,Rate Of Materials Based On,ອັດຕາຂອງວັດສະດຸພື້ນຖານກ່ຽວກັບ
@@ -7054,6 +7085,7 @@
 DocType: Budget,Warn,ເຕືອນ
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,ລາຍການທັງຫມົດໄດ້ຖືກຍົກຍ້າຍແລ້ວສໍາລັບຄໍາສັ່ງການເຮັດວຽກນີ້.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","ໃດຂໍ້ສັງເກດອື່ນໆ, ຄວາມພະຍາຍາມສັງເກດວ່າຄວນຈະຢູ່ໃນບັນທຶກດັ່ງກ່າວ."
+DocType: Bank Account,Company Account,ບັນຊີບໍລິສັດ
 DocType: Asset Maintenance,Manufacturing User,ຜູ້ໃຊ້ການຜະລິດ
 DocType: Purchase Invoice,Raw Materials Supplied,ວັດຖຸດິບທີ່ຈໍາຫນ່າຍ
 DocType: Subscription Plan,Payment Plan,ແຜນການຈ່າຍເງິນ
@@ -7095,6 +7127,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) ບໍ່ສາມາດຈະສູງກວ່າປະລິມານທີ່ວາງໄວ້ ({2}) ໃນຄໍາສັ່ງເຮັດວຽກ {3}
 DocType: Certification Application,Name of Applicant,ຊື່ຜູ້ສະຫມັກ
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Sheet ທີ່ໃຊ້ເວລາສໍາລັບການຜະລິດ.
+DocType: Quick Stock Balance,Quick Stock Balance,ຍອດຫຸ້ນດ່ວນ
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,ການເພີ່ມເຕີມ
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,ບໍ່ສາມາດປ່ຽນແປງຄຸນສົມບັດ Variant ຫຼັງຈາກການຊື້ຂາຍຫຼັກຊັບ. ທ່ານຈະຕ້ອງສ້າງລາຍການໃຫມ່ເພື່ອເຮັດສິ່ງນີ້.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA Mandate
@@ -7423,6 +7456,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} ແມ່ນນັກສຶກສາ inactive
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} ແມ່ນນັກສຶກສາ inactive
 DocType: Employee,Health Details,ລາຍລະອຽດສຸຂະພາບ
+DocType: Coupon Code,Coupon Type,ປະເພດຄູປອງ
 DocType: Leave Encashment,Encashable days,ວັນເຂົ້າກັນໄດ້
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,ເພື່ອສ້າງເປັນຂໍການຊໍາລະເງິນເອກະສານອ້າງອິງຈໍາເປັນຕ້ອງມີ
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,ເພື່ອສ້າງເປັນຂໍການຊໍາລະເງິນເອກະສານອ້າງອິງຈໍາເປັນຕ້ອງມີ
@@ -7711,6 +7745,7 @@
 DocType: Hotel Room Package,Amenities,ສິ່ງອໍານວຍຄວາມສະດວກ
 DocType: Accounts Settings,Automatically Fetch Payment Terms,ດຶງຂໍ້ມູນເງື່ອນໄຂການຈ່າຍເງິນໂດຍອັດຕະໂນມັດ
 DocType: QuickBooks Migrator,Undeposited Funds Account,ບັນຊີເງິນຝາກທີ່ບໍ່ໄດ້ຮັບຄືນ
+DocType: Coupon Code,Uses,ການ ນຳ ໃຊ້
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,ຮູບແບບໃນຕອນຕົ້ນຫຼາຍຂອງການຊໍາລະເງິນບໍ່ໄດ້ອະນຸຍາດໃຫ້
 DocType: Sales Invoice,Loyalty Points Redemption,Loyalty Points Redemption
 ,Appointment Analytics,Appointment Analytics
@@ -7728,6 +7763,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,ອອກຈາກ blank ຖ້າຫາກວ່າທ່ານເຮັດໃຫ້ກຸ່ມນັກຮຽນຕໍ່ປີ
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,ອອກຈາກ blank ຖ້າຫາກວ່າທ່ານເຮັດໃຫ້ກຸ່ມນັກຮຽນຕໍ່ປີ
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","ຖ້າຫາກວ່າການກວດກາ, ບໍ່ມີທັງຫມົດ. ຂອງການເຮັດວຽກວັນຈະປະກອບມີວັນພັກ, ແລະນີ້ຈະຊ່ວຍຫຼຸດຜ່ອນມູນຄ່າຂອງເງິນເດືອນຕໍ່ວັນ"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,ການເພີ່ມໂດເມນລົ້ມເຫລວ
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","ເພື່ອອະນຸຍາດໃຫ້ມີໃບຮັບເງິນ / ຄ່າຈັດສົ່ງ, ໃຫ້ອັບເດດ &quot;ເກີນການຮັບ / ຄ່າສົ່ງ&quot; ໃນການຕັ້ງຄ່າຫຸ້ນຫລືລາຍການ."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Apps ທີ່ໃຊ້ key ປັດຈຸບັນຈະບໍ່ສາມາດເຂົ້າເຖິງໄດ້, ທ່ານແນ່ໃຈບໍ?"
 DocType: Subscription Settings,Prorate,Prorate
@@ -7741,6 +7777,7 @@
 ,BOM Stock Report,Report Stock BOM
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","ຖ້າບໍ່ມີເວລາທີ່ຖືກມອບ ໝາຍ, ການສື່ສານຈະຖືກຈັດການໂດຍກຸ່ມນີ້"
 DocType: Stock Reconciliation Item,Quantity Difference,ປະລິມານທີ່ແຕກຕ່າງກັນ
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,ຜູ້ສະ ໜອງ ສິນຄ້າ&gt; ປະເພດຜູ້ສະ ໜອງ ສິນຄ້າ
 DocType: Opportunity Item,Basic Rate,ອັດຕາພື້ນຖານ
 DocType: GL Entry,Credit Amount,ການປ່ອຍສິນເຊື່ອ
 ,Electronic Invoice Register,ຈົດທະບຽນໃບເກັບເງິນເອເລັກໂຕຣນິກ
@@ -7995,6 +8032,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),ພາສີອາກອນແລະຄ່າບໍລິການຫັກ (ບໍລິສັດສະກຸນເງິນ)
 DocType: Item Group,General Settings,ການຕັ້ງຄ່າທົ່ວໄປ
 DocType: Article,Article,ມາດຕາ
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,ກະລຸນາໃສ່ລະຫັດຄູປອງ !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,ຈາກສະກຸນເງິນແລະສະກຸນເງິນບໍ່ສາມາດຈະເປັນຄືກັນ
 DocType: Taxable Salary Slab,Percent Deduction,ການຫັກສ່ວນຮ້ອຍ
 DocType: GL Entry,To Rename,ເພື່ອປ່ຽນຊື່
diff --git a/erpnext/translations/lt.csv b/erpnext/translations/lt.csv
index 90776f1..a9805ee 100644
--- a/erpnext/translations/lt.csv
+++ b/erpnext/translations/lt.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Klientų Susisiekite
 DocType: Shift Type,Enable Auto Attendance,Įgalinti automatinį lankymą
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Įveskite Sandėlį ir datą
 DocType: Lost Reason Detail,Opportunity Lost Reason,Galimybė prarasti priežastį
 DocType: Patient Appointment,Check availability,Patikrinkite užimtumą
 DocType: Retention Bonus,Bonus Payment Date,Premijos mokėjimo data
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Užbaigti darbo užsakymai
 DocType: Support Settings,Forum Posts,Forumo žinutės
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Užduotis užkoduota kaip pagrindinė užduotis. Jei kiltų kokių nors problemų dėl tvarkymo fone, sistema pridės komentarą apie šio akcijų suderinimo klaidą ir grįš į juodraščio etapą."
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Deja, kupono kodo galiojimas neprasidėjo"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,apmokestinamoji vertė
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Jūs nesate įgaliotas pridėti ar atnaujinti įrašus prieš {0}
 DocType: Leave Policy,Leave Policy Details,Išsaugokite informaciją apie politiką
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,vartojimo
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,klasė
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Prekės kodas&gt; Prekių grupė&gt; Prekės ženklas
 DocType: Restaurant Table,No of Seats,Sėdimų vietų skaičius
 DocType: Sales Invoice,Overdue and Discounted,Pavėluotai ir su nuolaida
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Skambutis atjungtas
@@ -507,6 +510,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Tarpai tarp eilučių ir suma žodžiais
 DocType: Vehicle,Additional Details,Papildoma informacija
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Nėra aprašymo suteikta
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Gauti daiktus iš sandėlio
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Užsisakyti įsigyti.
 DocType: POS Closing Voucher Details,Collected Amount,Surinkta suma
 DocType: Lab Test,Submitted Date,Pateiktas data
@@ -614,6 +618,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Mokytis
 ,Trial Balance (Simple),Bandomasis balansas (paprastas)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Įgalinti atidėtąsias išlaidas
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Taikomas kupono kodas
 DocType: Asset,Next Depreciation Date,Kitas Nusidėvėjimas data
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Veiklos sąnaudos vienam darbuotojui
 DocType: Accounts Settings,Settings for Accounts,Nustatymai sąskaitų
@@ -854,8 +859,6 @@
 DocType: Sales Invoice,Total Qty,viso Kiekis
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 E-mail ID
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 E-mail ID
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Ištrinkite darbuotoją <a href=""#Form/Employee/{0}"">{0}</a> \, kad galėtumėte atšaukti šį dokumentą"
 DocType: Item,Show in Website (Variant),Rodyti svetainė (variantas)
 DocType: Employee,Health Concerns,sveikatos problemas
 DocType: Payroll Entry,Select Payroll Period,Pasirinkite Darbo užmokesčio laikotarpis
@@ -1020,6 +1023,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Mokesčių išskaitymo sąskaita
 DocType: Pricing Rule,Sales Partner,Partneriai pardavimo
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Visi tiekėjų rezultatų kortelės.
+DocType: Coupon Code,To be used to get discount,Turi būti naudojamas norint gauti nuolaidą
 DocType: Buying Settings,Purchase Receipt Required,Pirkimo kvito Reikalinga
 DocType: Sales Invoice,Rail,Geležinkelis
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Tikroji kaina
@@ -1070,6 +1074,7 @@
 DocType: Production Plan,Production Plan,Gamybos planas
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Sąskaitų faktūrų kūrimo įrankio atidarymas
 DocType: Salary Component,Round to the Nearest Integer,Apvalus iki artimiausio sveikojo skaičiaus
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,"Leiskite prekėms, kurių nėra sandėlyje, dėti į krepšelį"
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,pardavimų Grįžti
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,"Nustatykite kiekį sandoriuose, kurie yra pagrįsti serijiniu numeriu"
 ,Total Stock Summary,Viso sandėlyje santrauka
@@ -1201,6 +1206,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Bazinė valandą greičiu (Įmonės valiuta)
 ,Qty To Be Billed,Kiekis turi būti apmokestintas
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Paskelbta suma
+DocType: Coupon Code,Gift Card,Dovanų kortelė
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Gamybinis kiekis: Žaliavų kiekis gaminant gaminius.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Išpirkimo data
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Ši banko operacija jau visiškai suderinta
@@ -1290,6 +1296,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Kurti darbo laiko apskaitos žiniaraštį
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Sąskaita {0} buvo įrašytas kelis kartus
 DocType: Account,Expenses Included In Valuation,"Sąnaudų, įtrauktų Vertinimo"
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Pirkimo sąskaitos faktūros
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Galite atnaujinti tik jei narystės terminas baigiasi per 30 dienų
 DocType: Shopping Cart Settings,Show Stock Availability,Rodyti sandėlyje
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Nustatykite {0} turto kategorijoje {1} arba įmonės {2}
@@ -1833,6 +1840,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Elementų ir UOM importavimas
 DocType: Repayment Schedule,Balance Loan Amount,Balansas Paskolos suma
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Pridėta prie detalių
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Atsiprašome, kupono kodas yra išnaudotas"
 DocType: Communication Medium,Catch All,Sugauk viską
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Tvarkaraštis Kurso
 DocType: Budget,Applicable on Material Request,Taikoma medžiagų prašymui
@@ -2003,6 +2011,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Neteisingas Įgūdis
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} turi būti pateiktas
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,El. Pašto kampanijos
+DocType: Sales Partner,To Track inbound purchase,Stebėti atvykstamąjį pirkimą
 DocType: Buying Settings,Default Supplier Group,Numatytoji tiekėjų grupė
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Kiekis turi būti mažesnis arba lygus {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},"Maksimali komponento, galiojančio komponentui {0}, viršija {1}"
@@ -2161,7 +2170,6 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Padaryti akcijų įrašą
 DocType: Hotel Room Reservation,Hotel Reservation User,Viešbučių rezervavimo vartotojas
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Nustatyti būseną
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Prašome nustatyti numeracijos serijas lankymui per sąranką&gt; Numeravimo serijos
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Prašome pasirinkti prefiksą pirmas
 DocType: Contract,Fulfilment Deadline,Įvykdymo terminas
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Šalia jūsų
@@ -2286,6 +2294,7 @@
 DocType: Quality Meeting Table,Under Review,Peržiūrimas
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Nepavyko prisijungti
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Turtas {0} sukurtas
+DocType: Coupon Code,Promotional,Reklaminė
 DocType: Special Test Items,Special Test Items,Specialūs testo elementai
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,"Turite būti su Sistemos valdytoju ir &quot;Item Manager&quot; vartotojais, kad galėtumėte užsiregistruoti &quot;Marketplace&quot;."
 apps/erpnext/erpnext/config/buying.py,Key Reports,Pagrindinės ataskaitos
@@ -2324,6 +2333,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc tipas
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Iš viso skyrė procentas pardavimų vadybininkas turi būti 100
 DocType: Subscription Plan,Billing Interval Count,Atsiskaitymo interviu skaičius
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Ištrinkite darbuotoją <a href=""#Form/Employee/{0}"">{0}</a> \, kad galėtumėte atšaukti šį dokumentą"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Paskyrimai ir pacientų susitikimai
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Trūksta vertės
 DocType: Employee,Department and Grade,Skyrius ir laipsnis
@@ -2427,6 +2438,7 @@
 DocType: Project,Start and End Dates,Pradžios ir pabaigos datos
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Kontraktinių šablonų įvykdymo sąlygos
 ,Delivered Items To Be Billed,Pristatyto objekto Norėdami būti mokami
+DocType: Coupon Code,Maximum Use,Maksimalus naudojimas
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Atviras BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Sandėlių negali būti keičiama Serijos Nr
 DocType: Authorization Rule,Average Discount,Vidutinis nuolaida
@@ -2588,6 +2600,7 @@
 DocType: Item,Inventory,inventorius
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Atsisiųsti kaip Json
 DocType: Item,Sales Details,pardavimų detalės
+DocType: Coupon Code,Used,Naudota
 DocType: Opportunity,With Items,su daiktais
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Kampanija „{0}“ jau egzistuoja {1} „{2}“
 DocType: Asset Maintenance,Maintenance Team,Techninės priežiūros komanda
@@ -2717,7 +2730,7 @@
 						Serial No cannot be ensured",Nebuvo rasta aktyvios BOM elementui {0}. Pristatymas pagal serijos numerį negali būti užtikrintas
 DocType: Sales Partner,Sales Partner Target,Partneriai pardavimo Tikslinė
 DocType: Loan Type,Maximum Loan Amount,Maksimali paskolos suma
-DocType: Pricing Rule,Pricing Rule,kainodaros taisyklė
+DocType: Coupon Code,Pricing Rule,kainodaros taisyklė
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Dublikatas ritinys numeris studentas {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Dublikatas ritinys numeris studentas {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Medžiaga Prašymas Pirkimo užsakymas
@@ -2784,6 +2797,8 @@
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Leave of type {0} cannot be longer than {1},Atostogos tipo {0} negali būti ilgesnis nei {1}
 DocType: Delivery Trip,Optimize Route,Optimizuoti maršrutą
 DocType: Manufacturing Settings,Try planning operations for X days in advance.,Pabandykite planuoja operacijas X dienų iš anksto.
+apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,"{0} vacancies and {1} budget for {2} already planned for subsidiary companies of {3}. \
+				You can only plan for upto {4} vacancies and and budget {5} as per staffing plan {6} for parent company {3}.","{0} laisvų darbo vietų ir {1} biudžetas {2} jau suplanuotas {3} dukterinėms įmonėms. \ Galite planuoti ne daugiau kaip {4} laisvas darbo vietas ir biudžetą {5}, kaip numatyta pagrindinės įmonės {3} personalo plane {6}."
 DocType: HR Settings,Stop Birthday Reminders,Sustabdyti Gimimo diena Priminimai
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Please set Default Payroll Payable Account in Company {0},Prašome Set Default Darbo užmokesčio MOKĖTINOS Narystė Bendrovėje {0}
 DocType: Pricing Rule Brand,Pricing Rule Brand,Kainos taisyklės prekės ženklas
@@ -2795,6 +2810,7 @@
 DocType: Payment Schedule,Payment Amount,Mokėjimo suma
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Pusės dienos data turėtų būti tarp darbo nuo datos iki darbo pabaigos datos
 DocType: Healthcare Settings,Healthcare Service Items,Sveikatos priežiūros paslaugos
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Netinkamas brūkšninis kodas. Prie šio brūkšninio kodo nėra pridėto elemento.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,suvartoti suma
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Grynasis Pakeisti pinigais
 DocType: Assessment Plan,Grading Scale,vertinimo skalė
@@ -2916,7 +2932,6 @@
 DocType: Share Transfer,Asset Account,Turto sąskaita
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Nauja išleidimo data turėtų būti ateityje
 DocType: Purchase Invoice,End date of current invoice's period,Pabaigos data einamųjų sąskaitos faktūros laikotarpį
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Prašome nustatyti darbuotojų įvardijimo sistemą skyriuje Žmogiškieji ištekliai&gt; HR nustatymai
 DocType: Lab Test,Technician Name,Technikos vardas
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3028,6 +3043,7 @@
 DocType: Products Settings,Hide Variants,Slėpti variantus
 DocType: Lead,Next Contact By,Kitas Susisiekti
 DocType: Compensatory Leave Request,Compensatory Leave Request,Kompensacinis atostogų prašymas
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Negalima permokėti už {0} eilutės {0} eilutę daugiau nei {2}. Jei norite leisti permokėti, nustatykite pašalpą Sąskaitų nustatymuose"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},reikalingas punktas {0} iš eilės Kiekis {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},"Sandėlių {0} negali būti išbrauktas, nes egzistuoja kiekis už prekę {1}"
 DocType: Blanket Order,Order Type,pavedimo tipas
@@ -3200,7 +3216,6 @@
 DocType: Student,Student Mobile Number,Studentų Mobilusis Telefonas Numeris
 DocType: Item,Has Variants,turi variantams
 DocType: Employee Benefit Claim,Claim Benefit For,Pretenzijos išmoka už
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Negalima perduoti {0} {1} daugiau nei {2} eilutėje. Jei norite leisti pernumeruoti mokestį, nustatykite Suvestinės nustatymuose"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Atnaujinti atsakymą
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Jūs jau pasirinkote elementus iš {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Pavadinimas Mėnesio pasiskirstymas
@@ -3493,6 +3508,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Prašome nurodyti valiutą Company
 DocType: Workstation,Wages per hour,Darbo užmokestis per valandą
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Konfigūruoti {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Klientas&gt; Klientų grupė&gt; Teritorija
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Akcijų balansas Serija {0} taps neigiamas {1} už prekę {2} į sandėlį {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Šios medžiagos prašymai buvo iškeltas automatiškai pagal elemento naujo užsakymo lygio
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Sąskaita {0} yra neteisinga. Sąskaitos valiuta turi būti {1}
@@ -3826,6 +3842,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Pateikti darbo užmokestį
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Laikomas
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Rinkinyje turi būti bent viena teisinga parinktis
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Pirkimo užsakymai
 DocType: Account,Inter Company Account,&quot;Inter&quot; įmonės sąskaita
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Importas į taros
 DocType: Sales Partner,Address & Contacts,Adresas ir kontaktai
@@ -3836,6 +3853,7 @@
 DocType: POS Profile,[Select],[Pasirinkti]
 DocType: Staffing Plan Detail,Number Of Positions,Pozicijų skaičius
 DocType: Vital Signs,Blood Pressure (diastolic),Kraujo spaudimas (diastolinis)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Pasirinkite klientą.
 DocType: SMS Log,Sent To,Siunčiami į
 DocType: Agriculture Task,Holiday Management,Atostogų valdymas
 DocType: Payment Request,Make Sales Invoice,Padaryti pardavimo sąskaita-faktūra
@@ -4045,7 +4063,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} nebus pateiktas
 DocType: Subscription,Trialling,Trialling
 DocType: Sales Invoice Item,Deferred Revenue,Atidėtosios pajamos
-DocType: Bank Account,GL Account,GL sąskaita
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Pinigų sąskaita bus naudojama pardavimo sąskaitų faktūrų sukūrimui
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Išimties sub kategorija
 DocType: Member,Membership Expiry Date,Narystės galiojimo data
@@ -4452,13 +4469,13 @@
 DocType: C-Form Invoice Detail,Territory,teritorija
 DocType: Pricing Rule,Apply Rule On Item Code,Taikyti prekės kodo taisyklę
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Paminėkite nėra apsilankymų reikalingų
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Atsargų balanso ataskaita
 DocType: Stock Settings,Default Valuation Method,Numatytasis vertinimo metodas
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Rinkliava
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Rodyti bendrą sumą
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Atnaujinimas vyksta. Tai gali užtrukti.
 DocType: Production Plan Item,Produced Qty,Pagamintas kiekis
 DocType: Vehicle Log,Fuel Qty,kuro Kiekis
-DocType: Stock Entry,Target Warehouse Name,Paskirties sandėlio pavadinimas
 DocType: Work Order Operation,Planned Start Time,Planuojamas Pradžios laikas
 DocType: Course,Assessment,įvertinimas
 DocType: Payment Entry Reference,Allocated,Paskirti
@@ -4524,10 +4541,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","Standartinės sąlygos, kurios gali būti įtrauktos į pardavimo ir pirkimo. Pavyzdžiai: 1. galiojimas pasiūlymą. 1. Mokėjimo sąlygos (iš anksto, kredito, dalis avanso ir tt). 1. Kas yra papildomų (arba turėtų sumokėti Užsakovui). 1. Saugumas / naudojimas įspėjimo. 1. Garantija, jei tokių yra. 1. grąžinimo politiką. 1. Terminai laivybos, jei taikoma. 1. būdus, kaip spręsti ginčus, civilinės atsakomybės, atsakomybės ir tt 1. Adresas ir kontaktai Jūsų įmonėje."
 DocType: Homepage Section,Section Based On,Skyrius pagrįstas
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Rodyti pritaikyti kupono kodą
 DocType: Issue,Issue Type,Problemos tipas
 DocType: Attendance,Leave Type,atostogos tipas
 DocType: Purchase Invoice,Supplier Invoice Details,Tiekėjas Sąskaitos informacija
 DocType: Agriculture Task,Ignore holidays,Ignoruoti atostogas
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Pridėti / redaguoti kupono sąlygas
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Kompensuojamos / Skirtumas sąskaita ({0}) turi būti &quot;pelnas arba nuostolis&quot; sąskaita
 DocType: Stock Entry Detail,Stock Entry Child,Akcijų įvedimo vaikas
 DocType: Project,Copied From,Nukopijuota iš
@@ -4703,6 +4722,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Vertinimo planas kriterijai
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Sandoriai
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Užkirsti kelią pirkimo užsakymams
+DocType: Coupon Code,Coupon Name,Kupono pavadinimas
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Jautrus
 DocType: Email Campaign,Scheduled,planuojama
 DocType: Shift Type,Working Hours Calculation Based On,Darbo valandų skaičiavimas remiantis
@@ -4719,7 +4739,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Kurti variantus
 DocType: Vehicle,Diesel,dyzelinis
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Kainų sąrašas Valiuta nepasirinkote
+DocType: Quick Stock Balance,Available Quantity,Galimas kiekis
 DocType: Purchase Invoice,Availed ITC Cess,Pasinaudojo ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Prašome įdiegti instruktoriaus pavadinimo sistemą švietime&gt; Švietimo nustatymai
 ,Student Monthly Attendance Sheet,Studentų Mėnesio Lankomumas lapas
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Pristatymo taisyklė taikoma tik Pardavimui
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Nusidėvėjimo eilutė {0}: kita Nusidėvėjimo data negali būti prieš Pirkimo datą
@@ -4788,6 +4810,7 @@
 DocType: Quality Meeting,Quality Meeting,Kokybės susitikimas
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Ne grupė į grupę
 DocType: Employee,ERPNext User,ERPNext vartotojas
+DocType: Coupon Code,Coupon Description,Kupono aprašymas
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Partijos yra imperatyvaus eilės {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Partijos yra imperatyvaus eilės {0}
 DocType: Company,Default Buying Terms,Numatytosios pirkimo sąlygos
@@ -4952,6 +4975,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Su dokumentų Išsamiau Nėra
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Pašalinti neleidžiama šaliai {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Šalis tipas yra privalomi
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Taikyti kupono kodą
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",Dėl darbo kortelės {0} galite atlikti tik atsargų įrašą „Gamybos perdavimas gamybai“
 DocType: Quality Inspection,Outgoing,išeinantis
 DocType: Customer Feedback Table,Customer Feedback Table,Klientų atsiliepimų lentelė
@@ -5104,7 +5128,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Pateikiant pirkimo užsakymą
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Pridėti visus tiekėjus
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Eilutė # {0}: Paskirstytas suma gali būti ne didesnis nei likutinę sumą.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Klientas&gt; Klientų grupė&gt; Teritorija
 DocType: Tally Migration,Parties,Vakarėliai
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Žmonės BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,užtikrintos paskolos
@@ -5136,7 +5159,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Neleisti nustatyti kito elemento elementui {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Data kartojamas
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Įgaliotas signataras
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Prašome įdiegti instruktoriaus pavadinimo sistemą švietime&gt; Švietimo nustatymai
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Galimas grynasis ITC (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Sukurkite mokesčius
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Viso įsigijimo savikainą (per pirkimo sąskaitoje faktūroje)
@@ -5161,6 +5183,7 @@
 DocType: Quiz Result,Wrong,Neteisinga
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Norma, pagal kurią Kainoraštis valiuta konvertuojama į kliento bazine valiuta"
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Grynasis kiekis (Įmonės valiuta)
+DocType: Sales Partner,Referral Code,Kreipimosi kodas
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Bendra avanso suma negali būti didesnė už visą sankcionuotą sumą
 DocType: Salary Slip,Hour Rate,Valandinis įkainis
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Įgalinti automatinį užsakymą
@@ -5290,6 +5313,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Rodyti prekių kiekį
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Grynieji pinigų srautai iš įprastinės veiklos
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Nr. {0}: sąskaitos faktūros nuolaidų būsena turi būti {1} {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM konversijos koeficientas ({0} -&gt; {1}) nerastas elementui: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,4 punktas
 DocType: Student Admission,Admission End Date,Priėmimo Pabaigos data
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Subrangovai
@@ -5312,6 +5336,7 @@
 DocType: Travel Request,Fully Sponsored,Visiškai remiama
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Atvirkštinis žurnalo įrašas
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Sukurkite darbo kortelę
+DocType: Quotation,Referral Sales Partner,Persiuntimo pardavimo partneris
 DocType: Quality Procedure Process,Process Description,Proceso aprašymas
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Klientas {0} sukurtas.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Šiuo metu nėra nei viename sandėlyje.
@@ -5446,6 +5471,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM Balsuok
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Įkelto failo skaitymas
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Sustabdyto darbo užsakymas negali būti atšauktas. Išjunkite jį iš pradžių, kad atšauktumėte"
+DocType: Coupon Code,Coupon Code,Kupono kodas
 DocType: Asset,Journal Entry for Scrap,Žurnalo įrašą laužo
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Prašome traukti elementus iš važtaraštyje
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Eilutė {0}: pasirinkite darbo vietą prieš operaciją {1}
@@ -5530,6 +5556,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,Būtina nurodyti „data“
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Dėl / Nuoroda data negali būti po {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Duomenų importas ir eksportas
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Deja, kupono kodo galiojimo laikas pasibaigė"
 DocType: Bank Account,Account Details,Išsami paskyros informacija
 DocType: Crop,Materials Required,Reikalingos medžiagos
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Studentai Surasta
@@ -5567,6 +5594,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Eikite į &quot;Vartotojai&quot;
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Mokama suma + nurašyti suma negali būti didesnė nei IŠ VISO
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} yra neteisingas SERIJOS NUMERIS už prekę {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Įveskite galiojantį kupono kodą !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Pastaba: Nėra pakankamai atostogos balansas Palikti tipas {0}
 DocType: Task,Task Description,Užduoties aprašymas
 DocType: Training Event,Seminar,seminaras
@@ -5833,6 +5861,7 @@
 ,TDS Payable Monthly,TDS mokamas kas mėnesį
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Buvo pakeista eilės tvarka. Tai gali užtrukti kelias minutes.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Negali atskaityti, kai kategorija skirta &quot;Vertinimo&quot; arba &quot;vertinimo ir viso&quot;"
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Prašome nustatyti darbuotojų įvardijimo sistemą skyriuje Žmogiškieji ištekliai&gt; HR nustatymai
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Iš viso mokėjimų
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Eilės Nr Reikalinga už Serijinis punkte {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Rungtynių Mokėjimai sąskaitų faktūrų
@@ -5923,6 +5952,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Gauk žaliavą gamybai
 DocType: Job Opening,Job Title,Darbo pavadinimas
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Ateities mokėjimo nuoroda
+DocType: Quotation,Additional Discount and Coupon Code,Papildomos nuolaidos ir kupono kodas
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} rodo, kad {1} nepateiks citatos, bet visi daiktai \ &quot;buvo cituoti. RFQ citatos statuso atnaujinimas."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Didžiausi mėginiai - {0} jau buvo išsaugoti paketui {1} ir elementui {2} partijoje {3}.
@@ -6152,7 +6182,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Nustatymai svetainės puslapyje
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} yra sulaikytas iki {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},"Paraiškos dėl RFQ dėl {0} neleidžiamos, nes rezultatų rodymas yra {1}"
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Sudaryti pirkimo sąskaitą
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Naudotos lapai
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,Naudojamas {0} kuponas yra {1}. Leistinas kiekis išnaudotas
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Ar norite pateikti medžiagos prašymą?
 DocType: Job Offer,Awaiting Response,Laukiama atsakymo
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6166,6 +6198,7 @@
 DocType: Training Event Employee,Optional,Neprivaloma
 DocType: Salary Slip,Earning & Deduction,Pelningiausi &amp; išskaičiavimas
 DocType: Agriculture Analysis Criteria,Water Analysis,Vandens analizė
+DocType: Sales Order,Skip Delivery Note,Praleisti pristatymo pranešimą
 DocType: Price List,Price Not UOM Dependent,Kaina nepriklauso nuo UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,Sukurta {0} variantų.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Numatytasis paslaugų lygio susitarimas jau yra.
@@ -6274,6 +6307,7 @@
 DocType: Vehicle,Last Carbon Check,Paskutinis Anglies Atvykimas
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,teisinės išlaidos
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Prašome pasirinkti kiekį ant eilėje
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Darbo užsakymas {0}: operacijai nerasta darbo kortelė {1}
 DocType: Purchase Invoice,Posting Time,Siunčiamos laikas
 DocType: Timesheet,% Amount Billed,% Suma Įvardintas
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,telefono išlaidas
@@ -6376,7 +6410,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Mokesčiai ir rinkliavos Pridėta
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Nusidėvėjimo eilutė {0}: tolimesnė nusidėvėjimo data negali būti ankstesnė. Galima naudoti data
 ,Sales Funnel,pardavimų piltuvas
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Prekės kodas&gt; Prekių grupė&gt; Prekės ženklas
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Santrumpa yra privaloma
 DocType: Project,Task Progress,užduotis pažanga
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,krepšelis
@@ -6472,6 +6505,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,"POS profilis reikalaujama, kad POS įrašą"
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",Lojalumo taškai bus skaičiuojami iš panaudoto atlikto (per pardavimo sąskaitą) remiantis nurodytu surinkimo faktoriumi.
 DocType: Program Enrollment Tool,Enroll Students,stoti Studentai
+DocType: Pricing Rule,Coupon Code Based,Kupono kodas pagrįstas
 DocType: Company,HRA Settings,HRA nustatymai
 DocType: Homepage,Hero Section,Herojaus skyrius
 DocType: Employee Transfer,Transfer Date,Persiuntimo data
@@ -6587,6 +6621,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',"Prašome nustatyti Įmonės filtruoti tuščias, jei Grupuoti pagal tai &quot;kompanija&quot;"
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Siunčiamos data negali būti ateitis data
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Eilutės # {0}: Serijos Nr {1} nesutampa su {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Prašome nustatyti numeracijos serijas lankymui per sąranką&gt; Numeravimo serijos
 DocType: Stock Entry,Target Warehouse Address,Target Warehouse Address
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Laisvalaikio atostogos
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,"Laikas prieš pamainos pradžios laiką, per kurį svarstomas darbuotojų registravimasis į lankomumą."
@@ -6621,7 +6656,6 @@
 DocType: Employee Grade,Employee Grade,Darbuotojų vertinimas
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,vienetinį
 DocType: GSTR 3B Report,June,Birželio mėn
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Tiekėjas&gt; Tiekėjo tipas
 DocType: Share Balance,From No,Iš Nr
 DocType: Shift Type,Early Exit Grace Period,Ankstyvasis išėjimo lengvatinis laikotarpis
 DocType: Task,Actual Time (in Hours),Tikrasis laikas (valandomis)
@@ -6908,7 +6942,6 @@
 DocType: Warehouse,Warehouse Name,Sandėlių Vardas
 DocType: Naming Series,Select Transaction,Pasirinkite Sandorio
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Prašome įvesti patvirtinimo vaidmuo arba patvirtinimo vartotoją
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM konversijos koeficientas ({0} -&gt; {1}) nerastas elementui: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Paslaugų lygio sutartis su {0} subjekto ir {1} subjektais jau yra.
 DocType: Journal Entry,Write Off Entry,Nurašyti įrašą
 DocType: BOM,Rate Of Materials Based On,Norma medžiagų pagrindu
@@ -7047,6 +7080,7 @@
 DocType: Budget,Warn,įspėti
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Visi daiktai jau buvo perkelti už šį darbo užsakymą.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Bet koks kitas pastabas, pažymėtina pastangų, kad reikia eiti į apskaitą."
+DocType: Bank Account,Company Account,Įmonės sąskaita
 DocType: Asset Maintenance,Manufacturing User,gamyba Vartotojas
 DocType: Purchase Invoice,Raw Materials Supplied,Žaliavos Pateikiamas
 DocType: Subscription Plan,Payment Plan,Mokesčių planas
@@ -7088,6 +7122,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) negali viršyti numatyto kiekio ({2}) darbo tvarkoje {3}
 DocType: Certification Application,Name of Applicant,Pareiškėjo vardas ir pavardė
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Laikas lapas gamybai.
+DocType: Quick Stock Balance,Quick Stock Balance,Greitas atsargų likutis
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Tarpinė suma
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,"Negalima keisti Variantų savybių po sandorio su akcijomis. Norėdami tai padaryti, turėsite padaryti naują punktą."
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,&quot;GoCardless&quot; SEPA mandatas
@@ -7416,6 +7451,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} yra neaktyvus studentas
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} yra neaktyvus studentas
 DocType: Employee,Health Details,sveikatos informacija
+DocType: Coupon Code,Coupon Type,Kupono tipas
 DocType: Leave Encashment,Encashable days,Encashable dienos
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Norėdami sukurti mokėjimo prašymas nuoroda dokumentas yra reikalingas
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Norėdami sukurti mokėjimo prašymas nuoroda dokumentas yra reikalingas
@@ -7704,6 +7740,7 @@
 DocType: Hotel Room Package,Amenities,Patogumai
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Automatiškai gauti mokėjimo sąlygas
 DocType: QuickBooks Migrator,Undeposited Funds Account,Nepaskirstyta lėšų sąskaita
+DocType: Coupon Code,Uses,Panaudojimas
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Kelis numatytasis mokėjimo būdas neleidžiamas
 DocType: Sales Invoice,Loyalty Points Redemption,Lojalumo taškų išpirkimas
 ,Appointment Analytics,Paskyrimų analizė
@@ -7721,6 +7758,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Palikite tuščią, jei jūs padarote studentų grupes per metus"
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Palikite tuščią, jei jūs padarote studentų grupes per metus"
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Jei pažymėta, viso nėra. darbo dienų bus atostogų, o tai sumažins Atlyginimas diena vertę"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Nepavyko pridėti domeno
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Norėdami leisti perduoti / pristatyti, atnaujinkite „Permokėjimo / pristatymo pašalpą“ atsargų nustatymuose arba prekėje."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Programos, kuriose naudojamas dabartinis raktas, negalėsite pasiekti, ar tikrai esate įsitikinę?"
 DocType: Subscription Settings,Prorate,Proratas
@@ -7734,6 +7772,7 @@
 ,BOM Stock Report,BOM sandėlyje ataskaita
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Jei nėra priskirto laiko tarpo, tada šią grupę tvarkys komunikacija"
 DocType: Stock Reconciliation Item,Quantity Difference,kiekis skirtumas
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Tiekėjas&gt; Tiekėjo tipas
 DocType: Opportunity Item,Basic Rate,bazinis tarifas
 DocType: GL Entry,Credit Amount,kredito suma
 ,Electronic Invoice Register,Elektroninis sąskaitų-faktūrų registras
@@ -7988,6 +8027,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Mokesčiai ir rinkliavos Išskaityta (Įmonės valiuta)
 DocType: Item Group,General Settings,Bendrieji nustatymai
 DocType: Article,Article,Straipsnis
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Įveskite kupono kodą !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Nuo Valiuta ir valiutos negali būti tas pats
 DocType: Taxable Salary Slab,Percent Deduction,Procentinis atskaitymas
 DocType: GL Entry,To Rename,Pervadinti
diff --git a/erpnext/translations/lv.csv b/erpnext/translations/lv.csv
index a22e637..12348de 100644
--- a/erpnext/translations/lv.csv
+++ b/erpnext/translations/lv.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Klientu Kontakti
 DocType: Shift Type,Enable Auto Attendance,Iespējot automātisko apmeklēšanu
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,"Lūdzu, ievadiet noliktavu un datumu"
 DocType: Lost Reason Detail,Opportunity Lost Reason,Iespēja zaudēta Iemesls
 DocType: Patient Appointment,Check availability,Pārbaudīt pieejamību
 DocType: Retention Bonus,Bonus Payment Date,Bonusa maksājuma datums
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Pabeigti darba uzdevumi
 DocType: Support Settings,Forum Posts,Foruma ziņas
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Uzdevums ir iemiesots kā fona darbs. Ja rodas kādas problēmas saistībā ar apstrādi fonā, sistēma pievienos komentāru par kļūdu šajā krājuma saskaņošanā un atgriezīsies melnraksta stadijā"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started",Diemžēl kupona koda derīgums nav sācies
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Ar nodokli apliekamā summa
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Jums nav atļauts pievienot vai atjaunināt ierakstus pirms {0}
 DocType: Leave Policy,Leave Policy Details,Atstājiet politikas informāciju
@@ -329,6 +331,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Patērējamās
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,pakāpe
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Preces kods&gt; Vienību grupa&gt; Zīmols
 DocType: Restaurant Table,No of Seats,Sēdvietu skaits
 DocType: Sales Invoice,Overdue and Discounted,Nokavēts un atlaides
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Zvans atvienots
@@ -506,6 +509,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Rindstarpas par summu vārdiem
 DocType: Vehicle,Additional Details,papildu Details
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Apraksts nav dota
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Ielādēt preces no noliktavas
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Pieprasīt iegādei.
 DocType: POS Closing Voucher Details,Collected Amount,Savākto summu
 DocType: Lab Test,Submitted Date,Iesniegtais datums
@@ -613,6 +617,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Mācīties
 ,Trial Balance (Simple),Izmēģinājuma bilance (vienkārša)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Iespējot atliktos izdevumus
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Piemērotais kupona kods
 DocType: Asset,Next Depreciation Date,Nākamais Nolietojums Datums
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Aktivitāte izmaksas uz vienu darbinieku
 DocType: Accounts Settings,Settings for Accounts,Iestatījumi kontu
@@ -852,8 +857,6 @@
 DocType: BOM,Work Order,Darba kārtība
 DocType: Sales Invoice,Total Qty,Kopā Daudz
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 Email ID
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Lūdzu, izdzēsiet darbinieku <a href=""#Form/Employee/{0}"">{0}</a> \, lai atceltu šo dokumentu"
 DocType: Item,Show in Website (Variant),Show Website (Variant)
 DocType: Employee,Health Concerns,Veselības problēmas
 DocType: Payroll Entry,Select Payroll Period,Izvēlieties Payroll periods
@@ -1018,6 +1021,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Nodokļu ieturēšanas konts
 DocType: Pricing Rule,Sales Partner,Sales Partner
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Visi Piegādātāju rādītāju kartes.
+DocType: Coupon Code,To be used to get discount,"Jāizmanto, lai saņemtu atlaidi"
 DocType: Buying Settings,Purchase Receipt Required,Pirkuma čeka Nepieciešamais
 DocType: Sales Invoice,Rail,Dzelzceļš
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Faktiskās izmaksas
@@ -1068,6 +1072,7 @@
 DocType: Production Plan,Production Plan,Ražošanas plāns
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Rēķinu izveides rīka atvēršana
 DocType: Salary Component,Round to the Nearest Integer,Kārta līdz tuvākajam veselajam skaitlim
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,"Atļaut preces, kuras nav noliktavā, pievienot grozam"
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Sales Return
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,"Iestatiet daudzumu darījumos, kuru pamatā ir sērijas Nr. Ievade"
 ,Total Stock Summary,Kopā Stock kopsavilkums
@@ -1199,6 +1204,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Bāzes stundu likme (Company valūta)
 ,Qty To Be Billed,Cik jāmaksā
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Pasludināts Summa
+DocType: Coupon Code,Gift Card,Dāvanu karte
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,"Ražošanas rezervētais daudzums: Izejvielu daudzums, lai izgatavotu ražošanas priekšmetus."
 DocType: Loyalty Point Entry Redemption,Redemption Date,Atpirkšanas datums
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Šis bankas darījums jau ir pilnībā saskaņots
@@ -1287,6 +1293,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Izveidot laika kontrolsarakstu
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Konts {0} ir ievadīts vairākas reizes
 DocType: Account,Expenses Included In Valuation,Izdevumi iekļauts vērtēšanā
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Pirkuma rēķini
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,"Jūs varat atjaunot tikai tad, ja jūsu dalības termiņš ir 30 dienu laikā"
 DocType: Shopping Cart Settings,Show Stock Availability,Rādīt pieejamību
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Iestatiet {0} īpašuma kategorijā {1} vai uzņēmumā {2}
@@ -1830,6 +1837,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Preču un UOM importēšana
 DocType: Repayment Schedule,Balance Loan Amount,Balance Kredīta summa
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Pievienots detaļām
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted",Diemžēl kupona kods ir izsmelts
 DocType: Communication Medium,Catch All,Noķert visu
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,grafiks Course
 DocType: Budget,Applicable on Material Request,Attiecas uz materiālu pieprasījumu
@@ -2000,6 +2008,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Nederīga Atribūtu
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0}{1} jāiesniedz
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,E-pasta kampaņas
+DocType: Sales Partner,To Track inbound purchase,Lai izsekotu ienākošo pirkumu
 DocType: Buying Settings,Default Supplier Group,Noklusējuma piegādātāju grupa
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Daudzumam ir jābūt mazākam vai vienādam ar {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Komponentam {0} piemērotākais maksimālais daudzums pārsniedz {1}
@@ -2157,8 +2166,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Veikt krājumu ierakstu
 DocType: Hotel Room Reservation,Hotel Reservation User,Viesnīcu rezervācijas lietotājs
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Iestatīt statusu
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,"Lūdzu, iestatiet apmeklējumu numerācijas sērijas, izmantojot Iestatīšana&gt; Numerācijas sērija"
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,"Lūdzu, izvēlieties kodu pirmais"
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,"Lūdzu, iestatiet Nosaukšanas sērija uz {0}, izmantojot Iestatīšana&gt; Iestatījumi&gt; Sēriju nosaukšana"
 DocType: Contract,Fulfilment Deadline,Izpildes termiņš
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Pie jums
 DocType: Student,O-,O-
@@ -2282,6 +2291,7 @@
 DocType: Quality Meeting Table,Under Review,Tiek pārskatīts
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Neizdevās pieslēgties
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Aktīvs {0} izveidots
+DocType: Coupon Code,Promotional,Reklāmas
 DocType: Special Test Items,Special Test Items,Īpašie testa vienumi
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,"Lai reģistrētos vietnē Marketplace, jums ir jābūt lietotājam ar sistēmas pārvaldnieka un vienumu pārvaldnieka lomu."
 apps/erpnext/erpnext/config/buying.py,Key Reports,Galvenie ziņojumi
@@ -2320,6 +2330,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc Type
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Kopējais piešķirtais procentuālu pārdošanas komanda būtu 100
 DocType: Subscription Plan,Billing Interval Count,Norēķinu intervāla skaits
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Lūdzu, izdzēsiet darbinieku <a href=""#Form/Employee/{0}"">{0}</a> \, lai atceltu šo dokumentu"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Tikšanās un pacientu tikšanās
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Trūkst vērtības
 DocType: Employee,Department and Grade,Nodaļa un pakāpe
@@ -2423,6 +2435,7 @@
 DocType: Project,Start and End Dates,Sākuma un beigu datumi
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Līguma veidņu izpildes noteikumi
 ,Delivered Items To Be Billed,Piegādāts posteņi ir Jāmaksā
+DocType: Coupon Code,Maximum Use,Maksimālais lietojums
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Atvērt BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Noliktava nevar mainīt Serial Nr
 DocType: Authorization Rule,Average Discount,Vidēji Atlaide
@@ -2584,6 +2597,7 @@
 DocType: Item,Inventory,Inventārs
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Lejupielādēt kā Json
 DocType: Item,Sales Details,Pārdošanas Details
+DocType: Coupon Code,Used,Lietots
 DocType: Opportunity,With Items,Ar preces
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Kampaņa &#39;{0}&#39; jau pastāv {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Apkopes komanda
@@ -2713,7 +2727,7 @@
 						Serial No cannot be ensured",Vienumam {0} nav atrasta aktīva BOM. Piegāde ar \ Serial No nevar tikt nodrošināta
 DocType: Sales Partner,Sales Partner Target,Sales Partner Mērķa
 DocType: Loan Type,Maximum Loan Amount,Maksimālais Kredīta summa
-DocType: Pricing Rule,Pricing Rule,Cenu noteikums
+DocType: Coupon Code,Pricing Rule,Cenu noteikums
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplicate roll numurs students {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplicate roll numurs students {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Materiāls Pieprasījums Pirkuma pasūtījums
@@ -2793,6 +2807,7 @@
 DocType: Payment Schedule,Payment Amount,Maksājuma summa
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Pusdiena datumam jābūt starp darbu no datuma un darba beigu datuma
 DocType: Healthcare Settings,Healthcare Service Items,Veselības aprūpes dienesta priekšmeti
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Nederīgs svītrkods. Šim svītrkodam nav pievienots vienums.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Patērētā summa
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Neto izmaiņas naudas
 DocType: Assessment Plan,Grading Scale,Šķirošana Scale
@@ -2914,7 +2929,6 @@
 DocType: Share Transfer,Asset Account,Aktīvu konts
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Jaunā izlaišanas datumam vajadzētu būt nākotnē
 DocType: Purchase Invoice,End date of current invoice's period,Beigu datums no kārtējā rēķinā s perioda
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Lūdzu, iestatiet Personāla nosaukšanas sistēma personāla resursos&gt; HR iestatījumi"
 DocType: Lab Test,Technician Name,Tehniķa vārds
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3198,7 +3212,6 @@
 DocType: Student,Student Mobile Number,Studentu Mobilā tālruņa numurs
 DocType: Item,Has Variants,Ir Varianti
 DocType: Employee Benefit Claim,Claim Benefit For,Pretenzijas pabalsts
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Prece {0} nevar būt pārnēsājama rindā {1} vairāk nekā {2}. Lai atļautu pārsniegt norēķinus, lūdzu, iestatiet akciju iestatījumus"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Atjaunināt atbildi
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Jūs jau atsevišķus posteņus {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Nosaukums Mēneša Distribution
@@ -3491,6 +3504,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,"Lūdzu, norādiet valūtu Company"
 DocType: Workstation,Wages per hour,Algas stundā
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Konfigurēt {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Klients&gt; Klientu grupa&gt; Teritorija
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Krājumu atlikumu partijā {0} kļūs negatīvs {1} postenī {2} pie Warehouse {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,"Šāds materiāls Pieprasījumi tika automātiski izvirzīts, balstoties uz posteni atjaunotne pasūtījuma līmenī"
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Konts {0} ir nederīgs. Konta valūta ir {1}
@@ -3824,6 +3838,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Iesniegt par atalgojumu
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Uzturēts
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Sadarbībai jābūt vismaz vienai pareizai opcijai
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Pirkuma pasūtījumi
 DocType: Account,Inter Company Account,Inter uzņēmuma konts
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Import masas
 DocType: Sales Partner,Address & Contacts,Adrese & Kontakti
@@ -3834,6 +3849,7 @@
 DocType: POS Profile,[Select],[Izvēlēties]
 DocType: Staffing Plan Detail,Number Of Positions,Pozīciju skaits
 DocType: Vital Signs,Blood Pressure (diastolic),Asinsspiediens (diastoliskais)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,"Lūdzu, atlasiet klientu."
 DocType: SMS Log,Sent To,Nosūtīts
 DocType: Agriculture Task,Holiday Management,Brīvdienu vadīšana
 DocType: Payment Request,Make Sales Invoice,Izveidot PPR
@@ -4044,7 +4060,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0}{1} nav iesniegta
 DocType: Subscription,Trialling,Trialēšana
 DocType: Sales Invoice Item,Deferred Revenue,Atliktie ieņēmumi
-DocType: Bank Account,GL Account,GL konts
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Naudas konts tiek izmantots pārdošanas rēķina izveidei
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Atbrīvojuma apakškategorija
 DocType: Member,Membership Expiry Date,Dalības termiņa beigu datums
@@ -4449,13 +4464,13 @@
 DocType: C-Form Invoice Detail,Territory,Teritorija
 DocType: Pricing Rule,Apply Rule On Item Code,Piemērot noteikumu kodu
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,"Lūdzu, norādiet neviena apmeklējumu nepieciešamo"
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Krājumu bilances ziņojums
 DocType: Stock Settings,Default Valuation Method,Default Vērtēšanas metode
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Maksa
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Rādīt kumulatīvo summu
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Atjaunināšana notiek Tas var aizņemt laiku.
 DocType: Production Plan Item,Produced Qty,Ražots daudzums
 DocType: Vehicle Log,Fuel Qty,degvielas Daudz
-DocType: Stock Entry,Target Warehouse Name,Mērķa noliktavas nosaukums
 DocType: Work Order Operation,Planned Start Time,Plānotais Sākuma laiks
 DocType: Course,Assessment,novērtējums
 DocType: Payment Entry Reference,Allocated,Piešķirtas
@@ -4521,10 +4536,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","Standarta noteikumi, kas var pievienot pārdošanu un pirkšanu. Piemēri: 1. derīgums piedāvājumu. 1. Maksājumu noteikumi (iepriekš, uz kredīta, daļa iepriekš uc). 1. Kas ir papildu (vai, kas Klientam jāmaksā). 1. Drošības / izmantošana brīdinājuma. 1. Garantija, ja tāda ir. 1. atgriešanās politiku. 1. Piegādes noteikumi, ja tādi ir. 1. kā risināt strīdus, atlīdzības, atbildību, u.tml 1. Adrese un kontaktinformācija Jūsu uzņēmumā."
 DocType: Homepage Section,Section Based On,Sadaļa balstīta uz
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Rādīt Lietot kupona kodu
 DocType: Issue,Issue Type,Problēmas veids
 DocType: Attendance,Leave Type,Atvaļinājums Type
 DocType: Purchase Invoice,Supplier Invoice Details,Piegādātāju rēķinu Detaļas
 DocType: Agriculture Task,Ignore holidays,Ignorēt brīvdienas
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Pievienot / rediģēt kupona nosacījumus
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Izdevumu / Starpība konts ({0}) ir jābūt ""peļņa vai zaudējumi"" konts"
 DocType: Stock Entry Detail,Stock Entry Child,Stock Entry bērns
 DocType: Project,Copied From,kopēts no
@@ -4700,6 +4717,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Novērtējums plāns Kritēriji
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Darījumi
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Novērst pirkumu pasūtījumus
+DocType: Coupon Code,Coupon Name,Kupona nosaukums
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Uzņēmīgs
 DocType: Email Campaign,Scheduled,Plānotais
 DocType: Shift Type,Working Hours Calculation Based On,"Darba laika aprēķins, pamatojoties uz"
@@ -4716,7 +4734,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Izveidot varianti
 DocType: Vehicle,Diesel,dīzelis
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Cenrādis Valūtu nav izvēlēta
+DocType: Quick Stock Balance,Available Quantity,Pieejamais daudzums
 DocType: Purchase Invoice,Availed ITC Cess,Izmantojis ITC Sess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,"Lūdzu, iestatiet instruktora nosaukšanas sistēmu sadaļā Izglītība&gt; Izglītības iestatījumi"
 ,Student Monthly Attendance Sheet,Student Mēneša Apmeklējumu lapa
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Piegādes noteikums attiecas tikai uz Pārdošanu
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Nolietojuma rinda {0}: Nākamais nolietojuma datums nevar būt pirms pirkuma datuma
@@ -4784,8 +4804,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Row {0}: Advance pret Klientu jābūt kredīts
 DocType: Quality Meeting,Quality Meeting,Kvalitātes sanāksme
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-Group grupas
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,"Lūdzu, iestatiet Nosaukšanas sērija uz {0}, izmantojot Iestatīšana&gt; Iestatījumi&gt; Sēriju nosaukšana"
 DocType: Employee,ERPNext User,ERPNext lietotājs
+DocType: Coupon Code,Coupon Description,Kupona apraksts
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Batch ir obligāta rindā {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Batch ir obligāta rindā {0}
 DocType: Company,Default Buying Terms,Pirkšanas noklusējuma nosacījumi
@@ -4950,6 +4970,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Pret Dokumentu Detail Nr
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Dzēšana nav atļauta valstij {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Puse Type ir obligāts
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Piesakies kupona kods
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",Darba kartei {0} var veikt tikai krājuma “Materiālu nodošana ražošanai” tipa ierakstus
 DocType: Quality Inspection,Outgoing,Izejošs
 DocType: Customer Feedback Table,Customer Feedback Table,Klientu atsauksmju tabula
@@ -5102,7 +5123,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Par pirkuma pasūtījuma iesniegšanu
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Pievienot visus piegādātājus
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Row # {0}: piešķirtā summa nedrīkst būt lielāka par nesamaksāto summu.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Klients&gt; Klientu grupa&gt; Teritorija
 DocType: Tally Migration,Parties,Ballītes
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Pārlūkot BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Nodrošināti aizdevumi
@@ -5134,7 +5154,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Nevar atļaut iestatīt alternatīvu objektu vienumam {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Datums tiek atkārtots
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Autorizēts Parakstītājs
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,"Lūdzu, iestatiet instruktora nosaukšanas sistēmu sadaļā Izglītība&gt; Izglītības iestatījumi"
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Pieejams neto ITC (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Izveidot maksas
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Total Cost iegāde (via pirkuma rēķina)
@@ -5159,6 +5178,7 @@
 DocType: Quiz Result,Wrong,Nepareizi
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Ātrums, kādā cenrādis valūta tiek pārvērsts klienta bāzes valūtā"
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Net Summa (Uzņēmējdarbības valūta)
+DocType: Sales Partner,Referral Code,Nodošanas kods
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Kopējā avansa summa nevar būt lielāka par kopējo sankciju summu
 DocType: Salary Slip,Hour Rate,Stundas likme
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Iespējot automātisko atkārtotu pasūtīšanu
@@ -5288,6 +5308,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Rādīt atlikumu daudzumu
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Neto naudas no operāciju
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},{0} rinda: rēķina diskonta {2} statusam jābūt {1}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Vienumam {2} nav atrasts UOM konversijas koeficients ({0} -&gt; {1}).
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Prece 4
 DocType: Student Admission,Admission End Date,Uzņemšana beigu datums
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Apakšlīguma
@@ -5310,6 +5331,7 @@
 DocType: Travel Request,Fully Sponsored,Pilnībā sponsorēts
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Reversās žurnāla ieraksts
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Izveidot darba karti
+DocType: Quotation,Referral Sales Partner,Pārdošanas partneris
 DocType: Quality Procedure Process,Process Description,Procesa apraksts
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Klients {0} ir izveidots.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Pašlaik nav nevienas noliktavas noliktavā
@@ -5444,6 +5466,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM Rate
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Augšupielādētā faila lasīšana
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Apstāšanās darba kārtību nevar atcelt, vispirms atceļiet to, lai atceltu"
+DocType: Coupon Code,Coupon Code,Kupona Kods
 DocType: Asset,Journal Entry for Scrap,Journal Entry metāllūžņos
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Lūdzu pull preces no piegādes pavadzīmē
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Rinda {0}: izvēlieties darbstaciju pret operāciju {1}
@@ -5528,6 +5551,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,Nepieciešams “datums”
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Due / Atsauce Date nevar būt pēc {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Datu importēšana un eksportēšana
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired",Diemžēl kupona koda derīguma termiņš ir beidzies
 DocType: Bank Account,Account Details,Konta informācija
 DocType: Crop,Materials Required,Nepieciešamie materiāli
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Nav studenti Atrasts
@@ -5565,6 +5589,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Iet uz Lietotājiem
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Samaksāta summa + norakstīt summa nedrīkst būt lielāka par Grand Kopā
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} nav derīgs Partijas skaits postenī {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,"Lūdzu, ievadiet derīgu kupona kodu !!"
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Piezīme: Nav pietiekami daudz atvaļinājums bilance Atstāt tipa {0}
 DocType: Task,Task Description,Uzdevuma apraksts
 DocType: Training Event,Seminar,seminārs
@@ -5831,6 +5856,7 @@
 ,TDS Payable Monthly,TDS maksājams katru mēnesi
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,"Rindas, lai aizstātu BOM. Tas var aizņemt dažas minūtes."
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Nevar atskaitīt, ja kategorija ir ""vērtēšanas"" vai ""Novērtēšanas un Total"""
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Lūdzu, iestatiet Personāla nosaukšanas sistēma personāla resursos&gt; HR iestatījumi"
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Kopējie maksājumi
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Sērijas Nos Nepieciešamais par sērijveida postenī {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Match Maksājumi ar rēķini
@@ -5921,6 +5947,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Iegūstiet izejvielas ražošanas vajadzībām
 DocType: Job Opening,Job Title,Amats
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Nākotnes maksājuma atsauce
+DocType: Quotation,Additional Discount and Coupon Code,Papildu atlaide un kupona kods
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} norāda, ka {1} nesniegs citātu, bet visas pozīcijas \ ir citētas. RFQ citātu statusa atjaunināšana."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maksimālais paraugu skaits - {0} jau ir saglabāts partijai {1} un vienumam {2} partijā {3}.
@@ -6150,7 +6177,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Iestatījumi mājas lapā mājas lapā
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} ir aizturēts līdz {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ nav atļauts {0} dēļ rezultātu rādītāja stāvokļa {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Padarīt Pirkuma rēķins
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Izmantotās lapas
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,Izmantotais {0} kupons ir {1}. Atļautais daudzums ir izsmelts
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Vai vēlaties iesniegt materiālo pieprasījumu?
 DocType: Job Offer,Awaiting Response,Gaida atbildi
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6164,6 +6193,7 @@
 DocType: Training Event Employee,Optional,Pēc izvēles
 DocType: Salary Slip,Earning & Deduction,Nopelnot & atskaitīšana
 DocType: Agriculture Analysis Criteria,Water Analysis,Ūdens analīze
+DocType: Sales Order,Skip Delivery Note,Izlaist piegādes piezīmi
 DocType: Price List,Price Not UOM Dependent,Cena nav atkarīga no UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,Izveidoti {0} varianti.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Noklusējuma pakalpojuma līmeņa līgums jau pastāv.
@@ -6272,6 +6302,7 @@
 DocType: Vehicle,Last Carbon Check,Pēdējais Carbon pārbaude
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Juridiskie izdevumi
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,"Lūdzu, izvēlieties daudzums uz rindu"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Darba pasūtījums {0}: darba kartīte operācijai {1} nav atrasta
 DocType: Purchase Invoice,Posting Time,Norīkošanu laiks
 DocType: Timesheet,% Amount Billed,% Summa Jāmaksā
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Telefona izdevumi
@@ -6374,7 +6405,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Nodokļi un maksājumi Pievienoja
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Nolietojuma rinda {0}: Nākamais nolietojuma datums nevar būt pirms pieejamā datuma
 ,Sales Funnel,Pārdošanas piltuve
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Preces kods&gt; Vienību grupa&gt; Zīmols
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Saīsinājums ir obligāta
 DocType: Project,Task Progress,uzdevums Progress
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Rati
@@ -6470,6 +6500,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS Profile jāveic POS Entry
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Lojalitātes punkti tiks aprēķināti no iztērētās pabeigtās summas (izmantojot pārdošanas rēķinu), pamatojoties uz minētajiem savākšanas koeficientiem."
 DocType: Program Enrollment Tool,Enroll Students,uzņemt studentus
+DocType: Pricing Rule,Coupon Code Based,Kupona kods balstīts
 DocType: Company,HRA Settings,HRA iestatījumi
 DocType: Homepage,Hero Section,Varoņu sadaļa
 DocType: Employee Transfer,Transfer Date,Pārsūtīšanas datums
@@ -6586,6 +6617,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',"Lūdzu noteikt Company filtrēt tukšu, ja Group By ir &quot;Uzņēmuma&quot;"
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Norīkošanu datums nevar būt nākotnes datums
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: Sērijas Nr {1} nesakrīt ar {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,"Lūdzu, iestatiet apmeklējumu numerācijas sērijas, izmantojot Iestatīšana&gt; Numerācijas sērija"
 DocType: Stock Entry,Target Warehouse Address,Mērķa noliktavas adrese
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Casual Leave
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,"Laiks pirms maiņas sākuma laika, kurā tiek apsvērta darbinieku reģistrēšanās."
@@ -6620,7 +6652,6 @@
 DocType: Employee Grade,Employee Grade,Darbinieku novērtējums
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Gabaldarbs
 DocType: GSTR 3B Report,June,jūnijs
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Piegādātājs&gt; Piegādātāja tips
 DocType: Share Balance,From No,No Nr
 DocType: Shift Type,Early Exit Grace Period,Agrīnās izejas labvēlības periods
 DocType: Task,Actual Time (in Hours),Faktiskais laiks (stundās)
@@ -6907,7 +6938,6 @@
 DocType: Warehouse,Warehouse Name,Noliktavas nosaukums
 DocType: Naming Series,Select Transaction,Izvēlieties Transaction
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Ievadiet apstiprināšana loma vai apstiprināšana lietotāju
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Vienumam: {2} nav atrasts UOM konversijas koeficients ({0} -&gt; {1}).
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Pakalpojuma līmeņa līgums ar entītijas veidu {0} un entītiju {1} jau pastāv.
 DocType: Journal Entry,Write Off Entry,Uzrakstiet Off Entry
 DocType: BOM,Rate Of Materials Based On,Novērtējiet materiālu specifikācijas Based On
@@ -7046,6 +7076,7 @@
 DocType: Budget,Warn,Brīdināt
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Visi priekšmeti jau ir nodoti šim darba pasūtījumam.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Jebkādas citas piezīmes, ievērības cienīgs piepūles ka jāiet ierakstos."
+DocType: Bank Account,Company Account,Uzņēmuma konts
 DocType: Asset Maintenance,Manufacturing User,Manufacturing User
 DocType: Purchase Invoice,Raw Materials Supplied,Izejvielas Kopā
 DocType: Subscription Plan,Payment Plan,Maksājumu plāns
@@ -7087,6 +7118,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) nevar būt lielāks par plānoto daudzumu ({2}) darba kārtībā {3}
 DocType: Certification Application,Name of Applicant,Dalībnieka vārds
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Time Sheet for ražošanā.
+DocType: Quick Stock Balance,Quick Stock Balance,Ātrs krājumu atlikums
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Starpsumma
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,"Variantu īpašības nevar mainīt pēc akciju darījuma. Lai to paveiktu, jums būs jāveic jauns punkts."
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA mandāts
@@ -7415,6 +7447,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} ir neaktīvs students
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} ir neaktīvs students
 DocType: Employee,Health Details,Veselības Details
+DocType: Coupon Code,Coupon Type,Kupona tips
 DocType: Leave Encashment,Encashable days,Encashable dienas
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Lai izveidotu maksājuma pieprasījums ir nepieciešama atsauces dokuments
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Lai izveidotu maksājuma pieprasījums ir nepieciešama atsauces dokuments
@@ -7703,6 +7736,7 @@
 DocType: Hotel Room Package,Amenities,Ērtības
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Automātiski ienest maksājuma noteikumus
 DocType: QuickBooks Migrator,Undeposited Funds Account,Nemainīgo līdzekļu konts
+DocType: Coupon Code,Uses,Lietojumi
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Vairāki noklusējuma maksājuma veidi nav atļauti
 DocType: Sales Invoice,Loyalty Points Redemption,Lojalitātes punkti Izpirkšana
 ,Appointment Analytics,Iecelšana par Analytics
@@ -7720,6 +7754,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Atstājiet tukšu, ja jūs veicat studentu grupas gadā"
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Atstājiet tukšu, ja jūs veicat studentu grupas gadā"
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Ja ieslēgts, Total nē. Darbadienu būs brīvdienas, un tas samazinātu vērtību Alga dienā"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Neizdevās pievienot domēnu
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Lai atļautu vairāk saņemšanu / piegādi, krājumu iestatījumos vai vienumā atjauniniet vienumu “Pārņemšanas / piegādes pabalsts”."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Lietotnes, kurās tiek izmantota pašreizējā atslēga, nevarēs piekļūt, vai jūs esat pārliecināts?"
 DocType: Subscription Settings,Prorate,Prorāts
@@ -7733,6 +7768,7 @@
 ,BOM Stock Report,BOM Stock pārskats
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Ja nav piešķirts laika intervāls, tad saziņu veiks šī grupa"
 DocType: Stock Reconciliation Item,Quantity Difference,daudzums Starpība
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Piegādātājs&gt; Piegādātāja tips
 DocType: Opportunity Item,Basic Rate,Basic Rate
 DocType: GL Entry,Credit Amount,Kredīta summa
 ,Electronic Invoice Register,Elektroniskais rēķinu reģistrs
@@ -7987,6 +8023,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Nodokļi un maksājumi Atskaitīts (Company valūta)
 DocType: Item Group,General Settings,Vispārīgie iestatījumi
 DocType: Article,Article,Raksts
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,"Lūdzu, ievadiet kupona kodu !!"
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,No valūtu un valūtu nevar būt vienādi
 DocType: Taxable Salary Slab,Percent Deduction,Procentu samazinājums
 DocType: GL Entry,To Rename,Pārdēvēt
diff --git a/erpnext/translations/mk.csv b/erpnext/translations/mk.csv
index 671a670..51f2726 100644
--- a/erpnext/translations/mk.csv
+++ b/erpnext/translations/mk.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Контакт со клиентите
 DocType: Shift Type,Enable Auto Attendance,Овозможи автоматско присуство
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Ве молиме внесете магацин и датум
 DocType: Lost Reason Detail,Opportunity Lost Reason,Изгубена причина за можност
 DocType: Patient Appointment,Check availability,Проверете достапност
 DocType: Retention Bonus,Bonus Payment Date,Датум на исплата на бонус
@@ -264,6 +265,7 @@
 ,Completed Work Orders,Завршени работни налози
 DocType: Support Settings,Forum Posts,Форуми
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Задачата е запишана како позадина работа. Во случај да се појави проблем во обработката во позадина, системот ќе додаде коментар за грешката на ова Спогодување за акции и ќе се врати на нацрт-фазата"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","За жал, валидноста на купонскиот код не е започната"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,оданочливиот износ
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Немате дозвола за да додадете или да ги ажурирате записи пред {0}
 DocType: Leave Policy,Leave Policy Details,Остави детали за политиката
@@ -328,6 +330,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Потрошни
 DocType: Student,B-,Б-
 DocType: Assessment Result,Grade,одделение
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Код на точка&gt; Група на производи&gt; Бренд
 DocType: Restaurant Table,No of Seats,Број на седишта
 DocType: Sales Invoice,Overdue and Discounted,Заостанати и намалени
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Повикот е исклучен
@@ -504,6 +507,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Проред за износот напишан со зборови
 DocType: Vehicle,Additional Details,дополнителни детали
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Нема опис даден
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Земи предмети од магацин
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Барање за купување.
 DocType: POS Closing Voucher Details,Collected Amount,Собран износ
 DocType: Lab Test,Submitted Date,Датум на поднесување
@@ -610,6 +614,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Научат
 ,Trial Balance (Simple),Судскиот биланс (едноставен)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Овозможи одложен расход
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Применет купонски код
 DocType: Asset,Next Depreciation Date,Следна Амортизација Датум
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Трошоци активност по вработен
 DocType: Accounts Settings,Settings for Accounts,Поставки за сметки
@@ -846,8 +851,6 @@
 DocType: Sales Invoice,Total Qty,Вкупно Количина
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 e-mail проект
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 e-mail проект
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Избришете го вработениот <a href=""#Form/Employee/{0}"">{0}</a> \ за да го откажете овој документ"
 DocType: Item,Show in Website (Variant),Прикажи во веб-страница (варијанта)
 DocType: Employee,Health Concerns,Здравствени проблеми
 DocType: Payroll Entry,Select Payroll Period,Изберете Даноци Период
@@ -1012,6 +1015,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Данок за задржување на данок
 DocType: Pricing Rule,Sales Partner,Продажбата партнер
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Сите броеви за оценување на добавувачи.
+DocType: Coupon Code,To be used to get discount,Да се користи за да добиете попуст
 DocType: Buying Settings,Purchase Receipt Required,Купување Прием Потребно
 DocType: Sales Invoice,Rail,Железнички
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Вистинска цена
@@ -1060,6 +1064,7 @@
 DocType: Production Plan,Production Plan,План за производство
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Отворање алатка за создавање фактура
 DocType: Salary Component,Round to the Nearest Integer,Круг до најблискиот интерес
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Оставете предмети што не се на залиха да бидат додадени во кошничката
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Продажбата Враќање
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Поставете Кол во трансакции врз основа на сериски број за внесување
 ,Total Stock Summary,Вкупно Акции Резиме
@@ -1189,6 +1194,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),База час стапка (Фирма валута)
 ,Qty To Be Billed,Количина за да се плати
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Дадени Износ
+DocType: Coupon Code,Gift Card,Честитка
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Резервирана количина за производство: Количина на суровини за производство на производи.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Датум на откуп
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Оваа банкарска трансакција е веќе целосно усогласена
@@ -1278,6 +1284,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Креирај тајмер
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Сметка {0} е внесен повеќе пати
 DocType: Account,Expenses Included In Valuation,Трошоци Вклучени Во Вреднување
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Набавете фактури
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Вие може да продолжите само ако вашето членство истекува во рок од 30 дена
 DocType: Shopping Cart Settings,Show Stock Availability,Прикажи ја достапноста на акциите
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Поставете {0} во категорија на средства {1} или компанија {2}
@@ -1819,6 +1826,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Внесување на артикли и UOM-и
 DocType: Repayment Schedule,Balance Loan Amount,Биланс на кредит Износ
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Додадено на детали
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Извинете, купонскиот код е исцрпен"
 DocType: Communication Medium,Catch All,Фати се
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,распоред на курсот
 DocType: Budget,Applicable on Material Request,Применливо за материјално барање
@@ -1989,6 +1997,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Невалиден Атрибут
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} мора да се поднесе
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Кампањи за е-пошта
+DocType: Sales Partner,To Track inbound purchase,Да се следи влезното купување
 DocType: Buying Settings,Default Supplier Group,Стандардна добавувачка група
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Количините може да биде помалку од или еднакво на {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Максималниот износ кој е подобен за компонентата {0} надминува {1}
@@ -2142,8 +2151,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Направете запис на акции
 DocType: Hotel Room Reservation,Hotel Reservation User,Корисник за резервација на хотел
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Поставете статус
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Поставете серија за нумерирање за присуство преку Поставување&gt; Серии за нумерирање
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Ве молиме изберете префикс прв
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Поставете Серија за именување за {0} преку Поставување&gt; Поставки&gt; Серии за именување
 DocType: Contract,Fulfilment Deadline,Рок на исполнување
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Во близина на тебе
 DocType: Student,O-,О-
@@ -2266,6 +2275,7 @@
 DocType: Quality Meeting Table,Under Review,Под преглед
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Не успеав да се најавам
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Средство {0} создадено
+DocType: Coupon Code,Promotional,Промотивно
 DocType: Special Test Items,Special Test Items,Специјални тестови
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Треба да бидете корисник со улогите на System Manager и менаџерот на елемент за да се регистрирате на Marketplace.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Клучни извештаи
@@ -2304,6 +2314,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc Тип
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Вкупно одобрени процентот за продажбата на тимот треба да биде 100
 DocType: Subscription Plan,Billing Interval Count,Интервал на фактурирање
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Избришете го вработениот <a href=""#Form/Employee/{0}"">{0}</a> \ за да го откажете овој документ"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Назначувања и средби со пациентите
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Недостасува вредност
 DocType: Employee,Department and Grade,Одделение и Одделение
@@ -2404,6 +2416,7 @@
 DocType: Project,Start and End Dates,Отпочнување и завршување
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Условите за исполнување на условите за договорот
 ,Delivered Items To Be Billed,Испорачани ставки за наплата
+DocType: Coupon Code,Maximum Use,Максимална употреба
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Отвори Бум {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Склад не може да се промени за Сериски број
 DocType: Authorization Rule,Average Discount,Просечната попуст
@@ -2563,6 +2576,7 @@
 DocType: Item,Inventory,Инвентар
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Преземете како Json
 DocType: Item,Sales Details,Детали за продажба
+DocType: Coupon Code,Used,Се користи
 DocType: Opportunity,With Items,Со предмети
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Кампањата „{0}“ веќе постои за {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Тим за одржување
@@ -2690,7 +2704,7 @@
 						Serial No cannot be ensured",Не е пронајдена активна спецификација за елемент {0}. Испораката со \ Serial No не може да се обезбеди
 DocType: Sales Partner,Sales Partner Target,Продажбата партнер Целна
 DocType: Loan Type,Maximum Loan Amount,Максимален заем Износ
-DocType: Pricing Rule,Pricing Rule,Цените Правило
+DocType: Coupon Code,Pricing Rule,Цените Правило
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplicate број ролна за ученикот {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplicate број ролна за ученикот {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Материјал Барање за нарачка
@@ -2770,6 +2784,7 @@
 DocType: Payment Schedule,Payment Amount,Исплата Износ
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Датумот на половина ден треба да биде помеѓу работа од датум и датум на завршување на работата
 DocType: Healthcare Settings,Healthcare Service Items,Теми за здравствена заштита
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Невалиден бар-код. Нема ставка прикачена на овој бар-код.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Конзумира Износ
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Нето промени во Пари
 DocType: Assessment Plan,Grading Scale,скала за оценување
@@ -2890,7 +2905,6 @@
 DocType: Share Transfer,Asset Account,Сметка на средства
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Новиот датум на објавување треба да биде во иднина
 DocType: Purchase Invoice,End date of current invoice's period,Датум на завршување на периодот тековната сметка е
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Поставете го системот за именување на вработените во човечки ресурси&gt; Поставки за човечки ресурси
 DocType: Lab Test,Technician Name,Име на техничар
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3171,7 +3185,6 @@
 DocType: Student,Student Mobile Number,Студентски мобилен број
 DocType: Item,Has Variants,Има варијанти
 DocType: Employee Benefit Claim,Claim Benefit For,Claim Benefit For
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Не може да се преоптоварување за Точка {0} во ред {1} повеќе од {2}. За да овозможите преголема наплата, ве молиме поставете ги Подесувања на акции"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Ажурирај го одговорот
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Веќе сте одбрале предмети од {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Име на месечна Дистрибуција
@@ -3460,6 +3473,7 @@
 DocType: Vehicle,Fuel Type,Тип на гориво
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Ве молиме наведете валута во компанијата
 DocType: Workstation,Wages per hour,Плати по час
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Клиент&gt; Група на клиенти&gt; Територија
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Акции рамнотежа во Серија {0} ќе стане негативна {1} за Точка {2} На Магацински {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Следните Материјал Барања биле воспитани автоматски врз основа на нивото повторно цел елемент
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Сметка {0} не е валиден. Валута сметка мора да биде {1}
@@ -3791,6 +3805,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Поднесе Плата фиш
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,На чекање
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Договорот мора да има барем една точна опција
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Нарачки за набавка
 DocType: Account,Inter Company Account,Интер-сметка
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Увоз во Масовно
 DocType: Sales Partner,Address & Contacts,Адреса и контакти
@@ -3801,6 +3816,7 @@
 DocType: POS Profile,[Select],[Избери]
 DocType: Staffing Plan Detail,Number Of Positions,Број на позиции
 DocType: Vital Signs,Blood Pressure (diastolic),Крвен притисок (дијастолен)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Ве молиме изберете го клиентот.
 DocType: SMS Log,Sent To,Испратени до
 DocType: Agriculture Task,Holiday Management,Холидејт менаџмент
 DocType: Payment Request,Make Sales Invoice,Направи Продажна Фактура
@@ -4008,7 +4024,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} не е поднесен
 DocType: Subscription,Trialling,Испитување
 DocType: Sales Invoice Item,Deferred Revenue,Одложен приход
-DocType: Bank Account,GL Account,Сметка за GL
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Парична сметка ќе се користи за креирање на фактура за продажба
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Подгрупа за ослободување
 DocType: Member,Membership Expiry Date,Датум на истекот на членството
@@ -4409,13 +4424,13 @@
 DocType: C-Form Invoice Detail,Territory,Територија
 DocType: Pricing Rule,Apply Rule On Item Code,Применете правило за шифра на точка
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Ве молиме спомнете Број на посети бара
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Извештај за состојбата на состојбата
 DocType: Stock Settings,Default Valuation Method,Метод за проценка стандардно
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Провизија
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Прикажи кумулативен износ
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Ажурирањето е во тек. Тоа може да потрае некое време.
 DocType: Production Plan Item,Produced Qty,Произведено количество
 DocType: Vehicle Log,Fuel Qty,Количина на гориво
-DocType: Stock Entry,Target Warehouse Name,Име на целниот магацин
 DocType: Work Order Operation,Planned Start Time,Планирани Почеток Време
 DocType: Course,Assessment,проценка
 DocType: Payment Entry Reference,Allocated,Распределуваат
@@ -4481,10 +4496,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","Стандардни услови, со кои може да се додаде на продажба и купување. Примери: 1. Важење на понудата. 1. Начин на плаќање (однапред, на кредит, дел однапред итн). 1. Што е екстра (или треба да се плати од страна на клиентите). Предупредување / употреба 1. безбедност. 1. Гаранција ако ги има. 1. враќа на политиката. 1. Услови за превозот, ако е применливо. 1. начини на решавање на спорови, обештетување, одговорност, итн 1. адреса и контакт на вашата компанија."
 DocType: Homepage Section,Section Based On,Секција заснована на
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Покажи Аплицирај код за купон
 DocType: Issue,Issue Type,Тип на проблем
 DocType: Attendance,Leave Type,Отсуство Тип
 DocType: Purchase Invoice,Supplier Invoice Details,Добавувачот Детали за фактура
 DocType: Agriculture Task,Ignore holidays,Игнорирај празници
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Додај / измени Услови за купони
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Расход / Разлика сметка ({0}) мора да биде на сметка &quot;Добивка или загуба&quot;
 DocType: Stock Entry Detail,Stock Entry Child,Детско запишување на акции
 DocType: Project,Copied From,копирани од
@@ -4655,6 +4672,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,План за оценување на критериумите
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Трансакции
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Спречи налози за набавки
+DocType: Coupon Code,Coupon Name,Име на купон
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Подложни
 DocType: Email Campaign,Scheduled,Закажана
 DocType: Shift Type,Working Hours Calculation Based On,Пресметка врз основа на работни часови
@@ -4671,7 +4689,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Креирај Варијанти
 DocType: Vehicle,Diesel,дизел
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Ценовник Валута не е избрано
+DocType: Quick Stock Balance,Available Quantity,Достапна количина
 DocType: Purchase Invoice,Availed ITC Cess,Искористил ИТЦ Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,"Ве молиме, поставете Систем за именување на инструктори во образованието&gt; Поставки за образование"
 ,Student Monthly Attendance Sheet,Студентски Месечен евидентен лист
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Правило за испорака единствено применливо за Продажба
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Ред за амортизација {0}: Следниот датум на амортизација не може да биде пред датумот на набавка
@@ -4739,8 +4759,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Ред {0}: напредување во однос на клиентите мора да бидат кредит
 DocType: Quality Meeting,Quality Meeting,Средба за квалитет
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Не-група до група
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Поставете Серија за именување за {0} преку Поставување&gt; Поставки&gt; Серии за именување
 DocType: Employee,ERPNext User,ERPNext корисник
+DocType: Coupon Code,Coupon Description,Опис на купонот
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Серија е задолжително во ред {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Серија е задолжително во ред {0}
 DocType: Company,Default Buying Terms,Стандардни услови за купување
@@ -4904,6 +4924,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Против Детална л.к
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Бришењето не е дозволено за земјата {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Тип на партијата е задолжително
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Аплицирајте код за купон
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","За работна картичка {0}, можете да го направите само записот на залиха од типот „Трансфер на материјал за производство“"
 DocType: Quality Inspection,Outgoing,Заминување
 DocType: Customer Feedback Table,Customer Feedback Table,Табела за повратни информации од клиенти
@@ -5055,7 +5076,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,На поднесување налог за набавка
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Додај ги сите добавувачи
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,"Ред # {0}: лимит, не може да биде поголем од преостанатиот износ."
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Клиент&gt; Група на клиенти&gt; Територија
 DocType: Tally Migration,Parties,Забави
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Преглед на бирото
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Препорачана кредити
@@ -5087,7 +5107,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Не дозволувајте да поставите алтернативен елемент за ставката {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Датум се повторува
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Овластен потписник
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,"Ве молиме, поставете Систем за именување на инструктори во образованието&gt; Поставки за образование"
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Достапен нето ИТЦ (А) - (Б)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Направете такси
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Вкупен трошок за Набавка (преку Влезна фактура)
@@ -5111,6 +5130,7 @@
 DocType: Quiz Result,Wrong,Погрешно
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Стапка по која Ценовник валута е претворена во основна валута купувачи
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Нето износ (Фирма валута)
+DocType: Sales Partner,Referral Code,референтен код
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Вкупниот износ на претплата не може да биде поголем од вкупниот санкциониран износ
 DocType: Salary Slip,Hour Rate,Цена на час
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Овозможи автоматско повторно нарачување
@@ -5261,6 +5281,7 @@
 DocType: Travel Request,Fully Sponsored,Целосно спонзорирана
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Внесување обратен весник
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Создадете картичка за работа
+DocType: Quotation,Referral Sales Partner,Партнер за продажба на упати
 DocType: Quality Procedure Process,Process Description,Опис на процесот
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Клиентот {0} е создаден.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Немам моментални ставки на пазарот
@@ -5392,6 +5413,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,Бум стапка
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Читање поставена датотека
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Прекинувањето на работната нарачка не може да се откаже, исклучете го прво да го откажете"
+DocType: Coupon Code,Coupon Code,Купонски код
 DocType: Asset,Journal Entry for Scrap,Весник за влез Отпад
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Ве молиме да се повлече предмети од Испратница
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Ред {0}: изберете работна станица против операцијата {1}
@@ -5471,6 +5493,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,Потребен е „датум“
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Поради / референтен датум не може да биде по {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Податоци за увоз и извоз
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","За жал, валидноста на купонскиот код истече"
 DocType: Bank Account,Account Details,детали за сметка
 DocType: Crop,Materials Required,Потребни материјали
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Не е пронајдено студенти
@@ -5508,6 +5531,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Одете на Корисниците
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Уплатениот износ + Отпишана сума не може да биде поголемо од Сѐ Вкупно
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} не е валиден сериски број за ставката {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Ве молиме внесете важечки код за забава !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Забелешка: Не е доволно одмор биланс за Оставете Тип {0}
 DocType: Task,Task Description,Опис на задачата
 DocType: Training Event,Seminar,Семинар
@@ -5773,6 +5797,7 @@
 ,TDS Payable Monthly,TDS се плаќа месечно
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Наведени за замена на Бум. Може да потрае неколку минути.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Не може да се одземе кога категорија е за 'Вреднување' или 'Вреднување и Вкупно'
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Поставете го системот за именување на вработените во човечки ресурси&gt; Поставки за човечки ресурси
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Вкупно плаќања
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Сериски броеви кои се потребни за серијали Точка {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Натпреварот плаќања со фактури
@@ -5861,6 +5886,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Земете сирови материјали за производство
 DocType: Job Opening,Job Title,Работно место
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Идно плаќање Реф
+DocType: Quotation,Additional Discount and Coupon Code,Дополнителен попуст и код за купон
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} покажува дека {1} нема да обезбеди цитат, но сите елементи \ биле цитирани. Ажурирање на статусот на понуда за понуда."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Максималните примероци - {0} веќе се задржани за Серија {1} и Точка {2} во Серија {3}.
@@ -6088,6 +6114,7 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Подесувања за веб-сајт почетната страница од пребарувачот
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} е на чекање до {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},Барањата за RFQ не се дозволени за {0} поради поставената оценка од {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Направете Набавка Фактура
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Користени листови
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Дали сакате да го доставите материјалното барање
 DocType: Job Offer,Awaiting Response,Чекам одговор
@@ -6102,6 +6129,7 @@
 DocType: Training Event Employee,Optional,Факултативно
 DocType: Salary Slip,Earning & Deduction,Заработувајќи &amp; Одбивање
 DocType: Agriculture Analysis Criteria,Water Analysis,Анализа на вода
+DocType: Sales Order,Skip Delivery Note,Прескокнете белешка за испорака
 DocType: Price List,Price Not UOM Dependent,Цена не зависен од UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} создадени варијанти.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Веќе постои Договорен договор за ниво на услуга.
@@ -6309,7 +6337,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Даноци и давачки Додадено
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Ред на амортизација {0}: Следниот датум на амортизација не може да биде пред датумот на достапност за употреба
 ,Sales Funnel,Продажбата на инка
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Код на точка&gt; Група на производи&gt; Бренд
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Кратенка задолжително
 DocType: Project,Task Progress,задача за напредокот
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Количка
@@ -6404,6 +6431,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS Профил потребно да се направи ПОС Влегување
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Точките за лојалност ќе се пресметаат од потрошеното (преку фактурата за продажба), врз основа на споменатиот фактор на наплата."
 DocType: Program Enrollment Tool,Enroll Students,Студентите кои се запишуваат
+DocType: Pricing Rule,Coupon Code Based,Врз основа на купонски код
 DocType: Company,HRA Settings,Поставувања за HRA
 DocType: Homepage,Hero Section,Дел херој
 DocType: Employee Transfer,Transfer Date,Датум на пренос
@@ -6518,6 +6546,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Поставете компанијата филтер празно ако група од страна е &quot;Друштвото&quot;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Датум на објавување не може да биде иднина
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Ред # {0}: Сериски Не {1} не се совпаѓа со {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Поставете серија за нумерирање за присуство преку Поставување&gt; Серии за нумерирање
 DocType: Stock Entry,Target Warehouse Address,Адреса за целни складишта
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Обичните Leave
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,"Времето пред времето на започнување на смената, за време на кое пријавувањето на вработените се смета за присуство."
@@ -6552,7 +6581,6 @@
 DocType: Employee Grade,Employee Grade,Вработен одделение
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Плаќаат на парче
 DocType: GSTR 3B Report,June,Јуни
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Добавувач&gt; Тип на снабдувач
 DocType: Share Balance,From No,Од бр
 DocType: Shift Type,Early Exit Grace Period,Предвремен период на благодат
 DocType: Task,Actual Time (in Hours),Крај на времето (во часови)
@@ -6972,6 +7000,7 @@
 DocType: Budget,Warn,Предупреди
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Сите предмети веќе се префрлени за овој работен налог.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Било други забелешки, да се спомене напори кои треба да одат во евиденцијата."
+DocType: Bank Account,Company Account,Сметка на компанијата
 DocType: Asset Maintenance,Manufacturing User,Производство корисник
 DocType: Purchase Invoice,Raw Materials Supplied,Суровини Опрема што се испорачува
 DocType: Subscription Plan,Payment Plan,План за исплата
@@ -7013,6 +7042,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) не може да биде поголема од планираната количина ({2}) во работниот налог {3}
 DocType: Certification Application,Name of Applicant,Име на апликантот
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Временски план за производство.
+DocType: Quick Stock Balance,Quick Stock Balance,Брз биланс на состојба
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,субтотална
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Не може да се променат својствата на варијанта по трансакција со акции. Ќе треба да направите нова ставка за да го направите тоа.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,Мапа на SEPA без овластување
@@ -7337,6 +7367,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} е неактивен ученикот
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} е неактивен ученикот
 DocType: Employee,Health Details,Детали за здравство
+DocType: Coupon Code,Coupon Type,Тип на купон
 DocType: Leave Encashment,Encashable days,Датуми што може да се приклучат
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Да се создаде Барање исплата е потребно референтен документ
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Да се создаде Барање исплата е потребно референтен документ
@@ -7621,6 +7652,7 @@
 DocType: Hotel Room Package,Amenities,Услуги
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Автоматски дополнете услови за плаќање
 DocType: QuickBooks Migrator,Undeposited Funds Account,Сметка за недоделени фондови
+DocType: Coupon Code,Uses,Употреби
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Не е дозволен повеќекратен стандарден начин на плаќање
 DocType: Sales Invoice,Loyalty Points Redemption,Откуп на поени за лојалност
 ,Appointment Analytics,Именување на анализи
@@ -7638,6 +7670,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Оставете го празно ако се направи на студентите групи годишно
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Оставете го празно ако се направи на студентите групи годишно
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Ако е обележано, Вкупно бр. на работните денови ќе бидат вклучени празници, а со тоа ќе се намали вредноста на платата по ден"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Не успеав да додадам домен
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","За да дозволите над приемот / испораката, ажурирајте го &quot;Дополнителен прием / испорака за доставување&quot; во поставките за акции или предметот."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Апликациите што користат тековен клуч нема да можат да пристапат, дали сте сигурни?"
 DocType: Subscription Settings,Prorate,Продре
@@ -7651,6 +7684,7 @@
 ,BOM Stock Report,Бум Пријави Акции
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Ако нема доделен временски распоред, тогаш оваа група ќе се ракува со комуникацијата"
 DocType: Stock Reconciliation Item,Quantity Difference,Кол разликата
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Добавувач&gt; Тип на снабдувач
 DocType: Opportunity Item,Basic Rate,Основната стапка
 DocType: GL Entry,Credit Amount,Износ на кредитот
 ,Electronic Invoice Register,Регистар на електронски фактури
@@ -7902,6 +7936,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Даноци и такси одзема (Фирма валута)
 DocType: Item Group,General Settings,Општи поставки
 DocType: Article,Article,Член
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Ве молиме внесете го купонскиот код !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Од валутен и до Валута не може да биде ист
 DocType: Taxable Salary Slab,Percent Deduction,Процентуална одбивка
 DocType: GL Entry,To Rename,Преименување
diff --git a/erpnext/translations/ml.csv b/erpnext/translations/ml.csv
index 39b0d42..33db47f 100644
--- a/erpnext/translations/ml.csv
+++ b/erpnext/translations/ml.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,കസ്റ്റമർ കോൺടാക്റ്റ്
 DocType: Shift Type,Enable Auto Attendance,യാന്ത്രിക ഹാജർ പ്രാപ്‌തമാക്കുക
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,വെയർഹ house സും തീയതിയും നൽകുക
 DocType: Lost Reason Detail,Opportunity Lost Reason,അവസരം നഷ്ടപ്പെട്ട കാരണം
 DocType: Patient Appointment,Check availability,ലഭ്യത ഉറപ്പു വരുത്തുക
 DocType: Retention Bonus,Bonus Payment Date,ബോണസ് പേയ്മെന്റ് തീയതി
@@ -260,6 +261,7 @@
 ,Completed Work Orders,പൂർത്തിയായ തൊഴിൽ ഉത്തരവുകൾ
 DocType: Support Settings,Forum Posts,ഫോറം പോസ്റ്റുകൾ
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","ടാസ്ക് ഒരു പശ്ചാത്തല ജോലിയായി ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. പശ്ചാത്തലത്തിൽ പ്രോസസ് ചെയ്യുന്നതിൽ എന്തെങ്കിലും പ്രശ്നമുണ്ടെങ്കിൽ, സിസ്റ്റം ഈ സ്റ്റോക്ക് അനുരഞ്ജനത്തിലെ പിശകിനെക്കുറിച്ച് ഒരു അഭിപ്രായം ചേർത്ത് ഡ്രാഫ്റ്റ് ഘട്ടത്തിലേക്ക് മടങ്ങും"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","ക്ഷമിക്കണം, കൂപ്പൺ കോഡ് സാധുത ആരംഭിച്ചിട്ടില്ല"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,ടാക്സബിളല്ല തുക
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},നിങ്ങൾ {0} മുമ്പായി എൻട്രികൾ ചേർക്കാൻ അല്ലെങ്കിൽ അപ്ഡേറ്റ് ചെയ്യാൻ അധികാരമില്ല
 DocType: Leave Policy,Leave Policy Details,നയ വിശദാംശങ്ങൾ വിടുക
@@ -324,6 +326,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Consumable
 DocType: Student,B-,ലോകോത്തര
 DocType: Assessment Result,Grade,പദവി
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,ഇന കോഡ്&gt; ഐറ്റം ഗ്രൂപ്പ്&gt; ബ്രാൻഡ്
 DocType: Restaurant Table,No of Seats,സീറ്റുകളുടെ എണ്ണം
 DocType: Sales Invoice,Overdue and Discounted,കാലഹരണപ്പെട്ടതും കിഴിവുള്ളതും
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,കോൾ വിച്ഛേദിച്ചു
@@ -501,6 +504,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,വാക്കുകളിൽ തുക വരി വിടവ്
 DocType: Vehicle,Additional Details,കൂടുതൽ വിവരങ്ങൾ
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,വിവരണം നൽകിയിട്ടില്ല
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,വെയർഹൗസിൽ നിന്ന് ഇനങ്ങൾ നേടുക
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,വാങ്ങിയതിന് അഭ്യർത്ഥന.
 DocType: POS Closing Voucher Details,Collected Amount,ശേഖരിച്ച തുക
 DocType: Lab Test,Submitted Date,സമർപ്പിച്ച തീയതി
@@ -608,6 +612,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,അറിയുക
 ,Trial Balance (Simple),ട്രയൽ ബാലൻസ് (ലളിതം)
 DocType: Purchase Invoice Item,Enable Deferred Expense,നിശ്ചിത ചെലവ് പ്രവർത്തനക്ഷമമാക്കുക
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,പ്രയോഗിച്ച കൂപ്പൺ കോഡ്
 DocType: Asset,Next Depreciation Date,അടുത്ത മൂല്യത്തകർച്ച തീയതി
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,ജീവനക്കാർ ശതമാനം പ്രവർത്തനം ചെലവ്
 DocType: Accounts Settings,Settings for Accounts,അക്കൗണ്ടുകൾക്കുമുള്ള ക്രമീകരണങ്ങൾ
@@ -840,8 +845,6 @@
 DocType: Sales Invoice,Total Qty,ആകെ Qty
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,ഗുഅര്ദിഅന്൨ ഇമെയിൽ ഐഡി
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,ഗുഅര്ദിഅന്൨ ഇമെയിൽ ഐഡി
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","ഈ പ്രമാണം റദ്ദാക്കുന്നതിന് ജീവനക്കാരൻ <a href=""#Form/Employee/{0}"">{0}</a> delete ഇല്ലാതാക്കുക"
 DocType: Item,Show in Website (Variant),വെബ്സൈറ്റിൽ കാണിക്കുക (വേരിയന്റ്)
 DocType: Employee,Health Concerns,ആരോഗ്യ ആശങ്കകൾ
 DocType: Payroll Entry,Select Payroll Period,ശമ്പളപ്പട്ടിക കാലാവധി തിരഞ്ഞെടുക്കുക
@@ -1003,6 +1006,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,ടാക്സ് വിത്ത്ഹോൾഡിംഗ് അക്കൗണ്ട്
 DocType: Pricing Rule,Sales Partner,സെയിൽസ് പങ്കാളി
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,എല്ലാ വിതരണ സ്റ്റോർകാർഡ്സും.
+DocType: Coupon Code,To be used to get discount,കിഴിവ് ലഭിക്കാൻ ഉപയോഗിക്കും
 DocType: Buying Settings,Purchase Receipt Required,വാങ്ങൽ രസീത് ആവശ്യമാണ്
 DocType: Sales Invoice,Rail,റെയിൽ
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,യഥാർത്ഥ ചെലവ്
@@ -1050,6 +1054,7 @@
 DocType: Production Plan,Production Plan,ഉല്പാദന പദ്ധതി
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,ഇൻവോയ്സ് ക്രിയേഷൻ ടൂൾ തുറക്കുന്നു
 DocType: Salary Component,Round to the Nearest Integer,അടുത്തുള്ള സംഖ്യയിലേക്ക് റ ound ണ്ട് ചെയ്യുക
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,സ്റ്റോക്കില്ലാത്ത ഇനങ്ങൾ കാർട്ടിലേക്ക് ചേർക്കാൻ അനുവദിക്കുക
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,സെയിൽസ് മടങ്ങിവരവ്
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,സീരിയൽ നോട്ടിഫിക്കേഷൻ അടിസ്ഥാനമാക്കി ഇടപാടുകാരെ ക്യൂട്ടി സജ്ജമാക്കുക
 ,Total Stock Summary,ആകെ ഓഹരി ചുരുക്കം
@@ -1176,6 +1181,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),ബേസ് അന്ത്യസമയം നിരക്ക് (കമ്പനി കറൻസി)
 ,Qty To Be Billed,ബില്ലുചെയ്യേണ്ട ക്യൂട്ടി
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,കൈമാറി തുക
+DocType: Coupon Code,Gift Card,ഗിഫ്റ്റ് കാർഡ്
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,ഉൽ‌പാദനത്തിനായി കരുതിവച്ചിരിക്കുന്ന ക്യൂട്ടി: ഉൽ‌പാദന ഇനങ്ങൾ‌ നിർമ്മിക്കുന്നതിനുള്ള അസംസ്കൃത വസ്തുക്കളുടെ അളവ്.
 DocType: Loyalty Point Entry Redemption,Redemption Date,വീണ്ടെടുക്കൽ തീയതി
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,ഈ ബാങ്ക് ഇടപാട് ഇതിനകം പൂർണ്ണമായും അനുരഞ്ജിപ്പിക്കപ്പെട്ടു
@@ -1264,6 +1270,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,ടൈംഷീറ്റ് സൃഷ്ടിക്കുക
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,അക്കൗണ്ട് {0} ഒന്നിലധികം തവണ നൽകിയിട്ടുണ്ടെന്നും
 DocType: Account,Expenses Included In Valuation,മൂലധനം ഉൾപ്പെടുത്തിയിട്ടുണ്ട് ചിലവുകൾ
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,ഇൻവോയ്സുകൾ വാങ്ങുക
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,നിങ്ങളുടെ അംഗത്വം 30 ദിവസത്തിനുള്ളിൽ കാലഹരണപ്പെടുമ്പോൾ മാത്രമേ നിങ്ങൾക്ക് പുതുക്കാനാകൂ
 DocType: Shopping Cart Settings,Show Stock Availability,സ്റ്റോക്ക് ലഭ്യത കാണിക്കുക
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,As per section 17(5),വകുപ്പ് 17 (5) പ്രകാരം
@@ -1798,6 +1805,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,ഇനങ്ങളും UOM- കളും ഇറക്കുമതി ചെയ്യുന്നു
 DocType: Repayment Schedule,Balance Loan Amount,ബാലൻസ് വായ്പാ തുക
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,വിശദാംശങ്ങളിൽ ചേർത്തു
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","ക്ഷമിക്കണം, കൂപ്പൺ കോഡ് തീർന്നു"
 DocType: Communication Medium,Catch All,എല്ലാം പിടിക്കുക
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,ഷെഡ്യൂൾ കോഴ്സ്
 DocType: Budget,Applicable on Material Request,മെറ്റീരിയൽ അഭ്യർത്ഥനയ്ക്ക് അനുസൃതമായി
@@ -1963,6 +1971,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,അസാധുവായ ആട്രിബ്യൂട്ട്
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} സമർപ്പിക്കേണ്ടതാണ്
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,ഇമെയിൽ കാമ്പെയ്‌നുകൾ
+DocType: Sales Partner,To Track inbound purchase,ഇൻ‌ബ ound ണ്ട് വാങ്ങൽ‌ ട്രാക്കുചെയ്യുന്നതിന്
 DocType: Buying Settings,Default Supplier Group,Default Supplier Group
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},ക്വാണ്ടിറ്റി കുറവോ {0} തുല്യമായിരിക്കണം
 DocType: Department Approver,Department Approver,ഡിപ്പാർട്ട്മെന്റ്അപ്രോവർ
@@ -2114,7 +2123,6 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,സ്റ്റോക്ക് എൻട്രി ഉണ്ടാക്കുക
 DocType: Hotel Room Reservation,Hotel Reservation User,ഹോട്ടൽ റിസർവേഷൻ ഉപയോക്താവ്
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,നില സജ്ജമാക്കുക
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,സജ്ജീകരണം&gt; നമ്പറിംഗ് സീരീസ് വഴി അറ്റൻഡൻസിനായി നമ്പറിംഗ് സീരീസ് സജ്ജമാക്കുക
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,ആദ്യം പ്രിഫിക്സ് തിരഞ്ഞെടുക്കുക
 DocType: Contract,Fulfilment Deadline,പൂർത്തിയാക്കൽ കാലാവധി
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,നിങ്ങളുടെ സമീപം
@@ -2236,6 +2244,7 @@
 DocType: Quality Meeting Table,Under Review,അവലോകനത്തിലാണ്
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,പ്രവേശിക്കുന്നത് പരാജയപ്പെട്ടു
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,അസറ്റ് {0} സൃഷ്ടിച്ചു
+DocType: Coupon Code,Promotional,പ്രമോഷണൽ
 DocType: Special Test Items,Special Test Items,പ്രത്യേക ടെസ്റ്റ് ഇനങ്ങൾ
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Marketplace- ൽ രജിസ്റ്റർ ചെയ്യുന്നതിന് സിസ്റ്റം മാനേജറും ഒരു ഇനം മാനേജുമെന്റ് റോളുകളും ഉള്ള ഒരു ഉപയോക്താവായിരിക്കണം നിങ്ങൾ.
 apps/erpnext/erpnext/config/buying.py,Key Reports,പ്രധാന റിപ്പോർട്ടുകൾ
@@ -2272,6 +2281,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,ഡോക് തരം
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,വിൽപ്പന സംഘത്തെ വേണ്ടി ആകെ നീക്കിവച്ചിരുന്നു ശതമാനം 100 ആയിരിക്കണം
 DocType: Subscription Plan,Billing Interval Count,ബില്ലിംഗ് ഇന്റർവൽ കൗണ്ട്
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","ഈ പ്രമാണം റദ്ദാക്കുന്നതിന് ജീവനക്കാരൻ <a href=""#Form/Employee/{0}"">{0}</a> delete ഇല്ലാതാക്കുക"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,അപ്പോയിൻമെൻറ് ആൻഡ് പേയ്മെന്റ് എൻകൌണ്ടറുകൾ
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,മൂല്യം നഷ്ടമായി
 DocType: Employee,Department and Grade,ഡിപ്പാർട്ട്മെന്റും ഗ്രേഡും
@@ -2372,6 +2383,7 @@
 DocType: Project,Start and End Dates,"ആരംഭ, അവസാന തീയതി"
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,ടെംപ്ലേറ്റ് ടെംപ്ലേറ്റ്മെന്റ് നിബന്ധനകൾ
 ,Delivered Items To Be Billed,ബില്ല് രക്ഷപ്പെട്ടിരിക്കുന്നു ഇനങ്ങൾ
+DocType: Coupon Code,Maximum Use,പരമാവധി ഉപയോഗം
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},തുറക്കുക BOM ലേക്ക് {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,വെയർഹൗസ് സീരിയൽ നമ്പർ വേണ്ടി മാറ്റാൻ കഴിയില്ല
 DocType: Authorization Rule,Average Discount,ശരാശരി ഡിസ്ക്കൌണ്ട്
@@ -2531,6 +2543,7 @@
 DocType: Item,Inventory,ഇൻവെന്ററി
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Json ആയി ഡൗൺലോഡുചെയ്യുക
 DocType: Item,Sales Details,സെയിൽസ് വിശദാംശങ്ങൾ
+DocType: Coupon Code,Used,ഉപയോഗിച്ചു
 DocType: Opportunity,With Items,ഇനങ്ങൾ കൂടി
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',{1} &#39;{2}&#39; എന്നതിനായി &#39;{0}&#39; കാമ്പെയ്‌ൻ ഇതിനകം നിലവിലുണ്ട്.
 DocType: Asset Maintenance,Maintenance Team,മെയിന്റനൻസ് ടീം
@@ -2657,7 +2670,7 @@
 						Serial No cannot be ensured",ഇനത്തിന് {0} സജീവ BOM ഒന്നും കണ്ടെത്തിയില്ല. \ സീരിയൽ ഡെലിവറി ഉറപ്പാക്കാൻ കഴിയില്ല
 DocType: Sales Partner,Sales Partner Target,സെയിൽസ് പങ്കാളി ടാർജറ്റ്
 DocType: Loan Type,Maximum Loan Amount,പരമാവധി വായ്പാ തുക
-DocType: Pricing Rule,Pricing Rule,പ്രൈസിങ് റൂൾ
+DocType: Coupon Code,Pricing Rule,പ്രൈസിങ് റൂൾ
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},വിദ്യാർത്ഥി {0} എന്ന റോൾ നമ്പർ തനിപ്പകർപ്പ്
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},വിദ്യാർത്ഥി {0} എന്ന റോൾ നമ്പർ തനിപ്പകർപ്പ്
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,ഓർഡർ വാങ്ങാൻ മെറ്റീരിയൽ അഭ്യർത്ഥന
@@ -2734,6 +2747,7 @@
 DocType: Payment Schedule,Payment Amount,പേയ്മെന്റ് തുക
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,തീയതി മുതൽ പ്രവർത്തി തീയതി വരെയുള്ള തീയതി മുതൽ പകുതി ദിവസം വരെ ദൈർഘ്യം ഉണ്ടായിരിക്കണം
 DocType: Healthcare Settings,Healthcare Service Items,ഹെൽത്ത് സേവന ഇനങ്ങൾ
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,അസാധുവായ ബാർകോഡ്. ഈ ബാർകോഡിൽ ഒരു ഇനവും അറ്റാച്ചുചെയ്തിട്ടില്ല.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,ക്ഷയിച്ചിരിക്കുന്നു തുക
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,പണമായി നെറ്റ് മാറ്റുക
 DocType: Assessment Plan,Grading Scale,ഗ്രേഡിംഗ് സ്കെയിൽ
@@ -2851,7 +2865,6 @@
 DocType: Share Transfer,Asset Account,അസറ്റ് അക്കൗണ്ട്
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,പുതിയ റിലീസ് തീയതി ഭാവിയിൽ ആയിരിക്കണം
 DocType: Purchase Invoice,End date of current invoice's period,നിലവിലെ ഇൻവോയ്സ് ന്റെ കാലയളവിൽ അന്ത്യം തീയതി
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,ഹ്യൂമൻ റിസോഴ്സ്&gt; എച്ച്ആർ ക്രമീകരണങ്ങളിൽ ജീവനക്കാരുടെ പേരിടൽ സംവിധാനം സജ്ജമാക്കുക
 DocType: Lab Test,Technician Name,സാങ്കേതിക നാമം നാമം
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3129,7 +3142,6 @@
 DocType: Student,Student Mobile Number,സ്റ്റുഡന്റ് മൊബൈൽ നമ്പർ
 DocType: Item,Has Variants,രൂപഭേദങ്ങൾ ഉണ്ട്
 DocType: Employee Benefit Claim,Claim Benefit For,ക്ലെയിം ബെനിഫിറ്റ് ഫോർ ഫോർ
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","{2} എന്നതിനേക്കാൾ {2} വരിയിൽ കൂടുതൽ {0} എന്നതിനായുള്ള overbill സാധ്യമല്ല. ഓവർ-ബില്ലിംഗ് അനുവദിക്കുന്നതിന്, ദയവായി ഓഹരി സജ്ജീകരണങ്ങളിൽ സജ്ജമാക്കുക"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,പ്രതികരണം അപ്ഡേറ്റുചെയ്യുക
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},നിങ്ങൾ ഇതിനകം നിന്ന് {0} {1} ഇനങ്ങൾ തിരഞ്ഞെടുത്തു
 DocType: Monthly Distribution,Name of the Monthly Distribution,പ്രതിമാസ വിതരണം പേര്
@@ -3415,6 +3427,7 @@
 DocType: Vehicle,Fuel Type,ഇന്ധന തരം
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,കമ്പനിയിൽ കറൻസി വ്യക്തമാക്കുക
 DocType: Workstation,Wages per hour,മണിക്കൂറിൽ വേതനം
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,കസ്റ്റമർ&gt; കസ്റ്റമർ ഗ്രൂപ്പ്&gt; ടെറിട്ടറി
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},ബാച്ച് ലെ സ്റ്റോക്ക് ബാലൻസ് {0} സംഭരണശാല {3} ചെയ്തത് ഇനം {2} വേണ്ടി {1} നെഗറ്റീവ് ആയിത്തീരും
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,തുടർന്ന് മെറ്റീരിയൽ അഭ്യർത്ഥനകൾ ഇനത്തിന്റെ റീ-ഓർഡർ തലത്തിൽ അടിസ്ഥാനമാക്കി സ്വയം ഉൾപ്പെടും
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},അക്കൗണ്ട് {0} അസാധുവാണ്. അക്കൗണ്ട് കറന്സി {1} ആയിരിക്കണം
@@ -3742,6 +3755,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,ശമ്പളം ജി സമർപ്പിക്കുക
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,ഹോൾഡ് ചെയ്തിരിക്കുന്നു
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,ഒരു ക്യൂഷന് കുറഞ്ഞത് ഒരു ശരിയായ ഓപ്ഷനുകളെങ്കിലും ഉണ്ടായിരിക്കണം
+apps/erpnext/erpnext/hooks.py,Purchase Orders,വാങ്ങൽ ഓർഡറുകൾ
 DocType: Account,Inter Company Account,ഇന്റർകോർ അക്കൗണ്ട് അക്കൗണ്ട്
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,ബൾക്ക് ലെ ഇംപോർട്ട്
 DocType: Sales Partner,Address & Contacts,വിലാസം &amp; ബന്ധങ്ങൾ
@@ -3752,6 +3766,7 @@
 DocType: POS Profile,[Select],[തിരഞ്ഞെടുക്കുക]
 DocType: Staffing Plan Detail,Number Of Positions,സ്ഥാനങ്ങളുടെ എണ്ണം
 DocType: Vital Signs,Blood Pressure (diastolic),രക്തസമ്മർദ്ദം (ഡയസ്റ്റോളിക്)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,ഉപഭോക്താവിനെ തിരഞ്ഞെടുക്കുക.
 DocType: SMS Log,Sent To,ലേക്ക് അയച്ചു
 DocType: Agriculture Task,Holiday Management,ഹോളിഡേ മാനേജ്മെന്റ്
 DocType: Payment Request,Make Sales Invoice,സെയിൽസ് ഇൻവോയിസ് നിർമ്മിക്കുക
@@ -3958,7 +3973,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} സമർപ്പിച്ചിട്ടില്ലെന്നതും
 DocType: Subscription,Trialling,വിചാരണ
 DocType: Sales Invoice Item,Deferred Revenue,വ്യതിരിക്തമായ വരുമാനം
-DocType: Bank Account,GL Account,GL അക്കൗണ്ട്
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,സെയിൽ ഇൻവോയ്സ് സൃഷ്ടിക്കുന്നതിന് പണ അക്കൗണ്ടുകൾ ഉപയോഗിക്കും
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,സബ്ബ്സ്ക്രിപ്ഷൻ സബ് വിഭാഗം
 DocType: Member,Membership Expiry Date,അംഗത്വം കാലാവധി തീയതി
@@ -4353,13 +4367,13 @@
 DocType: C-Form Invoice Detail,Territory,ടെറിട്ടറി
 DocType: Pricing Rule,Apply Rule On Item Code,ഇനം കോഡിൽ റൂൾ പ്രയോഗിക്കുക
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,ആവശ്യമായ സന്ദർശനങ്ങൾ യാതൊരു സൂചിപ്പിക്കുക
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,സ്റ്റോക്ക് ബാലൻസ് റിപ്പോർട്ട്
 DocType: Stock Settings,Default Valuation Method,സ്ഥിരസ്ഥിതി മൂലധനം രീതിയുടെ
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,ഫീസ്
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,മൊത്തം തുക കാണിക്കുക
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,അപ്ഡേറ്റ് പുരോഗതിയിലാണ്. ഇതിന് കുറച്ച് സമയമെടുത്തേക്കാം.
 DocType: Production Plan Item,Produced Qty,ഉല്പാദിപ്പിച്ച Qty
 DocType: Vehicle Log,Fuel Qty,ഇന്ധന അളവ്
-DocType: Stock Entry,Target Warehouse Name,ടാർഗെറ്റ് വെയർഹൗസ് നാമം
 DocType: Work Order Operation,Planned Start Time,ആസൂത്രണം ചെയ്ത ആരംഭിക്കുക സമയം
 DocType: Course,Assessment,നികുതിചുമത്തല്
 DocType: Payment Entry Reference,Allocated,അലോക്കേറ്റഡ്
@@ -4425,10 +4439,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","സെയിൽസ് ആൻഡ് വാങ്ങലുകൾ ചേർത്തു കഴിയുന്ന സ്റ്റാൻഡേർഡ് നിബന്ധനകള്. ഉദാഹരണങ്ങൾ: ഓഫർ 1. സാധുത. 1. പേയ്മെന്റ് നിബന്ധനകൾ (മുൻകൂറായി, ക്രെഡിറ്റ് ന് ഭാഗം മുൻകൂറായി തുടങ്ങിയവ). 1. അധിക (അല്ലെങ്കിൽ കസ്റ്റമർ വാടകയായ): എന്താണ്. 1. സുരക്ഷ / ഉപയോഗം മുന്നറിയിപ്പ്. 1. വാറന്റി എന്തെങ്കിലും ഉണ്ടെങ്കിൽ. 1. നയം റിട്ടേണ്സ്. ബാധകമായ എങ്കിൽ ഷിപ്പിംഗ് 1. നിബന്ധനകൾ. തുടങ്ങിയവ തർക്കങ്ങൾ സംബോധന 1. വഴികൾ, indemnity, ബാധ്യത, 1. വിശദാംശവും നിങ്ങളുടെ കമ്പനി കോണ്ടാക്ട്."
 DocType: Homepage Section,Section Based On,വിഭാഗം അടിസ്ഥാനമാക്കിയുള്ളത്
+DocType: Shopping Cart Settings,Show Apply Coupon Code,കൂപ്പൺ കോഡ് പ്രയോഗിക്കുക കാണിക്കുക
 DocType: Issue,Issue Type,പ്രശ്ന തരം
 DocType: Attendance,Leave Type,തരം വിടുക
 DocType: Purchase Invoice,Supplier Invoice Details,വിതരണക്കാരൻ ഇൻവോയ്സ് വിശദാംശങ്ങൾ
 DocType: Agriculture Task,Ignore holidays,അവധിദിന അവഗണനകൾ
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,കൂപ്പൺ നിബന്ധനകൾ ചേർക്കുക / എഡിറ്റുചെയ്യുക
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,ചിലവേറിയ / വ്യത്യാസം അക്കൗണ്ട് ({0}) ഒരു &#39;പ്രോഫിറ്റ് അല്ലെങ്കിൽ നഷ്ടം&#39; അക്കൗണ്ട് ആയിരിക്കണം
 DocType: Stock Entry Detail,Stock Entry Child,സ്റ്റോക്ക് എൻട്രി കുട്ടി
 DocType: Project,Copied From,നിന്നും പകർത്തി
@@ -4599,6 +4615,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,അസസ്മെന്റ് പദ്ധതി മാനദണ്ഡം
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,ഇടപാടുകൾ
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,വാങ്ങൽ ഓർഡറുകൾ തടയുക
+DocType: Coupon Code,Coupon Name,കൂപ്പൺ നാമം
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,സംശയിക്കാവുന്ന
 DocType: Email Campaign,Scheduled,ഷെഡ്യൂൾഡ്
 DocType: Shift Type,Working Hours Calculation Based On,പ്രവൃത്തി സമയ കണക്കുകൂട്ടൽ അടിസ്ഥാനമാക്കി
@@ -4615,7 +4632,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,വേരിയന്റുകൾ സൃഷ്ടിക്കുക
 DocType: Vehicle,Diesel,ഡീസൽ
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,വില പട്ടിക കറന്സി തിരഞ്ഞെടുത്തിട്ടില്ല
+DocType: Quick Stock Balance,Available Quantity,ലഭ്യമായ അളവ്
 DocType: Purchase Invoice,Availed ITC Cess,ഐടിസി സെസ്സ് ഉപയോഗിച്ചു
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,വിദ്യാഭ്യാസം&gt; വിദ്യാഭ്യാസ ക്രമീകരണങ്ങളിൽ ഇൻസ്ട്രക്ടർ നാമകരണ സംവിധാനം സജ്ജമാക്കുക
 ,Student Monthly Attendance Sheet,വിദ്യാർത്ഥി പ്രതിമാസ ഹാജർ ഷീറ്റ്
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,വിൽപ്പനയ്ക്കായി മാത്രം ഷിപ്പിംഗ് നിയമം ബാധകമാക്കുന്നു
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,മൂല്യശുദ്ധിവരുത്തൽ നിര {0}: വാങ്ങൽ തീയതിക്കു മുമ്പുള്ള അടുത്ത ഡിപ്രീസിയേഷൻ തീയതി ഉണ്ടായിരിക്കരുത്
@@ -4684,6 +4703,7 @@
 DocType: Quality Meeting,Quality Meeting,ഗുണനിലവാര യോഗം
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,ഗ്രൂപ്പ് നോൺ-ഗ്രൂപ്പ്
 DocType: Employee,ERPNext User,ERPNext ഉപയോക്താവ്
+DocType: Coupon Code,Coupon Description,കൂപ്പൺ വിവരണം
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},ബാച്ച് വരി {0} ൽ നിർബന്ധമായും
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},ബാച്ച് വരി {0} ൽ നിർബന്ധമായും
 DocType: Company,Default Buying Terms,സ്ഥിരസ്ഥിതി വാങ്ങൽ നിബന്ധനകൾ
@@ -4844,6 +4864,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,ഡോക്യുമെന്റ് വിശദാംശം പോസ്റ്റ് എഗൻസ്റ്റ്
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},രാജ്യം {0} എന്നതിനായി ഇല്ലാതാക്കൽ അനുവദനീയമല്ല
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,പാർട്ടി ഇനം നിർബന്ധമായും
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,കൂപ്പൺ കോഡ് പ്രയോഗിക്കുക
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","ജോബ് കാർഡിനായി {0}, നിങ്ങൾക്ക് &#39;നിർമ്മാണത്തിനായുള്ള മെറ്റീരിയൽ കൈമാറ്റം&#39; തരം സ്റ്റോക്ക് എൻട്രി മാത്രമേ ചെയ്യാൻ കഴിയൂ"
 DocType: Quality Inspection,Outgoing,അയയ്ക്കുന്ന
 DocType: Customer Feedback Table,Customer Feedback Table,ഉപഭോക്തൃ ഫീഡ്‌ബാക്ക് പട്ടിക
@@ -4994,7 +5015,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,വാങ്ങൽ ഓർഡർ സമർപ്പണത്തിൽ
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,എല്ലാ വിതരണക്കാരെയും ചേർക്കുക
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,വരി # {0}: തുക കുടിശ്ശിക തുക അധികമാകരുത് കഴിയില്ല.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,കസ്റ്റമർ&gt; കസ്റ്റമർ ഗ്രൂപ്പ്&gt; ടെറിട്ടറി
 DocType: Tally Migration,Parties,പാർട്ടികൾ
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,ബ്രൗസ് BOM ലേക്ക്
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,അടച്ച് വായ്പകൾ
@@ -5025,7 +5045,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},ഇനത്തിന് പകരം മറ്റൊന്ന് സജ്ജീകരിക്കാൻ അനുവദിക്കരുത് {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,തീയതി ആവർത്തിക്കുന്നുണ്ട്
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,അധികാരങ്ങളും നല്കുകയും
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,വിദ്യാഭ്യാസം&gt; വിദ്യാഭ്യാസ ക്രമീകരണങ്ങളിൽ ഇൻസ്ട്രക്ടർ നാമകരണ സംവിധാനം സജ്ജമാക്കുക
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),നെറ്റ് ഐടിസി ലഭ്യമാണ് (എ) - (ബി)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,ഫീസ് സൃഷ്ടിക്കുക
 DocType: Project,Total Purchase Cost (via Purchase Invoice),(വാങ്ങൽ ഇൻവോയിസ് വഴി) ആകെ വാങ്ങൽ ചെലവ്
@@ -5049,6 +5068,7 @@
 DocType: Quiz Result,Wrong,തെറ്റാണ്
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,വില പട്ടിക കറൻസി ഉപഭോക്താവിന്റെ അടിസ്ഥാന കറൻസി മാറ്റുമ്പോൾ തോത്
 DocType: Purchase Invoice Item,Net Amount (Company Currency),തുക (കമ്പനി കറൻസി)
+DocType: Sales Partner,Referral Code,റഫറൽ കോഡ്
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,മൊത്തം മുൻകൂർ തുകയിൽ കൂടുതൽ മുൻകൂർ തുകയായിരിക്കില്ല
 DocType: Salary Slip,Hour Rate,അന്ത്യസമയം റേറ്റ്
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,യാന്ത്രിക പുന -ക്രമീകരണം പ്രവർത്തനക്ഷമമാക്കുക
@@ -5176,6 +5196,7 @@
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian1,ഗുഅര്ദിഅന്൧ കൂടെ
 DocType: Shopping Cart Settings,Show Stock Quantity,സ്റ്റോക്ക് അളവ് കാണിക്കുക
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,ഓപ്പറേഷൻസ് നിന്നുള്ള നെറ്റ് ക്യാഷ്
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},ഇനത്തിനായി UOM പരിവർത്തന ഘടകം ({0} -&gt; {1}) കണ്ടെത്തിയില്ല: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,ഇനം 4
 DocType: Student Admission,Admission End Date,അഡ്മിഷൻ അവസാന തീയതി
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,ഉപ-കരാര്
@@ -5198,6 +5219,7 @@
 DocType: Travel Request,Fully Sponsored,പൂർണ്ണമായി സ്പോൺസർ ചെയ്തത്
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,ജേണൽ എൻട്രി റിവേഴ്സ് ചെയ്യുക
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,ജോബ് കാർഡ് സൃഷ്ടിക്കുക
+DocType: Quotation,Referral Sales Partner,റഫറൽ സെയിൽസ് പാർട്ണർ
 DocType: Quality Procedure Process,Process Description,പ്രോസസ്സ് വിവരണം
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,ഉപഭോക്താവ് {0} സൃഷ്ടിച്ചു.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,ഏതൊരു വെയർഹൌസിലും നിലവിൽ സ്റ്റോക്കില്ല
@@ -5329,6 +5351,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM റേറ്റ്
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,അപ്‌ലോഡുചെയ്‌ത ഫയൽ വായിക്കുന്നു
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","നിർത്തി ജോലി ഓർഡർ റദ്ദാക്കാൻ കഴിയുന്നില്ല, റദ്ദാക്കാൻ ആദ്യം അതിനെ തടഞ്ഞുനിർത്തുക"
+DocType: Coupon Code,Coupon Code,കൂപ്പൺ കോഡ്
 DocType: Asset,Journal Entry for Scrap,സ്ക്രാപ്പ് ജേണൽ എൻട്രി
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,ഡെലിവറി നോട്ട് നിന്നുള്ള ഇനങ്ങൾ pull ദയവായി
 apps/erpnext/erpnext/accounts/utils.py,Journal Entries {0} are un-linked,എൻട്രികൾ {0} അൺ-ലിങ്ക്ഡ് ചെയ്യുന്നു
@@ -5409,6 +5432,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;തീയതി&#39; ആവശ്യമാണ്
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},ഇക്കാരണങ്ങൾ / പരാമർശം തീയതി {0} ശേഷം ആകാൻ പാടില്ല
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,ഡാറ്റാ ഇറക്കുമതി എക്സ്പോർട്ട്
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","ക്ഷമിക്കണം, കൂപ്പൺ കോഡ് സാധുത കാലഹരണപ്പെട്ടു"
 DocType: Bank Account,Account Details,അക്കൗണ്ട് വിശദാംശങ്ങൾ
 DocType: Crop,Materials Required,ആവശ്യമുള്ള മെറ്റീരിയലുകൾ
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,ഇല്ല വിദ്യാർത്ഥികൾ കണ്ടെത്തിയില്ല
@@ -5446,6 +5470,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,ഉപയോക്താക്കളിലേക്ക് പോകുക
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,തുക + തുക ആകെ മൊത്തം വലുതായിരിക്കും കഴിയില്ല ഓഫാക്കുക എഴുതുക
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} ഇനം {1} ഒരു സാധുവായ ബാച്ച് നമ്പർ അല്ല
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,സാധുവായ കൂപ്പൺ കോഡ് നൽകുക !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},കുറിപ്പ്: വേണ്ടത്ര ലീവ് ബാലൻസ് അനുവാദ ടൈപ്പ് {0} വേണ്ടി ഇല്ല
 DocType: Task,Task Description,ടാസ്ക് വിവരണം
 DocType: Training Event,Seminar,സെമിനാര്
@@ -5711,6 +5736,7 @@
 ,TDS Payable Monthly,ടി ടി എസ് മാസിക മാസം
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,BOM- യ്ക്കു പകരം ക്യൂവിലുള്ള. ഇതിന് അൽപ്പസമയമെടുത്തേക്കാം.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"വിഭാഗം &#39;മൂലധനം&#39; അഥവാ &#39;മൂലധനം, മൊത്ത&#39; വേണ്ടി എപ്പോൾ കുറയ്ക്കാവുന്നതാണ് ചെയ്യാൻ കഴിയില്ല"
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,ഹ്യൂമൻ റിസോഴ്സ്&gt; എച്ച്ആർ ക്രമീകരണങ്ങളിൽ ജീവനക്കാരുടെ പേരിടൽ സംവിധാനം സജ്ജമാക്കുക
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,ആകെ പേയ്‌മെന്റുകൾ
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},സീരിയൽ ഇനം {0} വേണ്ടി സീരിയൽ ഒഴിവ് ആവശ്യമുണ്ട്
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,ഇൻവോയിസുകൾ കളിയിൽ പേയ്മെന്റുകൾ
@@ -5797,6 +5823,7 @@
 DocType: Production Plan,Get Raw Materials For Production,ഉത്പാദനത്തിനായി അസംസ്കൃത വസ്തുക്കൾ ലഭിക്കുക
 DocType: Job Opening,Job Title,തൊഴില് പേര്
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,ഭാവി പേയ്‌മെന്റ് റഫ
+DocType: Quotation,Additional Discount and Coupon Code,അധിക കിഴിവും കൂപ്പൺ കോഡും
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0}, {1} ഒരു ഉദ്ധരണനം നൽകില്ലെന്ന് സൂചിപ്പിക്കുന്നു, എന്നാൽ എല്ലാ ഇനങ്ങളും ഉദ്ധരിക്കുന്നു. RFQ ഉദ്ധരണി നില അപ്ഡേറ്റുചെയ്യുന്നു."
 DocType: Manufacturing Settings,Update BOM Cost Automatically,BOM നിര സ്വയമേ അപ്ഡേറ്റ് ചെയ്യുക
@@ -6007,6 +6034,7 @@
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Invoice {0} no longer exists,ഇൻവോയ്സ് {0} നിലവിലില്ല
 DocType: Guardian Interest,Guardian Interest,ഗാർഡിയൻ പലിശ
 DocType: Volunteer,Availability,ലഭ്യത
+apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.py,Leave application is linked with leave allocations {0}. Leave application cannot be set as leave without pay,ലീവ് ആപ്ലിക്കേഷൻ അവധി അലോക്കേഷനുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു {0}. അവധി അപേക്ഷ ശമ്പളമില്ലാതെ അവധി ആയി സജ്ജമാക്കാൻ കഴിയില്ല
 apps/erpnext/erpnext/config/retail.py,Setup default values for POS Invoices,POS ഇൻവോയിസുകൾക്കായി സ്ഥിര മൂല്യങ്ങൾ സജ്ജമാക്കുക
 DocType: Employee Training,Training,പരിശീലനം
 DocType: Project,Time to send,അയയ്ക്കാനുള്ള സമയം
@@ -6020,6 +6048,7 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,വെബ്സൈറ്റ് ഹോംപേജിൽ ക്രമീകരണങ്ങൾ
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},{1} എന്ന സ്കോർകാർഡ് സ്റ്റാൻഡേർഡ് കാരണം {0}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,വാങ്ങൽ ഇൻവോയ്സ് ഉണ്ടാക്കുക
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,ഉപയോഗിച്ച ഇലകൾ
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,മെറ്റീരിയൽ അഭ്യർത്ഥന സമർപ്പിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുണ്ടോ
 DocType: Job Offer,Awaiting Response,കാത്തിരിക്കുന്നു പ്രതികരണത്തിന്റെ
@@ -6033,6 +6062,7 @@
 DocType: Training Event Employee,Optional,ഓപ്ഷണൽ
 DocType: Salary Slip,Earning & Deduction,സമ്പാദിക്കാനുള്ള &amp; കിഴിച്ചുകൊണ്ടു
 DocType: Agriculture Analysis Criteria,Water Analysis,ജല വിശകലനം
+DocType: Sales Order,Skip Delivery Note,ഡെലിവറി കുറിപ്പ് ഒഴിവാക്കുക
 DocType: Price List,Price Not UOM Dependent,വില UOM ആശ്രിതമല്ല
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} വകഭേദങ്ങൾ സൃഷ്ടിച്ചു.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,ഒരു സ്ഥിരസ്ഥിതി സേവന ലെവൽ കരാർ ഇതിനകം നിലവിലുണ്ട്.
@@ -6239,7 +6269,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,നികുതി ചാർജുകളും ചേർത്തു
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,മൂല്യശുദ്ധീകരണ വരി {0}: ലഭ്യമായ മൂല്യവിനിമയ തീയതിയ്ക്ക് തൊട്ടടുത്തുള്ള വില വ്യത്യാസം തീയതി ഉണ്ടായിരിക്കരുത്
 ,Sales Funnel,സെയിൽസ് നാലുവിക്കറ്റ്
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,ഇന കോഡ്&gt; ഐറ്റം ഗ്രൂപ്പ്&gt; ബ്രാൻഡ്
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,ചുരുക്കെഴുത്ത് നിർബന്ധമാണ്
 DocType: Project,Task Progress,ടാസ്ക് പുരോഗതി
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,കാർട്ട്
@@ -6333,6 +6362,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS ൽ എൻട്രി ഉണ്ടാക്കുവാൻ ആവശ്യമായ POS പ്രൊഫൈൽ
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",സൂചിപ്പിച്ച ശേഖര ഘടകം അടിസ്ഥാനമാക്കിയുള്ള ചെലവിൽ (വിൽപ്പന ഇൻവോയ്സ് വഴി) ലോയൽറ്റി പോയിന്റുകൾ കണക്കാക്കപ്പെടും.
 DocType: Program Enrollment Tool,Enroll Students,വിദ്യാർഥികൾ എൻറോൾ
+DocType: Pricing Rule,Coupon Code Based,കൂപ്പൺ കോഡ് അടിസ്ഥാനമാക്കിയുള്ളത്
 DocType: Company,HRA Settings,HRA സജ്ജീകരണങ്ങൾ
 DocType: Homepage,Hero Section,ഹീറോ വിഭാഗം
 DocType: Employee Transfer,Transfer Date,തീയതി കൈമാറുക
@@ -6448,6 +6478,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',ശൂന്യമായ ഫിൽട്ടർ ഗ്രൂപ്പ് &#39;കമ്പനി&#39; എങ്കിൽ കമ്പനി സജ്ജമാക്കുക
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,പോസ്റ്റുചെയ്ത തീയതി ഭാവി തീയതി കഴിയില്ല
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},വരി # {0}: സീരിയൽ ഇല്ല {1} {2} {3} കൂടെ പൊരുത്തപ്പെടുന്നില്ല
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,സജ്ജീകരണം&gt; നമ്പറിംഗ് സീരീസ് വഴി അറ്റൻഡൻസിനായി നമ്പറിംഗ് സീരീസ് സജ്ജമാക്കുക
 DocType: Stock Entry,Target Warehouse Address,ടാർഗറ്റ് വേൾഹൗസ് വിലാസം
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,കാഷ്വൽ ലീവ്
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,ജീവനക്കാരുടെ ചെക്ക്-ഇൻ ഹാജരാകാൻ പരിഗണിക്കുന്ന ഷിഫ്റ്റ് ആരംഭ സമയത്തിന് മുമ്പുള്ള സമയം.
@@ -6482,7 +6513,6 @@
 DocType: Employee Grade,Employee Grade,തൊഴിലുടമ ഗ്രേഡ്
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Piecework
 DocType: GSTR 3B Report,June,ജൂൺ
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,വിതരണക്കാരൻ&gt; വിതരണ തരം
 DocType: Share Balance,From No,ഇല്ല
 DocType: Shift Type,Early Exit Grace Period,ആദ്യകാല എക്സിറ്റ് ഗ്രേസ് പിരീഡ്
 DocType: Task,Actual Time (in Hours),(അവേഴ്സ്) യഥാർത്ഥ സമയം
@@ -6765,7 +6795,6 @@
 DocType: Warehouse,Warehouse Name,വെയർഹൗസ് പേര്
 DocType: Naming Series,Select Transaction,ഇടപാട് തിരഞ്ഞെടുക്കുക
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,റോൾ അംഗീകരിക്കുന്നു അല്ലെങ്കിൽ ഉപയോക്താവ് അംഗീകരിക്കുന്നു നൽകുക
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},ഇനത്തിനായി UOM പരിവർത്തന ഘടകം ({0} -&gt; {1}) കണ്ടെത്തിയില്ല: {2}
 DocType: Journal Entry,Write Off Entry,എൻട്രി എഴുതുക
 DocType: BOM,Rate Of Materials Based On,മെറ്റീരിയൽസ് അടിസ്ഥാനത്തിൽ ഓൺ നിരക്ക്
 DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","പ്രാപ്തമാക്കിയാൽ, ഫീൽഡ് അക്കാദമിക് ടേം പ്രോഗ്രാം എൻറോൾമെന്റ് ടൂളിൽ നിർബന്ധമാണ്."
@@ -6901,6 +6930,7 @@
 DocType: Budget,Warn,മുന്നറിയിപ്പുകൊടുക്കുക
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,ഈ വർക്ക് ഓർഡറിന് എല്ലാ ഇനങ്ങളും ഇതിനകം ട്രാൻസ്ഫർ ചെയ്തു.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","മറ്റേതെങ്കിലും പരാമർശമാണ്, റെക്കോർഡുകൾ ചെല്ലേണ്ടതിന്നു ശ്രദ്ധേയമാണ് ശ്രമം."
+DocType: Bank Account,Company Account,കമ്പനി അക്കൗണ്ട്
 DocType: Asset Maintenance,Manufacturing User,ണം ഉപയോക്താവ്
 DocType: Purchase Invoice,Raw Materials Supplied,നൽകിയത് അസംസ്കൃത വസ്തുക്കൾ
 DocType: Subscription Plan,Payment Plan,പേയ്മെന്റ് പ്ലാൻ
@@ -6940,6 +6970,7 @@
 DocType: Sales Invoice,Commission,കമ്മീഷൻ
 DocType: Certification Application,Name of Applicant,അപേക്ഷകൻറെ പേര്
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,നിർമാണ സമയം ഷീറ്റ്.
+DocType: Quick Stock Balance,Quick Stock Balance,ദ്രുത സ്റ്റോക്ക് ബാലൻസ്
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,ആകെത്തുക
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,സ്റ്റോക്ക് ഇടപാടിനുശേഷം വ്യത്യാസമായ സ്വഭാവസവിശേഷത മാറ്റാനാവില്ല. ഇത് ചെയ്യുന്നതിന് നിങ്ങൾ ഒരു പുതിയ വസ്തു സൃഷ്ടിക്കേണ്ടി വരും.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA മാൻഡേറ്റ്
@@ -7262,6 +7293,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} വിദ്യാർത്ഥി നിഷ്ക്രിയമാണ്
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} വിദ്യാർത്ഥി നിഷ്ക്രിയമാണ്
 DocType: Employee,Health Details,ആരോഗ്യ വിശദാംശങ്ങൾ
+DocType: Coupon Code,Coupon Type,കൂപ്പൺ തരം
 DocType: Leave Encashment,Encashable days,രസകരമായ ദിവസങ്ങൾ
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,ഒരു പേയ്മെന്റ് അഭ്യർത്ഥന റഫറൻസ് പ്രമാണം ആവശ്യമാണ് സൃഷ്ടിക്കാൻ
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,ഒരു പേയ്മെന്റ് അഭ്യർത്ഥന റഫറൻസ് പ്രമാണം ആവശ്യമാണ് സൃഷ്ടിക്കാൻ
@@ -7543,6 +7575,7 @@
 DocType: Hotel Room Package,Amenities,സൌകര്യങ്ങൾ
 DocType: Accounts Settings,Automatically Fetch Payment Terms,പേയ്‌മെന്റ് നിബന്ധനകൾ യാന്ത്രികമായി നേടുക
 DocType: QuickBooks Migrator,Undeposited Funds Account,Undeposited ഫണ്ടുകൾ അക്കൗണ്ട്
+DocType: Coupon Code,Uses,ഉപയോഗങ്ങൾ
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,പണമടയ്ക്കലിന്റെ സ്ഥിരസ്ഥിതി മോഡ് അനുവദനീയമല്ല
 DocType: Sales Invoice,Loyalty Points Redemption,ലോയൽറ്റി പോയിന്റുകൾ റിഡംപ്ഷൻ
 ,Appointment Analytics,അപ്പോയിന്റ്മെൻറ് അനലിറ്റിക്സ്
@@ -7560,6 +7593,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,നിങ്ങൾ പ്രതിവർഷം വിദ്യാർത്ഥികളുടെ ഗ്രൂപ്പുകൾ ഉണ്ടാക്കുന്ന ശൂന്യമായിടൂ
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,നിങ്ങൾ പ്രതിവർഷം വിദ്യാർത്ഥികളുടെ ഗ്രൂപ്പുകൾ ഉണ്ടാക്കുന്ന ശൂന്യമായിടൂ
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","ചെക്കുചെയ്തിട്ടുണ്ടെങ്കിൽ ആകെ എങ്കിൽ. ത്തി ദിവസം വരയന് ഉൾപ്പെടുത്തും, ഈ സാലറി ദിവസം മൂല്യം കുറയ്ക്കും"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,ഡൊമെയ്ൻ ചേർക്കുന്നതിൽ പരാജയപ്പെട്ടു
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","ഓവർ രസീത് / ഡെലിവറി അനുവദിക്കുന്നതിന്, സ്റ്റോക്ക് ക്രമീകരണങ്ങളിലോ ഇനത്തിലോ &quot;ഓവർ രസീത് / ഡെലിവറി അലവൻസ്&quot; അപ്‌ഡേറ്റ് ചെയ്യുക."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","നിലവിലെ കീ ഉപയോഗിക്കുന്ന അപ്ലിക്കേഷനുകൾക്ക് ആക്സസ് ചെയ്യാൻ കഴിയില്ല, നിങ്ങൾക്ക് ഉറപ്പാണോ?"
 DocType: Subscription Settings,Prorate,പ്രോറേറ്റ്
@@ -7573,6 +7607,7 @@
 ,BOM Stock Report,BOM ൽ സ്റ്റോക്ക് റിപ്പോർട്ട്
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","നിയുക്ത ടൈംസ്‌ലോട്ട് ഇല്ലെങ്കിൽ, ആശയവിനിമയം ഈ ഗ്രൂപ്പ് കൈകാര്യം ചെയ്യും"
 DocType: Stock Reconciliation Item,Quantity Difference,ക്വാണ്ടിറ്റി വ്യത്യാസം
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,വിതരണക്കാരൻ&gt; വിതരണ തരം
 DocType: Opportunity Item,Basic Rate,അടിസ്ഥാന റേറ്റ്
 DocType: GL Entry,Credit Amount,ക്രെഡിറ്റ് തുക
 ,Electronic Invoice Register,ഇലക്ട്രോണിക് ഇൻവോയ്സ് രജിസ്റ്റർ
@@ -7825,6 +7860,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),ഒടുക്കിയ നികുതി ചാർജുകളും (കമ്പനി കറൻസി)
 DocType: Item Group,General Settings,പൊതുവായ ക്രമീകരണങ്ങൾ
 DocType: Article,Article,ലേഖനം
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,കൂപ്പൺ കോഡ് നൽകുക !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,കറൻസി കറൻസി ഒരേ ആയിരിക്കും കഴിയില്ല
 DocType: Taxable Salary Slab,Percent Deduction,ശതമാനം കിഴിവ്
 DocType: GL Entry,To Rename,പേരുമാറ്റാൻ
diff --git a/erpnext/translations/mr.csv b/erpnext/translations/mr.csv
index 765054f..36df911 100644
--- a/erpnext/translations/mr.csv
+++ b/erpnext/translations/mr.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,ग्राहक संपर्क
 DocType: Shift Type,Enable Auto Attendance,स्वयं उपस्थिती सक्षम करा
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,कृपया गोदाम आणि तारीख प्रविष्ट करा
 DocType: Lost Reason Detail,Opportunity Lost Reason,संधी गमावले कारण
 DocType: Patient Appointment,Check availability,उपलब्धता तपासा
 DocType: Retention Bonus,Bonus Payment Date,बोनस भरणा तारीख
@@ -263,6 +264,7 @@
 ,Completed Work Orders,पूर्ण झालेले कार्य ऑर्डर
 DocType: Support Settings,Forum Posts,फोरम पोस्ट
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","कार्य पार्श्वभूमी नोकरी म्हणून केले गेले आहे. पार्श्वभूमीवर प्रक्रियेसंदर्भात काही अडचण असल्यास, सिस्टम या स्टॉक सलोखावरील चुकांबद्दल टिप्पणी देईल आणि मसुद्याच्या टप्प्यात परत येईल."
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","क्षमस्व, कूपन कोड वैधता प्रारंभ झालेली नाही"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,करपात्र रक्कम
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},आपल्याला आधी नोंदी जमा करण्यासाठी  किंवा सुधारणा करण्यासाठी अधिकृत नाही {0}
 DocType: Leave Policy,Leave Policy Details,पॉलिसीचे तपशील द्या
@@ -328,6 +330,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Consumable
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,ग्रेड
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,आयटम कोड&gt; आयटम गट&gt; ब्रँड
 DocType: Restaurant Table,No of Seats,सीटची संख्या
 DocType: Sales Invoice,Overdue and Discounted,जादा आणि सूट
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,कॉल डिस्कनेक्ट झाला
@@ -505,6 +508,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,शब्दात रक्कम ओळींतील अंतर
 DocType: Vehicle,Additional Details,अतिरिक्त तपशील
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,वर्णन दिलेले नाही
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,गोदामातून वस्तू आणा
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,खरेदीसाठी विनंती.
 DocType: POS Closing Voucher Details,Collected Amount,एकत्रित रक्कम
 DocType: Lab Test,Submitted Date,सबमिट केलेली तारीख
@@ -611,6 +615,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,जाणून घ्या
 ,Trial Balance (Simple),चाचणी शिल्लक (साधे)
 DocType: Purchase Invoice Item,Enable Deferred Expense,डीफर्ड व्यय सक्षम करा
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,लागू केलेला कूपन कोड
 DocType: Asset,Next Depreciation Date,पुढील घसारा दिनांक
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,कर्मचारी दर क्रियाकलाप खर्च
 DocType: Accounts Settings,Settings for Accounts,खाती सेटिंग्ज
@@ -846,8 +851,6 @@
 DocType: Sales Invoice,Total Qty,एकूण Qty
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 ईमेल आयडी
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 ईमेल आयडी
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","कृपया हा कागदजत्र रद्द करण्यासाठी कर्मचारी <a href=""#Form/Employee/{0}"">{0}.</a> हटवा"
 DocType: Item,Show in Website (Variant),वेबसाइट दर्शवा (चल)
 DocType: Employee,Health Concerns,आरोग्य समस्यांसाठी
 DocType: Payroll Entry,Select Payroll Period,वेतनपट कालावधी निवडा
@@ -1010,6 +1013,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,करधारणा खाते
 DocType: Pricing Rule,Sales Partner,विक्री भागीदार
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,सर्व पुरवठादार स्कोरकार्ड
+DocType: Coupon Code,To be used to get discount,सवलत मिळविण्यासाठी वापरली जाणे
 DocType: Buying Settings,Purchase Receipt Required,खरेदी पावती आवश्यक
 DocType: Sales Invoice,Rail,रेल्वे
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,वास्तविक किंमत
@@ -1058,6 +1062,7 @@
 DocType: Production Plan,Production Plan,उत्पादन योजना
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,चलन तयार करण्याचे साधन
 DocType: Salary Component,Round to the Nearest Integer,जवळचे पूर्णांक पूर्णांक
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,स्टॉकमध्ये नसलेल्या आयटमला कार्टमध्ये जोडण्याची परवानगी द्या
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,विक्री परत
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,अनुक्रमांक इनपुटवर आधारित व्यवहारांची संख्या सेट करा
 ,Total Stock Summary,एकूण शेअर सारांश
@@ -1186,6 +1191,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),बेस तास दर (कंपनी चलन)
 ,Qty To Be Billed,बिल टाकायचे बिल
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,वितरित केले रक्कम
+DocType: Coupon Code,Gift Card,गिफ्ट कार्ड
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,उत्पादनासाठी राखीव ठेवलेली मात्रा: वस्तू बनवण्यासाठी कच्च्या मालाचे प्रमाण.
 DocType: Loyalty Point Entry Redemption,Redemption Date,रिडेम्प्शन तारीख
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,हा बँक व्यवहार आधीपासून पूर्णपणे समेट झाला आहे
@@ -1274,6 +1280,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,टाईमशीट तयार करा
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,खाते {0} अनेक वेळा प्रविष्ट केले गेले आहे
 DocType: Account,Expenses Included In Valuation,खर्च मूल्यांकन मध्ये समाविष्ट
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,पावत्या खरेदी करा
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,आपली सदस्यता 30 दिवसांच्या आत कालबाह्य झाल्यास आपण केवळ नूतनीकरण करू शकता
 DocType: Shopping Cart Settings,Show Stock Availability,शेअर उपलब्धता दर्शवा
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},{0} मालमत्ता श्रेणी {1} किंवा कंपनी {2} मध्ये सेट करा
@@ -1814,6 +1821,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,आयटम आणि यूओएम आयात करीत आहे
 DocType: Repayment Schedule,Balance Loan Amount,शिल्लक कर्ज रक्कम
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,तपशीलामध्ये जोडले
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","क्षमस्व, कूपन कोड संपला आहे"
 DocType: Communication Medium,Catch All,सर्व पकडा
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,वेळापत्रक कोर्स
 DocType: Budget,Applicable on Material Request,भौतिक विनंतीवर लागू
@@ -1984,6 +1992,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,अवैध विशेषता
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} सादर करणे आवश्यक आहे
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,ईमेल मोहिमा
+DocType: Sales Partner,To Track inbound purchase,अंतर्गामी खरेदीचा मागोवा घ्या
 DocType: Buying Settings,Default Supplier Group,डीफॉल्ट पुरवठादार गट
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},प्रमाणात या पेक्षा कमी किंवा या समान असणे आवश्यक आहे {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},घटक {0} साठी पात्र असलेली जास्तीत जास्त रक्कम {1} पेक्षा अधिक आहे
@@ -2138,7 +2147,6 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,स्टॉक एन्ट्री करा
 DocType: Hotel Room Reservation,Hotel Reservation User,हॉटेल आरक्षण वापरकर्ता
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,स्थिती सेट करा
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,कृपया सेटअप&gt; क्रमांकिंग सीरिजद्वारे उपस्थितीसाठी क्रमांकन मालिका सेट करा
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,कृपया पहले उपसर्ग निवडा
 DocType: Contract,Fulfilment Deadline,पूर्तता करण्याची अंतिम मुदत
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,तुमच्या जवळ
@@ -2262,6 +2270,7 @@
 DocType: Quality Meeting Table,Under Review,निरीक्षणाखाली
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,लॉगइन करण्यात अयशस्वी
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,मालमत्ता {0} तयार केली
+DocType: Coupon Code,Promotional,पदोन्नती
 DocType: Special Test Items,Special Test Items,स्पेशल टेस्ट आयटम्स
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,मार्केटप्लेसवर नोंदणी करण्यासाठी आपण सिस्टम मॅनेजर आणि आयटम व्यवस्थापक भूमिकेसह एक वापरकर्ता असणे आवश्यक आहे.
 apps/erpnext/erpnext/config/buying.py,Key Reports,की अहवाल
@@ -2300,6 +2309,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,दस्तऐवज प्रकार
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,विक्री संघ एकूण वाटप टक्केवारी 100 असावे
 DocType: Subscription Plan,Billing Interval Count,बिलिंग मध्यांतर संख्या
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","कृपया हा कागदजत्र रद्द करण्यासाठी कर्मचारी <a href=""#Form/Employee/{0}"">{0}.</a> हटवा"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,भेटी आणि रुग्णांच्या उद्घोषक
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,मूल्य गहाळ
 DocType: Employee,Department and Grade,विभाग आणि ग्रेड
@@ -2400,6 +2411,7 @@
 DocType: Project,Start and End Dates,सुरू आणि तारखा समाप्त
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,कॉण्ट्रॅक्ट टेम्पलेट पूर्तता अटी
 ,Delivered Items To Be Billed,वितरित केलेले  आयटम जे बिल करायचे आहेत
+DocType: Coupon Code,Maximum Use,जास्तीत जास्त वापर
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},BOM ओपन {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,कोठार सिरियल क्रमांक साठी बदलले जाऊ शकत नाही
 DocType: Authorization Rule,Average Discount,सरासरी सवलत
@@ -2559,6 +2571,7 @@
 DocType: Item,Inventory,सूची
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,जेसन म्हणून डाउनलोड करा
 DocType: Item,Sales Details,विक्री तपशील
+DocType: Coupon Code,Used,वापरलेले
 DocType: Opportunity,With Items,आयटम
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',मोहीम &#39;{0}&#39; आधीपासूनच {1} &#39;{2}&#39; साठी विद्यमान आहे
 DocType: Asset Maintenance,Maintenance Team,देखरेख कार्यसंघ
@@ -2663,6 +2676,7 @@
 apps/erpnext/erpnext/selling/doctype/customer/customer.py,Following fields are mandatory to create address:,पत्ता तयार करण्यासाठी खालील फील्ड अनिवार्य आहेत:
 DocType: Item Alternative,Two-way,दोन-मार्ग
 DocType: Item,Manufacturers,उत्पादक
+apps/erpnext/erpnext/accounts/deferred_revenue.py,Error while processing deferred accounting for {0},{0} साठी स्थगित लेखा प्रक्रिया करताना त्रुटी
 ,Employee Billing Summary,कर्मचारी बिलिंग सारांश
 DocType: Project,Day to Send,पाठवायचे दिवस
 DocType: Healthcare Settings,Manage Sample Collection,नमुना संकलन व्यवस्थापित करा
@@ -2685,7 +2699,7 @@
 						Serial No cannot be ensured",आयटम {0} साठी कोणतेही सक्रिय BOM आढळले नाही. \ Serial No द्वारे डिलिव्हरी सुनिश्चित केली जाऊ शकत नाही
 DocType: Sales Partner,Sales Partner Target,विक्री भागीदार लक्ष्य
 DocType: Loan Type,Maximum Loan Amount,कमाल कर्ज रक्कम
-DocType: Pricing Rule,Pricing Rule,किंमत नियम
+DocType: Coupon Code,Pricing Rule,किंमत नियम
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},विद्यार्थी रोल नंबर डुप्लिकेट {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},विद्यार्थी रोल नंबर डुप्लिकेट {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,ऑर्डर खरेदी करण्यासाठी साहित्य विनंती
@@ -2765,6 +2779,7 @@
 DocType: Payment Schedule,Payment Amount,भरणा रक्कम
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,कामाची तारीख आणि कामाची समाप्ती तारीख यांच्या दरम्यान अर्ध दिवस तारीख असावी
 DocType: Healthcare Settings,Healthcare Service Items,हेल्थकेअर सेवा वस्तू
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,अवैध बारकोड. या बारकोडला कोणताही आयटम जोडलेला नाही.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,नाश रक्कम
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,रोख निव्वळ बदला
 DocType: Assessment Plan,Grading Scale,प्रतवारी स्केल
@@ -2884,7 +2899,6 @@
 DocType: Share Transfer,Asset Account,मालमत्ता खाते
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,नवीन रीलिझ तारीख भविष्यात असावी
 DocType: Purchase Invoice,End date of current invoice's period,चालू चलन च्या कालावधी समाप्ती तारीख
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,मानव संसाधन&gt; एचआर सेटिंग्जमध्ये कर्मचारी नेमिंग सिस्टम सेट करा
 DocType: Lab Test,Technician Name,तंत्रज्ञानाचे नाव
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3331,6 +3345,7 @@
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Half Day Date should be between From Date and To Date,अर्धा दिवस तारीख पासून आणि तारिक करण्यासाठी दरम्यान असावे
 DocType: Maintenance Schedule Detail,Actual Date,वास्तविक तारीख
 apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please set the Default Cost Center in {0} company.,कृपया {0} कंपनीत डीफॉल्ट मूल्य केंद्र सेट करा.
+apps/erpnext/erpnext/projects/doctype/project/project.py,Daily Project Summary for {0},दैनिक प्रकल्प सारांश {0}
 DocType: Item,Has Batch No,बॅच नाही आहे
 apps/erpnext/erpnext/public/js/utils.js,Annual Billing: {0},वार्षिक बिलिंग: {0}
 DocType: Shopify Webhook Detail,Shopify Webhook Detail,Shopify वेबहूक तपशील
@@ -3450,6 +3465,7 @@
 DocType: Vehicle,Fuel Type,इंधन प्रकार
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,कृपया कंपनीतील  चलन निर्दिष्ट करा
 DocType: Workstation,Wages per hour,ताशी वेतन
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,ग्राहक&gt; ग्राहक गट&gt; प्रदेश
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},बॅच {0} मधील शेअर शिल्लक  नकारात्मक होईल{1}  आयटम {2} साठी वखार  {3} येथे
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,साहित्य विनंत्या खालील आयटम च्या पुन्हा ऑर्डर स्तरावर आधारित आपोआप उठविला गेला आहे
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},खाते {0} अवैध आहे. खाते चलन {1} असणे आवश्यक आहे
@@ -3783,6 +3799,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,पगाराच्या स्लिप्स सादर करा
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,होल्ड वर
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,एका क्शनमध्ये कमीतकमी एक योग्य पर्याय असणे आवश्यक आहे
+apps/erpnext/erpnext/hooks.py,Purchase Orders,खरेदी ऑर्डर
 DocType: Account,Inter Company Account,इंटर कंपनी खाते
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,मोठ्या प्रमाणात आयात
 DocType: Sales Partner,Address & Contacts,पत्ता आणि संपर्क
@@ -3793,6 +3810,7 @@
 DocType: POS Profile,[Select],[निवडा]
 DocType: Staffing Plan Detail,Number Of Positions,स्थितींची संख्या
 DocType: Vital Signs,Blood Pressure (diastolic),रक्तदाब (डायस्टोलिक)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,कृपया ग्राहक निवडा.
 DocType: SMS Log,Sent To,करण्यासाठी पाठविले
 DocType: Agriculture Task,Holiday Management,सुट्टी व्यवस्थापन
 DocType: Payment Request,Make Sales Invoice,विक्री चलन करा
@@ -4000,7 +4018,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,"{0} {1} हे सबमिट केलेली नाही,"
 DocType: Subscription,Trialling,ट्रायलिंग
 DocType: Sales Invoice Item,Deferred Revenue,डिफरड रेव्हेन्यू
-DocType: Bank Account,GL Account,जीएल खाते
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,रोख खाते विक्री बीजक निर्मितीसाठी वापरले जाईल
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,सवलत उप वर्ग
 DocType: Member,Membership Expiry Date,सदस्यता कालावधी समाप्ती तारीख
@@ -4403,13 +4420,13 @@
 DocType: C-Form Invoice Detail,Territory,प्रदेश
 DocType: Pricing Rule,Apply Rule On Item Code,आयटम कोडवर नियम लागू करा
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,आवश्यक भेटी क्रमांकाचा उल्लेख करा
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,स्टॉक बॅलन्स रिपोर्ट
 DocType: Stock Settings,Default Valuation Method,मुलभूत मूल्यांकन पद्धत
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,फी
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,संचयी रक्कम दर्शवा
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,अद्यतन प्रगतीपथावर यास थोडा वेळ लागू शकतो.
 DocType: Production Plan Item,Produced Qty,उत्पादित प्रमाण
 DocType: Vehicle Log,Fuel Qty,इंधन प्रमाण
-DocType: Stock Entry,Target Warehouse Name,लक्ष्य वेअरहाऊस नाव
 DocType: Work Order Operation,Planned Start Time,नियोजनबद्ध प्रारंभ वेळ
 DocType: Course,Assessment,मूल्यांकन
 DocType: Payment Entry Reference,Allocated,वाटप
@@ -4475,10 +4492,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","ज्या  विक्री आणि खरेदीला  जोडल्या  जाऊ शकतील अशा मानक  अटी. उदाहरणे: ऑफर 1. वैधता. 1. भरणा अटी (क्रेडिट रोजी आगाऊ, भाग आगाऊ इत्यादी). 1. अतिरिक्त (किंवा ग्राहक देय) काय आहे. 1. सुरक्षितता / वापर चेतावणी. 1. हमी जर असेल तर. 1. धोरण परतावा. 1.शिपिंग अटी लागू असल्यास 1. अटी, लागू असल्यास. वाद पत्ता, नुकसानभरपाई, दायित्व इ पत्याचे  मार्ग. पत्ता आणि आपल्या कंपनीच्या संपर्क."
 DocType: Homepage Section,Section Based On,विभाग आधारित
+DocType: Shopping Cart Settings,Show Apply Coupon Code,कूपन कोड लागू करा दर्शवा
 DocType: Issue,Issue Type,समस्या प्रकार
 DocType: Attendance,Leave Type,रजा प्रकार
 DocType: Purchase Invoice,Supplier Invoice Details,पुरवठादार चलन तपशील
 DocType: Agriculture Task,Ignore holidays,सुट्ट्या दुर्लक्ष करा
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,कूपन अटी जोडा / संपादित करा
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,खर्च / फरक खाते ({0}) एक &#39;नफा किंवा तोटा&#39; खाते असणे आवश्यक आहे
 DocType: Stock Entry Detail,Stock Entry Child,स्टॉक एन्ट्री मूल
 DocType: Project,Copied From,कॉपी
@@ -4651,6 +4670,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,मूल्यांकन योजना निकष
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,व्यवहार
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,खरेदी ऑर्डर थांबवा
+DocType: Coupon Code,Coupon Name,कूपन नाव
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,संवेदनशील
 DocType: Email Campaign,Scheduled,अनुसूचित
 DocType: Shift Type,Working Hours Calculation Based On,कार्यरत तास गणना आधारित
@@ -4667,7 +4687,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,अस्थिर तयार करा
 DocType: Vehicle,Diesel,डिझेल
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,किंमत सूची चलन निवडलेले नाही
+DocType: Quick Stock Balance,Available Quantity,उपलब्ध प्रमाण
 DocType: Purchase Invoice,Availed ITC Cess,लाभलेल्या आयटीसी उपकर
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,कृपया शिक्षण&gt; शिक्षण सेटिंग्ज मधील इन्स्ट्रक्टर नामांकन प्रणाली सेट करा
 ,Student Monthly Attendance Sheet,विद्यार्थी मासिक उपस्थिती पत्रक
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,शिपिंग नियम फक्त विक्रीसाठी लागू आहे
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,घसारा रो {0}: पुढील घसारा तारीख खरेदी तारखेपूर्वी असू शकत नाही
@@ -4736,6 +4758,7 @@
 DocType: Quality Meeting,Quality Meeting,गुणवत्ता बैठक
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,गट न गट
 DocType: Employee,ERPNext User,ERPNext वापरकर्ता
+DocType: Coupon Code,Coupon Description,कूपन वर्णन
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},बॅच सलग आवश्यक आहे {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},बॅच सलग आवश्यक आहे {0}
 DocType: Company,Default Buying Terms,डीफॉल्ट खरेदी अटी
@@ -4900,6 +4923,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,दस्तऐवज तपशील विरुद्ध नाही
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},देश {0} साठी हटविण्याची परवानगी नाही
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,पक्ष प्रकार अनिवार्य आहे
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,कूपन कोड लागू करा
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",जॉब कार्ड {0} साठी आपण केवळ &#39;मटेरियल ट्रान्सफर फॉर मॅन्युफॅक्चर&#39; प्रकारची स्टॉक एन्ट्री करू शकता
 DocType: Quality Inspection,Outgoing,जाणारे
 DocType: Customer Feedback Table,Customer Feedback Table,ग्राहक अभिप्राय सारणी
@@ -5051,7 +5075,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,खरेदी आदेश सबमिशनवर
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,सर्व पुरवठादार जोडा
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,पंक्ती # {0}: रक्कम थकबाकी रक्कम पेक्षा जास्त असू शकत नाही.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,ग्राहक&gt; ग्राहक गट&gt; प्रदेश
 DocType: Tally Migration,Parties,पक्ष
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,ब्राउझ करा BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,सुरक्षित कर्ज
@@ -5083,7 +5106,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},आयटम {0} साठी पर्यायी आयटम सेट करण्याची अनुमती नाही
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,तारीख पुनरावृत्ती आहे
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,अधिकृत स्वाक्षरीकर्ता
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,कृपया शिक्षण&gt; शिक्षण सेटिंग्ज मधील इन्स्ट्रक्टर नामांकन प्रणाली सेट करा
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),नेट आयटीसी उपलब्ध (ए) - (बी)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,फी तयार करा
 DocType: Project,Total Purchase Cost (via Purchase Invoice),एकूण खरेदी किंमत (खरेदी  चलन द्वारे)
@@ -5107,6 +5129,7 @@
 DocType: Quiz Result,Wrong,चुकीचे
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,दर ज्यामध्ये किंमत यादी चलन ग्राहक बेस चलनमधे  रूपांतरित आहे
 DocType: Purchase Invoice Item,Net Amount (Company Currency),निव्वळ रक्कम (कंपनी चलन)
+DocType: Sales Partner,Referral Code,संदर्भ कोड
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,एकूण आगाऊ रक्कम एकूण स्वीकृत रकमेपेक्षा जास्त असू शकत नाही
 DocType: Salary Slip,Hour Rate,तास दर
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,ऑटो री-ऑर्डर सक्षम करा
@@ -5235,6 +5258,7 @@
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},कृपया आयटम {0} विरुद्ध BOM निवडा
 DocType: Shopping Cart Settings,Show Stock Quantity,स्टॉक प्रमाण दर्शवा
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,ऑपरेशन्स निव्वळ रोख
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},आयटमसाठी यूओएम रूपांतरण घटक ({0} -&gt; {1}) आढळला नाही: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,आयटम 4
 DocType: Student Admission,Admission End Date,प्रवेश अंतिम तारीख
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,उप-करार
@@ -5257,6 +5281,7 @@
 DocType: Travel Request,Fully Sponsored,पूर्णतः प्रायोजित
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,रिव्हर्स जर्नल एंट्री
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,जॉब कार्ड तयार करा
+DocType: Quotation,Referral Sales Partner,रेफरल विक्री भागीदार
 DocType: Quality Procedure Process,Process Description,प्रक्रिया वर्णन
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,ग्राहक {0} तयार आहे.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,सध्या कोणत्याही कोठारमध्ये कोणतीही स्टॉक उपलब्ध नाही
@@ -5295,6 +5320,7 @@
 apps/erpnext/erpnext/setup/doctype/company/company.js,Company name not same,कंपनी नाव समान नाही
 DocType: Lead,Address Desc,Desc पत्ता
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party is mandatory,पक्ष अनिवार्य आहे
+apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.py,Please set account heads in GST Settings for Compnay {0},कृपया कॉम्पिने {0} साठी जीएसटी सेटिंग्जमध्ये खाते प्रमुख सेट करा.
 DocType: Course Topic,Topic Name,विषय नाव
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Approval Notification in HR Settings.,कृपया एचआर सेटिंग्जमध्ये स्वीकृति सूट देण्याकरिता डीफॉल्ट टेम्पलेट सेट करा.
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Atleast one of the Selling or Buying must be selected,विक्री किंवा खरेदी कमीत कमी एक निवडणे आवश्यक आहे
@@ -5387,6 +5413,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM दर
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,अपलोड केलेली फाईल वाचणे
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","थांबलेले वर्क ऑर्डर रद्द करता येत नाही, रद्द करण्यासाठी प्रथम तो अनस्टॉप करा"
+DocType: Coupon Code,Coupon Code,कूपन कोड
 DocType: Asset,Journal Entry for Scrap,स्क्रॅप साठी जर्नल प्रवेश
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,डिलिव्हरी Note मधून  आयटम पुल करा/ओढा
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},पंक्ती {0}: कार्याच्या विरूद्ध वर्कस्टेशन निवडा {1}
@@ -5468,6 +5495,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;तारीख&#39; आवश्यक आहे
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},मुळे / संदर्भ तारीख  {0} नंतर असू शकत नाही
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,डेटा आयात आणि निर्यात
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","क्षमस्व, कूपन कोड वैधता कालबाह्य झाली आहे"
 DocType: Bank Account,Account Details,खाते तपशील
 DocType: Crop,Materials Required,आवश्यक सामग्री
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,नाही विद्यार्थ्यांनी सापडले
@@ -5505,6 +5533,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,वापरकर्त्यांकडे जा
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,पेड रक्कम + एकूण रक्कमेपेक्षा   पेक्षा जास्त असू शकत नाही बंद लिहा
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} आयटम एक वैध बॅच क्रमांक नाही {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,कृपया वैध कूपन कोड प्रविष्ट करा !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},टीप: रजा प्रकार पुरेशी रजा शिल्लक नाही {0}
 DocType: Task,Task Description,कार्य वर्णन
 DocType: Training Event,Seminar,सेमिनार
@@ -5594,6 +5623,7 @@
 DocType: Vehicle,Insurance Company,विमा कंपनी
 DocType: Asset Category Account,Fixed Asset Account,मुदत मालमत्ता खाते
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Variable,अस्थिर
+apps/erpnext/erpnext/regional/italy/utils.py,"Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}","फिस्कल रेजिमेम अनिवार्य आहे, दयाळूपणे कंपनीमध्ये वित्तीय व्यवस्थेची रचना करा {0}"
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js,From Delivery Note,डिलिव्हरी टीप पासून
 DocType: Chapter,Members,सदस्य
 DocType: Student,Student Email Address,विद्यार्थी ई-मेल पत्ता
@@ -5769,6 +5799,7 @@
 ,TDS Payable Monthly,टीडीएस देय मासिक
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,BOM बदली करण्यासाठी रांगेत. यास काही मिनिटे लागतील.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',गटात मूल्यांकन &#39;किंवा&#39; मूल्यांकन आणि एकूण &#39;आहे तेव्हा वजा करू शकत नाही
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,कृपया मनुष्यबळ&gt; एचआर सेटिंग्जमध्ये कर्मचारी नेमिंग सिस्टम सेट करा
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,एकूण देयके
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},सिरीयलाइज आयटम  {0}साठी सिरियल क्रमांक आवश्यक
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,पावत्या सह देयके सामना
@@ -5857,6 +5888,7 @@
 DocType: Production Plan,Get Raw Materials For Production,उत्पादनासाठी कच्चा माल मिळवा
 DocType: Job Opening,Job Title,कार्य शीर्षक
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,भविष्य देय संदर्भ
+DocType: Quotation,Additional Discount and Coupon Code,अतिरिक्त सूट आणि कूपन कोड
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} इंगित करते की {1} उद्धरण प्रदान करणार नाही, परंतु सर्व बाबींचे उद्धृत केले गेले आहे. आरएफक्यू कोटेशन स्थिती सुधारणे"
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,कमाल नमुने - {0} आधीपासून बॅच {1} आणि आयटम {2} बॅच {3} मध्ये ठेवण्यात आले आहेत.
@@ -6082,6 +6114,7 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,वेबसाइट मुख्यपृष्ठ सेटिंग्ज
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} पर्यंत थांबलेला आहे {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},{1} च्या स्कोअरकार्ड स्टँडमुळे RFQs ला {0} अनुमती नाही
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,खरेदी चलन करा
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,वापरले पाने
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,आपण सामग्री विनंती सबमिट करू इच्छिता?
 DocType: Job Offer,Awaiting Response,प्रतिसाद प्रतीक्षा करत आहे
@@ -6096,6 +6129,7 @@
 DocType: Training Event Employee,Optional,पर्यायी
 DocType: Salary Slip,Earning & Deduction,कमाई आणि कपात
 DocType: Agriculture Analysis Criteria,Water Analysis,पाणी विश्लेषण
+DocType: Sales Order,Skip Delivery Note,वितरण नोट वगळा
 DocType: Price List,Price Not UOM Dependent,किंमत यूओएम अवलंबित नाही
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} वेरिएंट तयार केले.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,डीफॉल्ट सेवा स्तर करार आधीपासून विद्यमान आहे.
@@ -6203,6 +6237,7 @@
 DocType: Vehicle,Last Carbon Check,गेल्या कार्बन तपासा
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,कायदेशीर खर्च
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,कृपया रांगेत प्रमाणात निवडा
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},वर्क ऑर्डर {0}: ऑपरेशनसाठी जॉब कार्ड आढळले नाही {1}
 DocType: Purchase Invoice,Posting Time,पोस्टिंग वेळ
 DocType: Timesheet,% Amount Billed,% रक्कम बिल
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,टेलिफोन खर्च
@@ -6303,7 +6338,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,कर आणि शुल्क जोडले
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,घसारा रो {0}: पुढील अवमूल्यन तारीख उपलब्ध-वापरण्याच्या तारखेपूर्वी असू शकत नाही
 ,Sales Funnel,विक्री धुराचा
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,आयटम कोड&gt; आयटम गट&gt; ब्रँड
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,संक्षेप करणे आवश्यक आहे
 DocType: Project,Task Progress,कार्य प्रगती
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,कार्ट
@@ -6397,6 +6431,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,पीओएस प्रोफाइल पीओएस नोंद करण्यासाठी  आवश्यक
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",लॉयल्टी पॉइंट्सची गणना गणना केलेल्या कारणास्तव आधारे करण्यात आलेल्या खर्च (सेल्स इंवॉइस) द्वारे केली जाईल.
 DocType: Program Enrollment Tool,Enroll Students,विद्यार्थी ची नोंदणी करा
+DocType: Pricing Rule,Coupon Code Based,कूपन कोड आधारित
 DocType: Company,HRA Settings,एचआरए सेटिंग्ज
 DocType: Homepage,Hero Section,हिरो विभाग
 DocType: Employee Transfer,Transfer Date,हस्तांतरण तारीख
@@ -6511,6 +6546,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',गट करून &#39;कंपनी&#39; आहे तर कंपनी रिक्त फिल्टर सेट करा
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,पोस्टिंग तारीख भविष्यातील तारीख असू शकत नाही
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},रो # {0}: सिरियल क्रमांक  {1} हा {2} {3}सोबत  जुळत नाही
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,कृपया सेटअप&gt; क्रमांकिंग सीरिजद्वारे उपस्थितीसाठी क्रमांकन मालिका सेट करा
 DocType: Stock Entry,Target Warehouse Address,लक्ष्य वेअरहाऊस पत्ता
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,प्रासंगिक रजा
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,शिफ्ट सुरू होण्यापूर्वीचा वेळ ज्या दरम्यान हजेरीसाठी कर्मचारी तपासणीचा विचार केला जातो.
@@ -6545,7 +6581,6 @@
 DocType: Employee Grade,Employee Grade,कर्मचारी ग्रेड
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Piecework
 DocType: GSTR 3B Report,June,जून
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,पुरवठादार&gt; पुरवठादार प्रकार
 DocType: Share Balance,From No,नाही पासून
 DocType: Shift Type,Early Exit Grace Period,लवकर बाहेर पडा ग्रेस कालावधी
 DocType: Task,Actual Time (in Hours),(तास) वास्तविक वेळ
@@ -6828,7 +6863,6 @@
 DocType: Warehouse,Warehouse Name,वखार नाव
 DocType: Naming Series,Select Transaction,निवडक व्यवहार
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,भूमिका मंजूर किंवा सदस्य मंजूर प्रविष्ट करा
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},आयटमसाठी यूओएम रूपांतरण घटक ({0} -&gt; {1}) आढळला नाही: {2}
 DocType: Journal Entry,Write Off Entry,प्रवेश बंद लिहा
 DocType: BOM,Rate Of Materials Based On,दर साहित्य आधारित रोजी
 DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","सक्षम असल्यास, प्रोग्राम एनरोलमेंट टूलमध्ये फील्ड शैक्षणिक कालावधी अनिवार्य असेल."
@@ -6965,6 +6999,7 @@
 DocType: Budget,Warn,चेतावणी द्या
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,या कामाकरता सर्व बाबी यापूर्वीच हस्तांतरित करण्यात आल्या आहेत.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","इतर कोणताही अभिप्राय, रेकॉर्ड जावे की लक्षात घेण्याजोगा प्रयत्न."
+DocType: Bank Account,Company Account,कंपनी खाते
 DocType: Asset Maintenance,Manufacturing User,उत्पादन सदस्य
 DocType: Purchase Invoice,Raw Materials Supplied,कच्चा माल प्रदान
 DocType: Subscription Plan,Payment Plan,देयक योजना
@@ -7006,6 +7041,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) वर्क ऑर्डरमध्ये नियोजित प्रमाण ({2}) पेक्षा अधिक असू शकत नाही {3}
 DocType: Certification Application,Name of Applicant,अर्जदाराचे नाव
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,उत्पादन वेळ पत्रक.
+DocType: Quick Stock Balance,Quick Stock Balance,द्रुत स्टॉक शिल्लक
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,एकूण
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,शेअर व्यवहारा नंतर व्हेरियंट गुणधर्म बदलू शकत नाही. असे करण्यासाठी आपल्याला एक नवीन आयटम तयार करावा लागेल.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA मँडेट
@@ -7331,6 +7367,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} निष्क्रिय विद्यार्थी आहे
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} निष्क्रिय विद्यार्थी आहे
 DocType: Employee,Health Details,आरोग्य तपशील
+DocType: Coupon Code,Coupon Type,कूपन प्रकार
 DocType: Leave Encashment,Encashable days,ऍन्कॅश करण्यायोग्य दिवस
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,एक भरणा विनंती संदर्भ दस्तऐवज आवश्यक आहे तयार करण्यासाठी
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,एक भरणा विनंती संदर्भ दस्तऐवज आवश्यक आहे तयार करण्यासाठी
@@ -7616,6 +7653,7 @@
 DocType: Hotel Room Package,Amenities,सुविधा
 DocType: Accounts Settings,Automatically Fetch Payment Terms,देय अटी स्वयंचलितपणे मिळवा
 DocType: QuickBooks Migrator,Undeposited Funds Account,Undeposited निधी खाते
+DocType: Coupon Code,Uses,वापर
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,पेमेंटचा एकाधिक डीफॉल्ट मोड अनुमत नाही
 DocType: Sales Invoice,Loyalty Points Redemption,लॉयल्टी पॉइंट्स रिडेम्प्शन
 ,Appointment Analytics,नेमणूक Analytics
@@ -7633,6 +7671,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,आपण दर वर्षी विद्यार्थ्यांचे गट तर रिक्त सोडा
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,आपण दर वर्षी विद्यार्थ्यांचे गट तर रिक्त सोडा
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","चेक केलेले असल्यास, एकूण कार्यरत दिवसंमध्ये सुट्ट्यांचा समावेश असेल, आणि यामुळे  पगार प्रति दिवस मूल्य कमी होईल."
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,डोमेन जोडण्यात अयशस्वी
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.",प्राप्ती / वितरणास अनुमती देण्यासाठी स्टॉक सेटिंग्ज किंवा आयटममध्ये &quot;ओव्हर रसीद / डिलिव्हरी अलाउन्स&quot; अद्यतनित करा.
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","चालू की वापरणारे अॅप्स प्रवेश करण्यात सक्षम होणार नाहीत, आपल्याला खात्री आहे?"
 DocType: Subscription Settings,Prorate,प्रोरेट
@@ -7646,6 +7685,7 @@
 ,BOM Stock Report,BOM शेअर अहवाल
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","तेथे कोणतेही नियुक्त टाइमस्लॉट नसल्यास, संवाद या गटाद्वारे हाताळला जाईल"
 DocType: Stock Reconciliation Item,Quantity Difference,प्रमाण फरक
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,पुरवठादार&gt; पुरवठादार प्रकार
 DocType: Opportunity Item,Basic Rate,बेसिक रेट
 DocType: GL Entry,Credit Amount,क्रेडिट रक्कम
 ,Electronic Invoice Register,इलेक्ट्रॉनिक चलन नोंदणी
@@ -7898,6 +7938,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),कर आणि शुल्क वजा (कंपनी चलन)
 DocType: Item Group,General Settings,सामान्य सेटिंग्ज
 DocType: Article,Article,लेख
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,कृपया कूपन कोड प्रविष्ट करा !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,चलानापासून आणि  चलानापर्यंत  समान असू शकत नाही
 DocType: Taxable Salary Slab,Percent Deduction,टक्के कपात
 DocType: GL Entry,To Rename,पुनर्नामित करण्यासाठी
diff --git a/erpnext/translations/ms.csv b/erpnext/translations/ms.csv
index e711093..0db0aa9 100644
--- a/erpnext/translations/ms.csv
+++ b/erpnext/translations/ms.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Pelanggan Hubungi
 DocType: Shift Type,Enable Auto Attendance,Dayakan Auto Kehadiran
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Sila masukkan Gudang dan Tarikh
 DocType: Lost Reason Detail,Opportunity Lost Reason,Peluang Hilang Peluang
 DocType: Patient Appointment,Check availability,Semak ketersediaan
 DocType: Retention Bonus,Bonus Payment Date,Tarikh Pembayaran Bonus
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Perintah Kerja yang telah selesai
 DocType: Support Settings,Forum Posts,Forum Posts
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Tugas itu telah dipenuhi sebagai pekerjaan latar belakang. Sekiranya terdapat sebarang masalah dalam pemprosesan di latar belakang, sistem akan menambah komen mengenai kesilapan pada Penyelesaian Stok ini dan kembali ke peringkat Draf"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Maaf, kesahihan kod kupon belum bermula"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Amaun yang dikenakan cukai
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Anda tidak dibenarkan untuk menambah atau update entri sebelum {0}
 DocType: Leave Policy,Leave Policy Details,Tinggalkan Butiran Dasar
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Guna habis
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,gred
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kod Item&gt; Kumpulan Item&gt; Jenama
 DocType: Restaurant Table,No of Seats,Tiada tempat duduk
 DocType: Sales Invoice,Overdue and Discounted,Tertunggak dan Diskaun
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Panggilan Terputus
@@ -507,6 +510,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,jarak baris untuk jumlah dalam perkataan
 DocType: Vehicle,Additional Details,maklumat tambahan
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Keterangan tidak diberikan
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Ambil Item dari Gudang
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Meminta untuk pembelian.
 DocType: POS Closing Voucher Details,Collected Amount,Jumlah Dikumpul
 DocType: Lab Test,Submitted Date,Tarikh Dihantar
@@ -614,6 +618,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Belajar
 ,Trial Balance (Simple),Baki Percubaan (Mudah)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Mengaktifkan Perbelanjaan Tertunda
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Kod Kupon Gunaan
 DocType: Asset,Next Depreciation Date,Selepas Tarikh Susutnilai
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Kos aktiviti setiap Pekerja
 DocType: Accounts Settings,Settings for Accounts,Tetapan untuk Akaun
@@ -854,8 +859,6 @@
 DocType: Sales Invoice,Total Qty,Jumlah Kuantiti
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 ID E-mel
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 ID E-mel
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Sila padamkan Pekerja <a href=""#Form/Employee/{0}"">{0}</a> \ untuk membatalkan dokumen ini"
 DocType: Item,Show in Website (Variant),Show di Laman web (Variant)
 DocType: Employee,Health Concerns,Kebimbangan Kesihatan
 DocType: Payroll Entry,Select Payroll Period,Pilih Tempoh Payroll
@@ -1021,6 +1024,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Akaun Pegangan Cukai
 DocType: Pricing Rule,Sales Partner,Rakan Jualan
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Semua kad skor Pembekal.
+DocType: Coupon Code,To be used to get discount,Untuk digunakan untuk mendapatkan diskaun
 DocType: Buying Settings,Purchase Receipt Required,Resit pembelian Diperlukan
 DocType: Sales Invoice,Rail,Kereta api
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Kos sebenar
@@ -1071,6 +1075,7 @@
 DocType: Production Plan,Production Plan,Pelan Pengeluaran
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Pembukaan Alat Penciptaan Invois
 DocType: Salary Component,Round to the Nearest Integer,Pusingan ke Integer Hampir
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Benarkan item yang tidak ada dalam stok untuk dimasukkan ke dalam troli
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Jualan Pulangan
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Tetapkan Qty dalam Transaksi berdasarkan Serial No Input
 ,Total Stock Summary,Ringkasan Jumlah Saham
@@ -1202,6 +1207,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Kadar Jam Base (Syarikat Mata Wang)
 ,Qty To Be Billed,Qty To Be Dibilled
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Jumlah dihantar
+DocType: Coupon Code,Gift Card,Kad Hadiah
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Dicadangkan Qty untuk Pengeluaran: Kuantiti bahan mentah untuk membuat barangan perkilangan.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Tarikh Penebusan
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Urus niaga bank ini telah diselaraskan sepenuhnya
@@ -1291,6 +1297,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Buat Timesheet
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Akaun {0} telah dibuat beberapa kali
 DocType: Account,Expenses Included In Valuation,Perbelanjaan Termasuk Dalam Penilaian
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Pembelian Invois
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Anda hanya boleh memperbaharui sekiranya keahlian anda tamat tempoh dalam masa 30 hari
 DocType: Shopping Cart Settings,Show Stock Availability,Tunjukkan Ketersediaan Saham
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Tetapkan {0} dalam kategori aset {1} atau syarikat {2}
@@ -1834,6 +1841,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Mengimport Item dan UOM
 DocType: Repayment Schedule,Balance Loan Amount,Jumlah Baki Pinjaman
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Ditambah pada butiran
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Maaf, kod kupon habis"
 DocType: Communication Medium,Catch All,Tangkap Semua
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Kursus jadual
 DocType: Budget,Applicable on Material Request,Terpakai pada Permintaan Bahan
@@ -2004,6 +2012,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Sifat tidak sah
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} mestilah diserahkan
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Kempen E-mel
+DocType: Sales Partner,To Track inbound purchase,Untuk menjejaki pembelian masuk
 DocType: Buying Settings,Default Supplier Group,Kumpulan Pembekal Lalai
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Kuantiti mesti kurang daripada atau sama dengan {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Jumlah maksimum yang layak untuk komponen {0} melebihi {1}
@@ -2161,8 +2170,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Buat Entri Saham
 DocType: Hotel Room Reservation,Hotel Reservation User,Pengguna Tempahan Hotel
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Tetapkan Status
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Sila persediaan siri penomboran untuk Kehadiran melalui Persediaan&gt; Penomboran Siri
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Sila pilih awalan pertama
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Sila tetapkan Siri Penamaan untuk {0} melalui Persediaan&gt; Tetapan&gt; Penamaan Siri
 DocType: Contract,Fulfilment Deadline,Tarikh akhir penyempurnaan
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Berhampiran anda
 DocType: Student,O-,O-
@@ -2286,6 +2295,7 @@
 DocType: Quality Meeting Table,Under Review,Ditinjau
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Gagal masuk
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Aset {0} dibuat
+DocType: Coupon Code,Promotional,Promosi
 DocType: Special Test Items,Special Test Items,Item Ujian Khas
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Anda perlu menjadi pengguna dengan Pengurus Sistem dan peranan Pengurus Item untuk mendaftar di Marketplace.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Laporan Utama
@@ -2324,6 +2334,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc Jenis
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Jumlah peratusan yang diperuntukkan bagi pasukan jualan harus 100
 DocType: Subscription Plan,Billing Interval Count,Count Interval Pengebilan
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Sila padamkan Pekerja <a href=""#Form/Employee/{0}"">{0}</a> \ untuk membatalkan dokumen ini"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Pelantikan dan Pesakit yang Menemui
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Nilai hilang
 DocType: Employee,Department and Grade,Jabatan dan Gred
@@ -2427,6 +2439,7 @@
 DocType: Project,Start and End Dates,Tarikh mula dan tamat
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Terma Pemenuhan Template Kontrak
 ,Delivered Items To Be Billed,Item Dihantar dikenakan caj
+DocType: Coupon Code,Maximum Use,Penggunaan maksimum
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Terbuka BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Gudang tidak boleh diubah untuk No. Siri
 DocType: Authorization Rule,Average Discount,Diskaun Purata
@@ -2588,6 +2601,7 @@
 DocType: Item,Inventory,Inventori
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Muat turun sebagai Json
 DocType: Item,Sales Details,Jualan Butiran
+DocType: Coupon Code,Used,Digunakan
 DocType: Opportunity,With Items,Dengan Item
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Kempen &#39;{0}&#39; sudah wujud untuk {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Pasukan Penyelenggaraan
@@ -2717,7 +2731,7 @@
 						Serial No cannot be ensured",Tiada BOM aktif yang ditemui untuk item {0}. Penghantaran oleh \ Serial No tidak dapat dipastikan
 DocType: Sales Partner,Sales Partner Target,Jualan Rakan Sasaran
 DocType: Loan Type,Maximum Loan Amount,Jumlah Pinjaman maksimum
-DocType: Pricing Rule,Pricing Rule,Peraturan Harga
+DocType: Coupon Code,Pricing Rule,Peraturan Harga
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},jumlah roll salinan untuk pelajar {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},jumlah roll salinan untuk pelajar {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Permintaan bahan Membeli Pesanan
@@ -2797,6 +2811,7 @@
 DocType: Payment Schedule,Payment Amount,Jumlah Bayaran
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Tarikh Hari Separuh hendaklah di antara Kerja Dari Tarikh dan Tarikh Akhir Kerja
 DocType: Healthcare Settings,Healthcare Service Items,Item Perkhidmatan Penjagaan Kesihatan
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Barcode tidak sah. Tiada Item yang dilampirkan pada kod bar ini.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Jumlah dimakan
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Perubahan Bersih dalam Tunai
 DocType: Assessment Plan,Grading Scale,Skala penggredan
@@ -2918,7 +2933,6 @@
 DocType: Share Transfer,Asset Account,Akaun Aset
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Tarikh pelepasan baru sepatutnya pada masa hadapan
 DocType: Purchase Invoice,End date of current invoice's period,Tarikh akhir tempoh invois semasa
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Sila persediaan Sistem Penamaan Pekerja dalam Sumber Manusia&gt; Tetapan HR
 DocType: Lab Test,Technician Name,Nama juruteknik
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3030,6 +3044,7 @@
 DocType: Products Settings,Hide Variants,Sembunyikan Variasi
 DocType: Lead,Next Contact By,Hubungi Seterusnya By
 DocType: Compensatory Leave Request,Compensatory Leave Request,Permintaan Cuti Pampasan
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Tidak boleh mengatasi Perkara {0} dalam baris {1} lebih daripada {2}. Untuk membenarkan lebihan pengebilan, sila tentukan peruntukan dalam Tetapan Akaun"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Kuantiti yang diperlukan untuk Perkara {0} berturut-turut {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Gudang {0} tidak boleh dihapuskan sebagai kuantiti wujud untuk Perkara {1}
 DocType: Blanket Order,Order Type,Perintah Jenis
@@ -3202,7 +3217,6 @@
 DocType: Student,Student Mobile Number,Pelajar Nombor Telefon
 DocType: Item,Has Variants,Mempunyai Kelainan
 DocType: Employee Benefit Claim,Claim Benefit For,Manfaat Tuntutan Untuk
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Tidak boleh mengatasi Perkara {0} dalam baris {1} lebih daripada {2}. Untuk membenarkan lebihan pengebilan, sila tetapkan di Tetapan Stok"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Kemas kini Semula
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Anda telah memilih barangan dari {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Nama Pembahagian Bulanan
@@ -3495,6 +3509,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Sila nyatakan mata wang dalam Syarikat
 DocType: Workstation,Wages per hour,Upah sejam
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Konfigur {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Pelanggan&gt; Kumpulan Pelanggan&gt; Wilayah
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Baki saham dalam batch {0} akan menjadi negatif {1} untuk Perkara {2} di Gudang {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Mengikuti Permintaan Bahan telah dibangkitkan secara automatik berdasarkan pesanan semula tahap Perkara ini
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Akaun {0} tidak sah. Mata Wang Akaun mesti {1}
@@ -3828,6 +3843,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Hantar Slip Gaji
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Tunggu
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Kelengahan mesti mempunyai sekurang-kurangnya satu pilihan yang betul
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Pesanan Pembelian
 DocType: Account,Inter Company Account,Akaun Syarikat Antara
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Import di Bulk
 DocType: Sales Partner,Address & Contacts,Alamat Kenalan
@@ -3838,6 +3854,7 @@
 DocType: POS Profile,[Select],[Pilih]
 DocType: Staffing Plan Detail,Number Of Positions,Bilangan Jawatan
 DocType: Vital Signs,Blood Pressure (diastolic),Tekanan Darah (diastolik)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Sila pilih pelanggan.
 DocType: SMS Log,Sent To,Dihantar Kepada
 DocType: Agriculture Task,Holiday Management,Pengurusan Percutian
 DocType: Payment Request,Make Sales Invoice,Buat Jualan Invois
@@ -4048,7 +4065,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} tidak diserahkan
 DocType: Subscription,Trialling,Menguji
 DocType: Sales Invoice Item,Deferred Revenue,Pendapatan Tertunda
-DocType: Bank Account,GL Account,Akaun GL
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Akaun Tunai akan digunakan untuk penciptaan Jualan Invois
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Kategori Sub Pengecualian
 DocType: Member,Membership Expiry Date,Keahlian Tarikh Luput
@@ -4455,13 +4471,13 @@
 DocType: C-Form Invoice Detail,Territory,Wilayah
 DocType: Pricing Rule,Apply Rule On Item Code,Memohon Peraturan Mengenai Kod Perkara
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Sila menyebut ada lawatan diperlukan
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Laporan Imbangan Stok
 DocType: Stock Settings,Default Valuation Method,Kaedah Penilaian Default
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Bayaran
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Tunjukkan Jumlah Kumulatif
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Kemas kini sedang dijalankan. Ia mungkin mengambil sedikit masa.
 DocType: Production Plan Item,Produced Qty,Dikenali Qty
 DocType: Vehicle Log,Fuel Qty,Fuel Qty
-DocType: Stock Entry,Target Warehouse Name,Nama Gudang Sasaran
 DocType: Work Order Operation,Planned Start Time,Dirancang Mula Masa
 DocType: Course,Assessment,penilaian
 DocType: Payment Entry Reference,Allocated,Diperuntukkan
@@ -4527,10 +4543,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","Terma dan Syarat Standard yang boleh ditambah untuk Jualan dan Pembelian. Contoh: 1. Kesahan tawaran itu. 1. Terma Pembayaran (Dalam Advance, Mengenai Kredit, bahagian pendahuluan dan lain-lain). 1. Apakah tambahan (atau perlu dibayar oleh Pelanggan). 1. Keselamatan amaran / penggunaan. 1. Waranti jika ada. 1. Kembali Polisi. 1. Syarat-syarat penghantaran, jika berkenaan. 1. Cara-cara menangani pertikaian, tanggung rugi, kerugian, dan lain-lain 1. Alamat dan Contact Syarikat anda."
 DocType: Homepage Section,Section Based On,Seksyen Berdasarkan
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Paparkan Memohon Kod Kupon
 DocType: Issue,Issue Type,Jenis Isu
 DocType: Attendance,Leave Type,Cuti Jenis
 DocType: Purchase Invoice,Supplier Invoice Details,Pembekal Butiran Invois
 DocType: Agriculture Task,Ignore holidays,Abaikan cuti
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Tambah / Edit Syarat Kupon
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Akaun perbelanjaan / Perbezaan ({0}) mestilah akaun &#39;Keuntungan atau Kerugian&#39;
 DocType: Stock Entry Detail,Stock Entry Child,Anak Masuk Saham
 DocType: Project,Copied From,disalin Dari
@@ -4706,6 +4724,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Kriteria Penilaian Pelan
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Urus niaga
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Cegah Pesanan Pembelian
+DocType: Coupon Code,Coupon Name,Nama Kupon
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Mudah tersinggung
 DocType: Email Campaign,Scheduled,Berjadual
 DocType: Shift Type,Working Hours Calculation Based On,Pengiraan Jam Kerja Berdasarkan
@@ -4722,7 +4741,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Buat Kelainan
 DocType: Vehicle,Diesel,diesel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Senarai harga mata wang tidak dipilih
+DocType: Quick Stock Balance,Available Quantity,Kuantiti yang ada
 DocType: Purchase Invoice,Availed ITC Cess,Berkhidmat ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Sila persediaan Sistem Penamaan Pengajar dalam Pendidikan&gt; Tetapan Pendidikan
 ,Student Monthly Attendance Sheet,Pelajar Lembaran Kehadiran Bulanan
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Peraturan penghantaran hanya terpakai untuk Jualan
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Susut Susut {0}: Tarikh Susutnilai Seterusnya tidak boleh sebelum Tarikh Pembelian
@@ -4790,8 +4811,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Row {0}: Advance terhadap Pelanggan mesti kredit
 DocType: Quality Meeting,Quality Meeting,Mesyuarat Berkualiti
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-Group untuk Kumpulan
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Sila tetapkan Siri Penamaan untuk {0} melalui Persediaan&gt; Tetapan&gt; Penamaan Siri
 DocType: Employee,ERPNext User,Pengguna ERPNext
+DocType: Coupon Code,Coupon Description,Penerangan Kupon
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Batch adalah wajib berturut-turut {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Batch adalah wajib berturut-turut {0}
 DocType: Company,Default Buying Terms,Syarat Pembelian Lalai
@@ -4956,6 +4977,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Terhadap Detail Dokumen No
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Pemadaman tidak dibenarkan untuk negara {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Jenis Parti adalah wajib
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Guna Kod Kupon
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","Untuk kad kerja {0}, anda hanya boleh membuat entri jenis jenis &#39;Pemindahan Bahan untuk Pembuatan&#39;"
 DocType: Quality Inspection,Outgoing,Keluar
 DocType: Customer Feedback Table,Customer Feedback Table,Jadual Maklumbalas Pelanggan
@@ -5108,7 +5130,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Pada Pesanan Pesanan Pembelian
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Tambah Semua Pembekal
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Row # {0}: Jumlah Diperuntukkan tidak boleh lebih besar daripada jumlah tertunggak.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Pelanggan&gt; Kumpulan Pelanggan&gt; Wilayah
 DocType: Tally Migration,Parties,Pihak-pihak
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Browse BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Pinjaman Bercagar
@@ -5140,7 +5161,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Tidak membenarkan menetapkan item alternatif untuk item {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Tarikh diulang
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Penandatangan yang diberi kuasa
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Sila persediaan Sistem Penamaan Pengajar dalam Pendidikan&gt; Tetapan Pendidikan
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),ITC Bersih Tersedia (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Buat Yuran
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Jumlah Kos Pembelian (melalui Invois Belian)
@@ -5165,6 +5185,7 @@
 DocType: Quiz Result,Wrong,Salah
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Kadar di mana Senarai harga mata wang ditukar kepada mata wang asas pelanggan
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Jumlah Bersih (Syarikat mata wang)
+DocType: Sales Partner,Referral Code,Kod rujukan
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Jumlah jumlah pendahuluan tidak boleh lebih besar dari jumlah jumlah yang dibenarkan
 DocType: Salary Slip,Hour Rate,Kadar jam
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Dayakan Perintah Semula Automatik
@@ -5295,6 +5316,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Tunjukkan Kuantiti Stok
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Tunai bersih daripada Operasi
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Baris # {0}: Status mestilah {1} untuk Diskaun Invois {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Faktor penukaran UOM ({0} -&gt; {1}) tidak ditemui untuk item: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Perkara 4
 DocType: Student Admission,Admission End Date,Kemasukan Tarikh Tamat
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Sub-kontrak
@@ -5317,6 +5339,7 @@
 DocType: Travel Request,Fully Sponsored,Penuh Disokong
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Kemasukan Jurnal Terbalik
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Buat Kad Kerja
+DocType: Quotation,Referral Sales Partner,Rakan Jualan Rujukan
 DocType: Quality Procedure Process,Process Description,Penerangan proses
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Pelanggan {0} dibuat.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Tidak ada stok sedia ada di mana-mana gudang
@@ -5451,6 +5474,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,Kadar BOM
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Membaca Fail yang Dimuat naik
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Perintah Kerja Berhenti tidak boleh dibatalkan, Unstop terlebih dahulu untuk membatalkannya"
+DocType: Coupon Code,Coupon Code,Kod Kupon
 DocType: Asset,Journal Entry for Scrap,Kemasukan Jurnal untuk Scrap
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Sila tarik item daripada Nota Penghantaran
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Baris {0}: pilih stesen kerja terhadap operasi {1}
@@ -5535,6 +5559,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;Tarikh&#39; diperlukan
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Oleh kerana / Rujukan Tarikh dan boleh dikenakan {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Data Import dan Eksport
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Maaf, kesahihan kod kupon telah tamat tempoh"
 DocType: Bank Account,Account Details,Butiran Akaun
 DocType: Crop,Materials Required,Bahan yang diperlukan
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Tiada pelajar Terdapat
@@ -5572,6 +5597,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Pergi ke Pengguna
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Amaun yang dibayar + Tulis Off Jumlah tidak boleh lebih besar daripada Jumlah Besar
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} bukan Nombor Kumpulan sah untuk Perkara {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Sila masukkan kod kupon yang sah !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Nota: Tidak ada baki cuti yang cukup untuk Cuti Jenis {0}
 DocType: Task,Task Description,Penerangan Petugas
 DocType: Training Event,Seminar,Seminar
@@ -5839,6 +5865,7 @@
 ,TDS Payable Monthly,TDS Dibayar Bulanan
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Beratur untuk menggantikan BOM. Ia mungkin mengambil masa beberapa minit.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Tidak boleh memotong apabila kategori adalah untuk &#39;Penilaian&#39; atau &#39;Penilaian dan Jumlah&#39;
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Sila persediaan Sistem Penamaan Pekerja dalam Sumber Manusia&gt; Tetapan HR
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Jumlah Pembayaran
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serial No Diperlukan untuk Perkara bersiri {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Pembayaran perlawanan dengan Invois
@@ -5929,6 +5956,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Dapatkan Bahan Baku untuk Pengeluaran
 DocType: Job Opening,Job Title,Tajuk Kerja
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Rujukan Bayaran Masa Depan
+DocType: Quotation,Additional Discount and Coupon Code,Diskaun Tambahan dan Kod Kupon
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} menunjukkan bahawa {1} tidak akan memberikan sebut harga, tetapi semua item \ telah disebutkan. Mengemas kini status petikan RFQ."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Sampel Maksimum - {0} telah dikekalkan untuk Batch {1} dan Item {2} dalam Batch {3}.
@@ -6158,7 +6186,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Tetapan untuk laman web laman utama
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} ditangguhkan sehingga {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ tidak dibenarkan untuk {0} kerana kedudukan kad skor {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Buat Invois Belian
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Daun yang digunakan
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Kupon yang digunakan adalah {1}. Kuantiti dibiarkan habis
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Adakah anda ingin mengemukakan permintaan bahan
 DocType: Job Offer,Awaiting Response,Menunggu Response
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6172,6 +6202,7 @@
 DocType: Training Event Employee,Optional,Pilihan
 DocType: Salary Slip,Earning & Deduction,Pendapatan &amp; Potongan
 DocType: Agriculture Analysis Criteria,Water Analysis,Analisis Air
+DocType: Sales Order,Skip Delivery Note,Langkau Nota Penghantaran
 DocType: Price List,Price Not UOM Dependent,Harga tidak bergantung kepada UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} varian dibuat.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Perjanjian Tahap Perkhidmatan Lalai telah wujud.
@@ -6280,6 +6311,7 @@
 DocType: Vehicle,Last Carbon Check,Carbon lalu Daftar
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Perbelanjaan Undang-undang
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Sila pilih kuantiti hukuman
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Perintah Kerja {0}: kad kerja tidak dijumpai untuk operasi {1}
 DocType: Purchase Invoice,Posting Time,Penempatan Masa
 DocType: Timesheet,% Amount Billed,% Jumlah Dibilkan
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Perbelanjaan Telefon
@@ -6382,7 +6414,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Cukai dan Caj Tambahan
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Susut Susut {0}: Tarikh Susutnilai Seterusnya tidak boleh sebelum Tarikh Tersedia untuk Penggunaan
 ,Sales Funnel,Saluran Jualan
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kod Item&gt; Kumpulan Item&gt; Jenama
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Singkatan adalah wajib
 DocType: Project,Task Progress,Task Progress
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Dalam Troli
@@ -6478,6 +6509,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS Profil dikehendaki membuat POS Entry
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Mata Kesetiaan akan dikira dari perbelanjaan yang telah dibelanjakan (melalui Invois Jualan), berdasarkan faktor pengumpulan yang disebutkan."
 DocType: Program Enrollment Tool,Enroll Students,Daftarkan Pelajar
+DocType: Pricing Rule,Coupon Code Based,Kod Kupon Berdasarkan
 DocType: Company,HRA Settings,Tetapan HRA
 DocType: Homepage,Hero Section,Seksyen Hero
 DocType: Employee Transfer,Transfer Date,Tarikh Pemindahan
@@ -6594,6 +6626,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Sila tetapkan Syarikat menapis kosong jika Group By adalah &#39;Syarikat&#39;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Posting Tarikh tidak boleh tarikh masa depan
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: No Siri {1} tidak sepadan dengan {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Sila persediaan siri penomboran untuk Kehadiran melalui Persediaan&gt; Penomboran Siri
 DocType: Stock Entry,Target Warehouse Address,Alamat Gudang Sasaran
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Cuti kasual
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,Masa sebelum waktu mula peralihan semasa Pemeriksaan Kakitangan dianggap untuk kehadiran.
@@ -6628,7 +6661,6 @@
 DocType: Employee Grade,Employee Grade,Gred pekerja
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Piecework
 DocType: GSTR 3B Report,June,Jun
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Pembekal&gt; Jenis Pembekal
 DocType: Share Balance,From No,Daripada No
 DocType: Shift Type,Early Exit Grace Period,Jangka Masa Keluar Awal
 DocType: Task,Actual Time (in Hours),Masa sebenar (dalam jam)
@@ -6915,7 +6947,6 @@
 DocType: Warehouse,Warehouse Name,Nama Gudang
 DocType: Naming Series,Select Transaction,Pilih Transaksi
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Sila masukkan Meluluskan Peranan atau Meluluskan pengguna
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Faktor penukaran UOM ({0} -&gt; {1}) tidak ditemui untuk item: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Perjanjian Tahap Perkhidmatan dengan Entiti Jenis {0} dan Entiti {1} sudah wujud.
 DocType: Journal Entry,Write Off Entry,Tulis Off Entry
 DocType: BOM,Rate Of Materials Based On,Kadar Bahan Based On
@@ -7054,6 +7085,7 @@
 DocType: Budget,Warn,Beri amaran
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Semua item telah dipindahkan untuk Perintah Kerja ini.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Sebarang kenyataan lain, usaha perlu diberi perhatian yang sepatutnya pergi dalam rekod."
+DocType: Bank Account,Company Account,Akaun Syarikat
 DocType: Asset Maintenance,Manufacturing User,Pembuatan pengguna
 DocType: Purchase Invoice,Raw Materials Supplied,Bahan mentah yang dibekalkan
 DocType: Subscription Plan,Payment Plan,Pelan Pembayaran
@@ -7095,6 +7127,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) tidak boleh melebihi kuantiti terancang ({2}) dalam Perintah Kerja {3}
 DocType: Certification Application,Name of Applicant,Nama pemohon
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Lembaran Masa untuk pembuatan.
+DocType: Quick Stock Balance,Quick Stock Balance,Baki Stok Pantas
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,jumlah kecil
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Tidak boleh mengubah Variasi hartanah selepas transaksi stok. Anda perlu membuat Item baru untuk melakukan ini.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,Mandat SEPA GoCardless
@@ -7423,6 +7456,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} adalah pelajar aktif
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} adalah pelajar aktif
 DocType: Employee,Health Details,Kesihatan Butiran
+DocType: Coupon Code,Coupon Type,Jenis Kupon
 DocType: Leave Encashment,Encashable days,Hari-hari yang boleh ditanggalkan
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Untuk membuat Permintaan Pembayaran dokumen rujukan diperlukan
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Untuk membuat Permintaan Pembayaran dokumen rujukan diperlukan
@@ -7711,6 +7745,7 @@
 DocType: Hotel Room Package,Amenities,Kemudahan
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Termakan Pembayaran Secara Secara Automatik
 DocType: QuickBooks Migrator,Undeposited Funds Account,Akaun Dana Undeposited
+DocType: Coupon Code,Uses,Kegunaan
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Pelbagai mod lalai pembayaran tidak dibenarkan
 DocType: Sales Invoice,Loyalty Points Redemption,Penebusan Mata Kesetiaan
 ,Appointment Analytics,Pelantikan Analitis
@@ -7728,6 +7763,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Biarkan kosong jika anda membuat kumpulan pelajar setahun
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Biarkan kosong jika anda membuat kumpulan pelajar setahun
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Jika disemak, Jumlah no. Hari Kerja termasuk cuti, dan ini akan mengurangkan nilai Gaji Setiap Hari"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Gagal menambah Domain
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Untuk membenarkan penerimaan / penghantaran, kemas kini &quot;Lebih Elaun Resit / Penghantaran&quot; dalam Tetapan Stok atau Item."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Apl yang menggunakan kekunci semasa tidak dapat mengakses, adakah anda pasti?"
 DocType: Subscription Settings,Prorate,Prorate
@@ -7741,6 +7777,7 @@
 ,BOM Stock Report,Laporan Stok BOM
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Jika tidak ada timeslot yang ditetapkan, maka komunikasi akan dikendalikan oleh kumpulan ini"
 DocType: Stock Reconciliation Item,Quantity Difference,kuantiti Perbezaan
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Pembekal&gt; Jenis Pembekal
 DocType: Opportunity Item,Basic Rate,Kadar asas
 DocType: GL Entry,Credit Amount,Jumlah Kredit
 ,Electronic Invoice Register,Daftar Invois Elektronik
@@ -7995,6 +8032,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Cukai dan Caj Dipotong (Syarikat mata wang)
 DocType: Item Group,General Settings,Tetapan umum
 DocType: Article,Article,Artikel
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Sila masukkan kod kupon !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Dari Mata Wang dan Untuk mata wang tidak boleh sama
 DocType: Taxable Salary Slab,Percent Deduction,Potongan Percukaian
 DocType: GL Entry,To Rename,Untuk Namakan semula
diff --git a/erpnext/translations/my.csv b/erpnext/translations/my.csv
index eefd3b1..1b4f97e 100644
--- a/erpnext/translations/my.csv
+++ b/erpnext/translations/my.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-၎င်းကို-.YYYY.-
 DocType: Purchase Order,Customer Contact,customer ဆက်သွယ်ရန်
 DocType: Shift Type,Enable Auto Attendance,အော်တိုတက်ရောက် Enable
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,ကုန်လှောင်ရုံနှင့်နေ့စွဲကိုရိုက်ထည့်ပါ
 DocType: Lost Reason Detail,Opportunity Lost Reason,အခွင့်အလမ်းပျောက်ဆုံးသွားသောအကြောင်းရင်း
 DocType: Patient Appointment,Check availability,check ရရှိနိုင်မှု
 DocType: Retention Bonus,Bonus Payment Date,အပိုဆုငွေပေးချေမှုရမည့်နေ့စွဲ
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Completed လုပ်ငန်းခွင်အမိန့်
 DocType: Support Settings,Forum Posts,ဖိုရမ်ရေးသားချက်များ
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","အဆိုပါတာဝန်တစ်ခုနောက်ခံအလုပ်အဖြစ် enqueued ခဲ့တာဖြစ်ပါတယ်။ နောက်ခံအပြောင်းအလဲနဲ့အပေါ်မည်သည့်ပြဿနာလည်းမရှိကိစ္စတွင်ခုနှစ်, စနစ်ကဒီစတော့အိတ်ပြန်လည်သင့်မြတ်ရေးအပေါ်အမှားနှင့် ပတ်သက်. မှတ်ချက် add ပါလိမ့်မယ်နှင့်မူကြမ်းအဆင့်ကမှပြန်ပြောင်း"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started",စိတ်မကောင်းပါ၊ ကူပွန်နံပါတ်သက်တမ်းမစတင်သေးပါ
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Taxable ငွေပမာဏ
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},သင် {0} ခင် entries တွေကို add သို့မဟုတ် update ကိုမှခွင့်ပြုမထား
 DocType: Leave Policy,Leave Policy Details,ပေါ်လစီအသေးစိတ် Leave
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Consumer
 DocType: Student,B-,ပါဘူးရှငျ
 DocType: Assessment Result,Grade,grade
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,ပစ္စည်းကုဒ်&gt; ပစ္စည်းအုပ်စု&gt; ကုန်အမှတ်တံဆိပ်
 DocType: Restaurant Table,No of Seats,ထိုင်ခုံ၏အဘယ်သူမျှမ
 DocType: Sales Invoice,Overdue and Discounted,ရက်လွန်နှင့်စျေးလျှော့
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,ခေါ်ရန်အဆက်ပြတ်နေ
@@ -507,6 +510,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,စကားငွေပမာဏအဘို့အလိုင်းအကွာ
 DocType: Vehicle,Additional Details,နောက်ထပ်အသေးစိတ်
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,ဖော်ပြချက်ပေးအပ်မရှိပါ
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,ကုန်လှောင်ရုံမှပစ္စည်းများရယူပါ
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,ဝယ်ယူတောင်းဆိုခြင်း။
 DocType: POS Closing Voucher Details,Collected Amount,စုဆောင်းငွေပမာဏ
 DocType: Lab Test,Submitted Date,Submitted နေ့စွဲ
@@ -614,6 +618,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Learn
 ,Trial Balance (Simple),ရုံးတင်စစ်ဆေး Balance (ရိုးရှင်းသော)
 DocType: Purchase Invoice Item,Enable Deferred Expense,ရွှေ့ဆိုင်းသုံးစွဲမှု Enable
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,လျှောက်ထားကူပွန် Code ကို
 DocType: Asset,Next Depreciation Date,Next ကိုတန်ဖိုးနေ့စွဲ
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,ထမ်းနှုန်းဖြင့်လုပ်ဆောင်ချက်ကုန်ကျစရိတ်
 DocType: Accounts Settings,Settings for Accounts,ငွေစာရင်းသည် Settings ကို
@@ -854,8 +859,6 @@
 DocType: Sales Invoice,Total Qty,စုစုပေါင်း Qty
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 အီးမေးလ် ID ကို
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 အီးမေးလ် ID ကို
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","အဆိုပါထမ်း delete ကျေးဇူးပြု. <a href=""#Form/Employee/{0}"">{0}</a> ဤစာရွက်စာတမ်းဖျက်သိမ်းရန် \"
 DocType: Item,Show in Website (Variant),ဝက်ဘ်ဆိုက်ထဲမှာပြရန် (မူကွဲ)
 DocType: Employee,Health Concerns,ကနျြးမာရေးကိုဒေသခံများကစိုးရိမ်ပူပန်နေကြ
 DocType: Payroll Entry,Select Payroll Period,လစာကာလကို Select လုပ်ပါ
@@ -1021,6 +1024,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,အခွန်နှိမ်အကောင့်
 DocType: Pricing Rule,Sales Partner,အရောင်း Partner
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,အားလုံးပေးသွင်း scorecards ။
+DocType: Coupon Code,To be used to get discount,အထူးလျှော့စျေးရရန်
 DocType: Buying Settings,Purchase Receipt Required,ဝယ်ယူခြင်း Receipt လိုအပ်သော
 DocType: Sales Invoice,Rail,လက်ရန်းတန်း
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,အမှန်တကယ်ကုန်ကျစရိတ်
@@ -1071,6 +1075,7 @@
 DocType: Production Plan,Production Plan,ထုတ်လုပ်မှုအစီအစဉ်
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,ဖွင့်လှစ်ငွေတောင်းခံလွှာဖန်ဆင်းခြင်း Tool ကို
 DocType: Salary Component,Round to the Nearest Integer,အနီးဆုံး Integer မှ round
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,ကုန်ပစ္စည်းမရှိသောပစ္စည်းများကိုလှည်းထဲသို့ထည့်ရန်ခွင့်ပြုပါ
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,အရောင်းသို့ပြန်သွားသည်
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Serial ဘယ်သူမျှမက Input ကိုအပျေါအခွခေံအရောင်းအဝယ်အတွက်အရည်အတွက် Set
 ,Total Stock Summary,စုစုပေါငျးစတော့အိတ်အကျဉ်းချုပ်
@@ -1202,6 +1207,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),base နာရီနှုန်း (ကုမ္ပဏီငွေကြေးစနစ်)
 ,Qty To Be Billed,ငွေတောင်းခံထားမှုခံရစေရန်အရည်အတွက်
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,ကယ်နှုတ်တော်မူ၏ငွေပမာဏ
+DocType: Coupon Code,Gift Card,လက်ဆောင်ကဒ်
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,ထုတ်လုပ်မှုများအတွက် Reserved အရည်အတွက်: ကုန်ထုတ်ပစ္စည်းများလုပ်ကုန်ကြမ်းအရေအတွက်။
 DocType: Loyalty Point Entry Redemption,Redemption Date,ရွေးနှုတ်သောနေ့စွဲ
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,ဤဘဏ်ငွေပေးငွေယူထားပြီးအပြည့်အဝ ပြန်. နေသည်
@@ -1291,6 +1297,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Timesheet Create
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,အကောင့် {0} အကြိမ်ပေါင်းများစွာသို့ဝင်ခဲ့
 DocType: Account,Expenses Included In Valuation,အကောက်ခွန်တန်ဖိုးသတ်မှတ်မည်တွင်ထည့်သွင်းကုန်ကျစရိတ်
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,ဝယ်ယူငွေတောင်းခံလွှာ
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,သင့်ရဲ့အဖွဲ့ဝင်ရက်ပေါင်း 30 အတွင်းကုန်ဆုံးလျှင်သင်သာသက်တမ်းတိုးလို့ရပါတယ်
 DocType: Shopping Cart Settings,Show Stock Availability,စတော့အိတ်ရရှိနိုင်ပြရန်
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},ပိုင်ဆိုင်မှုအမျိုးအစား {1} သို့မဟုတ်ကုမ္ပဏီအတွက် set {0} {2}
@@ -1834,6 +1841,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,ပစ္စည်းများနှင့် UOMs တင်သွင်းခြင်း
 DocType: Repayment Schedule,Balance Loan Amount,balance ချေးငွေပမာဏ
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,အသေးစိတျမှ Added
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted",တောင်းပန်ပါတယ်၊ ကူပွန်ကုဒ်ကုန်သွားပါပြီ
 DocType: Communication Medium,Catch All,အားလုံးကိုဖမ်း
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,ဇယားသင်တန်းအမှတ်စဥ်
 DocType: Budget,Applicable on Material Request,ပစ္စည်းတောင်းဆိုမှုအပေါ်သက်ဆိုင်သော
@@ -2004,6 +2012,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,မှားနေသော Attribute
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} တင်သွင်းရဦးမည်
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,အီးမေးလ်ပို့ရန်ကမ်ပိန်းများ
+DocType: Sales Partner,To Track inbound purchase,အဝင်ဝယ်ယူခြေရာခံရန်
 DocType: Buying Settings,Default Supplier Group,default ပေးသွင်း Group မှ
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},အရေအတွက်ထက်လျော့နည်းသို့မဟုတ် {0} တန်းတူဖြစ်ရပါမည်
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},အဆိုပါအစိတ်အပိုင်း {0} များအတွက်အရည်အချင်းပြည့်မီအများဆုံးပမာဏကို {1} ထက်ကျော်လွန်
@@ -2161,8 +2170,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,စတော့အိတ် Entry &#39;Make
 DocType: Hotel Room Reservation,Hotel Reservation User,ဟိုတယ် Reservation များအသုံးပြုသူ
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Set အခြေအနေ
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,ကျေးဇူးပြု. Setup ကို&gt; နံပါတ်စီးရီးကနေတစ်ဆင့်တက်ရောက်ဘို့ setup ကိုစာရငျးစီးရီး
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,ပထမဦးဆုံးရှေ့ဆက်ကိုရွေးပါ ကျေးဇူးပြု.
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,ကျေးဇူးပြု၍ Setup&gt; Settings&gt; Naming Series မှ {0} အတွက် Naming Series ကိုသတ်မှတ်ပေးပါ
 DocType: Contract,Fulfilment Deadline,ပွညျ့စုံနောက်ဆုံး
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,သငျသညျအနီး
 DocType: Student,O-,O-
@@ -2286,6 +2295,7 @@
 DocType: Quality Meeting Table,Under Review,ဆန်းစစ်ခြင်းလက်အောက်တွင်
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,login ရန်မအောင်မြင်ခဲ့ပါ
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,ပိုင်ဆိုင်မှု {0} created
+DocType: Coupon Code,Promotional,မြှင့်တင်ရေး
 DocType: Special Test Items,Special Test Items,အထူးစမ်းသပ်ပစ္စည်းများ
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,သငျသညျ Marketplace တွင်မှတ်ပုံတင်ရန် System ကိုမန်နေဂျာနှင့် Item Manager ကိုအခန်းကဏ္ဍနှင့်အတူအသုံးပြုသူတစ်ဦးဖြစ်ဖို့လိုအပ်ပါတယ်။
 apps/erpnext/erpnext/config/buying.py,Key Reports,Key ကိုအစီရင်ခံစာများ
@@ -2427,6 +2437,7 @@
 DocType: Project,Start and End Dates,Start နဲ့ရပ်တန့်နေ့စွဲများ
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,စာချုပ် Template ကိုပြည့်စုံစည်းမျဉ်းများ
 ,Delivered Items To Be Billed,ကြေညာတဲ့ခံရဖို့ကယ်နှုတ်တော်မူ၏ပစ္စည်းများ
+DocType: Coupon Code,Maximum Use,အများဆုံးအသုံးပြုမှု
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},ပွင့်လင်း BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,ဂိုဒေါင် Serial နံပါတ်သည်ပြောင်းလဲမပြနိုင်
 DocType: Authorization Rule,Average Discount,ပျမ်းမျှအားလျှော့
@@ -2588,6 +2599,7 @@
 DocType: Item,Inventory,စာရင်း
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,JSON အဖြစ် Download
 DocType: Item,Sales Details,အရောင်းအသေးစိတ်ကို
+DocType: Coupon Code,Used,အသုံးပြုခံ့
 DocType: Opportunity,With Items,ပစ္စည်းများနှင့်အတူ
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',အဆိုပါကင်ပိန်း &#39;&#39; {0} &#39;&#39; ထားပြီး {1} &#39;{2}&#39; အဘို့တည်ရှိ
 DocType: Asset Maintenance,Maintenance Team,ကို Maintenance ရေးအဖွဲ့
@@ -2717,7 +2729,7 @@
 						Serial No cannot be ensured",အဘယ်သူမျှမတက်ကြွ BOM ကို item {0} များအတွက်တွေ့ရှိခဲ့ပါတယ်။ \ Serial အဘယ်သူမျှမနေဖြင့်ဖြန့်ဝေရေးအတွက်လုံလောက်မရနိုင်
 DocType: Sales Partner,Sales Partner Target,အရောင်း Partner Target က
 DocType: Loan Type,Maximum Loan Amount,အများဆုံးချေးငွေပမာဏ
-DocType: Pricing Rule,Pricing Rule,စျေးနှုန်း Rule
+DocType: Coupon Code,Pricing Rule,စျေးနှုန်း Rule
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},ကျောင်းသား {0} အဘို့အလိပ်အရေအတွက်က Duplicate
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},ကျောင်းသား {0} အဘို့အလိပ်အရေအတွက်က Duplicate
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,အမိန့်ကိုဝယ်ယူအသုံးပြုမှ material တောင်းဆိုခြင်း
@@ -2797,6 +2809,7 @@
 DocType: Payment Schedule,Payment Amount,ငွေပေးချေမှုရမည့်ငွေပမာဏ
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,ဝက်နေ့နေ့စွဲနေ့စွဲ မှစ. လုပ်ငန်းခွင်နှင့်လုပ်ငန်းပြီးဆုံးရက်စွဲအကြား၌ဖြစ်သင့်ပါတယ်
 DocType: Healthcare Settings,Healthcare Service Items,ကျန်းမာရေးစောင့်ရှောက်မှုဝန်ဆောင်မှုပစ္စည်းများ
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,မမှန်ကန်သောဘားကုဒ် ဒီဘားကုဒ်နှင့်တွဲထားသည့်ပစ္စည်းမရှိပါ။
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,စားသုံးသည့်ပမာဏ
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,ငွေအတွက်ပိုက်ကွန်ကိုပြောင်းရန်
 DocType: Assessment Plan,Grading Scale,grade စကေး
@@ -2918,7 +2931,6 @@
 DocType: Share Transfer,Asset Account,ပိုင်ဆိုင်မှုအကောင့်
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,နယူးလွှတ်ပေးရန်နေ့စွဲအနာဂတ်၌ဖြစ်သင့်
 DocType: Purchase Invoice,End date of current invoice's period,လက်ရှိကုန်ပို့လွှာရဲ့ကာလ၏အဆုံးနေ့စွဲ
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,လူ့စွမ်းအားအရင်းအမြစ်အတွက် System ကိုအမည်ဖြင့်သမုတ် ကျေးဇူးပြု. setup ကိုထမ်း&gt; HR က Settings
 DocType: Lab Test,Technician Name,Technician အအမည်
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3030,6 +3042,7 @@
 DocType: Products Settings,Hide Variants,မူကွဲ Hide
 DocType: Lead,Next Contact By,Next ကိုဆက်သွယ်ရန်အားဖြင့်
 DocType: Compensatory Leave Request,Compensatory Leave Request,အစားထိုးခွင့်တောင်းဆိုခြင်း
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings",{2} ထက်ပိုသောအတန်း {1} တွင် Item {0} အတွက် overbill မလုပ်နိုင်ပါ။ အလွန်အကျွံငွေပေးချေခြင်းကိုခွင့်ပြုရန် ကျေးဇူးပြု၍ Accounts Settings တွင်ခွင့်ပြုပါ
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},အတန်းအတွက် Item {0} သည်လိုအပ်သောအရေအတွက် {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},အရေအတွက် Item {1} သည်တည်ရှိအဖြစ်ဂိုဒေါင် {0} ဖျက်ပြီးမရနိုင်ပါ
 DocType: Blanket Order,Order Type,အမိန့် Type
@@ -3202,7 +3215,6 @@
 DocType: Student,Student Mobile Number,ကျောင်းသားသမဂ္ဂမိုဘိုင်းနံပါတ်
 DocType: Item,Has Variants,မူကွဲရှိပါတယ်
 DocType: Employee Benefit Claim,Claim Benefit For,သည်ပြောဆိုချက်ကိုအကျိုးခံစားခွင့်
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","{2} ထက် {0} အတန်းအတွက် {1} ကပိုပစ္စည်းများအတွက် overbill လို့မရပါဘူး။ Over-ငွေတောင်းခံခွင့်ပြုပါရန်, စတော့အိတ်ချိန်ညှိမှုများအတွက်သတ်မှတ်ထားကျေးဇူးပြုပြီး"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,တုံ့ပြန်မှုကိုအပ်ဒိတ်လုပ်
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},သငျသညျပြီးသား {0} {1} ကနေပစ္စည်းကိုရှေးခယျြခဲ့ကြ
 DocType: Monthly Distribution,Name of the Monthly Distribution,အဆိုပါလစဉ်ဖြန့်ဖြူးအမည်
@@ -3495,6 +3507,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,ကုမ္ပဏီအတွက်ငွေကြေးသတ်မှတ် ကျေးဇူးပြု.
 DocType: Workstation,Wages per hour,တစ်နာရီလုပ်ခ
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Configure {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,ဖောက်သည်&gt; ဖောက်သည်အုပ်စု&gt; နယ်မြေ
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Batch အတွက်စတော့အိတ်ချိန်ခွင် {0} ဂိုဒေါင် {3} မှာ Item {2} သည် {1} အနုတ်လက္ခဏာဖြစ်လိမ့်မည်
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,အောက်ပါပစ္စည်းများတောင်းဆိုမှုများပစ္စည်းရဲ့ Re-အမိန့် level ကိုအပေါ်အခြေခံပြီးအလိုအလြောကျထမြောက်ကြပါပြီ
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},အကောင့်ကို {0} မမှန်ကန်ဘူး။ အကောင့်ကိုငွေကြေးစနစ် {1} ဖြစ်ရပါမည်
@@ -3828,6 +3841,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,လစာစလစ်ဖြတ်ပိုင်းပုံစံ Submit
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,ခေတ္တဆိုင်းငံထားသည်
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,တစ်ဦးက qustion အနည်းဆုံးမှန်ကန်သောရွေးချယ်မှုများရှိရမည်
+apps/erpnext/erpnext/hooks.py,Purchase Orders,ဝယ်ယူအမိန့်
 DocType: Account,Inter Company Account,အင်တာမီလန်ကုမ္ပဏီအကောင့်
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,ထုထည်ကြီးအတွက်သွင်းကုန်
 DocType: Sales Partner,Address & Contacts,လိပ်စာ &amp; ဆက်သွယ်ရန်
@@ -3838,6 +3852,7 @@
 DocType: POS Profile,[Select],[ရွေးပါ]
 DocType: Staffing Plan Detail,Number Of Positions,ရာထူးနံပါတ်
 DocType: Vital Signs,Blood Pressure (diastolic),သွေးဖိအား (diastolic)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,ကျေးဇူးပြုပြီးဖောက်သည်ကိုရွေးပါ။
 DocType: SMS Log,Sent To,ရန်ကိုစလှေတျ
 DocType: Agriculture Task,Holiday Management,အားလပ်ရက်စီမံခန့်ခွဲမှု
 DocType: Payment Request,Make Sales Invoice,အရောင်းပြေစာလုပ်ပါ
@@ -4048,7 +4063,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} တင်သွင်းသည်မဟုတ်
 DocType: Subscription,Trialling,စမ်းသပ်
 DocType: Sales Invoice Item,Deferred Revenue,ရွှေ့ဆိုင်းအခွန်ဝန်ကြီးဌာန
-DocType: Bank Account,GL Account,GL အကောင့်
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,ငွေသားအကောင့်ကိုအရောင်းပြေစာဖန်တီးမှုအတွက်အသုံးပြုပါလိမ့်မယ်
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,ကင်းလွတ်ခွင့် Sub Category:
 DocType: Member,Membership Expiry Date,အသင်းဝင်သက်တမ်းကုန်ဆုံးနေ့စွဲ
@@ -4455,13 +4469,13 @@
 DocType: C-Form Invoice Detail,Territory,နယျမွေ
 DocType: Pricing Rule,Apply Rule On Item Code,Item Code ကိုတွင်စည်းမျဉ်း Apply
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,လိုအပ်သောလာရောက်လည်ပတ်သူမျှဖော်ပြထားခြင်း ကျေးဇူးပြု.
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,စတော့အိတ်ချိန်းအစီရင်ခံစာ
 DocType: Stock Settings,Default Valuation Method,default အကောက်ခွန်တန်ဖိုးသတ်မှတ်မည်နည်းနိဿယ
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,ကြေး
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,တိုးပွားလာသောငွေပမာဏပြရန်
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,တိုးတက်မှုအတွက် Update ကို။ ဒါဟာခဏတစ်ယူပေလိမ့်မည်။
 DocType: Production Plan Item,Produced Qty,ထုတ်လုပ်အရည်အတွက်
 DocType: Vehicle Log,Fuel Qty,လောင်စာအရည်အတွက်
-DocType: Stock Entry,Target Warehouse Name,ပစ်မှတ်ဂိုဒေါင်အမည်
 DocType: Work Order Operation,Planned Start Time,စီစဉ်ထား Start ကိုအချိန်
 DocType: Course,Assessment,အကဲဖြတ်
 DocType: Payment Entry Reference,Allocated,ခွဲဝေ
@@ -4527,10 +4541,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","အရောင်းနှင့်ဝယ်ယူထည့်သွင်းနိုင်ပါသည်က Standard စည်းကမ်းသတ်မှတ်ချက်များ။ ဥပမာ: ကမ်းလှမ်းမှုကို၏ 1. သက်တမ်းရှိ။ 1. ငွေပေးချေမှုရမည့်ဝေါဟာရများ (Advance မှာတော့ Credit တွင်တစ်စိတ်တစ်ပိုင်းကြိုတင်မဲစသည်တို့) ။ 1. အပို (သို့မဟုတ်ဖောက်သည်များကပေးဆောင်) သည်အဘယ်သို့။ 1. ဘေးကင်းရေး / အသုံးပြုမှုသတိပေးချက်ကို။ 1. အာမခံရှိလျှင်။ 1. မူဝါဒပြန်ပို့ပေးသည်။ သက်ဆိုင်လျှင်, တင်ပို့၏ 1. သက်မှတ်ချက်များ။ စသည်တို့အငြင်းပွားမှုများဖြေရှင်း၏ 1. နည်းလမ်းများ, လျော်ကြေး, တာဝန်ယူမှု, 1. လိပ်စာနှင့်သင့် Company ၏ဆက်သွယ်ရန်။"
 DocType: Homepage Section,Section Based On,ပုဒ်မတွင် အခြေခံ.
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Apply Coupon Code ကိုပြပါ
 DocType: Issue,Issue Type,ပြဿနာအမျိုးအစား
 DocType: Attendance,Leave Type,Type Leave
 DocType: Purchase Invoice,Supplier Invoice Details,ပေးသွင်းငွေတောင်းခံလွှာအသေးစိတ်
 DocType: Agriculture Task,Ignore holidays,အားလပ်ရက်လျစ်လျူရှု
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,ကူပွန်အခြေအနေများထည့်ပေါင်း / တည်းဖြတ်ပါ
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,စရိတ် / Difference အကောင့်ကို ({0}) တစ်ဦး &#39;&#39; အကျိုးအမြတ်သို့မဟုတ်ပျောက်ဆုံးခြင်း &#39;&#39; အကောင့်ကိုရှိရမည်
 DocType: Stock Entry Detail,Stock Entry Child,စတော့အိတ် Entry &#39;ကလေး
 DocType: Project,Copied From,မှစ. ကူးယူ
@@ -4706,6 +4722,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,အကဲဖြတ်အစီအစဉ်လိုအပ်ချက်
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,အရောင်းအ
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,အရစ်ကျမိန့်တားဆီး
+DocType: Coupon Code,Coupon Name,ကူပွန်အမည်
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,ဖြစ်ပေါ်နိုင်
 DocType: Email Campaign,Scheduled,Scheduled
 DocType: Shift Type,Working Hours Calculation Based On,အလုပ်လုပ်နာရီတွက်ချက်မှုတွင် အခြေခံ.
@@ -4722,7 +4739,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Variant Create
 DocType: Vehicle,Diesel,ဒီဇယ်
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,စျေးနှုန်း List ကိုငွေကြေးစနစ်ကိုမရွေးချယ်
+DocType: Quick Stock Balance,Available Quantity,ရရှိနိုင်အရေအတွက်
 DocType: Purchase Invoice,Availed ITC Cess,ရရှိနိုင်ပါ ITC အခွန်
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,ကျေးဇူးပြုပြီးပညာရေး&gt; ပညာရေးချိန်ညှိချက်များတွင်နည်းပြအမည်ပေးခြင်းစနစ်ကိုထည့်သွင်းပါ
 ,Student Monthly Attendance Sheet,ကျောင်းသားသမဂ္ဂလစဉ်တက်ရောက်စာရွက်
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,ရောင်းအားအဘို့ကိုသာသက်ဆိုင် shipping အုပ်ချုပ်မှုကို
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,တန်ဖိုးလျော့ Row {0}: Next ကိုတန်ဖိုးနေ့စွဲဝယ်ယူနေ့စွဲမတိုင်မီမဖွစျနိုငျ
@@ -4790,8 +4809,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,row {0}: ဖောက်သည်ဆန့်ကျင်ကြိုတင်အကြွေးဖြစ်ရပါမည်
 DocType: Quality Meeting,Quality Meeting,အရည်အသွေးအစည်းအဝေး
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Group ကိုမှ non-Group က
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Setup ကို&gt; Setting&gt; အမည်ဖြင့်သမုတ်စီးရီးကနေတဆင့် {0} များအတွက်စီးရီးအမည်ဖြင့်သမုတ်သတ်မှတ်ထား ကျေးဇူးပြု.
 DocType: Employee,ERPNext User,ERPNext အသုံးပြုသူ
+DocType: Coupon Code,Coupon Description,ကူပွန်ဖော်ပြချက်
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},batch အတန်း {0} အတွက်မဖြစ်မနေဖြစ်ပါသည်
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},batch အတန်း {0} အတွက်မဖြစ်မနေဖြစ်ပါသည်
 DocType: Company,Default Buying Terms,default သတ်မှတ်ချက်များကိုဝယ်ယူ
@@ -4956,6 +4975,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Document ဖိုင် Detail မရှိဆန့်ကျင်
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},ပယ်ဖျက်ခြင်းတိုင်းပြည် {0} အဘို့အခွင့်မရှိကြ
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,ပါတီအမျိုးအစားမဖြစ်မနေဖြစ်ပါသည်
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,ကူပွန် Code ကို Apply
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","အလုပ်ကဒ် {0}, သင်သာ type ကိုစတော့ရှယ်ယာ entry ကို &#39;&#39; ထုတ်လုပ်ခြင်းတို့အတွက်ပစ္စည်းလွှဲပြောင်း &#39;အစေနိုင်သည်"
 DocType: Quality Inspection,Outgoing,outgoing
 DocType: Customer Feedback Table,Customer Feedback Table,ဖောက်သည်တုံ့ပြန်ချက်ဇယား
@@ -5108,7 +5128,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,အရစ်ကျမိန့်တင်ပြမှုတွင်
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,အားလုံးပေးသွင်း Add
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,အတန်း # {0}: ခွဲဝေငွေပမာဏထူးချွန်ငွေပမာဏထက် သာ. ကြီးမြတ်မဖြစ်နိုင်ပါ။
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,ဖောက်သည်&gt; ဖောက်သည် Group မှ&gt; နယ်မြေတွေကို
 DocType: Tally Migration,Parties,ပါတီများက
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Browse ကို BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,လုံခြုံသောချေးငွေ
@@ -5140,7 +5159,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},ပစ္စည်း {0} များအတွက်အခြားရွေးချယ်စရာကို item set ဖို့ခွင့်မပြု
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,နေ့စွဲထပ်ခါတလဲလဲဖြစ်ပါတယ်
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Authorized လက်မှတ်ရေးထိုးထားသော
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,ပညာရေးအတွက် System ကိုအမည်ဖြင့်သမုတ် ကျေးဇူးပြု. setup ကိုနည်းပြ&gt; ပညာရေးကိုဆက်တင်
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Net က ITC ရရှိနိုင်သော (က) - (ခ)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,အခကြေးငွေ Create
 DocType: Project,Total Purchase Cost (via Purchase Invoice),(ဝယ်ယူခြင်းပြေစာကနေတဆင့်) စုစုပေါင်းဝယ်ယူကုန်ကျစရိတ်
@@ -5165,6 +5183,7 @@
 DocType: Quiz Result,Wrong,မှားသော
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,စျေးနှုန်းစာရင်းငွေကြေးဖောက်သည်ရဲ့အခြေစိုက်စခန်းငွေကြေးအဖြစ်ပြောင်းလဲသောအချိန်တွင် rate
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Net ကပမာဏ (ကုမ္ပဏီငွေကြေးစနစ်)
+DocType: Sales Partner,Referral Code,ရည်ညွှန်းကုဒ်
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,စုစုပေါင်းကြိုတင်မဲငွေပမာဏစုစုပေါင်းပိတ်ဆို့အရေးယူငွေပမာဏထက် သာ. ကြီးမြတ်မဖွစျနိုငျ
 DocType: Salary Slip,Hour Rate,အချိန်နာရီနှုန်း
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,အော်တိုပြန်အမိန့် Enable
@@ -5295,6 +5314,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,စတော့အိတ်အရေအတွက်ပြရန်
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,စစ်ဆင်ရေးကနေ Net ကငွေ
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},အတန်း # {0}: အခြေအနေ {1} ပြေစာများအတွက် {2} ဝရမည်ဖြစ်သည်
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM ပြောင်းလဲခြင်းအချက် ({0} -&gt; {1}) ကိုရှာမတွေ့ပါ။ {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,item 4
 DocType: Student Admission,Admission End Date,ဝန်ခံချက်အဆုံးနေ့စွဲ
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,sub-စာချုပ်ကိုချုပ်ဆို
@@ -5317,6 +5337,7 @@
 DocType: Travel Request,Fully Sponsored,အပြည့်အဝထောက်ပံ့ထား
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,ပြောင်းပြန်ဂျာနယ် Entry &#39;
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,ယောဘသည် Card ကို Create
+DocType: Quotation,Referral Sales Partner,လွှဲပြောင်းအရောင်းပါတနာ
 DocType: Quality Procedure Process,Process Description,ဖြစ်စဉ်ကိုဖျေါပွခကျြ
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,ဖောက်သည် {0} နေသူများကဖန်တီး။
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,မည်သည့်ဂိုဒေါင်ထဲမှာရရှိနိုင်လောလောဆယ်အဘယ်သူမျှမစတော့ရှယ်ယာ
@@ -5451,6 +5472,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM Rate
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Uploaded ဖိုင်မှတ်တမ်း Reading
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","လုပ်ငန်းခွင်အမိန့်ကိုပယ်ဖျက်ပေးဖို့ပထမဦးဆုံးက Unstop, ဖျက်သိမ်းမရနိုငျရပ်တန့်"
+DocType: Coupon Code,Coupon Code,ကူပွန်ကုဒ်
 DocType: Asset,Journal Entry for Scrap,အပိုင်းအစအဘို့အဂျာနယ် Entry &#39;
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Delivery မှတ်ချက်များထံမှပစ္စည်းများကိုဆွဲ ကျေးဇူးပြု.
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},အတန်း {0}: စစ်ဆင်ရေး {1} ဆန့်ကျင်ကို Workstation ကို select
@@ -5535,6 +5557,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;&#39; နေ့စွဲ &#39;&#39; လိုအပ်ပါသည်
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},ကြောင့် / ကိုးကားစရာနေ့စွဲ {0} ပြီးနောက်မဖွစျနိုငျ
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,ဒေတာပို့ကုန်သွင်းကုန်
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired",စိတ်မကောင်းပါ၊ ကူပွန်ကုဒ်သက်တမ်းကုန်သွားပြီ
 DocType: Bank Account,Account Details,အကောင့်အသေးစိတ်
 DocType: Crop,Materials Required,လိုအပ်သောပစ္စည်းများ
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,ကျောင်းသားများကို Found ဘယ်သူမျှမက
@@ -5572,6 +5595,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,အသုံးပြုသူများကိုသွားပါ
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Paid ပမာဏ + ငွေပမာဏက Grand စုစုပေါင်းထက် သာ. ကြီးမြတ်မဖွစျနိုငျပိတ်ရေးထား
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} Item {1} သည်မှန်ကန်သော Batch နံပါတ်မဟုတ်ပါဘူး
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,ကျေးဇူးပြု၍ မှန်ကန်သောကူပွန်ကုဒ်ကိုရိုက်ထည့်ပါ !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},မှတ်ချက်: လုံလောက်တဲ့ခွင့်ချိန်ခွင်လျှာထွက်ခွာ Type {0} သည်မရှိ
 DocType: Task,Task Description,task ကိုဖျေါပွခကျြ
 DocType: Training Event,Seminar,ညှိနှိုငျးဖလှယျပှဲ
@@ -5839,6 +5863,7 @@
 ,TDS Payable Monthly,TDS ပေးရန်လစဉ်
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,အဆိုပါ BOM အစားထိုးဘို့တန်းစီထားသည်။ ဒါဟာမိနစ်အနည်းငယ်ကြာနိုင်ပါသည်။
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',အမျိုးအစား &#39;&#39; အကောက်ခွန်တန်ဖိုးသတ်မှတ်မည် &#39;သို့မဟုတ်&#39; &#39;အကောက်ခွန်တန်ဖိုးသတ်မှတ်မည်နှင့်စုစုပေါင်း&#39; &#39;အဘို့ဖြစ်၏သောအခါအနှိမ်မချနိုင်
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,ကျေးဇူးပြု၍ လူ့စွမ်းအားအရင်းအမြစ်&gt; HR ဆက်တင်တွင် Employee Naming System ကိုထည့်သွင်းပါ
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,စုစုပေါင်းငွေချေမှု
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serial Item {0} သည် serial အမှတ်လိုအပ်ပါသည်
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,ငွေတောင်းခံလွှာနှင့်အတူပွဲစဉ်ငွေပေးချေ
@@ -5929,6 +5954,7 @@
 DocType: Production Plan,Get Raw Materials For Production,ထုတ်လုပ်မှုကုန်ကြမ်းကိုရယူလိုက်ပါ
 DocType: Job Opening,Job Title,အလုပ်အကိုင်အမည်
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,အနာဂတ်ငွေပေးချေမှုရမည့် Ref
+DocType: Quotation,Additional Discount and Coupon Code,အပိုဆောင်းလျှော့စျေးနှင့်ကူပွန် Code ကို
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.",{0} {1} တစ် quotation အပေးမည်မဟုတ်ကြောင်းညွှန်ပြပေမယ့်ပစ္စည်းများအားလုံးကိုးကားခဲ့ကြ \ ။ အဆိုပါ RFQ ကိုးကား status ကိုမွမ်းမံခြင်း။
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,အများဆုံးနမူနာ - {0} ပြီးသားအသုတ်လိုက် {1} နှင့် Item {2} အသုတ်လိုက်အတွက် {3} များအတွက်ထိန်းသိမ်းထားပါပြီ။
@@ -6158,7 +6184,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,ဝက်ဘ်ဆိုက်ပင်မစာမျက်နှာများအတွက်ချိန်ညှိမှုများ
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} {1} မှီတိုင်အောင်ဆိုင်းငံ့ထားဖြစ်ပါသည်
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQs ကြောင့် {1} တစ် scorecard ရပ်တည်မှုမှ {0} အဘို့အခွင့်ပြုခဲ့ကြသည်မဟုတ်
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,ဝယ်ယူခြင်းပြေစာလုပ်ပါ
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,တပတ်ရစ်အရွက်
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} ကူပွန်သည် {1} ဖြစ်သည်။ ခွင့်ပြုထားသောပမာဏကုန်သွားသည်
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,သငျသညျပစ္စည်းတောင်းဆိုစာတင်သွင်းချင်ပါနဲ့
 DocType: Job Offer,Awaiting Response,စောင့်ဆိုင်းတုန့်ပြန်
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU တွင်-CSH-.YYYY.-
@@ -6172,6 +6200,7 @@
 DocType: Training Event Employee,Optional,optional
 DocType: Salary Slip,Earning & Deduction,ဝင်ငွေ &amp; ထုတ်ယူ
 DocType: Agriculture Analysis Criteria,Water Analysis,ရေအားသုံးသပ်ခြင်း
+DocType: Sales Order,Skip Delivery Note,ပေးပို့မှတ်စုကိုကျော်လိုက်ပါ
 DocType: Price List,Price Not UOM Dependent,စျေး UOM မှီခိုမ
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} created variants ။
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,တစ်ဦးကပုံမှန်ဝန်ဆောင်မှုအဆင့်သဘောတူညီချက်ရှိပြီးဖြစ်သည်။
@@ -6280,6 +6309,7 @@
 DocType: Vehicle,Last Carbon Check,ပြီးခဲ့သည့်ကာဗွန်စစ်ဆေးမှု
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,ဥပဒေရေးရာအသုံးစရိတ်များ
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,အတန်းအပေါ်အရေအတွက်ကို select ပေးပါ
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},လုပ်ငန်းခွင် {0} - လုပ်ငန်းလည်ပတ်မှုအတွက်အလုပ်မရသေးသောအလုပ်ကဒ် {1}
 DocType: Purchase Invoice,Posting Time,posting အချိန်
 DocType: Timesheet,% Amount Billed,ကြေညာတဲ့% ပမာဏ
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,တယ်လီဖုန်းအသုံးစရိတ်များ
@@ -6382,7 +6412,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,အခွန်နှင့်စွပ်စွဲချက် Added
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,တန်ဖိုးလျော့ Row {0}: Next ကိုတန်ဖိုးနေ့စွဲရှိနိုင်-for-အသုံးပြုမှုနေ့စွဲမတိုင်မီမဖွစျနိုငျ
 ,Sales Funnel,အရောင်းကတော့
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,item Code ကို&gt; item Group မှ&gt; အမှတ်တံဆိပ်
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,အတိုကောက်မဖြစ်မနေဖြစ်ပါသည်
 DocType: Project,Task Progress,task ကိုတိုးတက်ရေးပါတီ
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,လှည်း
@@ -6478,6 +6507,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS Entry &#39;ပါစေရန်လိုအပ်သည် POS ကိုယ်ရေးအချက်အလက်များ profile
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","သစ္စာရှိမှုအမှတ်ဖော်ပြခဲ့တဲ့စုဆောင်းခြင်းအချက်ပေါ်အခြေခံပြီး, (ယင်းအရောင်းပြေစာမှတဆင့်) ကိုသုံးစွဲပြီးပြီထံမှတွက်ချက်ပါလိမ့်မည်။"
 DocType: Program Enrollment Tool,Enroll Students,ကျောင်းသားများကျောင်းအပ်
+DocType: Pricing Rule,Coupon Code Based,ကူပွန် Code ကိုအခြေခံပြီး
 DocType: Company,HRA Settings,ဟရားက Settings
 DocType: Homepage,Hero Section,သူရဲကောင်းပုဒ်မ
 DocType: Employee Transfer,Transfer Date,လွှဲပြောင်းနေ့စွဲ
@@ -6594,6 +6624,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',အုပ်စုအားဖြင့် &#39;&#39; ကုမ္ပဏီ &#39;&#39; လျှင်အလွတ် filter ကုမ္ပဏီသတ်မှတ်ပေးပါ
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Post date အနာဂတ်နေ့စွဲမဖွစျနိုငျ
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},row # {0}: Serial မရှိပါ {1} {2} {3} နှင့်ကိုက်ညီမပါဘူး
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,ကျေးဇူးပြု၍ Setup&gt; Numbering Series မှတဆင့်တက်ရောက်သူများအတွက်နံပါတ်စဉ်ဆက်တင်များကိုပြင်ဆင်ပါ
 DocType: Stock Entry,Target Warehouse Address,ပစ်မှတ်ဂိုဒေါင်လိပ်စာ
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,ကျပန်းထွက်ခွာ
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,အဆိုပါပြောင်းကုန်ပြီရှေ့တော်၌ထိုအချိန်ထမ်းစစ်ဆေးမှု-in ကိုတက်ရောက်သူဘို့စဉ်းစားသောကာလအတွင်းအချိန်ကိုစတင်ပါ။
@@ -6628,7 +6659,6 @@
 DocType: Employee Grade,Employee Grade,ဝန်ထမ်းအဆင့်
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Piecework
 DocType: GSTR 3B Report,June,ဇွန်လ
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,ပေးသွင်း&gt; ပေးသွင်းအမျိုးအစား
 DocType: Share Balance,From No,အဘယ်သူမျှမကနေ
 DocType: Shift Type,Early Exit Grace Period,အစောပိုင်း Exit ကိုကျေးဇူးတော်ရှိစေသတည်းကာလ
 DocType: Task,Actual Time (in Hours),(နာရီအတွက်) အမှန်တကယ်အချိန်
@@ -6915,7 +6945,6 @@
 DocType: Warehouse,Warehouse Name,ဂိုဒေါင်အမည်
 DocType: Naming Series,Select Transaction,Transaction ကိုရွေးပါ
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,အခန်းက္ပအတည်ပြုပေးသောသို့မဟုတ်အသုံးပြုသူအတည်ပြုပေးသောရိုက်ထည့်ပေးပါ
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM ကူးပြောင်းခြင်းအချက် ({0} -&gt; {1}) ကို item ဘို့မတွေ့ရှိ: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Entity အမျိုးအစား {0} နှင့် Entity {1} ပြီးသားတည်ရှိနှင့်အတူဝန်ဆောင်မှုအဆင့်သဘောတူညီချက်ကို။
 DocType: Journal Entry,Write Off Entry,Entry ပိတ်ရေးထား
 DocType: BOM,Rate Of Materials Based On,ပစ္စည်းများအခြေတွင်အမျိုးမျိုး rate
@@ -7054,6 +7083,7 @@
 DocType: Budget,Warn,အသိပေး
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,ပစ္စည်းများအားလုံးပြီးသားဒီအလုပျအမိန့်အဘို့အပြောင်းရွှေ့ပြီ။
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","အခြားမည်သည့်သဘောထားမှတ်ချက်, မှတ်တမ်းများအတွက်သွားသင့်ကြောင်းမှတ်သားဖွယ်အားထုတ်မှု။"
+DocType: Bank Account,Company Account,ကုမ္ပဏီအကောင့်
 DocType: Asset Maintenance,Manufacturing User,ကုန်ထုတ်လုပ်မှုအသုံးပြုသူတို့၏
 DocType: Purchase Invoice,Raw Materials Supplied,ပေးထားသည့်ကုန်ကြမ်းပစ္စည်းများ
 DocType: Subscription Plan,Payment Plan,ငွေပေးချေမှုရမည့်အစီအစဉ်
@@ -7095,6 +7125,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) လုပ်ငန်းခွင်အမိန့် {3} အတွက်စီစဉ်ထားအရေအတွက် ({2}) ထက် သာ. ကြီးမြတ်မဖွစျနိုငျ
 DocType: Certification Application,Name of Applicant,လျှောက်ထားသူအမည်
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,ကုန်ထုတ်လုပ်မှုများအတွက်အချိန်စာရွက်။
+DocType: Quick Stock Balance,Quick Stock Balance,လျင်မြန်စွာစတော့အိတ်လက်ကျန်
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,စုစုပေါင်း
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,စတော့ရှယ်ယာငွေပေးငွေယူပြီးနောက်မူကွဲဂုဏ်သတ္တိများမပြောင်းနိုင်ပါ။ သင်ဤလုပ်ဖို့သစ်တစ်ခုအရာဝတ္ထုလုပ်ရပါလိမ့်မယ်။
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA လုပ်ပိုင်ခွင့်
@@ -7423,6 +7454,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} မလှုပ်မရှားကျောင်းသားဖြစ်ပါသည်
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} မလှုပ်မရှားကျောင်းသားဖြစ်ပါသည်
 DocType: Employee,Health Details,ကနျြးမာရေးအသေးစိတ်ကို
+DocType: Coupon Code,Coupon Type,ကူပွန်အမျိုးအစား
 DocType: Leave Encashment,Encashable days,Encashable ရက်ပေါင်း
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,ရည်ညွှန်းစာရွက်စာတမ်းလိုအပ်ပါသည်တစ်ဦးငွေပေးချေမှုရမည့်တောင်းဆိုခြင်းကိုဖန်တီးရန်
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,ရည်ညွှန်းစာရွက်စာတမ်းလိုအပ်ပါသည်တစ်ဦးငွေပေးချေမှုရမည့်တောင်းဆိုခြင်းကိုဖန်တီးရန်
@@ -7711,6 +7743,7 @@
 DocType: Hotel Room Package,Amenities,အာမင်
 DocType: Accounts Settings,Automatically Fetch Payment Terms,ငွေပေးချေမှုရမည့်စည်းမျဉ်းစည်းကမ်းများအလိုအလြောကျခေါ်ယူ
 DocType: QuickBooks Migrator,Undeposited Funds Account,Undeposited ရန်ပုံငွေများအကောင့်
+DocType: Coupon Code,Uses,အသုံးပြုသည်
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,ငွေပေးချေမှု၏အကွိမျမြားစှာက default mode ကိုခွင့်မပြုပါ
 DocType: Sales Invoice,Loyalty Points Redemption,သစ္စာရှိမှုအမှတ်ရွေးနှုတ်ခြင်း
 ,Appointment Analytics,ခန့်အပ်တာဝန်ပေးခြင်း Analytics မှ
@@ -7728,6 +7761,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,သငျသညျတစ်နှစ်လျှင်ကျောင်းသားကျောင်းသူများအုပ်စုများစေလျှင်လွတ် Leave
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,သငျသညျတစ်နှစ်လျှင်ကျောင်းသားကျောင်းသူများအုပ်စုများစေလျှင်လွတ် Leave
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","checked, စုစုပေါင်းမျှမပါ။ အလုပ်အဖွဲ့ Days ၏အားလပ်ရက်ပါဝင်ပါလိမ့်မယ်, ဒီလစာ Per နေ့၏တန်ဖိုးကိုလျော့ချလိမ့်မည်"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,ဒိုမိန်းထည့်ရန်မအောင်မြင်ပါ
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","ငွေလက်ခံဖြတ်ပိုင်း / ပို့ဆောင်မှုကျော်ခွင့်ပြုပါရန်, စတော့အိတ်ချိန်ညှိမှုများ, သို့မဟုတ်အရာဝတ္ထုများတွင် &quot;ငွေလက်ခံပြေစာ / Delivery Allow ကျော်&quot; ကို update ။"
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","လက်ရှိ key ကိုသုံးပြီး Apps ကပရယူနိုင်လိမ့်မည်မဟုတ်ပေ, သင်သေချာရှိပါသလဲ"
 DocType: Subscription Settings,Prorate,Prorated
@@ -7741,6 +7775,7 @@
 ,BOM Stock Report,BOM စတော့အိတ်အစီရင်ခံစာ
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","အဘယ်သူမျှမတာဝန်ပေးအပ်အချိန်အပိုင်းအခြားများအားလည်းမရှိလျှင်, ဆက်သွယ်ရေးကဒီအဖွဲ့ကကိုင်တွယ်လိမ့်မည်"
 DocType: Stock Reconciliation Item,Quantity Difference,အရေအတွက် Difference
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,ပေးသွင်းသူ&gt; ပေးသွင်းသူအမျိုးအစား
 DocType: Opportunity Item,Basic Rate,အခြေခံပညာ Rate
 DocType: GL Entry,Credit Amount,အကြွေးပမာဏ
 ,Electronic Invoice Register,အီလက်ထရောနစ်ငွေတောင်းခံလွှာမှတ်ပုံတင်မည်
@@ -7995,6 +8030,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),နုတ်ယူအခွန်အခများနှင့်စွပ်စွဲချက် (ကုမ္ပဏီငွေကြေးစနစ်)
 DocType: Item Group,General Settings,General Settings
 DocType: Article,Article,ဆောင်းပါး
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,ကျေးဇူးပြု၍ ကူပွန်ကုဒ်ကိုရိုက်ထည့်ပါ !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,ငွေကြေးစနစ်နှင့်ငွေကြေးစနစ်နိုင်ရန်တူညီသောမဖွစျနိုငျ
 DocType: Taxable Salary Slab,Percent Deduction,ရာခိုင်နှုန်းကိုထုတ်ယူ
 DocType: GL Entry,To Rename,Rename မှ
diff --git a/erpnext/translations/nl.csv b/erpnext/translations/nl.csv
index ced3454..c14507c 100644
--- a/erpnext/translations/nl.csv
+++ b/erpnext/translations/nl.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Contactpersoon Klant
 DocType: Shift Type,Enable Auto Attendance,Automatische aanwezigheid inschakelen
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Voer Magazijn en datum in
 DocType: Lost Reason Detail,Opportunity Lost Reason,Gelegenheid verloren reden
 DocType: Patient Appointment,Check availability,Beschikbaarheid controleren
 DocType: Retention Bonus,Bonus Payment Date,Bonus Betalingsdatum
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Voltooide werkorders
 DocType: Support Settings,Forum Posts,Forum berichten
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","De taak is in de wacht gezet als achtergrondtaak. Als er een probleem is met de verwerking op de achtergrond, zal het systeem een opmerking toevoegen over de fout bij deze voorraadafstemming en terugkeren naar de conceptfase"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Sorry, de geldigheid van de couponcode is niet gestart"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Belastbaar bedrag
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},U bent niet bevoegd om items toe te voegen of bij te werken voor {0}
 DocType: Leave Policy,Leave Policy Details,Laat beleidsdetails achter
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Verbruiksartikelen
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,Rang
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Artikelcode&gt; Artikelgroep&gt; Merk
 DocType: Restaurant Table,No of Seats,Aantal zitplaatsen
 DocType: Sales Invoice,Overdue and Discounted,Achterstallig en afgeprijsd
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Oproep verbroken
@@ -507,6 +510,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Regelafstand voor het bedrag in woorden
 DocType: Vehicle,Additional Details,Overige gegevens
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Geen beschrijving gegeven
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Items ophalen uit magazijn
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Inkoopaanvraag
 DocType: POS Closing Voucher Details,Collected Amount,Verzameld bedrag
 DocType: Lab Test,Submitted Date,Datum indienen
@@ -614,6 +618,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Leren
 ,Trial Balance (Simple),Proefbalans (eenvoudig)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Uitgestelde kosten inschakelen
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Toegepaste couponcode
 DocType: Asset,Next Depreciation Date,Volgende Afschrijvingen Date
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Activiteitskosten per werknemer
 DocType: Accounts Settings,Settings for Accounts,Instellingen voor accounts
@@ -852,8 +857,6 @@
 DocType: Sales Invoice,Total Qty,Totaal Aantal
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 Email ID
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 Email ID
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Verwijder de werknemer <a href=""#Form/Employee/{0}"">{0}</a> \ om dit document te annuleren"
 DocType: Item,Show in Website (Variant),Show in Website (Variant)
 DocType: Employee,Health Concerns,Gezondheidszorgen
 DocType: Payroll Entry,Select Payroll Period,Selecteer Payroll Periode
@@ -1019,6 +1022,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Belasting-inhouding-account
 DocType: Pricing Rule,Sales Partner,Verkoop Partner
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Alle leveranciers scorecards.
+DocType: Coupon Code,To be used to get discount,Te gebruiken om korting te krijgen
 DocType: Buying Settings,Purchase Receipt Required,Ontvangstbevestiging Verplicht
 DocType: Sales Invoice,Rail,Het spoor
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Werkelijke kosten
@@ -1069,6 +1073,7 @@
 DocType: Production Plan,Production Plan,Productieplan
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Opening factuur creatie tool
 DocType: Salary Component,Round to the Nearest Integer,Rond naar het dichtstbijzijnde gehele getal
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Toestaan dat artikelen die niet op voorraad zijn aan winkelwagen worden toegevoegd
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Terugkerende verkoop
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Aantal instellen in transacties op basis van serieel geen invoer
 ,Total Stock Summary,Totale voorraadoverzicht
@@ -1200,6 +1205,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Base Uur Rate (Company Munt)
 ,Qty To Be Billed,Te factureren hoeveelheid
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Afgeleverd Bedrag
+DocType: Coupon Code,Gift Card,Cadeaukaart
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Gereserveerde hoeveelheid voor productie: Hoeveelheid grondstoffen om productieartikelen te maken.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Verlossingsdatum
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Deze banktransactie is al volledig afgestemd
@@ -1288,6 +1294,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Maak een urenstaat
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Account {0} is meerdere keren ingevoerd
 DocType: Account,Expenses Included In Valuation,Kosten inbegrepen in waardering
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Facturen kopen
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,U kunt alleen verlengen als uw lidmaatschap binnen 30 dagen verloopt
 DocType: Shopping Cart Settings,Show Stock Availability,Voorraadbeschikbaarheid tonen
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Stel {0} in in activacategorie {1} of bedrijf {2}
@@ -1849,6 +1856,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Items en UOM&#39;s importeren
 DocType: Repayment Schedule,Balance Loan Amount,Balans Leningsbedrag
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Toegevoegd aan details
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Sorry, kortingsboncode is op"
 DocType: Communication Medium,Catch All,Vang alles
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Schedule Course
 DocType: Budget,Applicable on Material Request,Van toepassing op artikelaanvraag
@@ -2017,6 +2025,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,ongeldige attribuut
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} moet worden ingediend
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,E-mailcampagnes
+DocType: Sales Partner,To Track inbound purchase,Inkomende aankopen volgen
 DocType: Buying Settings,Default Supplier Group,Standaard leveranciersgroep
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Hoeveelheid moet kleiner dan of gelijk aan {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Het maximumbedrag dat in aanmerking komt voor het onderdeel {0} overschrijdt {1}
@@ -2174,8 +2183,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Voorraad invoeren
 DocType: Hotel Room Reservation,Hotel Reservation User,Hotelreservering Gebruiker
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Stel status in
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Stel nummeringseries in voor Aanwezigheid via Setup&gt; Nummeringsseries
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Selecteer eerst een voorvoegsel
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Stel Naming Series in op {0} via Setup&gt; Instellingen&gt; Naming Series
 DocType: Contract,Fulfilment Deadline,Uiterste nalevingstermijn
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Dichtbij jou
 DocType: Student,O-,O-
@@ -2299,6 +2308,7 @@
 DocType: Quality Meeting Table,Under Review,Wordt beoordeeld
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Inloggen mislukt
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Asset {0} is gemaakt
+DocType: Coupon Code,Promotional,promotionele
 DocType: Special Test Items,Special Test Items,Speciale testartikelen
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,U moet een gebruiker zijn met de functies System Manager en Item Manager om zich te registreren op Marketplace.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Belangrijkste rapporten
@@ -2337,6 +2347,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc Type
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Totaal toegewezen percentage voor verkoopteam moet 100 zijn
 DocType: Subscription Plan,Billing Interval Count,Factuurinterval tellen
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Verwijder de werknemer <a href=""#Form/Employee/{0}"">{0}</a> \ om dit document te annuleren"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Afspraken en ontmoetingen met patiënten
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Waarde ontbreekt
 DocType: Employee,Department and Grade,Afdeling en rang
@@ -2439,6 +2451,7 @@
 DocType: Project,Start and End Dates,Begin- en einddatum
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Contractsjabloon nakomingstermijnen
 ,Delivered Items To Be Billed,Geleverde Artikelen nog te factureren
+DocType: Coupon Code,Maximum Use,Maximaal gebruik
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Open BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Magazijn kan niet worden gewijzigd voor Serienummer
 DocType: Authorization Rule,Average Discount,Gemiddelde korting
@@ -2601,6 +2614,7 @@
 DocType: Item,Inventory,Voorraad
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Downloaden als Json
 DocType: Item,Sales Details,Verkoop Details
+DocType: Coupon Code,Used,Gebruikt
 DocType: Opportunity,With Items,Met Items
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',De campagne &#39;{0}&#39; bestaat al voor de {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Onderhoudsteam
@@ -2730,7 +2744,7 @@
 						Serial No cannot be ensured",Geen actieve stuklijst gevonden voor item {0}. Bezorging via \ Serial No kan niet worden gegarandeerd
 DocType: Sales Partner,Sales Partner Target,Verkoop Partner Doel
 DocType: Loan Type,Maximum Loan Amount,Maximum Leningen
-DocType: Pricing Rule,Pricing Rule,Prijsbepalingsregel
+DocType: Coupon Code,Pricing Rule,Prijsbepalingsregel
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Dubbele rolnummer voor student {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Dubbele rolnummer voor student {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Materiaal aanvragen tot Purchase Order
@@ -2810,6 +2824,7 @@
 DocType: Payment Schedule,Payment Amount,Betaling Bedrag
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Halve dag moet tussen werk na datum en einddatum werken zijn
 DocType: Healthcare Settings,Healthcare Service Items,Items in de gezondheidszorg
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Ongeldige streepjescode. Er is geen artikel aan deze streepjescode gekoppeld.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Verbruikte hoeveelheid
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Netto wijziging in cash
 DocType: Assessment Plan,Grading Scale,Grading Scale
@@ -2931,7 +2946,6 @@
 DocType: Share Transfer,Asset Account,ActivAccount
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Nieuwe releasedatum zou in de toekomst moeten liggen
 DocType: Purchase Invoice,End date of current invoice's period,Einddatum van de huidige factuurperiode
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Stel het naamgevingssysteem voor werknemers in via Human Resource&gt; HR-instellingen
 DocType: Lab Test,Technician Name,Technicus Naam
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3043,6 +3057,7 @@
 DocType: Products Settings,Hide Variants,Varianten verbergen
 DocType: Lead,Next Contact By,Volgende Contact Door
 DocType: Compensatory Leave Request,Compensatory Leave Request,Compenserend verlofaanvraag
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Kan voor item {0} in rij {1} meer dan {2} niet teveel factureren. Als u overfactureren wilt toestaan, stelt u een toeslag in Accounts-instellingen in"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Benodigde hoeveelheid voor item {0} in rij {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Magazijn {0} kan niet worden verwijderd als er voorraad is voor artikel {1}
 DocType: Blanket Order,Order Type,Order Type
@@ -3215,7 +3230,6 @@
 DocType: Student,Student Mobile Number,Student Mobile Number
 DocType: Item,Has Variants,Heeft Varianten
 DocType: Employee Benefit Claim,Claim Benefit For,Claim voordeel voor
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Kan niet overbilleren voor item {0} in rij {1} meer dan {2}. Om overrekening toe te staan, stel in Voorraad Instellingen in"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Update reactie
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},U heeft reeds geselecteerde items uit {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Naam van de verdeling per maand
@@ -3508,6 +3522,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Omschrijf valuta Company
 DocType: Workstation,Wages per hour,Loon per uur
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Configureer {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Klant&gt; Klantengroep&gt; Gebied
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Voorraadbalans in Batch {0} zal negatief worden {1} voor Artikel {2} in Magazijn {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Volgende Material Aanvragen werden automatisch verhoogd op basis van re-order niveau-item
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Account {0} is ongeldig. Account Valuta moet {1} zijn
@@ -3840,6 +3855,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Indienen salarisstrook
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,In de wacht
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Een vraag moet ten minste één juiste optie hebben
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Inkooporders
 DocType: Account,Inter Company Account,Inter Company Account
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Import in bulk
 DocType: Sales Partner,Address & Contacts,Adres & Contacten
@@ -3850,6 +3866,7 @@
 DocType: POS Profile,[Select],[Selecteer]
 DocType: Staffing Plan Detail,Number Of Positions,Aantal posities
 DocType: Vital Signs,Blood Pressure (diastolic),Bloeddruk (diastolische)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Selecteer de klant.
 DocType: SMS Log,Sent To,Verzenden Naar
 DocType: Agriculture Task,Holiday Management,Vakantie Management
 DocType: Payment Request,Make Sales Invoice,Maak verkoopfactuur
@@ -4059,7 +4076,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} is niet ingediend
 DocType: Subscription,Trialling,proefprogramma
 DocType: Sales Invoice Item,Deferred Revenue,Uitgestelde omzet
-DocType: Bank Account,GL Account,GL-account
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Geldrekening wordt gebruikt voor het maken van verkoopfacturen
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Vrijstelling Subcategorie
 DocType: Member,Membership Expiry Date,Vervaldatum lidmaatschap
@@ -4485,13 +4501,13 @@
 DocType: C-Form Invoice Detail,Territory,Regio
 DocType: Pricing Rule,Apply Rule On Item Code,Regel toepassen op artikelcode
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Vermeld het benodigde aantal bezoeken
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Voorraadbalansrapport
 DocType: Stock Settings,Default Valuation Method,Standaard Waarderingsmethode
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,honorarium
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Cumulatief bedrag weergeven
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Update wordt uitgevoerd. Het kan even duren.
 DocType: Production Plan Item,Produced Qty,Geproduceerd aantal
 DocType: Vehicle Log,Fuel Qty,brandstof Aantal
-DocType: Stock Entry,Target Warehouse Name,Target Warehouse Name
 DocType: Work Order Operation,Planned Start Time,Geplande Starttijd
 DocType: Course,Assessment,Beoordeling
 DocType: Payment Entry Reference,Allocated,Toegewezen
@@ -4569,10 +4585,12 @@
  1. Methoden voor het aanpakken geschillen, schadevergoeding, aansprakelijkheid, enz. 
  1. Adres en contactgegevens van uw bedrijf."
 DocType: Homepage Section,Section Based On,Sectie gebaseerd op
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Toon kortingscode toepassen
 DocType: Issue,Issue Type,Uitgiftetype
 DocType: Attendance,Leave Type,Verlof Type
 DocType: Purchase Invoice,Supplier Invoice Details,Leverancier Invoice Details
 DocType: Agriculture Task,Ignore holidays,Vakantie negeren
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Couponvoorwaarden toevoegen / bewerken
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Kosten- / Verschillenrekening ({0}) moet een 'Winst of Verlies' rekening zijn.
 DocType: Stock Entry Detail,Stock Entry Child,Stock Entry Kind
 DocType: Project,Copied From,Gekopieerd van
@@ -4748,6 +4766,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Assessment Plan Criteria
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,transacties
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Voorkom aankopen
+DocType: Coupon Code,Coupon Name,Coupon naam
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,vatbaar
 DocType: Email Campaign,Scheduled,Geplande
 DocType: Shift Type,Working Hours Calculation Based On,Werkurenberekening op basis van
@@ -4764,7 +4783,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Maak Varianten
 DocType: Vehicle,Diesel,Diesel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Prijslijst Valuta nog niet geselecteerd
+DocType: Quick Stock Balance,Available Quantity,beschikbare kwaliteit
 DocType: Purchase Invoice,Availed ITC Cess,Beschikbaar ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Stel het instructeursysteem in onder onderwijs&gt; onderwijsinstellingen
 ,Student Monthly Attendance Sheet,Student Maandelijkse presentielijst
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Verzendregel alleen van toepassing op verkopen
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Afschrijving Rij {0}: Volgende Afschrijvingsdatum kan niet vóór Aankoopdatum zijn
@@ -4832,8 +4853,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Rij {0}: Advance tegen Klant moet krediet
 DocType: Quality Meeting,Quality Meeting,Kwaliteitsvergadering
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-groep tot groep
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Stel Naming Series in op {0} via Setup&gt; Instellingen&gt; Naming Series
 DocType: Employee,ERPNext User,ERPNext Gebruiker
+DocType: Coupon Code,Coupon Description,Couponbeschrijving
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Partij is verplicht in rij {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Partij is verplicht in rij {0}
 DocType: Company,Default Buying Terms,Standaard koopvoorwaarden
@@ -4998,6 +5019,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Tegen Document Detail nr
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Verwijderen is niet toegestaan voor land {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Party Type is verplicht
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Couponcode toepassen
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",Voor taakkaart {0} kunt u alleen de voorraad &#39;Artikeloverdracht voor fabricage&#39; invoeren
 DocType: Quality Inspection,Outgoing,Uitgaande
 DocType: Customer Feedback Table,Customer Feedback Table,Klantfeedbacktabel
@@ -5149,7 +5171,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Bij het indienen van een inkooporder
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Voeg alle leveranciers toe
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Rij # {0}: Toegewezen bedrag mag niet groter zijn dan het uitstaande bedrag.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Klant&gt; Klantengroep&gt; Gebied
 DocType: Tally Migration,Parties,partijen
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Bladeren BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Leningen met onderpand
@@ -5181,7 +5202,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Niet toestaan om alternatief item in te stellen voor het item {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Datum wordt herhaald
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Geautoriseerd ondertekenaar
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Stel het naamsysteem voor instructeurs in Onderwijs&gt; Onderwijsinstellingen in
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Net ITC beschikbaar (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Fees maken
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Totale aanschafkosten (via Purchase Invoice)
@@ -5206,6 +5226,7 @@
 DocType: Quiz Result,Wrong,Fout
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Koers waarmee Prijslijst valuta wordt omgerekend naar de basisvaluta van de klant
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Nettobedrag (Company valuta)
+DocType: Sales Partner,Referral Code,Verwijzingscode
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Het totale voorschotbedrag kan niet hoger zijn dan het totale gesanctioneerde bedrag
 DocType: Salary Slip,Hour Rate,Uurtarief
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Automatisch opnieuw bestellen inschakelen
@@ -5336,6 +5357,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Voorraadhoeveelheid weergeven
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,De netto kasstroom uit operationele activiteiten
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Rij # {0}: Status moet {1} zijn voor factuurkorting {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM-conversiefactor ({0} -&gt; {1}) niet gevonden voor item: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Punt 4
 DocType: Student Admission,Admission End Date,Toelating Einddatum
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Uitbesteding
@@ -5358,6 +5380,7 @@
 DocType: Travel Request,Fully Sponsored,Volledig gesponsord
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Reverse Journal Entry
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Maak een opdrachtkaart
+DocType: Quotation,Referral Sales Partner,Verwijzende verkooppartner
 DocType: Quality Procedure Process,Process Description,Procesbeschrijving
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Klant {0} is gemaakt.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Momenteel is er geen voorraad beschikbaar in een magazijn
@@ -5492,6 +5515,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,Stuklijst tarief
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Geupload bestand lezen
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Stopped Work Order kan niet geannuleerd worden, laat het eerst annuleren om te annuleren"
+DocType: Coupon Code,Coupon Code,coupon code
 DocType: Asset,Journal Entry for Scrap,Dagboek voor Productieverlies
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Haal aub artikelen uit de Vrachtbrief
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Rij {0}: selecteer het werkstation tegen de bewerking {1}
@@ -5576,6 +5600,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;Datum&#39; is verplicht
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Verval- / Referentiedatum kan niet na {0} zijn
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Gegevens importeren en exporteren
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Sorry, de geldigheid van de couponcode is verlopen"
 DocType: Bank Account,Account Details,Account Details
 DocType: Crop,Materials Required,Benodigde materialen
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Geen studenten gevonden
@@ -5613,6 +5638,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Ga naar gebruikers
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Betaald bedrag + Afgeschreven bedrag kan niet groter zijn dan Eindtotaal
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} is geen geldig batchnummer voor Artikel {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Voer een geldige couponcode in !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Opmerking: Er is niet genoeg verlofsaldo voor Verlof type {0}
 DocType: Task,Task Description,Taakomschrijving
 DocType: Training Event,Seminar,congres
@@ -5880,6 +5906,7 @@
 ,TDS Payable Monthly,TDS Payable Monthly
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,In de wachtrij geplaatst voor het vervangen van de stuklijst. Het kan een paar minuten duren.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Kan niet aftrekken als categorie is voor ' Valuation ' of ' Valuation en Total '
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Stel het naamgevingssysteem voor werknemers in via Human Resource&gt; HR-instellingen
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Totaal betalingen
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Volgnummers zijn vereist voor Seriegebonden Artikel {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Match Betalingen met Facturen
@@ -5970,6 +5997,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Krijg grondstoffen voor productie
 DocType: Job Opening,Job Title,Functietitel
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Toekomstige betaling Ref
+DocType: Quotation,Additional Discount and Coupon Code,Extra korting en couponcode
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} geeft aan dat {1} geen offerte zal opgeven, maar alle items \ zijn geciteerd. De RFQ-citaatstatus bijwerken."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maximale voorbeelden - {0} zijn al bewaard voor Batch {1} en Item {2} in Batch {3}.
@@ -6199,7 +6227,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Instellingen voor website homepage
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} staat in de wacht totdat {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ&#39;s zijn niet toegestaan voor {0} door een scorecard van {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Maak inkoopfactuur
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Gebruikte bladeren
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Gebruikte coupon is {1}. Toegestane hoeveelheid is op
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Wilt u het materiële verzoek indienen?
 DocType: Job Offer,Awaiting Response,Wachten op antwoord
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6213,6 +6243,7 @@
 DocType: Training Event Employee,Optional,facultatief
 DocType: Salary Slip,Earning & Deduction,Verdienen &amp; Aftrek
 DocType: Agriculture Analysis Criteria,Water Analysis,Water analyse
+DocType: Sales Order,Skip Delivery Note,Afleverbon overslaan
 DocType: Price List,Price Not UOM Dependent,Prijs niet UOM afhankelijk
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} varianten gemaakt.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Er bestaat al een standaard Service Level Agreement.
@@ -6321,6 +6352,7 @@
 DocType: Vehicle,Last Carbon Check,Laatste Carbon controleren
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Juridische Kosten
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Selecteer alstublieft de hoeveelheid op rij
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Werkorder {0}: opdrachtkaart niet gevonden voor de bewerking {1}
 DocType: Purchase Invoice,Posting Time,Plaatsing Time
 DocType: Timesheet,% Amount Billed,% Gefactureerd Bedrag
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Telefoonkosten
@@ -6423,7 +6455,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Belastingen en Toeslagen toegevoegd
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Afschrijving Rij {0}: Volgende Afschrijvingsdatum kan niet eerder zijn dan Beschikbaar-voor-gebruik Datum
 ,Sales Funnel,Verkoop Trechter
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Artikelcode&gt; Artikelgroep&gt; Merk
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Afkorting is verplicht
 DocType: Project,Task Progress,Task Progress
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Kar
@@ -6520,6 +6551,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS profiel nodig om POS Entry maken
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Loyaliteitspunten worden berekend op basis van het aantal gedaane uitgaven (via de verkoopfactuur), op basis van de genoemde verzamelfactor."
 DocType: Program Enrollment Tool,Enroll Students,inschrijven Studenten
+DocType: Pricing Rule,Coupon Code Based,Couponcode gebaseerd
 DocType: Company,HRA Settings,HRA-instellingen
 DocType: Homepage,Hero Section,Heldensectie
 DocType: Employee Transfer,Transfer Date,Datum van overdracht
@@ -6636,6 +6668,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Stel alsjeblieft Bedrijfsfilter leeg als Group By is &#39;Company&#39;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Posting datum kan niet de toekomst datum
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Rij # {0}: Serienummer {1} komt niet overeen met {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Stel nummeringseries in voor Aanwezigheid via Setup&gt; Nummeringsseries
 DocType: Stock Entry,Target Warehouse Address,Target Warehouse Address
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Casual Leave
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,De tijd vóór de starttijd van de dienst gedurende welke de werknemer incheckt voor aanwezigheid.
@@ -6670,7 +6703,6 @@
 DocType: Employee Grade,Employee Grade,Werknemersrang
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,stukwerk
 DocType: GSTR 3B Report,June,juni-
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Leverancier&gt; Type leverancier
 DocType: Share Balance,From No,Van Nee
 DocType: Shift Type,Early Exit Grace Period,Grace Exit-periode
 DocType: Task,Actual Time (in Hours),Werkelijke tijd (in uren)
@@ -6955,7 +6987,6 @@
 DocType: Warehouse,Warehouse Name,Magazijn Naam
 DocType: Naming Series,Select Transaction,Selecteer Transactie
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Vul de Goedkeurders Rol of Goedkeurende Gebruiker in
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM-conversiefactor ({0} -&gt; {1}) niet gevonden voor item: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Service Level Agreement met Entity Type {0} en Entity {1} bestaat al.
 DocType: Journal Entry,Write Off Entry,Invoer afschrijving
 DocType: BOM,Rate Of Materials Based On,Prijs van materialen op basis van
@@ -7093,6 +7124,7 @@
 DocType: Budget,Warn,Waarschuwen
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Alle items zijn al overgedragen voor deze werkbon.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Eventuele andere opmerkingen, noemenswaardig voor in de boekhouding,"
+DocType: Bank Account,Company Account,Bedrijfsaccount
 DocType: Asset Maintenance,Manufacturing User,Productie Gebruiker
 DocType: Purchase Invoice,Raw Materials Supplied,Grondstoffen Geleverd
 DocType: Subscription Plan,Payment Plan,Betaalplan
@@ -7134,6 +7166,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) kan niet groter zijn dan de geplande hoeveelheid ({2}) in werkorder {3}
 DocType: Certification Application,Name of Applicant,Naam aanvrager
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Time Sheet voor de productie.
+DocType: Quick Stock Balance,Quick Stock Balance,Snelle voorraadbalans
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Subtotaal
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Variant-eigenschappen kunnen niet worden gewijzigd na beurstransactie. U moet een nieuw item maken om dit te doen.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA-mandaat
@@ -7462,6 +7495,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} is inactieve student
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} is inactieve student
 DocType: Employee,Health Details,Gezondheid Details
+DocType: Coupon Code,Coupon Type,Type coupon
 DocType: Leave Encashment,Encashable days,Aanpasbare dagen
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Om een betalingsaanvraag te maken is referentie document vereist
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Om een betalingsaanvraag te maken is referentie document vereist
@@ -7749,6 +7783,7 @@
 DocType: Hotel Room Package,Amenities,voorzieningen
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Automatisch betalingsvoorwaarden ophalen
 DocType: QuickBooks Migrator,Undeposited Funds Account,Niet-gedeponeerd fondsenaccount
+DocType: Coupon Code,Uses,Toepassingen
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Meerdere standaard betalingswijze is niet toegestaan
 DocType: Sales Invoice,Loyalty Points Redemption,Loyalty Points-verlossing
 ,Appointment Analytics,Benoemingsanalyse
@@ -7766,6 +7801,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Verlaat leeg als u studentengroepen per jaar maakt
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Verlaat leeg als u studentengroepen per jaar maakt
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Indien aangevinkt, Totaal niet. van Werkdagen zal omvatten feestdagen, en dit zal de waarde van het salaris per dag te verminderen"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Kan domein niet toevoegen
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Om overontvangst / aflevering toe te staan, werkt u &quot;Overontvangst / afleveringstoeslag&quot; in Voorraadinstellingen of het Artikel bij."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Apps die de huidige sleutel gebruiken, hebben geen toegang, weet u het zeker?"
 DocType: Subscription Settings,Prorate,pro-rata
@@ -7779,6 +7815,7 @@
 ,BOM Stock Report,BOM Stock Report
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Als er geen tijdslot is toegewezen, wordt de communicatie door deze groep afgehandeld"
 DocType: Stock Reconciliation Item,Quantity Difference,Aantal Verschil
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Leverancier&gt; Type leverancier
 DocType: Opportunity Item,Basic Rate,Basis Tarief
 DocType: GL Entry,Credit Amount,Credit Bedrag
 ,Electronic Invoice Register,Elektronisch factuurregister
@@ -8033,6 +8070,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Belastingen en Toeslagen afgetrokken (Bedrijfsvaluta)
 DocType: Item Group,General Settings,Algemene Instellingen
 DocType: Article,Article,Artikel
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Voer kortingsboncode in !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Van Valuta en naar Valuta kan niet hetzelfde zijn
 DocType: Taxable Salary Slab,Percent Deduction,Procentaftrek
 DocType: GL Entry,To Rename,Hernoemen
diff --git a/erpnext/translations/no.csv b/erpnext/translations/no.csv
index 4c9d262..0995304 100644
--- a/erpnext/translations/no.csv
+++ b/erpnext/translations/no.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Kundekontakt
 DocType: Shift Type,Enable Auto Attendance,Aktiver automatisk deltakelse
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Vennligst skriv inn lager og dato
 DocType: Lost Reason Detail,Opportunity Lost Reason,Mulighet tapt grunn
 DocType: Patient Appointment,Check availability,Sjekk tilgjengelighet
 DocType: Retention Bonus,Bonus Payment Date,Bonus Betalingsdato
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Fullførte arbeidsordrer
 DocType: Support Settings,Forum Posts,Foruminnlegg
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Oppgaven er blitt pålagt som bakgrunnsjobb. I tilfelle det er noe problem med behandlingen i bakgrunnen, vil systemet legge til en kommentar om feilen på denne aksjeavstemmingen og gå tilbake til utkaststrinnet"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Beklager, gyldigheten av kupongkoden har ikke startet"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Skattepliktig beløp
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Du er ikke autorisert til å legge til eller oppdatere bloggen før {0}
 DocType: Leave Policy,Leave Policy Details,Legg til policyinformasjon
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Konsum
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,grade
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Varekode&gt; Varegruppe&gt; Merke
 DocType: Restaurant Table,No of Seats,Antall plasser
 DocType: Sales Invoice,Overdue and Discounted,Forfalte og rabatterte
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Ring frakoblet
@@ -507,6 +510,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Linjeavstand for beløpet i ord
 DocType: Vehicle,Additional Details,ekstra detaljer
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Ingen beskrivelse gitt
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Hent gjenstander fra lageret
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Be for kjøp.
 DocType: POS Closing Voucher Details,Collected Amount,Samlet beløp
 DocType: Lab Test,Submitted Date,Innleveringsdato
@@ -614,6 +618,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Lære
 ,Trial Balance (Simple),Prøvebalanse (enkel)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Aktiver utsatt utgift
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Anvendt kupongkode
 DocType: Asset,Next Depreciation Date,Neste Avskrivninger Dato
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Aktivitet Kostnad per Employee
 DocType: Accounts Settings,Settings for Accounts,Innstillinger for kontoer
@@ -854,8 +859,6 @@
 DocType: Sales Invoice,Total Qty,Total Antall
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 Email ID
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 Email ID
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Slett ansatt <a href=""#Form/Employee/{0}"">{0}</a> \ for å avbryte dette dokumentet"
 DocType: Item,Show in Website (Variant),Vis i Website (Variant)
 DocType: Employee,Health Concerns,Helse Bekymringer
 DocType: Payroll Entry,Select Payroll Period,Velg Lønn Periode
@@ -1021,6 +1024,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Skattebetalingskonto
 DocType: Pricing Rule,Sales Partner,Sales Partner
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Alle leverandørens scorecards.
+DocType: Coupon Code,To be used to get discount,Brukes for å få rabatt
 DocType: Buying Settings,Purchase Receipt Required,Kvitteringen Påkrevd
 DocType: Sales Invoice,Rail,Rail
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Faktiske kostnader
@@ -1071,6 +1075,7 @@
 DocType: Production Plan,Production Plan,Produksjonsplan
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Åpning av fakturaopprettingsverktøy
 DocType: Salary Component,Round to the Nearest Integer,Rund til nærmeste heltall
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,La varer som ikke er på lager legges i handlekurven
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Sales Return
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Angi antall i transaksjoner basert på serienummerinngang
 ,Total Stock Summary,Totalt lageroppsummering
@@ -1202,6 +1207,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Base Hour Rate (Selskap Valuta)
 ,Qty To Be Billed,Antall som skal faktureres
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Leveres Beløp
+DocType: Coupon Code,Gift Card,Gavekort
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Reservert antall for produksjon: Råvaremengde for å lage produksjonsvarer.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Innløsningsdato
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Denne banktransaksjonen er allerede fullstendig avstemt
@@ -1291,6 +1297,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Lag timeliste
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Konto {0} er angitt flere ganger
 DocType: Account,Expenses Included In Valuation,Kostnader som inngår i verdivurderings
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Kjøp fakturaer
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Du kan bare fornye hvis medlemskapet ditt utløper innen 30 dager
 DocType: Shopping Cart Settings,Show Stock Availability,Vis lager tilgjengelighet
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Angi {0} i aktivakategori {1} eller firma {2}
@@ -1834,6 +1841,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Importere elementer og UOM-er
 DocType: Repayment Schedule,Balance Loan Amount,Balanse Lånebeløp
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Lagt til detaljer
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Beklager, kupongkoden er oppbrukt"
 DocType: Communication Medium,Catch All,Fang alle
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Schedule Course
 DocType: Budget,Applicable on Material Request,Gjelder på materialforespørsel
@@ -2004,6 +2012,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Ugyldig Egenskap
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} må sendes
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,E-postkampanjer
+DocType: Sales Partner,To Track inbound purchase,For å spore inngående kjøp
 DocType: Buying Settings,Default Supplier Group,Standard leverandørgruppe
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Antall må være mindre enn eller lik {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Maksimumsbeløp som er kvalifisert for komponenten {0} overstiger {1}
@@ -2161,8 +2170,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Gjør lageroppføring
 DocType: Hotel Room Reservation,Hotel Reservation User,Hotel Reservation Bruker
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Angi status
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Angi nummereringsserier for Oppmøte via Oppsett&gt; Nummereringsserier
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Vennligst velg først prefiks
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Angi Naming Series for {0} via Setup&gt; Settings&gt; Naming Series
 DocType: Contract,Fulfilment Deadline,Oppfyllingsfrist
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,I nærheten av deg
 DocType: Student,O-,O-
@@ -2286,6 +2295,7 @@
 DocType: Quality Meeting Table,Under Review,Til vurdering
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Kunne ikke logge inn
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Asset {0} opprettet
+DocType: Coupon Code,Promotional,Promotional
 DocType: Special Test Items,Special Test Items,Spesielle testelementer
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Du må være en bruker med System Manager og Item Manager roller for å registrere deg på Marketplace.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Nøkkelrapporter
@@ -2324,6 +2334,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc Type
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Totalt bevilget prosent for salgsteam skal være 100
 DocType: Subscription Plan,Billing Interval Count,Faktureringsintervalltelling
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Slett ansatt <a href=""#Form/Employee/{0}"">{0}</a> \ for å avbryte dette dokumentet"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Utnevnelser og pasientmøter
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Verdi mangler
 DocType: Employee,Department and Grade,Avdeling og karakter
@@ -2427,6 +2439,7 @@
 DocType: Project,Start and End Dates,Start- og sluttdato
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Kontraktsmall Fulfillment Vilkår
 ,Delivered Items To Be Billed,Leverte varer til å bli fakturert
+DocType: Coupon Code,Maximum Use,Maksimal bruk
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Åpen BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Warehouse kan ikke endres for Serial No.
 DocType: Authorization Rule,Average Discount,Gjennomsnittlig Rabatt
@@ -2588,6 +2601,7 @@
 DocType: Item,Inventory,Inventar
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Last ned som Json
 DocType: Item,Sales Details,Salgs Detaljer
+DocType: Coupon Code,Used,brukes
 DocType: Opportunity,With Items,Med Items
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Kampanjen &#39;{0}&#39; eksisterer allerede for {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Vedlikeholdsteam
@@ -2717,7 +2731,7 @@
 						Serial No cannot be ensured",Ingen aktiv BOM funnet for elementet {0}. Levering med \ Serienummer kan ikke sikres
 DocType: Sales Partner,Sales Partner Target,Sales Partner Target
 DocType: Loan Type,Maximum Loan Amount,Maksimal Lånebeløp
-DocType: Pricing Rule,Pricing Rule,Prising Rule
+DocType: Coupon Code,Pricing Rule,Prising Rule
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Dupliseringsnummer for student {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Dupliseringsnummer for student {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Materialet Request til innkjøpsordre
@@ -2797,6 +2811,7 @@
 DocType: Payment Schedule,Payment Amount,Betalings Beløp
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Halvdagsdato bør være mellom arbeid fra dato og arbeidsdato
 DocType: Healthcare Settings,Healthcare Service Items,Helsevesenetjenesteelementer
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Ugyldig strekkode. Det er ingen ting knyttet til denne strekkoden.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Forbrukes Beløp
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Netto endring i kontanter
 DocType: Assessment Plan,Grading Scale,Grading Scale
@@ -2917,7 +2932,6 @@
 DocType: Share Transfer,Asset Account,Asset-konto
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Ny utgivelsesdato bør være i fremtiden
 DocType: Purchase Invoice,End date of current invoice's period,Sluttdato for gjeldende faktura periode
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Sett inn ansattes navnsystem i menneskelige ressurser&gt; HR-innstillinger
 DocType: Lab Test,Technician Name,Tekniker Navn
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3029,6 +3043,7 @@
 DocType: Products Settings,Hide Variants,Skjul varianter
 DocType: Lead,Next Contact By,Neste Kontakt Av
 DocType: Compensatory Leave Request,Compensatory Leave Request,Kompenserende permisjon
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Kan ikke overbillige for varen {0} i rad {1} mer enn {2}. For å tillate overfakturering, må du angi godtgjørelse i Kontoinnstillinger"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Mengden som kreves for Element {0} i rad {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Warehouse {0} kan ikke slettes som kvantitet finnes for Element {1}
 DocType: Blanket Order,Order Type,Ordretype
@@ -3198,7 +3213,6 @@
 DocType: Student,Student Mobile Number,Student Mobilnummer
 DocType: Item,Has Variants,Har Varianter
 DocType: Employee Benefit Claim,Claim Benefit For,Krav til fordel for
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Kan ikke overbillett for element {0} i rad {1} mer enn {2}. For å tillate overfakturering, vennligst sett inn Lagerinnstillinger"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Oppdater svar
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Du har allerede valgt elementer fra {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Navn på Monthly Distribution
@@ -3491,6 +3505,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Vennligst oppgi valuta i selskapet
 DocType: Workstation,Wages per hour,Lønn per time
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Konfigurer {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Kunde&gt; Kundegruppe&gt; Territorium
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Stock balanse i Batch {0} vil bli negativ {1} for Element {2} på Warehouse {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Følgende materiale Requests har vært reist automatisk basert på element re-order nivå
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Konto {0} er ugyldig. Account Valuta må være {1}
@@ -3824,6 +3839,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Send Lønn Slip
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,På vent
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,En spørsmål må ha minst ett riktig alternativ
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Innkjøpsordrer
 DocType: Account,Inter Company Account,Inter Company Account
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Import i Bulk
 DocType: Sales Partner,Address & Contacts,Adresse og Kontakt
@@ -3834,6 +3850,7 @@
 DocType: POS Profile,[Select],[Velg]
 DocType: Staffing Plan Detail,Number Of Positions,Antall posisjoner
 DocType: Vital Signs,Blood Pressure (diastolic),Blodtrykk (diastolisk)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Velg kunde.
 DocType: SMS Log,Sent To,Sendt til
 DocType: Agriculture Task,Holiday Management,Holiday Management
 DocType: Payment Request,Make Sales Invoice,Gjør Sales Faktura
@@ -4043,7 +4060,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} ikke er sendt
 DocType: Subscription,Trialling,Tester ut
 DocType: Sales Invoice Item,Deferred Revenue,Utsatt inntekt
-DocType: Bank Account,GL Account,GL-konto
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Kontantkonto brukes til opprettelse av salgsfaktura
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Fritak underkategori
 DocType: Member,Membership Expiry Date,Medlemskapets utløpsdato
@@ -4450,13 +4466,13 @@
 DocType: C-Form Invoice Detail,Territory,Territorium
 DocType: Pricing Rule,Apply Rule On Item Code,Bruk regel om varekode
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Vennligst oppgi ingen av besøk som kreves
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Aksjekursrapport
 DocType: Stock Settings,Default Valuation Method,Standard verdsettelsesmetode
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Avgift
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Vis kumulativ beløp
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Oppdatering pågår. Det kan ta en stund.
 DocType: Production Plan Item,Produced Qty,Produsert antall
 DocType: Vehicle Log,Fuel Qty,drivstoff Antall
-DocType: Stock Entry,Target Warehouse Name,Mållagernavn
 DocType: Work Order Operation,Planned Start Time,Planlagt Starttid
 DocType: Course,Assessment,Assessment
 DocType: Payment Entry Reference,Allocated,Avsatt
@@ -4522,10 +4538,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","Standardvilkårene som kan legges til salg og kjøp. Eksempler: 1. Gyldighet av tilbudet. 1. Betalingsvilkår (på forhånd, på kreditt, del forhånd etc). 1. Hva er ekstra (eller skal betales av kunden). 1. Sikkerhet / bruk advarsel. 1. Garanti om noen. 1. Returrett. 1. Vilkår for frakt, hvis aktuelt. 1. Måter adressering tvister, erstatning, ansvar, etc. 1. Adresse og kontakt med din bedrift."
 DocType: Homepage Section,Section Based On,Seksjon basert på
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Vis Bruk kupongkode
 DocType: Issue,Issue Type,Utgave type
 DocType: Attendance,Leave Type,La Type
 DocType: Purchase Invoice,Supplier Invoice Details,Leverandør Fakturadetaljer
 DocType: Agriculture Task,Ignore holidays,Ignorer ferier
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Legg til / rediger kupongbetingelser
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Expense / Difference konto ({0}) må være en &quot;resultatet&quot; konto
 DocType: Stock Entry Detail,Stock Entry Child,Lagerinngangsbarn
 DocType: Project,Copied From,Kopiert fra
@@ -4701,6 +4719,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Assessment Plan Kriterier
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,transaksjoner
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Forhindre innkjøpsordrer
+DocType: Coupon Code,Coupon Name,Kupongnavn
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,utsatt
 DocType: Email Campaign,Scheduled,Planlagt
 DocType: Shift Type,Working Hours Calculation Based On,Beregning av arbeidstider basert på
@@ -4717,7 +4736,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Lag Varianter
 DocType: Vehicle,Diesel,diesel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Prisliste Valuta ikke valgt
+DocType: Quick Stock Balance,Available Quantity,Tilgjengelig mengde
 DocType: Purchase Invoice,Availed ITC Cess,Benyttet ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Oppsett Instructor Naming System i Education&gt; Education Settings
 ,Student Monthly Attendance Sheet,Student Månedlig Oppmøte Sheet
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Fraktregel gjelder kun for salg
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Avskrivningsraden {0}: Neste avskrivningsdato kan ikke være før kjøpsdato
@@ -4785,8 +4806,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Rad {0}: Advance mot Kunden må være kreditt
 DocType: Quality Meeting,Quality Meeting,Kvalitetsmøte
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-gruppe til gruppe
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Angi Naming Series for {0} via Setup&gt; Settings&gt; Naming Series
 DocType: Employee,ERPNext User,ERPNext Bruker
+DocType: Coupon Code,Coupon Description,Kupongbeskrivelse
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Batch er obligatorisk i rad {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Batch er obligatorisk i rad {0}
 DocType: Company,Default Buying Terms,Standard kjøpsbetingelser
@@ -4951,6 +4972,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Mot Document Detail Nei
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Sletting er ikke tillatt for land {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Partiet Type er obligatorisk
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Bruk kupongkode
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",For jobbkort {0} kan du bare oppgi type &#39;Material Transfer for Manufacture&#39;
 DocType: Quality Inspection,Outgoing,Utgående
 DocType: Customer Feedback Table,Customer Feedback Table,Kunde Tilbakemelding Tabell
@@ -5101,7 +5123,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Ved innkjøpsordreinnlevering
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Legg til alle leverandører
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Rad # {0}: Tilordnet beløp kan ikke være større enn utestående beløp.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Kunde&gt; Kundegruppe&gt; Territorium
 DocType: Tally Migration,Parties,Partene
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Bla BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Sikret lån
@@ -5133,7 +5154,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Ikke tillat å angi alternativt element for elementet {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Dato gjentas
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Autorisert signatur
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Oppsett Instructor Naming System i Education&gt; Education Settings
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Netto ITC tilgjengelig (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Opprett gebyrer
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Total anskaffelseskost (via fakturaen)
@@ -5158,6 +5178,7 @@
 DocType: Quiz Result,Wrong,Feil
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Hastigheten som Prisliste valuta er konvertert til kundens basisvaluta
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Nettobeløp (Company Valuta)
+DocType: Sales Partner,Referral Code,Henvisningskode
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Samlet forskuddbeløp kan ikke være større enn total sanksjonert beløp
 DocType: Salary Slip,Hour Rate,Time Rate
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Aktiver automatisk nybestilling
@@ -5288,6 +5309,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Vis lager Antall
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Netto kontantstrøm fra driften
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Rad # {0}: Status må være {1} for fakturabatering {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM konverteringsfaktor ({0} -&gt; {1}) ikke funnet for varen: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Sak 4
 DocType: Student Admission,Admission End Date,Opptak Sluttdato
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Underleverandører
@@ -5310,6 +5332,7 @@
 DocType: Travel Request,Fully Sponsored,Fullt sponset
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Omvendt journalinngang
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Lag jobbkort
+DocType: Quotation,Referral Sales Partner,Henvisning Salgspartner
 DocType: Quality Procedure Process,Process Description,Prosess beskrivelse
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Kunden {0} er opprettet.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Foreløpig ingen lager tilgjengelig i varehus
@@ -5444,6 +5467,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM Rate
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Leser opplastet fil
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Stoppet arbeidsordre kan ikke kanselleres, Unstop det først for å avbryte"
+DocType: Coupon Code,Coupon Code,Kupongkode
 DocType: Asset,Journal Entry for Scrap,Bilagsregistrering for Scrap
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Kan trekke elementer fra følgeseddel
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Row {0}: velg arbeidsstasjonen mot operasjonen {1}
@@ -5528,6 +5552,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;Dato&#39; er påkrevd
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Due / Reference Datoen kan ikke være etter {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Data import og eksport
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Beklager, gyldigheten av kupongkoden er utløpt"
 DocType: Bank Account,Account Details,kontodetaljer
 DocType: Crop,Materials Required,Materialer som kreves
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Ingen studenter Funnet
@@ -5565,6 +5590,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Gå til Brukere
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Innbetalt beløp + avskrive Beløpet kan ikke være større enn Totalsum
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} er ikke en gyldig batchnummer for varen {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Vennligst tast inn gyldig kupongkode !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Merk: Det er ikke nok permisjon balanse for La Type {0}
 DocType: Task,Task Description,Oppgavebeskrivelse
 DocType: Training Event,Seminar,Seminar
@@ -5832,6 +5858,7 @@
 ,TDS Payable Monthly,TDS betales månedlig
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Kjøtt for å erstatte BOM. Det kan ta noen minutter.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Kan ikke trekke når kategorien er for verdsetting &quot;eller&quot; Verdsettelse og Totals
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Sett inn ansattes navnsystem i menneskelige ressurser&gt; HR-innstillinger
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Totale betalinger
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serial Nos Nødvendig for Serialisert Element {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Match Betalinger med Fakturaer
@@ -5922,6 +5949,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Få råmaterialer til produksjon
 DocType: Job Opening,Job Title,Jobbtittel
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Fremtidig betaling ref
+DocType: Quotation,Additional Discount and Coupon Code,Ekstra rabatt- og kupongkode
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} indikerer at {1} ikke vil gi et tilbud, men alle elementer \ er blitt sitert. Oppdaterer RFQ sitatstatus."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maksimale prøver - {0} har allerede blitt beholdt for Batch {1} og Item {2} i Batch {3}.
@@ -6151,7 +6179,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Innstillinger for nettstedet hjemmeside
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} er ventet til {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ er ikke tillatt for {0} på grunn av et resultatkort som står for {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Gjør fakturaen
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Brukte blad
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Kupongen som brukes er {1}. Tillatt mengde er oppbrukt
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Ønsker du å sende inn materialforespørselen
 DocType: Job Offer,Awaiting Response,Venter på svar
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6165,6 +6195,7 @@
 DocType: Training Event Employee,Optional,Valgfri
 DocType: Salary Slip,Earning & Deduction,Tjene &amp; Fradrag
 DocType: Agriculture Analysis Criteria,Water Analysis,Vannanalyse
+DocType: Sales Order,Skip Delivery Note,Hopp over leveringsmerknad
 DocType: Price List,Price Not UOM Dependent,Pris ikke UOM-avhengig
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} varianter opprettet.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,En standard servicenivåavtale eksisterer allerede.
@@ -6273,6 +6304,7 @@
 DocType: Vehicle,Last Carbon Check,Siste Carbon Sjekk
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Rettshjelp
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Vennligst velg antall på rad
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Arbeidsordre {0}: jobbkortet ble ikke funnet for operasjonen {1}
 DocType: Purchase Invoice,Posting Time,Postering Tid
 DocType: Timesheet,% Amount Billed,% Mengde Fakturert
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Telefon Utgifter
@@ -6375,7 +6407,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Skatter og avgifter legges
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Avskrivningsraden {0}: Neste avskrivningsdato kan ikke være før Tilgjengelig-til-bruk-dato
 ,Sales Funnel,Sales trakt
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Varekode&gt; Varegruppe&gt; Merke
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Forkortelsen er obligatorisk
 DocType: Project,Task Progress,Task Progress
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Kurven
@@ -6471,6 +6502,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS Profile nødvendig å foreta POS Entry
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Lojalitetspoeng beregnes ut fra den brukte ferdige (via salgsfakturaen), basert på innsamlingsfaktor som er nevnt."
 DocType: Program Enrollment Tool,Enroll Students,Meld Studenter
+DocType: Pricing Rule,Coupon Code Based,Basert på kupongkode
 DocType: Company,HRA Settings,HRA Innstillinger
 DocType: Homepage,Hero Section,Helteseksjonen
 DocType: Employee Transfer,Transfer Date,Overføringsdato
@@ -6586,6 +6618,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Vennligst sett Company filter blank hvis Group By er &#39;Company&#39;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Publiseringsdato kan ikke være fremtidig dato
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: Serial No {1} samsvarer ikke med {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Angi nummereringsserier for Oppmøte via Oppsett&gt; Nummereringsserier
 DocType: Stock Entry,Target Warehouse Address,Mållageradresse
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Casual La
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,Tiden før skiftets starttidspunkt hvor ansattes innsjekking vurderes for oppmøte.
@@ -6620,7 +6653,6 @@
 DocType: Employee Grade,Employee Grade,Ansatte grad
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Akkord
 DocType: GSTR 3B Report,June,juni
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Leverandør&gt; Leverandørtype
 DocType: Share Balance,From No,Fra nr
 DocType: Shift Type,Early Exit Grace Period,Tidlig utgangsperiode
 DocType: Task,Actual Time (in Hours),Virkelig tid (i timer)
@@ -6905,7 +6937,6 @@
 DocType: Warehouse,Warehouse Name,Warehouse Name
 DocType: Naming Series,Select Transaction,Velg Transaksjons
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Skriv inn Godkjenne Rolle eller Godkjenne User
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM konverteringsfaktor ({0} -&gt; {1}) ikke funnet for varen: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Servicenivåavtale med enhetstype {0} og enhet {1} eksisterer allerede.
 DocType: Journal Entry,Write Off Entry,Skriv Off Entry
 DocType: BOM,Rate Of Materials Based On,Valuta materialer basert på
@@ -7043,6 +7074,7 @@
 DocType: Budget,Warn,Advare
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Alle elementer er allerede overført for denne arbeidsordren.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Eventuelle andre bemerkninger, bemerkelsesverdig innsats som bør gå i postene."
+DocType: Bank Account,Company Account,Firmakonto
 DocType: Asset Maintenance,Manufacturing User,Manufacturing User
 DocType: Purchase Invoice,Raw Materials Supplied,Råvare Leveres
 DocType: Subscription Plan,Payment Plan,Betalingsplan
@@ -7084,6 +7116,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) kan ikke være større enn planlagt antall ({2}) i Work Order {3}
 DocType: Certification Application,Name of Applicant,Navn på søkeren
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Timeregistrering for produksjon.
+DocType: Quick Stock Balance,Quick Stock Balance,Rask aksjebalanse
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,delsum
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Kan ikke endre Variant egenskaper etter aksje transaksjon. Du må lage en ny gjenstand for å gjøre dette.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA Mandat
@@ -7411,6 +7444,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} er inaktiv student
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} er inaktiv student
 DocType: Employee,Health Details,Helse Detaljer
+DocType: Coupon Code,Coupon Type,Kupongtype
 DocType: Leave Encashment,Encashable days,Klembare dager
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,For å opprette en betalingsforespørsel kreves referansedokument
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,For å opprette en betalingsforespørsel kreves referansedokument
@@ -7698,6 +7732,7 @@
 DocType: Hotel Room Package,Amenities,fasiliteter
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Hent automatisk betalingsbetingelser
 DocType: QuickBooks Migrator,Undeposited Funds Account,Ubestemt fondskonto
+DocType: Coupon Code,Uses,Bruker
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Flere standard betalingsmåter er ikke tillatt
 DocType: Sales Invoice,Loyalty Points Redemption,Lojalitetspoeng Innløsning
 ,Appointment Analytics,Avtale Analytics
@@ -7715,6 +7750,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,La være tom hvis du lager studentgrupper hvert år
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,La være tom hvis du lager studentgrupper hvert år
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Hvis det er merket, Total nei. arbeidsdager vil omfatte helligdager, og dette vil redusere verdien av Lønn per dag"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Kunne ikke legge til domenet
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","For å tillate over mottak / levering, oppdaterer du &quot;Over kvittering / levering kvote&quot; i lagerinnstillinger eller varen."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Apper som bruker nåværende nøkkel vil ikke kunne få tilgang til, er du sikker?"
 DocType: Subscription Settings,Prorate,prorate
@@ -7728,6 +7764,7 @@
 ,BOM Stock Report,BOM aksjerapport
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Hvis det ikke er tildelt tidsluke, vil kommunikasjonen bli håndtert av denne gruppen"
 DocType: Stock Reconciliation Item,Quantity Difference,Antall Difference
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Leverandør&gt; Leverandørtype
 DocType: Opportunity Item,Basic Rate,Basic Rate
 DocType: GL Entry,Credit Amount,Credit Beløp
 ,Electronic Invoice Register,Elektronisk fakturaregister
@@ -7982,6 +8019,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Skatter og avgifter fratrukket (Company Valuta)
 DocType: Item Group,General Settings,Generelle Innstillinger
 DocType: Article,Article,Artikkel
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Vennligst tast inn kupongkode !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Fra Valuta og til valuta kan ikke være det samme
 DocType: Taxable Salary Slab,Percent Deduction,Prosent avdrag
 DocType: GL Entry,To Rename,Å gi nytt navn
diff --git a/erpnext/translations/pl.csv b/erpnext/translations/pl.csv
index fa4bacf..97dc1fb 100644
--- a/erpnext/translations/pl.csv
+++ b/erpnext/translations/pl.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.RRRR.-
 DocType: Purchase Order,Customer Contact,Kontakt z klientem
 DocType: Shift Type,Enable Auto Attendance,Włącz automatyczne uczestnictwo
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Proszę podać Magazyn i datę
 DocType: Lost Reason Detail,Opportunity Lost Reason,Możliwość utracona z powodu
 DocType: Patient Appointment,Check availability,Sprawdź dostępność
 DocType: Retention Bonus,Bonus Payment Date,Data wypłaty bonusu
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Zrealizowane zlecenia pracy
 DocType: Support Settings,Forum Posts,Posty na forum
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Zadanie zostało zakolejkowane jako zadanie w tle. W przypadku jakichkolwiek problemów z przetwarzaniem w tle, system doda komentarz dotyczący błędu w tym uzgadnianiu i powróci do etapu wersji roboczej"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Przepraszamy, ważność kodu kuponu nie rozpoczęła się"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Kwota podlegająca opodatkowaniu
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Nie masz uprawnień aby zmieniać lub dodawać elementy przed {0}
 DocType: Leave Policy,Leave Policy Details,Szczegóły Polityki Nieobecności
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Konsumpcyjny
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,Stopień
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kod pozycji&gt; Grupa produktów&gt; Marka
 DocType: Restaurant Table,No of Seats,Liczba miejsc
 DocType: Sales Invoice,Overdue and Discounted,Zaległe i zdyskontowane
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Zadzwoń Rozłączony
@@ -507,6 +510,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Odstępy między wierszami dla kwoty w słowach
 DocType: Vehicle,Additional Details,Dodatkowe Szczegóły
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Brak opisu
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Pobierz przedmioty z magazynu
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Prośba o zakup
 DocType: POS Closing Voucher Details,Collected Amount,Zebrana kwota
 DocType: Lab Test,Submitted Date,Zaakceptowana Data
@@ -614,6 +618,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Samouczek
 ,Trial Balance (Simple),Bilans próbny (prosty)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Włącz odroczony koszt
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Zastosowany kod kuponu
 DocType: Asset,Next Depreciation Date,Następny Amortyzacja Data
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Koszt aktywność na pracownika
 DocType: Accounts Settings,Settings for Accounts,Ustawienia Konta
@@ -854,8 +859,6 @@
 DocType: Sales Invoice,Total Qty,Razem szt
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Identyfikator e-mail Guardian2
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Identyfikator e-mail Guardian2
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Usuń pracownika <a href=""#Form/Employee/{0}"">{0}</a> \, aby anulować ten dokument"
 DocType: Item,Show in Website (Variant),Pokaż w Serwisie (Variant)
 DocType: Employee,Health Concerns,Problemy Zdrowotne
 DocType: Payroll Entry,Select Payroll Period,Wybierz Okres Payroll
@@ -1021,6 +1024,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Rachunek potrącenia podatku u źródła
 DocType: Pricing Rule,Sales Partner,Partner Sprzedaży
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Wszystkie karty oceny dostawcy.
+DocType: Coupon Code,To be used to get discount,Do wykorzystania w celu uzyskania rabatu
 DocType: Buying Settings,Purchase Receipt Required,Wymagane potwierdzenie zakupu
 DocType: Sales Invoice,Rail,Szyna
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Aktualna cena
@@ -1071,6 +1075,7 @@
 DocType: Production Plan,Production Plan,Plan produkcji
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Otwieranie narzędzia tworzenia faktury
 DocType: Salary Component,Round to the Nearest Integer,Zaokrąglij do najbliższej liczby całkowitej
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Zezwól na dodanie produktów niedostępnych w magazynie do koszyka
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Zwrot sprzedaży
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Ustaw liczbę w transakcjach na podstawie numeru seryjnego
 ,Total Stock Summary,Całkowity podsumowanie zasobów
@@ -1202,6 +1207,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Baza Hour Rate (Spółka waluty)
 ,Qty To Be Billed,Ilość do naliczenia
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Dostarczone Ilość
+DocType: Coupon Code,Gift Card,Karta podarunkowa
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Zarezerwowane Ilość na produkcję: Ilość surowców do produkcji artykułów.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Data wykupu
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Ta transakcja bankowa została już w pełni uzgodniona
@@ -1291,6 +1297,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Utwórz grafik
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Konto {0} zostało wprowadzone wielokrotnie
 DocType: Account,Expenses Included In Valuation,Zaksięgowane wydatki w wycenie
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Faktury zakupu
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Przedłużenie członkostwa można odnowić w ciągu 30 dni
 DocType: Shopping Cart Settings,Show Stock Availability,Pokaż dostępność zapasów
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Ustaw {0} w kategorii aktywów {1} lub firmie {2}
@@ -1853,6 +1860,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Importowanie elementów i UOM
 DocType: Repayment Schedule,Balance Loan Amount,Kwota salda kredytu
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Dodano do szczegółów
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Przepraszamy, kod kuponu jest wyczerpany"
 DocType: Communication Medium,Catch All,Złap wszystkie
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Plan zajęć
 DocType: Budget,Applicable on Material Request,Obowiązuje na wniosek materiałowy
@@ -2022,6 +2030,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Nieprawidłowy Atrybut
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} musi zostać wysłane
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Kampanie e-mail
+DocType: Sales Partner,To Track inbound purchase,Aby śledzić zakupy przychodzące
 DocType: Buying Settings,Default Supplier Group,Domyślna grupa dostawców
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Ilość musi być mniejsze niż lub równe {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Maksymalna kwota kwalifikująca się do komponentu {0} przekracza {1}
@@ -2179,8 +2188,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Zrób wejście na giełdę
 DocType: Hotel Room Reservation,Hotel Reservation User,Użytkownik rezerwacji hotelu
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Ustaw status
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Skonfiguruj serie numeracji dla frekwencji poprzez Ustawienia&gt; Serie numeracji
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Wybierz prefiks
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Ustaw Serie nazw dla {0} poprzez Ustawienia&gt; Ustawienia&gt; Serie nazw
 DocType: Contract,Fulfilment Deadline,Termin realizacji
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Blisko Ciebie
 DocType: Student,O-,O-
@@ -2304,6 +2313,7 @@
 DocType: Quality Meeting Table,Under Review,W ramach przeglądu
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Nie udało się zalogować
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Utworzono zasoby {0}
+DocType: Coupon Code,Promotional,Promocyjny
 DocType: Special Test Items,Special Test Items,Specjalne przedmioty testowe
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,"Aby zarejestrować się w Marketplace, musisz być użytkownikiem z rolami System Manager i Item Manager."
 apps/erpnext/erpnext/config/buying.py,Key Reports,Kluczowe raporty
@@ -2342,6 +2352,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc Type
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Łącznie przydzielony procent sprzedaży dla zespołu powinien wynosić 100
 DocType: Subscription Plan,Billing Interval Count,Liczba interwałów rozliczeń
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Usuń pracownika <a href=""#Form/Employee/{0}"">{0}</a> \, aby anulować ten dokument"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Spotkania i spotkania z pacjentami
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Wartość brakująca
 DocType: Employee,Department and Grade,Wydział i stopień
@@ -2445,6 +2457,7 @@
 DocType: Project,Start and End Dates,Daty rozpoczęcia i zakończenia
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Warunki realizacji szablonu umowy
 ,Delivered Items To Be Billed,Dostarczone przedmioty oczekujące na fakturowanie
+DocType: Coupon Code,Maximum Use,Maksymalne wykorzystanie
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Otwarte BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Magazyn nie może być zmieniony dla Nr Seryjnego
 DocType: Authorization Rule,Average Discount,Średni Rabat
@@ -2607,6 +2620,7 @@
 DocType: Item,Inventory,Inwentarz
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Pobierz jako Json
 DocType: Item,Sales Details,Szczegóły sprzedaży
+DocType: Coupon Code,Used,Używany
 DocType: Opportunity,With Items,Z przedmiotami
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Kampania „{0}” już istnieje dla {1} ”{2}”
 DocType: Asset Maintenance,Maintenance Team,Zespół serwisowy
@@ -2736,7 +2750,7 @@
 						Serial No cannot be ensured",Nie znaleziono aktywnego LM dla pozycji {0}. Nie można zapewnić dostawy przez \ Numer seryjny
 DocType: Sales Partner,Sales Partner Target,Cel Partnera Sprzedaży
 DocType: Loan Type,Maximum Loan Amount,Maksymalna kwota kredytu
-DocType: Pricing Rule,Pricing Rule,Zasada ustalania cen
+DocType: Coupon Code,Pricing Rule,Zasada ustalania cen
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplikat numeru rolki dla ucznia {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplikat numeru rolki dla ucznia {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Twoje zamówienie jest w realizacji
@@ -2816,6 +2830,7 @@
 DocType: Payment Schedule,Payment Amount,Kwota płatności
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Data pół dnia powinna znajdować się pomiędzy datą pracy a datą zakończenia pracy
 DocType: Healthcare Settings,Healthcare Service Items,Przedmioty opieki zdrowotnej
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Nieprawidłowy kod kreskowy. Brak kodu dołączonego do tego kodu kreskowego.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Skonsumowana wartość
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Zmiana netto stanu środków pieniężnych
 DocType: Assessment Plan,Grading Scale,Skala ocen
@@ -2936,7 +2951,6 @@
 DocType: Share Transfer,Asset Account,Konto aktywów
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Nowa data wydania powinna być w przyszłości
 DocType: Purchase Invoice,End date of current invoice's period,Data zakończenia okresu bieżącej faktury
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Skonfiguruj system nazewnictwa pracowników w dziale Zasoby ludzkie&gt; Ustawienia HR
 DocType: Lab Test,Technician Name,Nazwa technika
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3048,6 +3062,7 @@
 DocType: Products Settings,Hide Variants,Ukryj warianty
 DocType: Lead,Next Contact By,Następny Kontakt Po
 DocType: Compensatory Leave Request,Compensatory Leave Request,Wniosek o urlop Wyrównawczy
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Nie można przepłacić za element {0} w wierszu {1} więcej niż {2}. Aby zezwolić na nadmierne fakturowanie, ustaw limit w Ustawieniach kont"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Ilość wymagana dla Przedmiotu {0} w rzędzie {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Magazyn {0} nie może zostać usunięty ponieważ istnieje wartość dla przedmiotu {1}
 DocType: Blanket Order,Order Type,Typ zamówienia
@@ -3220,7 +3235,6 @@
 DocType: Student,Student Mobile Number,Student Mobile Number
 DocType: Item,Has Variants,Ma Warianty
 DocType: Employee Benefit Claim,Claim Benefit For,Zasiłek roszczenia dla
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Nie można przeliterować dla elementu {0} w wierszu {1} więcej niż {2}. Aby umożliwić zawyżanie opłat, ustaw w Ustawieniach fotografii"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Zaktualizuj odpowiedź
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Już wybrane pozycje z {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Nazwa dystrybucji miesięcznej
@@ -3514,6 +3528,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Proszę określić walutę w Spółce
 DocType: Workstation,Wages per hour,Zarobki na godzinę
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Konfiguruj {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Klient&gt; Grupa klientów&gt; Terytorium
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Saldo Zdjęcie w serii {0} będzie negatywna {1} dla pozycji {2} w hurtowni {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Niniejszy materiał Wnioski zostały podniesione automatycznie na podstawie poziomu ponownego zamówienia elementu
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Konto {0} jest nieprawidłowe. Walutą konta musi być {1}
@@ -3847,6 +3862,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Zatwierdź potrącenie z pensji
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,W oczekiwaniu
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Qustion musi mieć co najmniej jedną poprawną opcję
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Zlecenia kupna
 DocType: Account,Inter Company Account,Konto firmowe Inter
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Masowego importu
 DocType: Sales Partner,Address & Contacts,Adresy i kontakty
@@ -3857,6 +3873,7 @@
 DocType: POS Profile,[Select],[Wybierz]
 DocType: Staffing Plan Detail,Number Of Positions,Liczba pozycji
 DocType: Vital Signs,Blood Pressure (diastolic),Ciśnienie krwi (rozkurczowe)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Wybierz klienta.
 DocType: SMS Log,Sent To,Wysłane Do
 DocType: Agriculture Task,Holiday Management,Zarządzanie wakacjami
 DocType: Payment Request,Make Sales Invoice,Nowa faktura sprzedaży
@@ -4067,7 +4084,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} nie zostało dodane
 DocType: Subscription,Trialling,Trialling
 DocType: Sales Invoice Item,Deferred Revenue,Odroczone przychody
-DocType: Bank Account,GL Account,Konto GL
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Konto gotówkowe zostanie użyte do utworzenia faktury sprzedaży
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Kategoria zwolnienia
 DocType: Member,Membership Expiry Date,Data wygaśnięcia członkostwa
@@ -4494,13 +4510,13 @@
 DocType: C-Form Invoice Detail,Territory,Region
 DocType: Pricing Rule,Apply Rule On Item Code,Zastosuj regułę do kodu towaru
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Raport stanu zapasów
 DocType: Stock Settings,Default Valuation Method,Domyślna metoda wyceny
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Opłata
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Pokaż łączną kwotę
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Aktualizacja w toku. To może trochę potrwać.
 DocType: Production Plan Item,Produced Qty,Wytworzona ilość
 DocType: Vehicle Log,Fuel Qty,Ilość paliwa
-DocType: Stock Entry,Target Warehouse Name,Docelowa nazwa magazynu
 DocType: Work Order Operation,Planned Start Time,Planowany czas rozpoczęcia
 DocType: Course,Assessment,Oszacowanie
 DocType: Payment Entry Reference,Allocated,Przydzielone
@@ -4578,10 +4594,12 @@
  1. Sposobów rozwiązywania sporów, odszkodowania, odpowiedzialność itp 
  1. Adres i kontakt z Twojej firmy."
 DocType: Homepage Section,Section Based On,Sekcja na podstawie
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Pokaż zastosuj kod kuponu
 DocType: Issue,Issue Type,rodzaj zagadnienia
 DocType: Attendance,Leave Type,Typ urlopu
 DocType: Purchase Invoice,Supplier Invoice Details,Dostawca Szczegóły faktury
 DocType: Agriculture Task,Ignore holidays,Ignoruj święta
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Dodaj / edytuj warunki kuponu
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Konto koszty / Różnica ({0}) musi być kontem ""rachunek zysków i strat"""
 DocType: Stock Entry Detail,Stock Entry Child,Dziecko do wejścia na giełdę
 DocType: Project,Copied From,Skopiowano z
@@ -4757,6 +4775,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Kryteria oceny planu
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Transakcje
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Zapobiegaj zamówieniom zakupu
+DocType: Coupon Code,Coupon Name,Nazwa kuponu
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Podatny
 DocType: Email Campaign,Scheduled,Zaplanowane
 DocType: Shift Type,Working Hours Calculation Based On,Obliczanie godzin pracy na podstawie
@@ -4773,7 +4792,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Tworzenie Warianty
 DocType: Vehicle,Diesel,Diesel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Nie wybrano Cennika w Walucie
+DocType: Quick Stock Balance,Available Quantity,Dostępna Ilość
 DocType: Purchase Invoice,Availed ITC Cess,Korzystał z ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Skonfiguruj system nazewnictwa instruktorów w edukacji&gt; Ustawienia edukacji
 ,Student Monthly Attendance Sheet,Student miesięczny Obecność Sheet
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Reguła wysyłki dotyczy tylko sprzedaży
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Wiersz amortyzacji {0}: Data następnej amortyzacji nie może być wcześniejsza niż Data zakupu
@@ -4841,8 +4862,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Wiersz {0}: Zaliczka  Klienta jest po stronie kredytowej
 DocType: Quality Meeting,Quality Meeting,Spotkanie jakościowe
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Dla grupy do grupy
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Ustaw Serie nazw dla {0} poprzez Ustawienia&gt; Ustawienia&gt; Serie nazw
 DocType: Employee,ERPNext User,ERPNext Użytkownik
+DocType: Coupon Code,Coupon Description,Opis kuponu
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Batch jest obowiązkowy w rzędzie {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Batch jest obowiązkowy w rzędzie {0}
 DocType: Company,Default Buying Terms,Domyślne warunki zakupu
@@ -5007,6 +5028,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Usunięcie jest niedozwolone w przypadku kraju {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Rodzaj Partia jest obowiązkowe
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Wprowadź Kod Kuponu
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",W przypadku karty pracy {0} można dokonać tylko wpisu typu „Transfer materiałów do produkcji”
 DocType: Quality Inspection,Outgoing,Wychodzący
 DocType: Customer Feedback Table,Customer Feedback Table,Tabela opinii klientów
@@ -5159,7 +5181,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Po złożeniu zamówienia
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Dodaj wszystkich dostawców
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Wiersz {0}: alokowana kwota nie może być większa niż kwota pozostająca do spłaty.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Klient&gt; Grupa klientów&gt; Terytorium
 DocType: Tally Migration,Parties,Strony
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Przeglądaj BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Kredyty Hipoteczne
@@ -5191,7 +5212,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Nie zezwalaj na ustawienie pozycji alternatywnej dla pozycji {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Data jest powtórzona
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Upoważniony sygnatariusz
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Skonfiguruj system nazewnictwa instruktorów w sekcji Edukacja&gt; Ustawienia edukacji
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Net ITC Available (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Utwórz opłaty
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Całkowity koszt zakupu (faktura zakupu za pośrednictwem)
@@ -5216,6 +5236,7 @@
 DocType: Quiz Result,Wrong,Źle
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Stawka przy użyciu której waluta Listy Cen jest konwertowana do podstawowej waluty klienta
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Kwota netto (Waluta Spółki)
+DocType: Sales Partner,Referral Code,kod polecającego
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Całkowita kwota zaliczki nie może być większa niż całkowita kwota sankcjonowana
 DocType: Salary Slip,Hour Rate,Stawka godzinowa
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Włącz automatyczne ponowne zamówienie
@@ -5345,6 +5366,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Pokaż ilość zapasów
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Środki pieniężne netto z działalności operacyjnej
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Wiersz # {0}: status musi być {1} dla rabatu na faktury {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Nie znaleziono współczynnika konwersji UOM ({0} -&gt; {1}) dla elementu: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Pozycja 4
 DocType: Student Admission,Admission End Date,Wstęp Data zakończenia
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Podwykonawstwo
@@ -5367,6 +5389,7 @@
 DocType: Travel Request,Fully Sponsored,W pełni sponsorowane
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Reverse Journal Entry
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Utwórz kartę pracy
+DocType: Quotation,Referral Sales Partner,Polecony partner handlowy
 DocType: Quality Procedure Process,Process Description,Opis procesu
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Utworzono klienta {0}.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Obecnie brak dostępnych zasobów w magazynach
@@ -5501,6 +5524,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM Kursy
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Odczyt przesłanego pliku
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Zatwierdzone zlecenie pracy nie może zostać anulowane, należy je najpierw anulować, aby anulować"
+DocType: Coupon Code,Coupon Code,Kod kuponu
 DocType: Asset,Journal Entry for Scrap,Księgowanie na złom
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Wyciągnij elementy z dowodu dostawy
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Wiersz {0}: wybierz stację roboczą w stosunku do operacji {1}
@@ -5585,6 +5609,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,„Data” jest wymagana
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Data referencyjne / Termin nie może być po {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Import i eksport danych
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Przepraszamy, ważność kodu kuponu wygasła"
 DocType: Bank Account,Account Details,Szczegóły konta
 DocType: Crop,Materials Required,Wymagane materiały
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Nie znaleziono studentów
@@ -5622,6 +5647,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Przejdź do Użytkownicy
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Wartość zapłaty + Wartość odliczenia nie może być większa niż Cała Kwota
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Wprowadź poprawny kod kuponu !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Uwaga: Nie ma wystarczającej ilości urlopu aby ustalić typ zwolnienia {0}
 DocType: Task,Task Description,Opis zadania
 DocType: Training Event,Seminar,Seminarium
@@ -5889,6 +5915,7 @@
 ,TDS Payable Monthly,Miesięczny płatny TDS
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,W kolejce do zastąpienia BOM. Może to potrwać kilka minut.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Nie można wywnioskować, kiedy kategoria dotyczy ""Ocena"" a kiedy ""Oceny i Total"""
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Skonfiguruj system nazewnictwa pracowników w dziale Zasoby ludzkie&gt; Ustawienia HR
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Płatności ogółem
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Nr-y seryjne Wymagane do szeregowania pozycji {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Płatności mecz fakturami
@@ -5979,6 +6006,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Zdobądź surowce do produkcji
 DocType: Job Opening,Job Title,Nazwa stanowiska pracy
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Przyszła płatność Nr ref
+DocType: Quotation,Additional Discount and Coupon Code,Dodatkowy kod rabatowy i kuponowy
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} wskazuje, że {1} nie poda cytatu, ale wszystkie cytaty \ zostały cytowane. Aktualizowanie stanu cytatu RFQ."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maksymalne próbki - {0} zostały już zachowane dla Partii {1} i pozycji {2} w Partii {3}.
@@ -6208,7 +6236,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Ustawienia strony głównej
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} jest wstrzymane do {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},Zlecenia RFQ nie są dozwolone w {0} z powodu karty wyników {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Nowa faktura zakupu
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Wykorzystane Nieobecności
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Wykorzystany kupon to {1}. Dozwolona ilość jest wyczerpana
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Czy chcesz przesłać żądanie materiałowe
 DocType: Job Offer,Awaiting Response,Oczekuje na Odpowiedź
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.RRRR.-
@@ -6222,6 +6252,7 @@
 DocType: Training Event Employee,Optional,Opcjonalny
 DocType: Salary Slip,Earning & Deduction,Dochód i Odliczenie
 DocType: Agriculture Analysis Criteria,Water Analysis,Analiza wody
+DocType: Sales Order,Skip Delivery Note,Pomiń dowód dostawy
 DocType: Price List,Price Not UOM Dependent,Cena nie zależy od ceny
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,Utworzono wariantów {0}.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Domyślna umowa dotycząca poziomu usług już istnieje.
@@ -6330,6 +6361,7 @@
 DocType: Vehicle,Last Carbon Check,Ostatni Carbon Sprawdź
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Wydatki na obsługę prawną
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Wybierz ilość w wierszu
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Zlecenie pracy {0}: nie znaleziono karty pracy dla operacji {1}
 DocType: Purchase Invoice,Posting Time,Czas publikacji
 DocType: Timesheet,% Amount Billed,% wartości rozliczonej
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Wydatki telefoniczne
@@ -6432,7 +6464,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Dodano podatki i opłaty
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Wiersz amortyzacji {0}: Data następnej amortyzacji nie może być wcześniejsza niż data przydatności do użycia
 ,Sales Funnel,Lejek Sprzedaży
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kod pozycji&gt; Grupa produktów&gt; Marka
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Skrót jest obowiązkowy
 DocType: Project,Task Progress,Postęp wykonywania zadania
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Koszyk
@@ -6529,6 +6560,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,Profil POS wymagany do tworzenia wpisu z POS
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Punkty lojalnościowe będą obliczane na podstawie zużytego (za pomocą faktury sprzedaży), na podstawie wspomnianego współczynnika zbierania."
 DocType: Program Enrollment Tool,Enroll Students,zapisać studentów
+DocType: Pricing Rule,Coupon Code Based,Na podstawie kodu kuponu
 DocType: Company,HRA Settings,Ustawienia HRA
 DocType: Homepage,Hero Section,Sekcja bohatera
 DocType: Employee Transfer,Transfer Date,Data przeniesienia
@@ -6645,6 +6677,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',"Proszę wyłączyć filtr firmy, jeśli Group By jest &quot;Company&quot;"
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Data publikacji nie może być datą przyszłą
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Wiersz # {0}: Numer seryjny: {1} nie jest zgodny z {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Skonfiguruj serie numeracji dla frekwencji poprzez Ustawienia&gt; Serie numeracji
 DocType: Stock Entry,Target Warehouse Address,Docelowy adres hurtowni
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Urlop okolicznościowy
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,"Czas przed rozpoczęciem zmiany, podczas którego odprawa pracownicza jest brana pod uwagę przy uczestnictwie."
@@ -6679,7 +6712,6 @@
 DocType: Employee Grade,Employee Grade,Klasa pracownika
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Praca akordowa
 DocType: GSTR 3B Report,June,czerwiec
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dostawca&gt; Rodzaj dostawcy
 DocType: Share Balance,From No,Od Nie
 DocType: Shift Type,Early Exit Grace Period,Wczesny okres wyjścia z inwestycji
 DocType: Task,Actual Time (in Hours),Rzeczywisty czas (w godzinach)
@@ -6966,7 +6998,6 @@
 DocType: Warehouse,Warehouse Name,Nazwa magazynu
 DocType: Naming Series,Select Transaction,Wybierz Transakcję
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Proszę wprowadzić Rolę osoby zatwierdzającej dla użytkownika zatwierdzającego
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Nie znaleziono współczynnika konwersji UOM ({0} -&gt; {1}) dla elementu: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Umowa o poziomie usług z typem podmiotu {0} i podmiotem {1} już istnieje.
 DocType: Journal Entry,Write Off Entry,Odpis
 DocType: BOM,Rate Of Materials Based On,Stawka Materiałów Wzorowana na
@@ -7105,6 +7136,7 @@
 DocType: Budget,Warn,Ostrzeż
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Wszystkie przedmioty zostały już przekazane dla tego zlecenia pracy.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Wszelkie inne uwagi, zauważyć, że powinien iść nakładu w ewidencji."
+DocType: Bank Account,Company Account,Konto firmowe
 DocType: Asset Maintenance,Manufacturing User,Produkcja użytkownika
 DocType: Purchase Invoice,Raw Materials Supplied,Dostarczone surowce
 DocType: Subscription Plan,Payment Plan,Plan płatności
@@ -7146,6 +7178,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) nie może być większe niż planowana ilość ({2}) w zleceniu pracy {3}
 DocType: Certification Application,Name of Applicant,Nazwa wnioskodawcy
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Arkusz Czas produkcji.
+DocType: Quick Stock Balance,Quick Stock Balance,Szybkie saldo zapasów
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Razem
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,"Nie można zmienić właściwości wariantu po transakcji giełdowej. Będziesz musiał zrobić nową rzecz, aby to zrobić."
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,Mandat SEPA bez karty
@@ -7474,6 +7507,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} to nieaktywny student
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} to nieaktywny student
 DocType: Employee,Health Details,Szczegóły Zdrowia
+DocType: Coupon Code,Coupon Type,Rodzaj kuponu
 DocType: Leave Encashment,Encashable days,Szykowne dni
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,"Aby utworzyć dokument referencyjny żądania zapłaty, wymagane jest"
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,"Aby utworzyć dokument referencyjny żądania zapłaty, wymagane jest"
@@ -7763,6 +7797,7 @@
 DocType: Hotel Room Package,Amenities,Udogodnienia
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Automatycznie pobierz warunki płatności
 DocType: QuickBooks Migrator,Undeposited Funds Account,Rachunek nierozliczonych funduszy
+DocType: Coupon Code,Uses,Używa
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Wielokrotny domyślny tryb płatności nie jest dozwolony
 DocType: Sales Invoice,Loyalty Points Redemption,Odkupienie punktów lojalnościowych
 ,Appointment Analytics,Analytics analityków
@@ -7780,6 +7815,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Zostaw puste, jeśli uczysz grupy studentów rocznie"
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Zostaw puste, jeśli uczysz grupy studentów rocznie"
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Jeśli zaznaczone, Całkowita liczba Dni Roboczych obejmie święta, a to zmniejsza wartość Wynagrodzenie za dzień"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Nie udało się dodać domeny
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Aby zezwolić na odbiór / dostawę, zaktualizuj „Przekazywanie / dostawę” w Ustawieniach magazynowych lub pozycji."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Aplikacje używające obecnego klucza nie będą mogły uzyskać dostępu, czy na pewno?"
 DocType: Subscription Settings,Prorate,Prorate
@@ -7793,6 +7829,7 @@
 ,BOM Stock Report,BOM Zdjęcie Zgłoś
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Jeśli nie ma przypisanej szczeliny czasowej, komunikacja będzie obsługiwana przez tę grupę"
 DocType: Stock Reconciliation Item,Quantity Difference,Ilość Różnica
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dostawca&gt; Rodzaj dostawcy
 DocType: Opportunity Item,Basic Rate,Podstawowy wskaźnik
 DocType: GL Entry,Credit Amount,Kwota kredytu
 ,Electronic Invoice Register,Rejestr faktur elektronicznych
@@ -8047,6 +8084,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Podatki i opłaty potrącone (Firmowe)
 DocType: Item Group,General Settings,Ustawienia ogólne
 DocType: Article,Article,Artykuł
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Wpisz kod kuponu !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Od Waluty i Do Waluty nie mogą być te same
 DocType: Taxable Salary Slab,Percent Deduction,Odliczenie procentowe
 DocType: GL Entry,To Rename,Aby zmienić nazwę
diff --git a/erpnext/translations/ps.csv b/erpnext/translations/ps.csv
index c86f926..5b0bc31 100644
--- a/erpnext/translations/ps.csv
+++ b/erpnext/translations/ps.csv
@@ -45,6 +45,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT -YYYY-
 DocType: Purchase Order,Customer Contact,پيرودونکو سره اړيکي
 DocType: Shift Type,Enable Auto Attendance,د آٹو ګډون فعال کړئ
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,مهرباني وکړئ ګودام او نیټه دننه کړئ
 DocType: Lost Reason Detail,Opportunity Lost Reason,فرصت له لاسه وتلی دلیل
 DocType: Patient Appointment,Check availability,د لاسرسي کتنه
 DocType: Retention Bonus,Bonus Payment Date,د بونس تادیاتو نیټه
@@ -259,6 +260,7 @@
 ,Completed Work Orders,د کار بشپړ شوي سپارښتنې
 DocType: Support Settings,Forum Posts,د فورم پوسټونه
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage",دا دنده د شاليد دندې په توګه منل شوې ده. که په شاليد کې د پروسس کولو په اړه کومه مسله شتون ولري ، سیسټم به د دې سټاک پخالینې کې د غلطۍ په اړه نظر اضافه کړي او د مسودې مرحلې ته به بیرته راستون شي.
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started",بښنه غواړو ، د کوپن کوډ اعتبار نه دی پیل شوی
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,د ماليې وړ مقدار
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},تاسو اختيار نه لري چې مخکې ثبت کرښې زیاتولی او یا تازه {0}
 DocType: Leave Policy,Leave Policy Details,د پالیسي تفصیلات پریږدئ
@@ -323,6 +325,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,د مصرف
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,ټولګي
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,د توکو کوډ&gt; د توکي ګروپ&gt; نښه
 DocType: Restaurant Table,No of Seats,د څوکیو شمیر
 DocType: Sales Invoice,Overdue and Discounted,ډیرښت او تخفیف
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,اړیکه قطع شوه
@@ -500,6 +503,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,لپاره په لفظ اندازه ليکې تشه
 DocType: Vehicle,Additional Details,اضافي نورولوله
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,نه توضيحات ورکړل
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,توکي د ګودام څخه راوړي
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,لپاره د اخیستلو غوښتنه وکړي.
 DocType: POS Closing Voucher Details,Collected Amount,راغونډ شوي مقدار
 DocType: Lab Test,Submitted Date,سپارل شوی نیټه
@@ -606,6 +610,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,وکړئ
 ,Trial Balance (Simple),د محاکمې انډول (ساده)
 DocType: Purchase Invoice Item,Enable Deferred Expense,د لیږد شوي لګښت فعالول
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,نافذ کوپن کوډ
 DocType: Asset,Next Depreciation Date,بل د استهالک نېټه
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,فعالیت لګښت په سلو کې د کارګر
 DocType: Accounts Settings,Settings for Accounts,لپاره حسابونه امستنې
@@ -840,8 +845,6 @@
 DocType: BOM,Work Order,د کار امر
 DocType: Sales Invoice,Total Qty,Total Qty
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 بريښناليک ID
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","مهرباني وکړئ د دې سند لغوه کولو لپاره کارمند <a href=""#Form/Employee/{0}"">{0}</a> delete حذف کړئ"
 DocType: Item,Show in Website (Variant),په ویب پاڼه ښودل (متحول)
 DocType: Employee,Health Concerns,روغتیا اندیښنې
 DocType: Payroll Entry,Select Payroll Period,انتخاب د معاشاتو د دورې
@@ -872,6 +875,7 @@
 DocType: Customer,Buyer of Goods and Services.,د توکو او خدماتو د اخستونکو لپاره.
 apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,'employee_field_value' and 'timestamp' are required.,&#39;مامور_ فیلډ_ویلیو&#39; او &#39;ټایمسټیمپ&#39; اړین دی.
 DocType: Journal Entry,Accounts Payable,ورکړې وړ حسابونه
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,The amount of {0} set in this payment request is different from the calculated amount of all payment plans: {1}. Make sure this is correct before submitting the document.,د دې تادیې غوښتنه کې د ټاکل شوي {0} مقدار د تادیې د ټولو پلانونو محاسبه مقدار څخه توپیر لري: {1}. ډاډ ترلاسه کړئ چې دا د سند سپارلو دمخه درست دی.
 DocType: Patient,Allergies,الندي
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,The selected BOMs are not for the same item,د ټاکل شوي BOMs د همدغه توکي نه دي
 apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Item Code,د توکو کوډ بدل کړئ
@@ -1001,6 +1005,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,د مالیه ورکوونکي مالیه حساب
 DocType: Pricing Rule,Sales Partner,خرڅلاو همکار
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,د ټولو سپلویر کټګورډونه.
+DocType: Coupon Code,To be used to get discount,د تخفیف ترلاسه کولو لپاره کارول کیږي
 DocType: Buying Settings,Purchase Receipt Required,رانيول رسيد اړین
 DocType: Sales Invoice,Rail,رېل
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,اصل لګښت
@@ -1050,6 +1055,7 @@
 DocType: Production Plan,Production Plan,د تولید پلان
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,د انوائس د جوړولو وسیله پرانیزي
 DocType: Salary Component,Round to the Nearest Integer,نږدی عدد پوری
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,اجازه راکړئ چې توکي په کارت کې نه اضافه شي
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,خرڅلاو Return
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,د سیریل نمبر انټرنیټ پر بنسټ د راکړې ورکړې مقدار ټاکئ
 ,Total Stock Summary,Total سټاک لنډيز
@@ -1178,6 +1184,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),اډه قيامت کچه (د شرکت د اسعارو)
 ,Qty To Be Billed,د مقدار بیل کول
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,تحویلوونکی مقدار
+DocType: Coupon Code,Gift Card,ډالۍ کارت
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,د تولید لپاره خوندي مقدار: د تولید توکو جوړولو لپاره د خامو موادو مقدار.
 DocType: Loyalty Point Entry Redemption,Redemption Date,د استملاک نېټه
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,د دې بانک لیږد دمخه په بشپړه توګه پخلا شوی
@@ -1266,6 +1273,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,ټایم شیټ جوړ کړئ
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,ګڼون {0} په څو ځله داخل شوي دي
 DocType: Account,Expenses Included In Valuation,لګښتونه شامل په ارزښت
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,د پیسو پیرود
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,تاسو کولی شئ یواځې نوی توب وکړئ که ستاسو غړیتوب په 30 ورځو کې پای ته ورسیږي
 DocType: Shopping Cart Settings,Show Stock Availability,د ذخیرې شتون ښودل
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},{0} د شتمني په کټګوری {1} یا کمپنۍ {2} کې مقرر کړئ.
@@ -1804,6 +1812,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,د توکو او UOMs واردول
 DocType: Repayment Schedule,Balance Loan Amount,د توازن د پور مقدار
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,تفصیلات ته اضافه شوی
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted",بښنه غواړو ، د کوپن کوډ ختم شو
 DocType: Communication Medium,Catch All,ټول واخلئ
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,مهال ويش کورس
 DocType: Budget,Applicable on Material Request,د موادو غوښتنلیک باندې د تطبیق وړ دی
@@ -1969,6 +1978,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,ناباوره ځانتیا
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} د {1} بايد وسپارل شي
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,د بریښنالیک کمپاینونه
+DocType: Sales Partner,To Track inbound purchase,د دننه باوري پیرود تعقیبولو لپاره
 DocType: Buying Settings,Default Supplier Group,د اصلي پیرودونکي ګروپ
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},مقدار باید د لږ-تر یا مساوي وي {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},د {0} برخې {1} څخه زیات وي
@@ -2123,7 +2133,6 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,د سټاک ننوتنه وکړئ
 DocType: Hotel Room Reservation,Hotel Reservation User,د هوټل رژیم کارن
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,وضعیت وټاکئ
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,مهرباني وکړئ د تنظیم کولو له لارې د شمیره ورکولو لړۍ له لارې د ګډون لپاره د شمېرنې لړۍ تنظیم کړئ
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,مهرباني وکړئ لومړی مختاړی وټاکئ
 DocType: Contract,Fulfilment Deadline,د پوره کولو وروستۍ نیټه
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,تاسره نږدې
@@ -2248,6 +2257,7 @@
 DocType: Quality Meeting Table,Under Review,د بیاکتنې لاندې
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,ننوتل کې ناکام شو
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,شتمني {0} رامینځته شوه
+DocType: Coupon Code,Promotional,پروموشنل
 DocType: Special Test Items,Special Test Items,د ځانګړي ازموینې توکي
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,تاسو اړتیا لرئ چې د کاروونکي راجستر کولو لپاره د سیسټم مدیر او د مدیر مدیر رول سره یو کارن وي.
 apps/erpnext/erpnext/config/buying.py,Key Reports,مهم راپورونه
@@ -2286,6 +2296,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,د ډاټا ډول
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,د خرڅلاو ټيم ټولې سلنه بايد 100 وي
 DocType: Subscription Plan,Billing Interval Count,د بلې درجې د شمېرنې شمېره
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","مهرباني وکړئ د دې سند لغوه کولو لپاره کارمند <a href=""#Form/Employee/{0}"">{0}</a> delete حذف کړئ"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,ګمارل شوي او د ناروغانو مسؤلین
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,ارزښت ورک دی
 DocType: Employee,Department and Grade,څانګه او درجه
@@ -2386,6 +2398,7 @@
 DocType: Project,Start and End Dates,بیا او نیټی پای
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,د تړون فورمه د بشپړتیا شرایط
 ,Delivered Items To Be Billed,تحویلوونکی توکي چې د محاسبې ته شي
+DocType: Coupon Code,Maximum Use,اعظمي استفاده
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},د پرانیستې هیښ {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,ګدام د سریال شمیره بدلون نه شي کولای
 DocType: Authorization Rule,Average Discount,په اوسط ډول کمښت
@@ -2545,6 +2558,7 @@
 DocType: Item,Inventory,موجودي
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,د Json په څیر ډاونلوډ کړئ
 DocType: Item,Sales Details,د پلورنې په بشپړه توګه کتل
+DocType: Coupon Code,Used,کارول شوی
 DocType: Opportunity,With Items,د هغو اقلامو
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',کمپاین &#39;{0}&#39; دمخه د {1} &#39;{2}&#39; لپاره شتون لري
 DocType: Asset Maintenance,Maintenance Team,د ساتنی ټیم
@@ -2672,7 +2686,7 @@
 						Serial No cannot be ensured",د توکي {0} لپاره هیڅ فعال BOM ونه موندل شو. د \ سیریل لمبر لخوا تحویلي تضمین نشي کیدی
 DocType: Sales Partner,Sales Partner Target,خرڅلاو همکار هدف
 DocType: Loan Type,Maximum Loan Amount,اعظمي پور مقدار
-DocType: Pricing Rule,Pricing Rule,د بیې د حاکمیت
+DocType: Coupon Code,Pricing Rule,د بیې د حاکمیت
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},د زده کوونکو د دوه ګونو رول شمېر {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},د زده کوونکو د دوه ګونو رول شمېر {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,د نظم پیري موادو غوښتنه
@@ -2751,6 +2765,7 @@
 DocType: Payment Schedule,Payment Amount,د تادياتو مقدار
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,د نیمایي نیټه باید د کار څخه نیټه او د کار پای نیټه کې وي
 DocType: Healthcare Settings,Healthcare Service Items,د روغتیا خدماتو توکي
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,ناباوره بارکوډ. دې بارکوډ پورې هیڅ توکی ندی تړلی.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,په مصرف مقدار
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,په نغدو خالص د بدلون
 DocType: Assessment Plan,Grading Scale,د رتبو او مقياس
@@ -2870,7 +2885,6 @@
 DocType: Share Transfer,Asset Account,د شتمنۍ حساب
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,د خوشې کولو نوي نیټه باید په راتلونکي کې وي
 DocType: Purchase Invoice,End date of current invoice's period,د روان صورتحساب د دورې د پای نیټه
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,مهرباني وکړئ د بشري سرچینو&gt; HR ترتیبات کې د کارمند نوم ورکولو سیسټم تنظیم کړئ
 DocType: Lab Test,Technician Name,د تخنیک نوم
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3148,7 +3162,6 @@
 DocType: Student,Student Mobile Number,د زده کوونکو د موبايل په شمېر
 DocType: Item,Has Variants,لري تانبه
 DocType: Employee Benefit Claim,Claim Benefit For,د ګټې لپاره ادعا وکړئ
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings",د {1} څخه په {1} څخه زیات {2} د اضافي زیان نشي کولی. د اضافه کولو اجازه ورکول، مهرباني وکړئ د سټیټ سیسټمونو کې ځای ونیسئ
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,تازه ځواب
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},تاسو وخته ټاکل څخه توکي {0} د {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,د میاشتنی ویش نوم
@@ -3433,6 +3446,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,لطفا په شرکت اسعارو مشخص
 DocType: Workstation,Wages per hour,په هر ساعت کې د معاشونو
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},د {0} تشکیل کړئ
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,پیرودونکي&gt; د پیرودونکي ګروپ&gt; سیمه
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},دحمل په دسته توازن {0} به منفي {1} لپاره د قالب {2} په ګدام {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,مادي غوښتنې لاندې پر بنسټ د قالب د بيا نظم په کچه دي په اتوماتيک ډول راپورته شوې
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},ګڼون {0} ناباوره دی. حساب د اسعارو باید د {1}
@@ -3765,6 +3779,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,سپارل معاش ټوټه
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,په انتظار
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,قوشن باید لږترلږه یو مناسب انتخابونه ولري
+apps/erpnext/erpnext/hooks.py,Purchase Orders,د پیرود امرونه
 DocType: Account,Inter Company Account,د شرکت شرکت حساب
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,په حجم د وارداتو
 DocType: Sales Partner,Address & Contacts,پته او د اړيکې
@@ -3775,6 +3790,7 @@
 DocType: POS Profile,[Select],[انتخاب]
 DocType: Staffing Plan Detail,Number Of Positions,د پوستونو شمیر
 DocType: Vital Signs,Blood Pressure (diastolic),د وینی فشار
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,مهرباني وکړئ پیرودونکی وټاکئ.
 DocType: SMS Log,Sent To,لیږل شوی ورته
 DocType: Agriculture Task,Holiday Management,د رخصتۍ اداره
 DocType: Payment Request,Make Sales Invoice,د کمکیانو لپاره د خرڅلاو صورتحساب
@@ -3980,7 +3996,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} د {1} نه سپارل
 DocType: Subscription,Trialling,درېم
 DocType: Sales Invoice Item,Deferred Revenue,د عاید شوي عواید
-DocType: Bank Account,GL Account,GL ګ .ون
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,د پیسو حساب به د خرڅلاو انوائس جوړولو لپاره کارول کیږي
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,د معافیت فرعي کټګورۍ
 DocType: Member,Membership Expiry Date,د غړیتوب پای نیټه
@@ -4380,13 +4395,13 @@
 DocType: C-Form Invoice Detail,Territory,خاوره
 DocType: Pricing Rule,Apply Rule On Item Code,د توکی کوډ باندې قانون پلي کړئ
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,لورينه وکړئ د اړتيا کتنو نه یادونه
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,د سټاک بیلانس راپور
 DocType: Stock Settings,Default Valuation Method,تلواله ارزښت Method
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,فیس
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,مجموعي مقدار ښکاره کړئ
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,اوسمهال په پرمختګ کې دی. دا ممکن یو څه وخت ونیسي.
 DocType: Production Plan Item,Produced Qty,تولید شوی مقدار
 DocType: Vehicle Log,Fuel Qty,د تیلو د Qty
-DocType: Stock Entry,Target Warehouse Name,د هدف ګودام نوم
 DocType: Work Order Operation,Planned Start Time,پلان د پیل وخت
 DocType: Course,Assessment,ارزونه
 DocType: Payment Entry Reference,Allocated,تخصيص
@@ -4452,10 +4467,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.",معياري اصطلاحات او شرايط، چې کولی شي د پلورنې او پېرودلو زياته شي. مثالونه: 1. د وړاندیز د اعتبار. 1. د ورکړې شرایط (په پرمختللی، د پور، برخه مخکې داسې نور). 1. څه شی دی اضافي (يا د پيرودونکو له خوا اخیستل کیږی). 1. د خوندیتوب / بېلګې خبرداری. 1. ګرنټی که کوم. 1. د راستنیدنې د پالیسۍ. 1. د انتقال اصطلاحات، که د تطبيق وړ. 1. د شخړو د حل، د دنغدي، مسؤليت لارې، او داسې نور 1. پته او د خپل شرکت سره اړیکه.
 DocType: Homepage Section,Section Based On,برخه پر بنسټ
+DocType: Shopping Cart Settings,Show Apply Coupon Code,د کوپن کوډ غوښتنه وکاروئ
 DocType: Issue,Issue Type,د سند ډول
 DocType: Attendance,Leave Type,رخصت ډول
 DocType: Purchase Invoice,Supplier Invoice Details,عرضه صورتحساب نورولوله
 DocType: Agriculture Task,Ignore holidays,د رخصتیو توضیحات
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,د کوپن شرایط اضافه / ترمیم کړئ
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,اخراجاتو / بدلون حساب ({0}) باید یو &#39;ګټه یا زیان&#39; حساب وي
 DocType: Stock Entry Detail,Stock Entry Child,د سټاک ننوتۍ ماشوم
 DocType: Project,Copied From,کاپي له
@@ -4628,6 +4645,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,د ارزونې معیارونه پلان
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,راکړې ورکړې
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,د پیرودونکو مخنیوی مخه ونیسئ
+DocType: Coupon Code,Coupon Name,د کوپن نوم
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,د منلو وړ
 DocType: Email Campaign,Scheduled,ټاکل شوې
 DocType: Shift Type,Working Hours Calculation Based On,د کاري ساعتونو محاسبې پراساس
@@ -4644,7 +4662,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,بدلونونه رامینځته کړئ
 DocType: Vehicle,Diesel,دیزل
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,د اسعارو بیې په لېست کې نه ټاکل
+DocType: Quick Stock Balance,Available Quantity,موجود مقدار
 DocType: Purchase Invoice,Availed ITC Cess,د آی ټي ټي سي انټرنیټ ترلاسه کول
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,مهرباني وکړئ د ښوونې او روزنې ترتیبات کې د ښوونکي نوم ورکولو سیسټم تنظیم کړئ
 ,Student Monthly Attendance Sheet,د زده کوونکو میاشتنی حاضرۍ پاڼه
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,د پلور کولو لپاره یوازې د لیږد حاکمیت
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,د استهالک صف {0}: د استملاک نیټه د پیرودنې نیټې څخه وړاندې نشي
@@ -4711,6 +4731,7 @@
 DocType: Quality Meeting,Quality Meeting,د کیفیت ناسته
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,غیر ګروپ ته ګروپ
 DocType: Employee,ERPNext User,د ERPNext کارن
+DocType: Coupon Code,Coupon Description,د کوپن تفصیل
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},batch په قطار الزامی دی {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},batch په قطار الزامی دی {0}
 DocType: Company,Default Buying Terms,د پیرودلو شرطونه
@@ -4875,6 +4896,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,په وړاندې د سند جزییات نشته
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},ړنګول د هیواد لپاره اجازه نلري {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,ګوند ډول فرض ده
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,د کوپن کوډ پلي کړئ
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",د دندې کارت {0} لپاره ، تاسو کولی شئ یوازې د تولید لپاره مادي لیږدونې ډول سټاک ننوتنه وکړئ
 DocType: Quality Inspection,Outgoing,د تېرې
 DocType: Customer Feedback Table,Customer Feedback Table,د پیرودونکي نظریاتو جدول
@@ -5025,7 +5047,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,د پیرود امر سپارنې ته
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,ټول سپلولونه زیات کړئ
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,د کتارونو تر # {0}: ځانګړې شوې مقدار نه بيالنس اندازه په پرتله زیات وي.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,پیرودونکي&gt; د پیرودونکي ګروپ&gt; سیمه
 DocType: Tally Migration,Parties,ګوندونه
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,کتنه د هیښ
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,خوندي پور
@@ -5056,7 +5077,6 @@
 DocType: Subscription,Past Due Date,د تېر وخت نیټه
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,نېټه تکرار
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,اجازه لاسليک
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,مهرباني وکړئ د ښوونې او روزنې ترتیبات کې د ښوونکي نوم ورکولو سیسټم تنظیم کړئ
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),د معلوماتي ټیکنالوژۍ شبکه موجوده ده (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,فیسونه جوړ کړئ
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Total رانيول لګښت (له لارې رانيول صورتحساب)
@@ -5081,6 +5101,7 @@
 DocType: Quiz Result,Wrong,غلط
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,په ميزان کي د بیو د لست د اسعارو ده چې د مشتريانو د اډې اسعارو بدل
 DocType: Purchase Invoice Item,Net Amount (Company Currency),خالص مقدار (شرکت د اسعارو)
+DocType: Sales Partner,Referral Code,د مراجع کوډ
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,ټول وړاندیز شوی رقم کیدای شي د ټولو منظور شوي مقدار څخه ډیر نه وي
 DocType: Salary Slip,Hour Rate,ساعت Rate
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,د آٹو ری آرډر فعال کړئ
@@ -5209,6 +5230,7 @@
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},مهرباني وکړئ BOM د توکو په وړاندې وټاکئ {0}
 DocType: Shopping Cart Settings,Show Stock Quantity,د سټاک مقدار
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,له عملیاتو خالص د نغدو
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},د UOM د بدلون فاکتور ({0} -&gt; {1}) د توکي لپاره ونه موندل شو: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,د قالب 4
 DocType: Student Admission,Admission End Date,د شاملیدو د پای نیټه
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,فرعي قرارداد
@@ -5230,6 +5252,7 @@
 DocType: Travel Request,Fully Sponsored,په بشپړه توګه تمویل شوي
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,د ژورنالیستانو ننوتلو ته
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,دندې کارت جوړ کړئ
+DocType: Quotation,Referral Sales Partner,د ریفرل پلور شریک
 DocType: Quality Procedure Process,Process Description,د پروسې توضیحات
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,پیرودونکی {0} جوړ شوی.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,اوس مهال په کوم ګودام کې هیڅ ذخیره شتون نلري
@@ -5361,6 +5384,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,هیښ Rate
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,د پورته شوې فایل لوستل
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel",د کار امر بند شوی نشي تایید شوی، دا لومړی ځل وځنډول چې فسخه شي
+DocType: Coupon Code,Coupon Code,د کوپن کوډ
 DocType: Asset,Journal Entry for Scrap,د Scrap ژورنال انفاذ
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,لطفآ د سپارنې پرمهال يادونه توکي وباسي
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Row {0}: د عملیات په وړاندې د کارسټنشن غوره کول {1}
@@ -5373,6 +5397,7 @@
 DocType: Purchase Invoice,Terms,اصطلاح ګاني
 apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Select Days,ورځونه وټاکئ
 DocType: Academic Term,Term Name,اصطلاح نوم
+apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set the correct code on Mode of Payment {1},قطار {0}: مهرباني وکړئ د تادیې په حالت کې سم کوډ تنظیم کړئ {1}
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Credit ({0}),کریډیټ ({0}
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Creating Salary Slips...,د معاشونو سلونه جوړول ...
 apps/erpnext/erpnext/hr/doctype/department/department.js,You cannot edit root node.,تاسو د ریډ نوډ سمون نشو کولی.
@@ -5441,6 +5466,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,نیټه مطلوب ده
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},له امله / ماخذ نېټه وروسته نه شي {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,په معلوماتو کې د وارداتو او صادراتو د
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired",بښنه غواړو ، د کوپن کوډ اعتبار پای ته ورسید
 DocType: Bank Account,Account Details,د حساب توضیحات
 DocType: Crop,Materials Required,توکي اړین دي
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,نه زده کوونکي موندل
@@ -5478,6 +5504,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,کاروونکو ته لاړ شه
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,ورکړل اندازه + ولیکئ پړاو مقدار نه شي کولای په پرتله Grand Total ډيره وي
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} لپاره د قالب یو باوري دسته شمېر نه دی {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,مهرباني وکړئ د کوپن کوډ کوډ داخل کړئ!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},نوټ: د اجازه ډول کافي رخصت توازن نه شته {0}
 DocType: Task,Task Description,د کاري توکی
 DocType: Training Event,Seminar,سیمینار
@@ -5745,6 +5772,7 @@
 ,TDS Payable Monthly,د تادیه وړ میاشتنۍ TDS
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,د BOM ځای نیولو لپاره قطع شوی. دا کیدای شي څو دقیقو وخت ونیسي.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',وضع نه شي کله چې وېشنيزه کې د &#39;ارزښت&#39; یا د &#39;ارزښت او Total&#39; دی
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,مهرباني وکړئ د بشري سرچینو&gt; HR ترتیبات کې د کارمند نوم ورکولو سیسټم تنظیم کړئ
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,ټولې تادیې
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},د Serialized د قالب سریال ترانسفارمرونو د مطلوب {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,سره صورتحساب لوبه د پیسو ورکړه
@@ -5833,6 +5861,7 @@
 DocType: Production Plan,Get Raw Materials For Production,د تولید لپاره خاموش توکي ترلاسه کړئ
 DocType: Job Opening,Job Title,د دندې سرلیک
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,راتلونکي تادیه ریف
+DocType: Quotation,Additional Discount and Coupon Code,د اضافي تخفیف او کوپن کوډ
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.",{1} اشاره کوي چې {1} به یو کوډ چمتو نکړي، مګر ټول توکي \ نقل شوي دي. د آر ایف پی د اقتباس حالت وضع کول
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,ډیری نمونې - {1} د مخه د بچ لپاره {1} او Item {2} په بچ {3} کې ساتل شوي دي.
@@ -6058,6 +6087,7 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,د ویب پاڼه امستنې
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{1} تر هغې پورې نیسي چې {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFJs د {1} لپاره د سکډورډ کارډ له امله اجازه نه لري {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,د پیرود بل
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,استعمال شوي پاڼي
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,ایا تاسو غواړئ د موادو غوښتنه وړاندې کړئ
 DocType: Job Offer,Awaiting Response,په تمه غبرګون
@@ -6072,6 +6102,7 @@
 DocType: Training Event Employee,Optional,اختیاري
 DocType: Salary Slip,Earning & Deduction,وټې &amp; Deduction
 DocType: Agriculture Analysis Criteria,Water Analysis,د اوبو تحلیل
+DocType: Sales Order,Skip Delivery Note,د سپارنې یادداشت پریږدئ
 DocType: Price List,Price Not UOM Dependent,قیمت د UOM پورې اړه نلري
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} ډولونه جوړ شوي.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,د ډیفالټ خدماتو کچې تړون لا دمخه شتون لري.
@@ -6179,6 +6210,7 @@
 DocType: Vehicle,Last Carbon Check,تېره کاربن Check
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,قانوني داخراجاتو
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,لطفا د قطار په کمیت وټاکي
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},د کار امر {0}: د عملیاتو لپاره دندې کارت ونه موندل شو {1}
 DocType: Purchase Invoice,Posting Time,نوکرې وخت
 DocType: Timesheet,% Amount Billed,٪ بیل د
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Telephone داخراجاتو
@@ -6279,7 +6311,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,مالیه او په تور د ورزیاتولو
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,د استهالک صف {0}: د استملاک نیټه د لاسرسي لپاره د لاس رسی نیولو څخه وړاندې نشي
 ,Sales Funnel,خرڅلاو کیږدئ
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,د توکو کوډ&gt; د توکي ګروپ&gt; نښه
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Abbreviation الزامی دی
 DocType: Project,Task Progress,کاري پرمختګ
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,کراچۍ
@@ -6374,6 +6405,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS د پېژندنې اړتيا ته POS انفاذ لپاره
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",د وفادارۍ ټکي به د مصرف شوي (د پلور انو له لارې) حساب شي، د راغونډولو فکتور په اساس به ذکر شي.
 DocType: Program Enrollment Tool,Enroll Students,زده کوونکي شامل کړي
+DocType: Pricing Rule,Coupon Code Based,د کوپن کوډ پر اساس
 DocType: Company,HRA Settings,د HRA ترتیبات
 DocType: Homepage,Hero Section,د هیرو برخه
 DocType: Employee Transfer,Transfer Date,د لېږد نیټه
@@ -6489,6 +6521,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',لطفا جوړ شرکت چاڼ خالي که ډله په دی شرکت
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,نوکرې نېټه نه شي کولای راتلونکې نیټه وي.
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},د کتارونو تر # {0}: شعبه {1} سره سمون نه خوري {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,مهرباني وکړئ د تنظیم کولو له لارې د شمیره ورکولو لړۍ له لارې د ګډون لپاره د شمېرنې لړۍ تنظیم کړئ
 DocType: Stock Entry,Target Warehouse Address,د ګودام ګودام پته
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,واله ته لاړل
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,د شفټ د پیل وخت څخه مخکې وخت په جریان کې د کارمند چیک اپ د حاضری لپاره ګ consideredل کیږي.
@@ -6523,7 +6556,6 @@
 DocType: Employee Grade,Employee Grade,د کارموندنې درجه
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Piecework
 DocType: GSTR 3B Report,June,جون
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,عرضه کونکي&gt; عرضه کونکي ډول
 DocType: Share Balance,From No,له
 DocType: Shift Type,Early Exit Grace Period,د ژر وتلو فضل ګړندی دوره
 DocType: Task,Actual Time (in Hours),واقعي وخت (په ساعتونه)
@@ -6806,7 +6838,6 @@
 DocType: Warehouse,Warehouse Name,ګدام نوم
 DocType: Naming Series,Select Transaction,انتخاب معامالتو
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,لطفا رول تصويب يا تصويب کارن
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},د UOM د بدلون فاکتور ({0} -&gt; {1}) د توکي لپاره ونه موندل شو: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,د شرکت ډول {0} او شرکت {1} سره د خدماتي کچې تړون لا دمخه موجود دی.
 DocType: Journal Entry,Write Off Entry,ولیکئ پړاو په انفاذ
 DocType: BOM,Rate Of Materials Based On,کچه د موادو پر بنسټ
@@ -6944,6 +6975,7 @@
 DocType: Budget,Warn,خبرداری
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,ټول توکي د مخه د دې کار امر لپاره لیږدول شوي دي.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.",کوم بل څرګندونې، د یادولو وړ هڅې چې بايد په اسنادو ته ولاړ شي.
+DocType: Bank Account,Company Account,د شرکت حساب
 DocType: Asset Maintenance,Manufacturing User,دفابريکي کارن
 DocType: Purchase Invoice,Raw Materials Supplied,خام مواد
 DocType: Subscription Plan,Payment Plan,د تادیاتو پلان
@@ -6984,6 +7016,7 @@
 DocType: Sales Invoice,Commission,کمیسیون
 DocType: Certification Application,Name of Applicant,د غوښتونکي نوم
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,د تولید د وخت پاڼه.
+DocType: Quick Stock Balance,Quick Stock Balance,د ګړندي سټاک بیلانس
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,پاسنۍ
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,د سود لیږد وروسته مختلف توپیرونه نشي راوولی. تاسو باید دا کار کولو لپاره نوي توکي جوړ کړئ.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,د ګیرډless SEPA منډول
@@ -7310,6 +7343,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} دی فعال محصل
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} دی فعال محصل
 DocType: Employee,Health Details,د روغتیا په بشپړه توګه کتل
+DocType: Coupon Code,Coupon Type,د کوپن ډول
 DocType: Leave Encashment,Encashable days,د منلو وړ ورځې
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,د پیسو غوښتنه مرجع سند ته اړتيا ده پيدا
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,د پیسو غوښتنه مرجع سند ته اړتيا ده پيدا
@@ -7592,6 +7626,7 @@
 DocType: Hotel Room Package,Amenities,امکانات
 DocType: Accounts Settings,Automatically Fetch Payment Terms,د تادیې شرایط په اوتومات ډول راوړل
 DocType: QuickBooks Migrator,Undeposited Funds Account,د نه منل شوي فنډ حساب
+DocType: Coupon Code,Uses,کاروي
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,د پیسو ډیری ډیزاین موډل اجازه نه لري
 DocType: Sales Invoice,Loyalty Points Redemption,د وفادارۍ ټکي مخنیوی
 ,Appointment Analytics,د استوګنې انټرنېټونه
@@ -7609,6 +7644,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,خالي پريږدئ که تاسو په هر کال کې زده کوونکو ډلو لپاره
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,خالي پريږدئ که تاسو په هر کال کې زده کوونکو ډلو لپاره
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day",که وکتل، ټول نه. د کاري ورځې به رخصتي شامل دي او دا کار به د معاش د ورځې د ارزښت د کمولو
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,د ډومین اضافه کول ناکام شول
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.",د رسید / تحویلۍ ته اجازه ورکولو لپاره ، په سټاک ترتیباتو یا توکي کې &quot;د رسید څخه ډیر / رسیدي الاونس&quot; تازه کړئ.
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?",د اوسني کیلي کارولو کاروونې به د لاسرسي وړ نه وي، ایا تاسو ډاډه یاست؟
 DocType: Subscription Settings,Prorate,پراخوالی
@@ -7622,6 +7658,7 @@
 ,BOM Stock Report,هیښ سټاک راپور
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group",که چیرې ټاکل شوی مهال ویش شتون ونلري ، نو بیا مخابرات به د دې ډلې لخوا اداره کیږي
 DocType: Stock Reconciliation Item,Quantity Difference,مقدار بدلون
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,عرضه کونکي&gt; عرضه کونکي ډول
 DocType: Opportunity Item,Basic Rate,اساسي Rate
 DocType: GL Entry,Credit Amount,اعتبار مقدار
 ,Electronic Invoice Register,د بریښنایی رسید ثبت
@@ -7873,6 +7910,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),مالیه او په تور مجرايي (شرکت د اسعارو)
 DocType: Item Group,General Settings,جنرال امستنې
 DocType: Article,Article,مقاله
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,مهرباني وکړئ کوپن کوډ داخل کړئ !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,څخه د اسعارو او د پیسو د نه شي کولای ورته وي
 DocType: Taxable Salary Slab,Percent Deduction,فيصدي کسر
 DocType: GL Entry,To Rename,نوم بدلول
diff --git a/erpnext/translations/pt.csv b/erpnext/translations/pt.csv
index b060aba..afb38be 100644
--- a/erpnext/translations/pt.csv
+++ b/erpnext/translations/pt.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Contato do Cliente
 DocType: Shift Type,Enable Auto Attendance,Ativar atendimento automático
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Entre o armazém e a data
 DocType: Lost Reason Detail,Opportunity Lost Reason,Oportunidade Razão Perdida
 DocType: Patient Appointment,Check availability,Verificar disponibilidade
 DocType: Retention Bonus,Bonus Payment Date,Data de Pagamento do Bônus
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Ordens de trabalho concluídas
 DocType: Support Settings,Forum Posts,Posts no Fórum
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","A tarefa foi enfileirada como um trabalho em segundo plano. Caso haja algum problema no processamento em background, o sistema adicionará um comentário sobre o erro nessa reconciliação de estoque e reverterá para o estágio de rascunho"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Desculpe, a validade do código do cupom não foi iniciada"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Valor taxado
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Não está autorizado a adicionar ou atualizar registos antes de {0}
 DocType: Leave Policy,Leave Policy Details,Deixar detalhes da política
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Consumíveis
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,Classe
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Código do item&gt; Grupo de itens&gt; Marca
 DocType: Restaurant Table,No of Seats,No of Seats
 DocType: Sales Invoice,Overdue and Discounted,Em atraso e descontado
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Chamada Desconectada
@@ -507,6 +510,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Espaçamento entre linhas para o valor por extenso
 DocType: Vehicle,Additional Details,Dados Adicionais
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Não foi dada qualquer descrição
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Buscar itens do armazém
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Pedido de compra.
 DocType: POS Closing Voucher Details,Collected Amount,Montante Recolhido
 DocType: Lab Test,Submitted Date,Data enviada
@@ -614,6 +618,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Aprender
 ,Trial Balance (Simple),Balancete (simples)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Ativar Despesa Adiada
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Código de cupom aplicado
 DocType: Asset,Next Depreciation Date,Próxima Data de Depreciação
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Custo de Atividade por Funcionário
 DocType: Accounts Settings,Settings for Accounts,Definições de Contas
@@ -854,8 +859,6 @@
 DocType: Sales Invoice,Total Qty,Qtd Total
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,ID de e-mail do Guardian2
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,ID de e-mail do Guardian2
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Por favor, exclua o funcionário <a href=""#Form/Employee/{0}"">{0}</a> \ para cancelar este documento"
 DocType: Item,Show in Website (Variant),Show em site (Variant)
 DocType: Employee,Health Concerns,Problemas Médicos
 DocType: Payroll Entry,Select Payroll Period,Selecione o Período de Pagamento
@@ -1021,6 +1024,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Conta de Retenção Fiscal
 DocType: Pricing Rule,Sales Partner,Parceiro de Vendas
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Todos os scorecards do fornecedor.
+DocType: Coupon Code,To be used to get discount,Para ser usado para obter desconto
 DocType: Buying Settings,Purchase Receipt Required,É Obrigatório o Recibo de Compra
 DocType: Sales Invoice,Rail,Trilho
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Custo real
@@ -1071,6 +1075,7 @@
 DocType: Production Plan,Production Plan,Plano de produção
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Ferramenta de criação de fatura de abertura
 DocType: Salary Component,Round to the Nearest Integer,Arredondar para o número inteiro mais próximo
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Permitir que itens não em estoque sejam adicionados ao carrinho
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Retorno de Vendas
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Definir Qtd em transações com base na entrada serial
 ,Total Stock Summary,Resumo de estoque total
@@ -1200,6 +1205,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Preço Base por Hora (Moeda da Empresa)
 ,Qty To Be Billed,Quantidade a ser faturada
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Montante Entregue
+DocType: Coupon Code,Gift Card,Cartão Presente
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Quantidade reservada para produção: quantidade de matérias-primas para fabricar itens de produção.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Data de resgate
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Esta transação bancária já está totalmente reconciliada
@@ -1287,6 +1293,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Criar quadro de horários
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,A Conta {0} foi inserida várias vezes
 DocType: Account,Expenses Included In Valuation,Despesas Incluídas na Estimativa
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Faturas de compra
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Você só pode renovar se a sua adesão expirar dentro de 30 dias
 DocType: Shopping Cart Settings,Show Stock Availability,Mostrar disponibilidade de estoque
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Defina {0} na categoria de recurso {1} ou na empresa {2}
@@ -1847,6 +1854,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Importando Itens e UOMs
 DocType: Repayment Schedule,Balance Loan Amount,Saldo Valor do Empréstimo
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Adicionado aos detalhes
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Desculpe, o código do cupom está esgotado"
 DocType: Communication Medium,Catch All,Pegar tudo
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Calendário de Cursos
 DocType: Budget,Applicable on Material Request,Aplicável no Pedido de Material
@@ -2017,6 +2025,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Atributo Inválido
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} deve ser enviado
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Campanhas de e-mail
+DocType: Sales Partner,To Track inbound purchase,Para rastrear compras de entrada
 DocType: Buying Settings,Default Supplier Group,Grupo de fornecedores padrão
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},A quantidade deve ser inferior ou igual a {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},A quantia máxima elegível para o componente {0} excede {1}
@@ -2172,8 +2181,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Fazer entrada de estoque
 DocType: Hotel Room Reservation,Hotel Reservation User,Usuário de reserva de hotel
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Definir status
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Configure séries de numeração para Presença em Configuração&gt; Série de numeração
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,"Por favor, seleccione o prefixo primeiro"
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Defina Naming Series como {0} em Configuração&gt; Configurações&gt; Naming Series
 DocType: Contract,Fulfilment Deadline,Prazo de Cumprimento
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Perto de você
 DocType: Student,O-,O-
@@ -2297,6 +2306,7 @@
 DocType: Quality Meeting Table,Under Review,Sob revisão
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Falha ao fazer o login
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Ativo {0} criado
+DocType: Coupon Code,Promotional,Promocional
 DocType: Special Test Items,Special Test Items,Itens de teste especiais
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Você precisa ser um usuário com as funções System Manager e Item Manager para registrar no Marketplace.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Relatórios principais
@@ -2334,6 +2344,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Tipo Doc
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,A percentagem total atribuída à equipa de vendas deve ser de 100
 DocType: Subscription Plan,Billing Interval Count,Contagem de intervalos de faturamento
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Por favor, exclua o funcionário <a href=""#Form/Employee/{0}"">{0}</a> \ para cancelar este documento"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Nomeações e Encontros com Pacientes
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Valor ausente
 DocType: Employee,Department and Grade,Departamento e Grau
@@ -2437,6 +2449,7 @@
 DocType: Project,Start and End Dates,Datas de início e Término
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Termos de Cumprimento do Modelo de Contrato
 ,Delivered Items To Be Billed,Itens Entregues a Serem Cobrados
+DocType: Coupon Code,Maximum Use,Uso Máximo
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Abrir BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,O Armazém não pode ser modificado pelo Nr. de Série
 DocType: Authorization Rule,Average Discount,Desconto Médio
@@ -2599,6 +2612,7 @@
 DocType: Item,Inventory,Inventário
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Baixe como Json
 DocType: Item,Sales Details,Dados de Vendas
+DocType: Coupon Code,Used,Usava
 DocType: Opportunity,With Items,Com Itens
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',A Campanha &#39;{0}&#39; já existe para o {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Equipe de manutenção
@@ -2728,7 +2742,7 @@
 						Serial No cannot be ensured",Nenhuma lista de materiais ativa encontrada para o item {0}. Entrega por \ Serial No não pode ser assegurada
 DocType: Sales Partner,Sales Partner Target,Objetivo de Parceiro de Vendas
 DocType: Loan Type,Maximum Loan Amount,Montante máximo do empréstimo
-DocType: Pricing Rule,Pricing Rule,Regra de Fixação de Preços
+DocType: Coupon Code,Pricing Rule,Regra de Fixação de Preços
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Número de rolo duplicado para o estudante {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Número de rolo duplicado para o estudante {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Pedido de Material para Ordem de Compra
@@ -2808,6 +2822,7 @@
 DocType: Payment Schedule,Payment Amount,Valor do Pagamento
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,A data de meio dia deve estar entre o trabalho da data e a data de término do trabalho
 DocType: Healthcare Settings,Healthcare Service Items,Itens de serviço de saúde
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Código de barras inválido. Não há nenhum item anexado a este código de barras.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Montante Consumido
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Variação Líquida na Caixa
 DocType: Assessment Plan,Grading Scale,Escala de classificação
@@ -2929,7 +2944,6 @@
 DocType: Share Transfer,Asset Account,Conta de Ativo
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,A nova data de lançamento deve estar no futuro
 DocType: Purchase Invoice,End date of current invoice's period,A data de término do período de fatura atual
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Configure o sistema de nomeação de funcionários em Recursos humanos&gt; Configurações de RH
 DocType: Lab Test,Technician Name,Nome do Técnico
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3041,6 +3055,7 @@
 DocType: Products Settings,Hide Variants,Ocultar variantes
 DocType: Lead,Next Contact By,Próximo Contacto Por
 DocType: Compensatory Leave Request,Compensatory Leave Request,Pedido de Licença Compensatória
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Não é possível exceder o item {0} na linha {1} mais que {2}. Para permitir cobrança excessiva, defina a permissão nas Configurações de contas"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},A quantidade necessária para o item {0} na linha {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Armazém {0} não pode ser excluído como existe quantidade para item {1}
 DocType: Blanket Order,Order Type,Tipo de Pedido
@@ -3213,7 +3228,6 @@
 DocType: Student,Student Mobile Number,Número de telemóvel do Estudante
 DocType: Item,Has Variants,Tem Variantes
 DocType: Employee Benefit Claim,Claim Benefit For,Reivindicar benefício para
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Não é possível sobrepor o item {0} na linha {1} mais do que {2}. Para permitir o excesso de cobrança, defina Configurações de estoque"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Atualizar Resposta
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Já selecionou itens de {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Nome da Distribuição Mensal
@@ -3507,6 +3521,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,"Por favor, especifique a moeda na Empresa"
 DocType: Workstation,Wages per hour,Salários por hora
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Configure {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Cliente&gt; Grupo de clientes&gt; Território
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},O saldo de stock no Lote {0} vai ficar negativo {1} para o item {2} no Armazém {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,As seguintes Solicitações de Materiais têm sido automaticamente executadas com base no nível de reencomenda do Item
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},A conta {0} é inválida. A Moeda da Conta deve ser {1}
@@ -3840,6 +3855,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Enviar Folha de Vencimento
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Em espera
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Uma questão deve ter pelo menos uma opção correta
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Ordens de compra
 DocType: Account,Inter Company Account,Conta Intercompanhia
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Importação em Massa
 DocType: Sales Partner,Address & Contacts,Endereço e Contactos
@@ -3850,6 +3866,7 @@
 DocType: POS Profile,[Select],[Selecionar]
 DocType: Staffing Plan Detail,Number Of Positions,Número de posições
 DocType: Vital Signs,Blood Pressure (diastolic),Pressão sanguínea (diastólica)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,"Por favor, selecione o cliente."
 DocType: SMS Log,Sent To,Enviado Para
 DocType: Agriculture Task,Holiday Management,Gestão de férias
 DocType: Payment Request,Make Sales Invoice,Efetuar Fatura de Compra
@@ -4059,7 +4076,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} não foi enviado
 DocType: Subscription,Trialling,Julgamento
 DocType: Sales Invoice Item,Deferred Revenue,Receita Diferida
-DocType: Bank Account,GL Account,Conta GL
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Conta de caixa será usada para criação de fatura de vendas
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Subcategoria de isenção
 DocType: Member,Membership Expiry Date,Data de expiração da associação
@@ -4486,13 +4502,13 @@
 DocType: C-Form Invoice Detail,Territory,Território
 DocType: Pricing Rule,Apply Rule On Item Code,Aplicar regra no código do item
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,"Por favor, mencione o nr. de visitas necessárias"
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Relatório de balanço de ações
 DocType: Stock Settings,Default Valuation Method,Método de Estimativa Padrão
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Taxa
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Mostrar Montante Cumulativo
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Atualização em andamento. Pode demorar um pouco.
 DocType: Production Plan Item,Produced Qty,Qtd produzido
 DocType: Vehicle Log,Fuel Qty,Qtd de Comb.
-DocType: Stock Entry,Target Warehouse Name,Nome do Armazém de Destino
 DocType: Work Order Operation,Planned Start Time,Tempo de Início Planeado
 DocType: Course,Assessment,Avaliação
 DocType: Payment Entry Reference,Allocated,Atribuído
@@ -4570,10 +4586,12 @@
  1. Formas de abordar litígios, indemnização, responsabilidade, etc. 
  1. Endereço e Contacto da sua Empresa."
 DocType: Homepage Section,Section Based On,Seção Baseada Em
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Mostrar Aplicar Código de Cupom
 DocType: Issue,Issue Type,Tipo de problema
 DocType: Attendance,Leave Type,Tipo de Licença
 DocType: Purchase Invoice,Supplier Invoice Details,Fornecedor Detalhes da fatura
 DocType: Agriculture Task,Ignore holidays,Ignorar feriados
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Adicionar / editar condições do cupom
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"A conta de Despesas / Diferenças ({0}) deve ser uma conta de ""Lucros e Perdas"""
 DocType: Stock Entry Detail,Stock Entry Child,Filho de entrada de estoque
 DocType: Project,Copied From,Copiado de
@@ -4749,6 +4767,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Critérios plano de avaliação
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Transações
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Prevenir ordens de compra
+DocType: Coupon Code,Coupon Name,Nome do Cupom
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Susceptível
 DocType: Email Campaign,Scheduled,Programado
 DocType: Shift Type,Working Hours Calculation Based On,Cálculo das horas de trabalho com base em
@@ -4765,7 +4784,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Criar Variantes
 DocType: Vehicle,Diesel,Gasóleo
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Não foi selecionada uma Moeda para a Lista de Preços
+DocType: Quick Stock Balance,Available Quantity,Quantidade disponível
 DocType: Purchase Invoice,Availed ITC Cess,Aproveitou o ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Configure o Sistema de Nomenclatura do Instrutor em Educação&gt; Configurações de educação
 ,Student Monthly Attendance Sheet,Folha de Assiduidade Mensal de Estudante
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Regra de envio aplicável apenas para venda
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Linha de depreciação {0}: a próxima data de depreciação não pode ser anterior à data de compra
@@ -4833,8 +4854,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Linha {0}: O Avanço do Cliente deve ser creditado
 DocType: Quality Meeting,Quality Meeting,Encontro de Qualidade
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,De Fora do Grupo a Grupo
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Defina Naming Series como {0} em Configuração&gt; Configurações&gt; Naming Series
 DocType: Employee,ERPNext User,Usuário do ERPNext
+DocType: Coupon Code,Coupon Description,Descrição do cupom
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},O lote é obrigatório na linha {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},O lote é obrigatório na linha {0}
 DocType: Company,Default Buying Terms,Termos de compra padrão
@@ -4999,6 +5020,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,No Nr. de Dados de Documento
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},A exclusão não está permitida para o país {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,É obrigatório colocar o Tipo de Parte
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Aplicar código de cupom
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","Para o cartão de trabalho {0}, você só pode fazer a entrada de estoque do tipo &#39;Transferência de material para produção&#39;"
 DocType: Quality Inspection,Outgoing,Saída
 DocType: Customer Feedback Table,Customer Feedback Table,Tabela de feedback do cliente
@@ -5150,7 +5172,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,No envio do pedido
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Adicionar todos os fornecedores
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Row # {0}: Allocated Amount não pode ser maior do que o montante pendente.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Cliente&gt; Grupo de clientes&gt; Território
 DocType: Tally Migration,Parties,Festas
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Pesquisar na LDM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Empréstimos Garantidos
@@ -5182,7 +5203,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Não permite definir item alternativo para o item {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,A data está repetida
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Signatário Autorizado
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Configure o Sistema de Nomenclatura do Instrutor em Educação&gt; Configurações de educação
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),ITC líquido disponível (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Criar Taxas
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Custo total de compra (através da Fatura de Compra)
@@ -5207,6 +5227,7 @@
 DocType: Quiz Result,Wrong,Errado
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Taxa à qual a moeda da lista de preços é convertida para a moeda principal do cliente
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Valor Líquido (Moeda da Empresa)
+DocType: Sales Partner,Referral Code,Código de Referencia
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,O montante do adiantamento total não pode ser maior do que o montante sancionado total
 DocType: Salary Slip,Hour Rate,Preço por Hora
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Ativar reordenação automática
@@ -5337,6 +5358,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Mostrar a quantidade de estoque
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Caixa Líquido de Operações
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Linha # {0}: o status deve ser {1} para desconto na fatura {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Fator de conversão de UOM ({0} -&gt; {1}) não encontrado para o item: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Item 4
 DocType: Student Admission,Admission End Date,Data de Término de Admissão
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Sub-contratação
@@ -5359,6 +5381,7 @@
 DocType: Travel Request,Fully Sponsored,Totalmente Patrocinado
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Entrada de Diário Reversa
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Criar cartão de trabalho
+DocType: Quotation,Referral Sales Partner,Parceiro de vendas de referência
 DocType: Quality Procedure Process,Process Description,Descrição do processo
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,O cliente {0} é criado.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Atualmente não há estoque disponível em qualquer armazém
@@ -5493,6 +5516,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,Preço na LDM
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Lendo arquivo carregado
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","A ordem de trabalho interrompida não pode ser cancelada, descompacte-a primeiro para cancelar"
+DocType: Coupon Code,Coupon Code,Código do cupom
 DocType: Asset,Journal Entry for Scrap,Lançamento Contabilístico para Sucata
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,"Por favor, remova os itens da Guia de Remessa"
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Linha {0}: selecione a estação de trabalho contra a operação {1}
@@ -5577,6 +5601,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;Data&#39; é obrigatório
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},A Data de Vencimento / Referência não pode ser após {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Dados de Importação e Exportação
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired",A validade do código do cupom expirou
 DocType: Bank Account,Account Details,Detalhes da conta
 DocType: Crop,Materials Required,Materiais requisitados
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Não foi Encontrado nenhum aluno
@@ -5614,6 +5639,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Ir aos usuários
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,O Montante Pago + Montante Liquidado não pode ser superior ao Total Geral
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} não é um Número de Lote válido para o Item {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Digite o código de cupom válido !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Nota: Não possui saldo de licença suficiente para o Tipo de Licença {0}
 DocType: Task,Task Description,Descrição da tarefa
 DocType: Training Event,Seminar,Seminário
@@ -5881,6 +5907,7 @@
 ,TDS Payable Monthly,TDS a pagar mensalmente
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Em fila para substituir a lista de materiais. Pode demorar alguns minutos.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Não pode deduzir quando a categoria é da ""Estimativa"" ou ""Estimativa e Total"""
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Configure o sistema de nomeação de funcionários em Recursos humanos&gt; Configurações de RH
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Total de pagamentos
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},É Necessário colocar o Nr. de Série para o Item em Série {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Combinar Pagamentos com Faturas
@@ -5971,6 +5998,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Obtenha matérias-primas para a produção
 DocType: Job Opening,Job Title,Título de Emprego
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Referência de Pagamento Futuro
+DocType: Quotation,Additional Discount and Coupon Code,Código adicional de desconto e cupom
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} indica que {1} não fornecerá uma cotação, mas todos os itens \ foram citados. Atualizando o status da cotação RFQ."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Amostras máximas - {0} já foram mantidas para Batch {1} e Item {2} no Batch {3}.
@@ -6199,7 +6227,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Definições para página inicial do website
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} está em espera até {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQs não são permitidos para {0} devido a um ponto de avaliação de {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Maak inkoopfactuur
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Folhas Usadas
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} O cupom usado é {1}. A quantidade permitida está esgotada
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Você deseja enviar a solicitação de material
 DocType: Job Offer,Awaiting Response,A aguardar Resposta
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6213,6 +6243,7 @@
 DocType: Training Event Employee,Optional,Opcional
 DocType: Salary Slip,Earning & Deduction,Remunerações e Deduções
 DocType: Agriculture Analysis Criteria,Water Analysis,Análise de água
+DocType: Sales Order,Skip Delivery Note,Ignorar nota de entrega
 DocType: Price List,Price Not UOM Dependent,Preço Não Dependente da UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} variantes criadas.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Um contrato de nível de serviço padrão já existe.
@@ -6321,6 +6352,7 @@
 DocType: Vehicle,Last Carbon Check,Último Duplicado de Cheque
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Despesas Legais
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Selecione a quantidade na linha
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Ordem de Serviço {0}: cartão de trabalho não encontrado para a operação {1}
 DocType: Purchase Invoice,Posting Time,Hora de Postagem
 DocType: Timesheet,% Amount Billed,% Valor Faturado
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Despesas Telefónicas
@@ -6423,7 +6455,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Impostos e Encargos Adicionados
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Linha de depreciação {0}: a próxima data de depreciação não pode ser anterior à data disponível para uso
 ,Sales Funnel,Canal de Vendas
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Código do item&gt; Grupo de itens&gt; Marca
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,É obrigatório colocar uma abreviatura
 DocType: Project,Task Progress,Progresso da Tarefa
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Carrinho
@@ -6520,6 +6551,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,É necessário colocar o Perfil POS para efetuar um Registo POS
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Os pontos de fidelidade serão calculados a partir do gasto realizado (via fatura de vendas), com base no fator de cobrança mencionado."
 DocType: Program Enrollment Tool,Enroll Students,Matricular Estudantes
+DocType: Pricing Rule,Coupon Code Based,Baseado em código de cupom
 DocType: Company,HRA Settings,Configurações de HRA
 DocType: Homepage,Hero Section,Seção Hero
 DocType: Employee Transfer,Transfer Date,Data de transferência
@@ -6636,6 +6668,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Defina o filtro de empresa em branco se Group By for &#39;Company&#39;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,A Data de Postagem não pode ser uma data futura
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Linha # {0}: O Nr. de Série {1} não corresponde a {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Configure séries de numeração para Presença em Configuração&gt; Série de numeração
 DocType: Stock Entry,Target Warehouse Address,Endereço do depósito de destino
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Licença Ocasional
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,O horário antes do horário de início do turno durante o qual o Check-in do funcionário é considerado para participação.
@@ -6670,7 +6703,6 @@
 DocType: Employee Grade,Employee Grade,Employee Grade
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Trabalho à Peça
 DocType: GSTR 3B Report,June,Junho
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Fornecedor&gt; Tipo de fornecedor
 DocType: Share Balance,From No,De não
 DocType: Shift Type,Early Exit Grace Period,Período de Carência da Saída Antecipada
 DocType: Task,Actual Time (in Hours),Tempo Real (em Horas)
@@ -6963,7 +6995,6 @@
 DocType: Warehouse,Warehouse Name,Nome dp Armazém
 DocType: Naming Series,Select Transaction,Selecionar Transação
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,"Por favor, insira a Função Aprovadora ou o Utilizador Aprovador"
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Fator de conversão de UOM ({0} -&gt; {1}) não encontrado para o item: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,O Acordo de Nível de Serviço com o Tipo de Entidade {0} e a Entidade {1} já existe.
 DocType: Journal Entry,Write Off Entry,Registo de Liquidação
 DocType: BOM,Rate Of Materials Based On,Taxa de Materiais Baseada Em
@@ -7102,6 +7133,7 @@
 DocType: Budget,Warn,Aviso
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Todos os itens já foram transferidos para esta Ordem de Serviço.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Quaisquer outras observações, dignas de serem mencionadas, que devem ir para os registos."
+DocType: Bank Account,Company Account,Conta da empresa
 DocType: Asset Maintenance,Manufacturing User,Utilizador de Fabrico
 DocType: Purchase Invoice,Raw Materials Supplied,Matérias-primas Fornecidas
 DocType: Subscription Plan,Payment Plan,Plano de pagamento
@@ -7143,6 +7175,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) não pode ser maior que a quantidade planejada ({2}) na Ordem de Serviço {3}
 DocType: Certification Application,Name of Applicant,Nome do requerente
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Folha de Presença de fabrico.
+DocType: Quick Stock Balance,Quick Stock Balance,Balanço Rápido de Ações
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Subtotal
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Não é possível alterar as propriedades da Variante após a transação de estoque. Você terá que fazer um novo item para fazer isso.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,Mandato SEPA GoCardless
@@ -7471,6 +7504,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} é estudante inativo
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} é estudante inativo
 DocType: Employee,Health Details,Dados Médicos
+DocType: Coupon Code,Coupon Type,Tipo de Cupom
 DocType: Leave Encashment,Encashable days,Dias encapsulados
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Para criar um documento de referência de Pedido de pagamento é necessário
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Para criar um documento de referência de Pedido de pagamento é necessário
@@ -7758,6 +7792,7 @@
 DocType: Hotel Room Package,Amenities,Facilidades
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Buscar automaticamente condições de pagamento
 DocType: QuickBooks Migrator,Undeposited Funds Account,Conta de fundos não depositados
+DocType: Coupon Code,Uses,Usos
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,O modo de pagamento padrão múltiplo não é permitido
 DocType: Sales Invoice,Loyalty Points Redemption,Resgate de pontos de fidelidade
 ,Appointment Analytics,Análise de nomeação
@@ -7774,6 +7809,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Orçamento total
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Deixe em branco se você fizer grupos de alunos por ano
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Se for selecionado, o nr. Total de Dias de Úteis incluirá os feriados, e isto irá reduzir o valor do Salário Por Dia"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Falha ao adicionar domínio
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Para permitir o recebimento / entrega excedente, atualize &quot;Recebimento em excesso / Fornecimento de remessa&quot; em Configurações de estoque ou no Item."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Aplicativos que usam a chave atual não poderão acessar, tem certeza?"
 DocType: Subscription Settings,Prorate,Proporcionado
@@ -7787,6 +7823,7 @@
 ,BOM Stock Report,Relatório de stock da LDM
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Se não houver período de atividade atribuído, a comunicação será tratada por este grupo"
 DocType: Stock Reconciliation Item,Quantity Difference,Diferença de Quantidade
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Fornecedor&gt; Tipo de fornecedor
 DocType: Opportunity Item,Basic Rate,Taxa Básica
 DocType: GL Entry,Credit Amount,Montante de Crédito
 ,Electronic Invoice Register,Registro de fatura eletrônica
@@ -8041,6 +8078,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Impostos e Taxas Deduzidos (Moeda da Empresa)
 DocType: Item Group,General Settings,Definições Gerais
 DocType: Article,Article,Artigo
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Digite o código do cupom !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,A Moeda De e Para não pode ser igual
 DocType: Taxable Salary Slab,Percent Deduction,Dedução Percentual
 DocType: GL Entry,To Rename,Renomear
diff --git a/erpnext/translations/pt_br.csv b/erpnext/translations/pt_br.csv
index 9d5c191..9c029e4 100644
--- a/erpnext/translations/pt_br.csv
+++ b/erpnext/translations/pt_br.csv
@@ -57,7 +57,7 @@
 DocType: Job Opening,Job Title,Cargo
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Investment Banking,Investimento Bancário
 DocType: BOM,Item UOM,Unidade de Medida do Item
-DocType: Pricing Rule,Pricing Rule,Regra de Preços
+DocType: Coupon Code,Pricing Rule,Regra de Preços
 DocType: Item Customer Detail,Item Customer Detail,Detalhe do Cliente do Item
 apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Asset {0} must be submitted,O Ativo {0} deve ser enviado
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work-in-Progress Warehouse is required before Submit,Armazén de Trabalho em Andamento é necessário antes de Enviar
@@ -2032,6 +2032,7 @@
 DocType: Journal Entry Account,If Income or Expense,Se é Receita ou Despesa
 apps/erpnext/erpnext/controllers/accounts_controller.py,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Linha #{0}: A qtde deve ser 1, pois o item é um ativo imobilizado. Por favor, utilize uma linha separada para múltiplas qtdes."
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Please enter company first,Por favor insira primeira empresa
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Criar fatura de compra
 DocType: Price List,Applicable for Countries,Aplicável para os Países
 DocType: Landed Cost Voucher,Additional Charges,Encargos Adicionais
 DocType: Delivery Note Item,Against Sales Invoice,Contra a Fatura de Venda
diff --git a/erpnext/translations/ro.csv b/erpnext/translations/ro.csv
index b76120d..bfa5f57 100644
--- a/erpnext/translations/ro.csv
+++ b/erpnext/translations/ro.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Clientul A lua legatura
 DocType: Shift Type,Enable Auto Attendance,Activați prezența automată
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Vă rugăm să introduceți Depozitul și data
 DocType: Lost Reason Detail,Opportunity Lost Reason,Motivul pierdut din oportunitate
 DocType: Patient Appointment,Check availability,Verifică Disponibilitate
 DocType: Retention Bonus,Bonus Payment Date,Data de plată Bonus
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Ordine de lucru finalizate
 DocType: Support Settings,Forum Posts,Mesaje pe forum
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Sarcina a fost considerată ca o lucrare de fond. În cazul în care există vreo problemă cu privire la procesare în fundal, sistemul va adăuga un comentariu despre eroarea la această reconciliere a stocului și va reveni la etapa de proiectare."
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Ne pare rău, validitatea codului cupon nu a început"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Sumă impozabilă
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Nu ești autorizat să adăugi sau să actualizezi intrări înainte de {0}
 DocType: Leave Policy,Leave Policy Details,Lăsați detaliile politicii
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Consumabile
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,calitate
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Cod articol&gt; Grup de articole&gt; Marcă
 DocType: Restaurant Table,No of Seats,Numărul de scaune
 DocType: Sales Invoice,Overdue and Discounted,Întârziat și redus
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Apel deconectat
@@ -507,6 +510,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,distanța dintre rânduri pentru suma în cuvinte
 DocType: Vehicle,Additional Details,Detalii suplimentare
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Nici o descriere dat
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Obține obiecte de la Depozit
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Cerere de achizitie.
 DocType: POS Closing Voucher Details,Collected Amount,Suma colectată
 DocType: Lab Test,Submitted Date,Data transmisă
@@ -614,6 +618,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Învață
 ,Trial Balance (Simple),Soldul de încercare (simplu)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Activați cheltuielile amânate
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Codul cuponului aplicat
 DocType: Asset,Next Depreciation Date,Data următoarei amortizări
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Cost activitate per angajat
 DocType: Accounts Settings,Settings for Accounts,Setări pentru conturi
@@ -854,8 +859,6 @@
 DocType: Sales Invoice,Total Qty,Raport Cantitate
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Codul de e-mail Guardian2
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Codul de e-mail Guardian2
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Vă rugăm să ștergeți Angajatul <a href=""#Form/Employee/{0}"">{0}</a> \ pentru a anula acest document"
 DocType: Item,Show in Website (Variant),Afișați în site-ul (Variant)
 DocType: Employee,Health Concerns,Probleme de Sanatate
 DocType: Payroll Entry,Select Payroll Period,Perioada de selectare Salarizare
@@ -1021,6 +1024,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Contul de reținere fiscală
 DocType: Pricing Rule,Sales Partner,Partener de Vânzări
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Toate cardurile de evaluare ale furnizorilor.
+DocType: Coupon Code,To be used to get discount,Pentru a fi folosit pentru a obține reducere
 DocType: Buying Settings,Purchase Receipt Required,Cumpărare de primire Obligatoriu
 DocType: Sales Invoice,Rail,șină
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Costul actual
@@ -1071,6 +1075,7 @@
 DocType: Production Plan,Production Plan,Plan de productie
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Deschiderea Instrumentului de creare a facturilor
 DocType: Salary Component,Round to the Nearest Integer,Rotund la cel mai apropiat număr întreg
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Permiteți adăugarea în coș a articolelor care nu sunt în stoc
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Vânzări de returnare
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Setați cantitatea din tranzacții pe baza numărului de intrare sir
 ,Total Stock Summary,Rezumatul Total al Stocului
@@ -1202,6 +1207,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Rata de bază ore (companie Moneda)
 ,Qty To Be Billed,Cantitate de a fi plătită
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Suma Pronunțată
+DocType: Coupon Code,Gift Card,Card cadou
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Cantitate rezervată pentru producție: cantitate de materii prime pentru fabricarea articolelor de fabricație.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Data de răscumpărare
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Această tranzacție bancară este deja complet reconciliată
@@ -1291,6 +1297,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Creați o foaie de lucru
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Contul {0} a fost introdus de mai multe ori
 DocType: Account,Expenses Included In Valuation,Cheltuieli Incluse în Evaluare
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Facturi de cumpărare
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Puteți reînnoi numai dacă expirați în termen de 30 de zile
 DocType: Shopping Cart Settings,Show Stock Availability,Afișați disponibilitatea stocului
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Setați {0} în categoria de active {1} sau în companie {2}
@@ -1852,6 +1859,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Importarea de articole și UOM-uri
 DocType: Repayment Schedule,Balance Loan Amount,Soldul Suma creditului
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Adăugat la detalii
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Ne pare rău, codul cuponului este epuizat"
 DocType: Communication Medium,Catch All,Prindele pe toate
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Curs orar
 DocType: Budget,Applicable on Material Request,Aplicabil la solicitarea materialului
@@ -2021,6 +2029,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Atribut nevalid
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} trebuie să fie introdus
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Campanii prin e-mail
+DocType: Sales Partner,To Track inbound purchase,Pentru a urmări achiziția de intrare
 DocType: Buying Settings,Default Supplier Group,Grupul prestabilit de furnizori
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Cantitatea trebuie sa fie mai mic sau egal cu {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Suma maximă eligibilă pentru componenta {0} depășește {1}
@@ -2178,8 +2187,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Faceți intrarea în stoc
 DocType: Hotel Room Reservation,Hotel Reservation User,Utilizator rezervare hotel
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Setați starea
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Vă rugăm să configurați seria de numerotare pentru prezență prin Setare&gt; Numerotare
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Vă rugăm să selectați prefix întâi
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Vă rugăm să setați Naming Series pentru {0} prin Setare&gt; Setări&gt; Serie pentru denumire
 DocType: Contract,Fulfilment Deadline,Termenul de îndeplinire
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Lângă tine
 DocType: Student,O-,O-
@@ -2305,6 +2314,7 @@
 DocType: Quality Meeting Table,Under Review,În curs de revizuire
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Eroare la autentificare
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Asset {0} a fost creat
+DocType: Coupon Code,Promotional,promoționale
 DocType: Special Test Items,Special Test Items,Elemente speciale de testare
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Trebuie să fiți utilizator cu funcții Manager Manager și Manager de posturi pentru a vă înregistra pe Marketplace.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Rapoarte cheie
@@ -2342,6 +2352,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Tip Doc
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Procentul total alocat pentru echipa de vânzări ar trebui să fie de 100
 DocType: Subscription Plan,Billing Interval Count,Intervalul de facturare
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Vă rugăm să ștergeți Angajatul <a href=""#Form/Employee/{0}"">{0}</a> \ pentru a anula acest document"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Numiri și întâlniri cu pacienții
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Valoarea lipsește
 DocType: Employee,Department and Grade,Departamentul și Gradul
@@ -2445,6 +2457,7 @@
 DocType: Project,Start and End Dates,Începere și de încheiere Date
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Termenii de îndeplinire a modelului de contract
 ,Delivered Items To Be Billed,Produse Livrate Pentru a fi Facturate
+DocType: Coupon Code,Maximum Use,Utilizare maximă
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Deschideți BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Depozit nu poate fi schimbat pentru Serial No.
 DocType: Authorization Rule,Average Discount,Discount mediiu
@@ -2607,6 +2620,7 @@
 DocType: Item,Inventory,Inventarierea
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Descărcați ca Json
 DocType: Item,Sales Details,Detalii Vânzări
+DocType: Coupon Code,Used,Folosit
 DocType: Opportunity,With Items,Cu articole
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Campania „{0}” există deja pentru {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Echipă de Mentenanță
@@ -2736,7 +2750,7 @@
 						Serial No cannot be ensured",Nu a fost găsit niciun BOM activ pentru articolul {0}. Livrarea prin \ Nr. De serie nu poate fi asigurată
 DocType: Sales Partner,Sales Partner Target,Vânzări Partner țintă
 DocType: Loan Type,Maximum Loan Amount,Suma maximă a împrumutului
-DocType: Pricing Rule,Pricing Rule,Regula de stabilire a prețurilor
+DocType: Coupon Code,Pricing Rule,Regula de stabilire a prețurilor
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Numărul de rolă duplicat pentru student {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Numărul de rolă duplicat pentru student {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Cerere de material de cumpărare Ordine
@@ -2817,6 +2831,7 @@
 DocType: Payment Schedule,Payment Amount,Plata Suma
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Data de la jumătate de zi ar trebui să se afle între Data de lucru și Data de terminare a lucrului
 DocType: Healthcare Settings,Healthcare Service Items,Servicii medicale
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Cod de bare nevalid. Nu există niciun articol atașat acestui cod de bare.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Consumat Suma
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Schimbarea net în numerar
 DocType: Assessment Plan,Grading Scale,Scala de notare
@@ -2938,7 +2953,6 @@
 DocType: Share Transfer,Asset Account,Cont de active
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Noua dată a lansării ar trebui să fie în viitor
 DocType: Purchase Invoice,End date of current invoice's period,Data de încheiere a perioadei facturii curente
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Vă rugăm să configurați sistemul de numire a angajaților în resurse umane&gt; Setări HR
 DocType: Lab Test,Technician Name,Numele tehnicianului
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3050,6 +3064,7 @@
 DocType: Products Settings,Hide Variants,Ascundeți variantele
 DocType: Lead,Next Contact By,Următor Contact Prin
 DocType: Compensatory Leave Request,Compensatory Leave Request,Solicitare de plecare compensatorie
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Nu se poate depăși pentru articolul {0} din rândul {1} mai mult decât {2}. Pentru a permite supra-facturarea, vă rugăm să setați alocația în Setările conturilor"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Cantitatea necesară pentru postul {0} în rândul {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Depozit {0} nu poate fi ștearsă ca exista cantitate pentru postul {1}
 DocType: Blanket Order,Order Type,Tip comandă
@@ -3222,7 +3237,6 @@
 DocType: Student,Student Mobile Number,Elev Număr mobil
 DocType: Item,Has Variants,Are variante
 DocType: Employee Benefit Claim,Claim Benefit For,Revendicați beneficiul pentru
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Nu puteți suprascrie pentru articolul {0} pe rândul {1} mai mult de {2}. Pentru a permite facturarea excesivă, vă rugăm să setați Setări stoc"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Actualizați răspunsul
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Ați selectat deja un produs de la {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Numele de Distributie lunar
@@ -3515,6 +3529,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Vă rugăm să specificați în valută companie
 DocType: Workstation,Wages per hour,Salarii pe oră
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Configurare {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Client&gt; Grup de clienți&gt; Teritoriul
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},echilibru stoc în Serie {0} va deveni negativ {1} pentru postul {2} la Depozitul {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Ca urmare a solicitărilor de materiale au fost ridicate în mod automat în funcție de nivelul de re-comanda item
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Contul {0} nu este valid. Valuta contului trebuie să fie {1}
@@ -3847,6 +3862,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Prezenta Salariul Slip
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,In asteptare
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,O chestiune trebuie să aibă cel puțin o opțiune corectă
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Ordine de achiziție
 DocType: Account,Inter Company Account,Contul Companiei Inter
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Importare în masă
 DocType: Sales Partner,Address & Contacts,Adresă şi contacte
@@ -3857,6 +3873,7 @@
 DocType: POS Profile,[Select],[Selectati]
 DocType: Staffing Plan Detail,Number Of Positions,Numărul de poziții
 DocType: Vital Signs,Blood Pressure (diastolic),Tensiunea arterială (diastolică)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Vă rugăm să selectați clientul.
 DocType: SMS Log,Sent To,Trimis La
 DocType: Agriculture Task,Holiday Management,Gestionarea concediului
 DocType: Payment Request,Make Sales Invoice,Faceți Factură de Vânzare
@@ -4066,7 +4083,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} nu este introdus
 DocType: Subscription,Trialling,experimentării
 DocType: Sales Invoice Item,Deferred Revenue,Venituri amânate
-DocType: Bank Account,GL Account,Cont GL
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Contul de numerar va fi utilizat pentru crearea facturii de vânzări
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Scutirea subcategoria
 DocType: Member,Membership Expiry Date,Data expirării membrilor
@@ -4492,13 +4508,13 @@
 DocType: C-Form Invoice Detail,Territory,Teritoriu
 DocType: Pricing Rule,Apply Rule On Item Code,Aplicați regula pe codul articolului
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Vă rugăm să menționați nici de vizite necesare
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Raportul soldului stocurilor
 DocType: Stock Settings,Default Valuation Method,Metoda de Evaluare Implicită
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,taxă
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Afișați suma cumulată
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Actualizare în curs. Ar putea dura ceva timp.
 DocType: Production Plan Item,Produced Qty,Cantitate produsă
 DocType: Vehicle Log,Fuel Qty,combustibil Cantitate
-DocType: Stock Entry,Target Warehouse Name,Nume destinație depozit
 DocType: Work Order Operation,Planned Start Time,Planificate Ora de începere
 DocType: Course,Assessment,Evaluare
 DocType: Payment Entry Reference,Allocated,Alocat
@@ -4576,10 +4592,12 @@
  1. Modalitati de litigii de adresare, indemnizație, răspunderea, etc. 
  1. Adresa și de contact ale companiei."
 DocType: Homepage Section,Section Based On,Secțiune bazată pe
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Afișați Aplicați codul de cupon
 DocType: Issue,Issue Type,Tipul problemei
 DocType: Attendance,Leave Type,Tip Concediu
 DocType: Purchase Invoice,Supplier Invoice Details,Furnizor Detalii factură
 DocType: Agriculture Task,Ignore holidays,Ignorați sărbătorile
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Adăugați / Editați Condițiile cuponului
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Cheltuială cont / Diferența ({0}) trebuie să fie un cont de ""profit sau pierdere"""
 DocType: Stock Entry Detail,Stock Entry Child,Copil de intrare în stoc
 DocType: Project,Copied From,Copiat de la
@@ -4754,6 +4772,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Criterii Plan de evaluare
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,tranzacţii
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Împiedicați comenzile de achiziție
+DocType: Coupon Code,Coupon Name,Numele cuponului
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Susceptibil
 DocType: Email Campaign,Scheduled,Programat
 DocType: Shift Type,Working Hours Calculation Based On,Calculul orelor de lucru bazat pe
@@ -4770,7 +4789,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Creați Variante
 DocType: Vehicle,Diesel,Diesel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Lista de pret Valuta nu selectat
+DocType: Quick Stock Balance,Available Quantity,Cantitate Disponibilă
 DocType: Purchase Invoice,Availed ITC Cess,Avansat ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Vă rugăm să configurați sistemul de numire a instructorului în educație&gt; Setări educație
 ,Student Monthly Attendance Sheet,Elev foaia de prezență lunară
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Regulă de expediere aplicabilă numai pentru vânzare
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Rata de amortizare {0}: data următoare a amortizării nu poate fi înainte de data achiziției
@@ -4838,8 +4859,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Row {0}: avans Clientul trebuie să fie de credit
 DocType: Quality Meeting,Quality Meeting,Întâlnire de calitate
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-Grup la Grup
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Vă rugăm să setați Naming Series pentru {0} prin Setare&gt; Setări&gt; Serie pentru denumire
 DocType: Employee,ERPNext User,Utilizator ERPNext
+DocType: Coupon Code,Coupon Description,Descrierea cuponului
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Lotul este obligatoriu în rândul {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Lotul este obligatoriu în rândul {0}
 DocType: Company,Default Buying Terms,Condiții de cumpărare implicite
@@ -5004,6 +5025,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Comparativ detaliilor documentului nr.
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Ștergerea nu este permisă pentru țara {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Tipul de partid este obligatorie
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Aplicați codul promoțional
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","Pentru cartea de muncă {0}, puteți înscrie doar stocul de tip „Transfer de material pentru fabricare”"
 DocType: Quality Inspection,Outgoing,Trimise
 DocType: Customer Feedback Table,Customer Feedback Table,Tabelul de feedback al clienților
@@ -5155,7 +5177,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,La trimiterea comenzii de cumpărare
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Adăugați toți furnizorii
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Rândul # {0}: Suma alocată nu poate fi mai mare decât suma rămasă.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Client&gt; Grup de clienți&gt; Teritoriul
 DocType: Tally Migration,Parties,Petreceri
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Navigare BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Împrumuturi garantate
@@ -5187,7 +5208,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Nu permiteți setarea unui element alternativ pentru articolul {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Data se repetă
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Semnatar autorizat
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Vă rugăm să configurați sistemul de denumire a instructorului în educație&gt; Setări educație
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),ITC net disponibil (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Creați taxe
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Cost total de achiziție (prin cumparare factură)
@@ -5212,6 +5232,7 @@
 DocType: Quiz Result,Wrong,Gresit
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Rata la care lista de prețuri moneda este convertit în valuta de bază a clientului
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Suma netă (companie de valuta)
+DocType: Sales Partner,Referral Code,Codul de recomandare
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Suma avansului total nu poate fi mai mare decât suma totală sancționată
 DocType: Salary Slip,Hour Rate,Rata Oră
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Activați re-comanda automată
@@ -5342,6 +5363,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Afișați cantitatea stocului
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Numerar net din operațiuni
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Rândul # {0}: starea trebuie să fie {1} pentru reducerea facturilor {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Factorul de conversie UOM ({0} -&gt; {1}) nu a fost găsit pentru articol: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Punctul 4
 DocType: Student Admission,Admission End Date,Data de încheiere Admiterii
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Sub-contractare
@@ -5364,6 +5386,7 @@
 DocType: Travel Request,Fully Sponsored,Sponsorizat complet
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Intrare în jurnal invers
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Creați carte de muncă
+DocType: Quotation,Referral Sales Partner,Partener de vânzări de recomandări
 DocType: Quality Procedure Process,Process Description,Descrierea procesului
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Clientul {0} este creat.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,În prezent nu există stoc disponibil în niciun depozit
@@ -5498,6 +5521,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,Rată BOM
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Citind fișierul încărcat
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Oprirea comenzii de lucru nu poate fi anulată, deblocați mai întâi pentru a anula"
+DocType: Coupon Code,Coupon Code,Codul promoțional
 DocType: Asset,Journal Entry for Scrap,Intrare Jurnal pentru Deșeuri
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Vă rugăm să trage elemente de livrare Nota
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Rând {0}: selectați stația de lucru pentru operația {1}
@@ -5581,6 +5605,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,„Data” este necesară
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Datorită / Reference Data nu poate fi după {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Datele de import și export
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Ne pare rău, validitatea codului cuponului a expirat"
 DocType: Bank Account,Account Details,Detalii cont
 DocType: Crop,Materials Required,Materiale necesare
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Nu există elevi găsit
@@ -5618,6 +5643,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Accesați Utilizatori
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Suma plătită + Scrie Off Suma nu poate fi mai mare decât Grand total
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} nu este un număr de lot valid aferent articolului {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Vă rugăm să introduceți un cod valabil pentru cupon !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Notă: Nu este echilibrul concediu suficient pentru concediul de tip {0}
 DocType: Task,Task Description,Descrierea sarcinii
 DocType: Training Event,Seminar,Seminar
@@ -5885,6 +5911,7 @@
 ,TDS Payable Monthly,TDS plătibil lunar
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,În așteptare pentru înlocuirea BOM. Ar putea dura câteva minute.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Nu se poate deduce când categoria este de 'Evaluare' sau 'Evaluare și total'
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Vă rugăm să configurați sistemul de numire a angajaților în resurse umane&gt; Setări HR
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Total plăți
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serial nr necesare pentru postul serializat {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Plățile se potrivesc cu facturi
@@ -5975,6 +6002,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Obțineți materii prime pentru producție
 DocType: Job Opening,Job Title,Denumire Post
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Plată viitoare Ref
+DocType: Quotation,Additional Discount and Coupon Code,Cod suplimentar de reducere și cupon
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} indică faptul că {1} nu va oferi o cotație, dar toate articolele \ au fost cotate. Se actualizează statusul cererii de oferta."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Probele maxime - {0} au fost deja reținute pentru lotul {1} și articolul {2} din lotul {3}.
@@ -6204,7 +6232,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Setările pentru pagina de start site-ul web
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} este în așteptare până la {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},CV-urile nu sunt permise pentru {0} datorită unui punctaj din {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Realizeaza Factura de Cumparare
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Frunze utilizate
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Cuponul utilizat este {1}. Cantitatea admisă este epuizată
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Doriți să trimiteți solicitarea materialului
 DocType: Job Offer,Awaiting Response,Se aşteaptă răspuns
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6218,6 +6248,7 @@
 DocType: Training Event Employee,Optional,facultativ
 DocType: Salary Slip,Earning & Deduction,Câștig Salarial si Deducere
 DocType: Agriculture Analysis Criteria,Water Analysis,Analiza apei
+DocType: Sales Order,Skip Delivery Note,Salt nota de livrare
 DocType: Price List,Price Not UOM Dependent,Pretul nu este dependent de UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} variante create.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Există deja un Acord de nivel de serviciu implicit.
@@ -6326,6 +6357,7 @@
 DocType: Vehicle,Last Carbon Check,Ultima Verificare carbon
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Cheltuieli Juridice
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Selectați cantitatea pe rând
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Comandă de lucru {0}: cartea de muncă nu a fost găsită pentru operație {1}
 DocType: Purchase Invoice,Posting Time,Postarea de timp
 DocType: Timesheet,% Amount Billed,% Suma facturata
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Cheltuieli de telefon
@@ -6428,7 +6460,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Impozite și Taxe Added
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Rândul de amortizare {0}: Data următoarei amortizări nu poate fi înaintea datei disponibile pentru utilizare
 ,Sales Funnel,Pâlnie Vânzări
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Cod articol&gt; Grup de articole&gt; Marcă
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Abreviere este obligatorie
 DocType: Project,Task Progress,Progresul sarcină
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Coș
@@ -6525,6 +6556,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS Profil necesare pentru a face POS intrare
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Punctele de loialitate vor fi calculate din suma cheltuită (prin factura de vânzare), pe baza factorului de colectare menționat."
 DocType: Program Enrollment Tool,Enroll Students,Studenți Enroll
+DocType: Pricing Rule,Coupon Code Based,Bazat pe codul cuponului
 DocType: Company,HRA Settings,Setări HRA
 DocType: Homepage,Hero Section,Secția Eroilor
 DocType: Employee Transfer,Transfer Date,Data transferului
@@ -6641,6 +6673,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Filtru filtru de companie gol dacă grupul de grup este &quot;companie&quot;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Dată postare nu poate fi data viitoare
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: Serial No {1} nu se potrivește cu {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Vă rugăm să configurați seria de numerotare pentru prezență prin Setare&gt; Numerotare
 DocType: Stock Entry,Target Warehouse Address,Adresa de destinație a depozitului
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Concediu Aleator
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,Timpul înainte de ora de începere a schimbului în timpul căruia se consideră check-in-ul angajaților pentru participare.
@@ -6675,7 +6708,6 @@
 DocType: Employee Grade,Employee Grade,Clasa angajaților
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Muncă în acord
 DocType: GSTR 3B Report,June,iunie
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Furnizor&gt; Tip furnizor
 DocType: Share Balance,From No,De la nr
 DocType: Shift Type,Early Exit Grace Period,Perioada de grație de ieșire timpurie
 DocType: Task,Actual Time (in Hours),Timpul efectiv (în ore)
@@ -6961,7 +6993,6 @@
 DocType: Warehouse,Warehouse Name,Denumire Depozit
 DocType: Naming Series,Select Transaction,Selectați Transaction
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Vă rugăm să introduceți Aprobarea Rolul sau aprobarea de utilizare
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Factorul de conversie UOM ({0} -&gt; {1}) nu a fost găsit pentru articol: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Acordul privind nivelul serviciului cu tipul de entitate {0} și entitatea {1} există deja.
 DocType: Journal Entry,Write Off Entry,Amortizare intrare
 DocType: BOM,Rate Of Materials Based On,Rate de materiale bazate pe
@@ -7100,6 +7131,7 @@
 DocType: Budget,Warn,Avertiza
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Toate articolele au fost deja transferate pentru această comandă de lucru.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Orice alte observații, efort remarcabil care ar trebui înregistrate."
+DocType: Bank Account,Company Account,Contul companiei
 DocType: Asset Maintenance,Manufacturing User,Producție de utilizare
 DocType: Purchase Invoice,Raw Materials Supplied,Materii prime furnizate
 DocType: Subscription Plan,Payment Plan,Plan de plată
@@ -7141,6 +7173,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) nu poate fi mai mare decât cantitatea planificată ({2}) din Ordinul de Lucru {3}
 DocType: Certification Application,Name of Applicant,Numele aplicantului
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Fișa de timp pentru fabricație.
+DocType: Quick Stock Balance,Quick Stock Balance,Soldul rapid al stocurilor
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,subtotală
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Nu se pot modifica proprietățile Variant după tranzacția stoc. Va trebui să faceți un nou element pentru a face acest lucru.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless Mandatul SEPA
@@ -7469,6 +7502,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} este student inactiv
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} este elev inactiv
 DocType: Employee,Health Details,Detalii Sănătate
+DocType: Coupon Code,Coupon Type,Tip cupon
 DocType: Leave Encashment,Encashable days,Zile încorporate
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Pentru a crea un document de referință privind solicitarea de plată este necesar
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Pentru a crea un document de referință privind solicitarea de plată este necesar
@@ -7757,6 +7791,7 @@
 DocType: Hotel Room Package,Amenities,dotări
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Obțineți automat Termenii de plată
 DocType: QuickBooks Migrator,Undeposited Funds Account,Contul fondurilor nedeclarate
+DocType: Coupon Code,Uses,utilizări
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Modul implicit de plată multiple nu este permis
 DocType: Sales Invoice,Loyalty Points Redemption,Răscumpărarea punctelor de loialitate
 ,Appointment Analytics,Analiza programării
@@ -7773,6 +7808,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Buget total
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Lăsați necompletat dacă faceți grupuri de elevi pe an
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","In cazul in care se bifeaza, nr. total de zile lucratoare va include si sarbatorile, iar acest lucru va reduce valoarea Salariul pe Zi"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Nu a putut adăuga Domeniul
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Pentru a permite primirea / livrarea, actualizați „Indemnizația de primire / livrare” în Setări de stoc sau articol."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Aplicațiile care utilizează cheia curentă nu vor putea accesa, sunteți sigur?"
 DocType: Subscription Settings,Prorate,Prorate
@@ -7786,6 +7822,7 @@
 ,BOM Stock Report,BOM Raport stoc
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Dacă nu există un interval de timp alocat, comunicarea va fi gestionată de acest grup"
 DocType: Stock Reconciliation Item,Quantity Difference,cantitate diferenţă
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Furnizor&gt; Tip furnizor
 DocType: Opportunity Item,Basic Rate,Rată elementară
 DocType: GL Entry,Credit Amount,Suma de credit
 ,Electronic Invoice Register,Registrul electronic al facturilor
@@ -8040,6 +8077,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Impozite și taxe deduse (Compania de valuta)
 DocType: Item Group,General Settings,Setări generale
 DocType: Article,Article,Articol
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Vă rugăm să introduceți codul promoțional !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Din Valuta și In Valuta nu pot fi identice
 DocType: Taxable Salary Slab,Percent Deduction,Deducție procentuală
 DocType: GL Entry,To Rename,Pentru a redenumi
diff --git a/erpnext/translations/ru.csv b/erpnext/translations/ru.csv
index 981d9ff..3d40fa5 100644
--- a/erpnext/translations/ru.csv
+++ b/erpnext/translations/ru.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Контакты с клиентами
 DocType: Shift Type,Enable Auto Attendance,Включить автоматическое посещение
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,"Пожалуйста, введите Склад и Дата"
 DocType: Lost Reason Detail,Opportunity Lost Reason,Возможность потерянной причины
 DocType: Patient Appointment,Check availability,Проверить наличие свободных мест
 DocType: Retention Bonus,Bonus Payment Date,Дата выплаты бонуса
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Завершенные рабочие задания
 DocType: Support Settings,Forum Posts,Сообщения форума
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage",Задача была поставлена в качестве фонового задания. В случае возникновения каких-либо проблем с обработкой в фоновом режиме система добавит комментарий об ошибке в этой сверке запасов и вернется к этапу черновика.
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Извините, срок действия кода купона еще не начался"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Налогооблагаемая сумма
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},"Вы не авторизованы, чтобы добавлять или обновлять записи ранее {0}"
 DocType: Leave Policy,Leave Policy Details,Оставьте сведения о политике
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Потребляемый
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,Класс
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Код товара&gt; Группа товаров&gt; Марка
 DocType: Restaurant Table,No of Seats,Количество мест
 DocType: Sales Invoice,Overdue and Discounted,Просроченный и со скидкой
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Вызов отключен
@@ -507,6 +510,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Интервал между строками на сумму в словах
 DocType: Vehicle,Additional Details,дополнительные детали
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Не введено описание
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Получить товары со склада
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Заявка на закупку.
 DocType: POS Closing Voucher Details,Collected Amount,Собранная сумма
 DocType: Lab Test,Submitted Date,Дата отправки
@@ -614,6 +618,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Справка
 ,Trial Balance (Simple),Пробный баланс (простой)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Включить отложенные расходы
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Прикладной код купона
 DocType: Asset,Next Depreciation Date,Следующий Износ Дата
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Деятельность Стоимость одного работника
 DocType: Accounts Settings,Settings for Accounts,Настройки для счетов
@@ -854,8 +859,6 @@
 DocType: Sales Invoice,Total Qty,Всего Кол-во
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Идентификатор электронной почты Guardian2
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Идентификатор электронной почты Guardian2
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Пожалуйста, удалите Сотрудника <a href=""#Form/Employee/{0}"">{0}</a> \, чтобы отменить этот документ"
 DocType: Item,Show in Website (Variant),Показать в веб-сайт (вариант)
 DocType: Employee,Health Concerns,Проблемы здоровья
 DocType: Payroll Entry,Select Payroll Period,Выберите Период начисления заработной платы
@@ -1021,6 +1024,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Удержание налога
 DocType: Pricing Rule,Sales Partner,Партнер по продажам
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Все оценочные карточки поставщиков.
+DocType: Coupon Code,To be used to get discount,"Быть использованным, чтобы получить скидку"
 DocType: Buying Settings,Purchase Receipt Required,Покупка Получение необходимое
 DocType: Sales Invoice,Rail,рельсовый
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Действительная цена
@@ -1071,6 +1075,7 @@
 DocType: Production Plan,Production Plan,План производства
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Открытие инструмента создания счета-фактуры
 DocType: Salary Component,Round to the Nearest Integer,Округление до ближайшего целого
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,"Разрешить добавление в корзину товаров, которых нет в наличии"
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Возвраты с продаж
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Установить количество в транзакциях на основе ввода без последовательного ввода
 ,Total Stock Summary,Общая статистика запасов
@@ -1202,6 +1207,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Базовый час Rate (Компания Валюта)
 ,Qty To Be Billed,Кол-во будет выставлено
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Поставляется Сумма
+DocType: Coupon Code,Gift Card,Подарочная карта
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Зарезервированный кол-во для производства: количество сырья для изготовления изделий.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Дата погашения
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Эта банковская операция уже полностью выверена
@@ -1290,6 +1296,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Создать расписание
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Счёт {0} был введен несколько раз
 DocType: Account,Expenses Included In Valuation,"Затрат, включаемых в оценке"
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Счета на покупку
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Вы можете продлить действие только в случае истечения срока действия вашего членства в течение 30 дней
 DocType: Shopping Cart Settings,Show Stock Availability,Доступность
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Установите {0} в категории активов {1} или компании {2}
@@ -1852,6 +1859,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Импорт предметов и UOM
 DocType: Repayment Schedule,Balance Loan Amount,Баланс Сумма кредита
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Добавлено в подробности
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Извините, код купона исчерпан"
 DocType: Communication Medium,Catch All,Поймать все
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Расписание курса
 DocType: Budget,Applicable on Material Request,Применимо по запросу материала
@@ -2020,6 +2028,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Неправильный атрибут
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} должен быть проведен
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Кампании по электронной почте
+DocType: Sales Partner,To Track inbound purchase,Отслеживать входящие покупки
 DocType: Buying Settings,Default Supplier Group,Группа поставщиков по умолчанию
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Количество должно быть меньше или равно {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},"Максимальное количество, подходящее для компонента {0}, превышает {1}"
@@ -2176,8 +2185,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Сделать складской запас
 DocType: Hotel Room Reservation,Hotel Reservation User,Бронирование отеля
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Установить статус
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,"Пожалуйста, настройте серию нумерации для Посещаемости через Настройка&gt; Серия нумерации"
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,"Пожалуйста, выберите префикс первым"
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,"Пожалуйста, установите серию имен для {0} через Настройка&gt; Настройки&gt; Серия имен"
 DocType: Contract,Fulfilment Deadline,Срок выполнения
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Возле тебя
 DocType: Student,O-,О-
@@ -2301,6 +2310,7 @@
 DocType: Quality Meeting Table,Under Review,На рассмотрении
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Не удалось войти
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Объект {0} создан
+DocType: Coupon Code,Promotional,рекламный
 DocType: Special Test Items,Special Test Items,Специальные тестовые элементы
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Для регистрации на Marketplace вам необходимо быть пользователем с диспетчерами System Manager и Item Manager.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Ключевые отчеты
@@ -2339,6 +2349,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Тип документа
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Всего выделено процент для отдела продаж должен быть 100
 DocType: Subscription Plan,Billing Interval Count,Счет интервала фактурирования
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Пожалуйста, удалите Сотрудника <a href=""#Form/Employee/{0}"">{0}</a> \, чтобы отменить этот документ"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Назначения и встречи с пациентами
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Недостающее значение
 DocType: Employee,Department and Grade,Отдел и класс
@@ -2442,6 +2454,7 @@
 DocType: Project,Start and End Dates,Даты начала и окончания
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Условия заключения контрактов
 ,Delivered Items To Be Billed,"Поставленные товары, на которые нужно выписать счет"
+DocType: Coupon Code,Maximum Use,Максимальное использование
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Открыть ВОМ {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Склад не может быть изменен для серийный номер
 DocType: Authorization Rule,Average Discount,Средняя скидка
@@ -2604,6 +2617,7 @@
 DocType: Item,Inventory,Товарный запас
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Скачать как Json
 DocType: Item,Sales Details,Продажи Подробности
+DocType: Coupon Code,Used,Используемый
 DocType: Opportunity,With Items,С продуктами
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Кампания &#39;{0}&#39; уже существует для {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Группа поддержки
@@ -2733,7 +2747,7 @@
 						Serial No cannot be ensured",Для элемента {0} не найдено активной спецификации. Доставка по \ Serial No не может быть гарантирована
 DocType: Sales Partner,Sales Partner Target,Цели Партнера по продажам
 DocType: Loan Type,Maximum Loan Amount,Максимальная сумма кредита
-DocType: Pricing Rule,Pricing Rule,Цены Правило
+DocType: Coupon Code,Pricing Rule,Цены Правило
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Повторяющийся номер ролика для ученика {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Материал Заказать орденом
 DocType: Company,Default Selling Terms,Условия продажи по умолчанию
@@ -2812,6 +2826,7 @@
 DocType: Payment Schedule,Payment Amount,Сумма платежа
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Половина дня должна находиться между Работой с даты и датой окончания работы
 DocType: Healthcare Settings,Healthcare Service Items,Товары медицинского обслуживания
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Неверный штрих-код. К этому штрих-коду не прикреплено ни одного предмета.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Израсходованное количество
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Чистое изменение денежных средств
 DocType: Assessment Plan,Grading Scale,Оценочная шкала
@@ -2933,7 +2948,6 @@
 DocType: Share Transfer,Asset Account,Аккаунт активов
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Дата нового релиза должна быть в будущем
 DocType: Purchase Invoice,End date of current invoice's period,Дата и время окончания периода текущего счета-фактуры в
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Пожалуйста, настройте систему имен сотрудников в разделе «Управление персоналом»&gt; «Настройки HR»"
 DocType: Lab Test,Technician Name,Имя техника
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3045,6 +3059,7 @@
 DocType: Products Settings,Hide Variants,Скрыть варианты
 DocType: Lead,Next Contact By,Следующий контакт назначен
 DocType: Compensatory Leave Request,Compensatory Leave Request,Компенсационный отпуск
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Невозможно переплатить за элемент {0} в строке {1} более чем {2}. Чтобы разрешить перерасчет, пожалуйста, установите скидку в настройках аккаунта"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Кол-во для Пункт {0} в строке {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Склад {0} не может быть удален как существует количество для Пункт {1}
 DocType: Blanket Order,Order Type,Тип заказа
@@ -3217,7 +3232,6 @@
 DocType: Student,Student Mobile Number,Студент Мобильный телефон
 DocType: Item,Has Variants,Имеет варианты
 DocType: Employee Benefit Claim,Claim Benefit For,Требование о пособиях для
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Невозможно переопределить элемент {0} в строке {1} больше, чем {2}. Чтобы разрешить перерасчет, пожалуйста, установите в настройках запаса"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Обновить ответ
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Вы уже выбрали продукты из {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Название ежемесячное распределение
@@ -3511,6 +3525,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,"Пожалуйста, сформулируйте валюту в обществе"
 DocType: Workstation,Wages per hour,Заработная плата в час
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Настроить {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Клиент&gt; Группа клиентов&gt; Территория
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Для продукта {2} на складе {3} остатки запасов для партии {0} станут отрицательными {1}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Следующие запросы на материалы были созданы автоматически на основании минимального уровня запасов продукта
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Счёт {0} является недопустимым. Валюта счёта должна быть {1}
@@ -3844,6 +3859,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Провести Зарплатную ведомость
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,На удерживании
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,У q должно быть хотя бы одно правильное значение
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Заказы
 DocType: Account,Inter Company Account,Интер-учетная запись компании
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Импорт наливом
 DocType: Sales Partner,Address & Contacts,Адрес и контакты
@@ -3854,6 +3870,7 @@
 DocType: POS Profile,[Select],[Выберите]
 DocType: Staffing Plan Detail,Number Of Positions,Количество позиций
 DocType: Vital Signs,Blood Pressure (diastolic),артериальное давление (диастолическое)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,"Пожалуйста, выберите клиента."
 DocType: SMS Log,Sent To,Отправить
 DocType: Agriculture Task,Holiday Management,Праздничное управление
 DocType: Payment Request,Make Sales Invoice,Создать счёт
@@ -4063,7 +4080,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} не проведен
 DocType: Subscription,Trialling,возможность проверки
 DocType: Sales Invoice Item,Deferred Revenue,Отложенный доход
-DocType: Bank Account,GL Account,GL Account
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Денежный счет будет использоваться для создания счета-фактуры
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Освобождение подкатегории
 DocType: Member,Membership Expiry Date,Дата истечения срока членства
@@ -4488,13 +4504,13 @@
 DocType: C-Form Invoice Detail,Territory,Территория
 DocType: Pricing Rule,Apply Rule On Item Code,Применить правило на код товара
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,"Пожалуйста, укажите кол-во посещений, необходимых"
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Отчет об остатках на складе
 DocType: Stock Settings,Default Valuation Method,Метод оценки по умолчанию
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,плата
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Показать суммарную сумму
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Идет обновление. Это может занять некоторое время.
 DocType: Production Plan Item,Produced Qty,Произведенное количество
 DocType: Vehicle Log,Fuel Qty,Топливо Кол-во
-DocType: Stock Entry,Target Warehouse Name,Название целевого склада
 DocType: Work Order Operation,Planned Start Time,Планируемые Время
 DocType: Course,Assessment,Оценка
 DocType: Payment Entry Reference,Allocated,Выделенные
@@ -4572,10 +4588,12 @@
  1. Пути решения споров, возмещения, ответственности и т.д. 
  1. Адрес и контактная Вашей компании."
 DocType: Homepage Section,Section Based On,Раздел на основе
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Показать Применить код купона
 DocType: Issue,Issue Type,Тип вопроса
 DocType: Attendance,Leave Type,Оставьте Тип
 DocType: Purchase Invoice,Supplier Invoice Details,Подробная информация о поставщике счета
 DocType: Agriculture Task,Ignore holidays,Игнорировать праздники
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Добавить / изменить условия купона
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Расходов / Разница счет ({0}) должен быть ""прибыль или убыток» счета"
 DocType: Stock Entry Detail,Stock Entry Child,Фондовый вход ребенка
 DocType: Project,Copied From,Скопировано из
@@ -4751,6 +4769,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Критерии оценки плана
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,операции
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Запретить заказы на поставку
+DocType: Coupon Code,Coupon Name,Название купона
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,восприимчивый
 DocType: Email Campaign,Scheduled,Запланированно
 DocType: Shift Type,Working Hours Calculation Based On,Расчет рабочего времени на основе
@@ -4767,7 +4786,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Создать Варианты
 DocType: Vehicle,Diesel,дизель
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Прайс-лист Обмен не выбран
+DocType: Quick Stock Balance,Available Quantity,Доступное количество
 DocType: Purchase Invoice,Availed ITC Cess,Пользуется ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,"Пожалуйста, настройте систему имен инструкторов в «Образование»"
 ,Student Monthly Attendance Sheet,Ежемесячная посещаемость студентов
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Правило доставки применимо только для продажи
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Строка амортизации {0}: следующая дата амортизации не может быть до даты покупки
@@ -4835,8 +4856,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Ряд {0}: Предварительная отношении Клиента должен быть кредит
 DocType: Quality Meeting,Quality Meeting,Встреча качества
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-группы к группе
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,"Пожалуйста, установите серию имен для {0} через Настройка&gt; Настройки&gt; Серия имен"
 DocType: Employee,ERPNext User,Пользователь ERPNext
+DocType: Coupon Code,Coupon Description,Описание купона
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Пакет является обязательным в строке {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Пакет является обязательным в строке {0}
 DocType: Company,Default Buying Terms,Условия покупки по умолчанию
@@ -5001,6 +5022,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Против деталях документа Нет
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Для страны не разрешено удаление {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Тип партии является обязательным
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Применить код купона
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",Для карты задания {0} вы можете только сделать запись запаса типа &#39;Передача материала для производства&#39;
 DocType: Quality Inspection,Outgoing,Исходящий
 DocType: Customer Feedback Table,Customer Feedback Table,Таблица отзывов клиентов
@@ -5152,7 +5174,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,При подаче заказа на поставку
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Добавить все поставщики
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Строка # {0}: выделенная сумма не может превышать невыплаченную сумму.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Клиент&gt; Группа клиентов&gt; Территория
 DocType: Tally Migration,Parties,Стороны
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Просмотр спецификации
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Обеспеченные кредиты
@@ -5184,7 +5205,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Не разрешить установку альтернативного элемента для элемента {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Дата повторяется
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Право подписи
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,"Пожалуйста, настройте систему имен инструкторов в «Образование»&gt; «Настройки образования»"
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Чистый ITC Доступен (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Создать сборы
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Общая стоимость покупки (через счет покупки)
@@ -5209,6 +5229,7 @@
 DocType: Quiz Result,Wrong,Неправильно
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Курс по которому валюта Прайс листа конвертируется в базовую валюту покупателя
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Чистая сумма (валюта Компании)
+DocType: Sales Partner,Referral Code,Промо-код
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Общая сумма аванса не может превышать общую сумму санкций
 DocType: Salary Slip,Hour Rate,Часовой разряд
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Включить автоматический повторный заказ
@@ -5339,6 +5360,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Показывать количество запаса
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Чистые денежные средства от операционной
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Строка # {0}: статус должен быть {1} для дисконтирования счета-фактуры {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Коэффициент преобразования UOM ({0} -&gt; {1}) не найден для элемента: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Пункт 4
 DocType: Student Admission,Admission End Date,Дата окончания приёма
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Суб-сжимания
@@ -5361,6 +5383,7 @@
 DocType: Travel Request,Fully Sponsored,Полностью спонсируемый
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Обратная запись журнала
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Создать вакансию
+DocType: Quotation,Referral Sales Partner,Реферальный партнер по продажам
 DocType: Quality Procedure Process,Process Description,Описание процесса
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Клиент {0} создан.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Сейчас нет доступного запаса на складах
@@ -5495,6 +5518,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,Цена спецификации
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Чтение загруженного файла
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Прекращенный рабочий заказ не может быть отменен, отмените его сначала, чтобы отменить"
+DocType: Coupon Code,Coupon Code,код купона
 DocType: Asset,Journal Entry for Scrap,Запись в журнале для лома
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Пожалуйста вытяните продукты из транспортной накладной
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Строка {0}: выберите рабочую станцию против операции {1}
@@ -5579,6 +5603,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,Требуется дата
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Из-за / Reference Дата не может быть в течение {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Импорт и экспорт данных
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Извините, срок действия кода купона истек"
 DocType: Bank Account,Account Details,Подробности аккаунта
 DocType: Crop,Materials Required,Необходимые материалы
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Нет студентов не найдено
@@ -5616,6 +5641,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Перейти к Пользователям
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Оплаченная сумма + сумма списания не могут быть больше общего итога
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} недопустимый номер партии для продукта {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,"Пожалуйста, введите действительный код купона!"
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Примечание: Существует не хватает отпуск баланс для отпуске Тип {0}
 DocType: Task,Task Description,Описание задания
 DocType: Training Event,Seminar,Семинар
@@ -5882,6 +5908,7 @@
 ,TDS Payable Monthly,TDS Payable Monthly
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Очередь на замену спецификации. Это может занять несколько минут.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Не можете вычесть, когда категория для ""Оценка"" или ""Оценка и Всего"""
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Пожалуйста, настройте систему имен сотрудников в разделе «Управление персоналом»&gt; «Настройки HR»"
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Всего платежей
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Требуются серийные номера для серийного продукта {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Соответствие Платежи с счетов-фактур
@@ -5972,6 +5999,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Получить сырье для производства
 DocType: Job Opening,Job Title,Должность
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Будущий платеж Ref
+DocType: Quotation,Additional Discount and Coupon Code,Дополнительная скидка и код купона
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} указывает, что {1} не будет предоставлять предложение, но все позиции были оценены. Обновление статуса предложения RFQ."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Максимальные образцы - {0} уже сохранены для Batch {1} и Item {2} в пакете {3}.
@@ -6201,7 +6229,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Настройки для сайта домашнюю страницу
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} выполняется до {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},"Запросы не допускаются для {0} из-за того, что значение показателя {1}"
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Сделать счете-фактуре
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Используемые листы
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,Использован {0} купон: {1}. Допустимое количество исчерпано
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Вы хотите отправить материальный запрос
 DocType: Job Offer,Awaiting Response,В ожидании ответа
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6215,6 +6245,7 @@
 DocType: Training Event Employee,Optional,Необязательный
 DocType: Salary Slip,Earning & Deduction,Заработок & Вычет
 DocType: Agriculture Analysis Criteria,Water Analysis,Анализ воды
+DocType: Sales Order,Skip Delivery Note,Пропустить накладную
 DocType: Price List,Price Not UOM Dependent,Цена не зависит от UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,Созданы варианты {0}.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Соглашение об уровне обслуживания по умолчанию уже существует.
@@ -6322,6 +6353,7 @@
 DocType: Vehicle,Last Carbon Check,Последний Carbon Проверить
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Судебные издержки
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Выберите количество в строке
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Заказ на работу {0}: карточка задания не найдена для операции {1}
 DocType: Purchase Invoice,Posting Time,Время публикации
 DocType: Timesheet,% Amount Billed,% Сумма счета
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Телефон Расходы
@@ -6424,7 +6456,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Налоги и сборы добавлены
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,"Строка амортизации {0}: следующая дата амортизации не может быть до даты, доступной для использования"
 ,Sales Funnel,Воронка продаж
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Код товара&gt; Группа товаров&gt; Марка
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Сокращение является обязательным
 DocType: Project,Task Progress,Готовность задачи
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Тележка
@@ -6521,6 +6552,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,"POS-профиля требуется, чтобы сделать запись POS"
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",Точки лояльности будут рассчитываться исходя из проведенного (с помощью счета-фактуры) на основе упомянутого коэффициента сбора.
 DocType: Program Enrollment Tool,Enroll Students,зачислить студентов
+DocType: Pricing Rule,Coupon Code Based,Код купона
 DocType: Company,HRA Settings,Настройки HRA
 DocType: Homepage,Hero Section,Раздел героя
 DocType: Employee Transfer,Transfer Date,Дата передачи
@@ -6637,6 +6669,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',"Пожалуйста, установите фильтр компании blank, если Group By является «Company»"
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Дата размещения не может быть будущая дата
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},"Ряд # {0}: Серийный номер {1}, не соответствует {2} {3}"
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,"Пожалуйста, настройте серию нумерации для Посещаемости через Настройка&gt; Серия нумерации"
 DocType: Stock Entry,Target Warehouse Address,Адрес целевого склада
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Повседневная Оставить
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,"Время до начала смены, в течение которого регистрация сотрудников рассматривается для посещения."
@@ -6671,7 +6704,6 @@
 DocType: Employee Grade,Employee Grade,Уровень персонала
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Сдельная работа
 DocType: GSTR 3B Report,June,июнь
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Поставщик&gt; Тип поставщика
 DocType: Share Balance,From No,От Нет
 DocType: Shift Type,Early Exit Grace Period,Льготный период раннего выхода
 DocType: Task,Actual Time (in Hours),Фактическое время (в часах)
@@ -6958,7 +6990,6 @@
 DocType: Warehouse,Warehouse Name,Название склада
 DocType: Naming Series,Select Transaction,Выберите операцию
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,"Пожалуйста, введите утверждении роли или утверждении Пользователь"
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Коэффициент преобразования UOM ({0} -&gt; {1}) не найден для элемента: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Соглашение об уровне обслуживания с типом объекта {0} и объектом {1} уже существует.
 DocType: Journal Entry,Write Off Entry,Списание запись
 DocType: BOM,Rate Of Materials Based On,Оценить материалов на основе
@@ -7097,6 +7128,7 @@
 DocType: Budget,Warn,Важно
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Все продукты уже переведены для этого Заказа.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Любые другие замечания, отметить усилия, которые должны идти в записях."
+DocType: Bank Account,Company Account,Аккаунт компании
 DocType: Asset Maintenance,Manufacturing User,Сотрудник производства
 DocType: Purchase Invoice,Raw Materials Supplied,Поставка сырья
 DocType: Subscription Plan,Payment Plan,Платежный план
@@ -7138,6 +7170,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) не может быть больше запланированного количества ({2}) в рабочем порядке {3}
 DocType: Certification Application,Name of Applicant,Имя заявителя
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Время Лист для изготовления.
+DocType: Quick Stock Balance,Quick Stock Balance,Быстрый сток баланс
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Промежуточный итог
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Невозможно изменить свойства Variant после транзакции с акциями. Вам нужно будет сделать новый элемент для этого.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,Безрукий мандат SEPA
@@ -7465,6 +7498,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} - неактивный ученик
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} - неактивный ученик
 DocType: Employee,Health Details,Подробности здоровья
+DocType: Coupon Code,Coupon Type,Тип купона
 DocType: Leave Encashment,Encashable days,Места для инкаширования
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Для создания ссылочного документа запроса платежа требуется
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Для создания ссылочного документа запроса платежа требуется
@@ -7753,6 +7787,7 @@
 DocType: Hotel Room Package,Amenities,Удобства
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Автоматически получать условия оплаты
 DocType: QuickBooks Migrator,Undeposited Funds Account,Учет нераспределенных средств
+DocType: Coupon Code,Uses,Пользы
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Множественный режим оплаты по умолчанию не разрешен
 DocType: Sales Invoice,Loyalty Points Redemption,Выкуп лояльности очков
 ,Appointment Analytics,Аналитика встреч
@@ -7770,6 +7805,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Оставьте пустым, если вы создаете группы студентов в год"
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Оставьте пустым, если вы создаете группы студентов в год"
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Если флажок установлен, все время не. рабочих дней будет включать в себя праздники, и это приведет к снижению стоимости Зарплата в день"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Не удалось добавить домен
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Чтобы разрешить перерасход / доставку, обновите параметр «Сверх квитанция / доставка» в настройках запаса или позиции."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Приложения, использующие текущий ключ, не смогут получить доступ, вы уверены?"
 DocType: Subscription Settings,Prorate,пропорциональная доля
@@ -7782,6 +7818,7 @@
 ,BOM Stock Report,BOM Stock Report
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Если нет назначенного временного интервала, то связь будет обрабатываться этой группой"
 DocType: Stock Reconciliation Item,Quantity Difference,Количество Разница
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Поставщик&gt; Тип поставщика
 DocType: Opportunity Item,Basic Rate,Основная ставка
 DocType: GL Entry,Credit Amount,Сумма кредита
 ,Electronic Invoice Register,Электронный реестр счетов
@@ -8036,6 +8073,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),"Налоги, которые вычитаются (Компания Валюта)"
 DocType: Item Group,General Settings,Основные настройки
 DocType: Article,Article,Статья
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,"Пожалуйста, введите код купона!"
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,"Из валюты и В валюту не может быть таким же,"
 DocType: Taxable Salary Slab,Percent Deduction,Процент вычетов
 DocType: GL Entry,To Rename,Переименовать
diff --git a/erpnext/translations/si.csv b/erpnext/translations/si.csv
index 0fb1cd7..25da9a8 100644
--- a/erpnext/translations/si.csv
+++ b/erpnext/translations/si.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,පාරිභෝගික ඇමතුම්
 DocType: Shift Type,Enable Auto Attendance,ස්වයංක්‍රීය පැමිණීම සක්‍රීය කරන්න
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,කරුණාකර ගබඩාව සහ දිනය ඇතුළත් කරන්න
 DocType: Lost Reason Detail,Opportunity Lost Reason,අවස්ථාව අහිමි වීමට හේතුව
 DocType: Patient Appointment,Check availability,ලබා ගන්න
 DocType: Retention Bonus,Bonus Payment Date,Bonus Payment Date
@@ -260,6 +261,7 @@
 ,Completed Work Orders,සම්පූර්ණ කරන ලද වැඩ ඇණවුම්
 DocType: Support Settings,Forum Posts,සංසද තැපැල්
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","කාර්යය පසුබිම් රැකියාවක් ලෙස ඇතුළත් කර ඇත. පසුබිම සැකසීම පිළිබඳ කිසියම් ගැටළුවක් ඇත්නම්, පද්ධතිය මෙම කොටස් ප්‍රතිසන්ධානය පිළිබඳ දෝෂය පිළිබඳව අදහස් දැක්වීමක් එකතු කර කෙටුම්පත් අදියර වෙත ආපසු යනු ඇත"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","කණගාටුයි, කූපන් කේත වලංගු භාවය ආරම්භ වී නොමැත"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,බදු අයකල හැකි ප්රමාණය
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},ඔබ {0} පෙර සටහන් ඇතුළත් කිරීම් එකතු කිරීම හෝ යාවත්කාලීන කිරීම කිරීමට තමන්ට අවසර නොමැති
 DocType: Leave Policy,Leave Policy Details,ප්රතිපත්ති විස්තර
@@ -324,6 +326,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,පාරිෙභෝජන
 DocType: Student,B-,බී-
 DocType: Assessment Result,Grade,ශ්රේණියේ
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,අයිතම කේතය&gt; අයිතම සමූහය&gt; වෙළඳ නාමය
 DocType: Restaurant Table,No of Seats,ආසන ගණන
 DocType: Sales Invoice,Overdue and Discounted,කල් ඉකුත් වූ සහ වට්ටම්
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,අමතන්න විසන්ධි කරන්න
@@ -500,6 +503,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,වචන මුදල සඳහා පේළි පරතරය
 DocType: Vehicle,Additional Details,අතිරේක විස්තර
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,විස්තර ලබා නැත
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,ගබඩාවෙන් අයිතම ලබා ගන්න
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,මිලදී ගැනීම සඳහා ඉල්ලීම.
 DocType: POS Closing Voucher Details,Collected Amount,එකතු කළ මුදල
 DocType: Lab Test,Submitted Date,ඉදිරිපත් කළ දිනය
@@ -606,6 +610,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,ඉගෙන ගන්න
 ,Trial Balance (Simple),අත්හදා බැලීමේ ශේෂය (සරල)
 DocType: Purchase Invoice Item,Enable Deferred Expense,විෙමෝචිත වියදම් සබල කරන්න
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,ව්‍යවහාරික කූපන් කේතය
 DocType: Asset,Next Depreciation Date,ඊළඟ ක්ෂය දිනය
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,සේවක අනුව ලද වියදම
 DocType: Accounts Settings,Settings for Accounts,ගිණුම් සඳහා සැකසුම්
@@ -839,8 +844,6 @@
 DocType: BOM,Work Order,වැඩ පිළිවෙල
 DocType: Sales Invoice,Total Qty,යවන ලද මුළු
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 විද්යුත් හැඳුනුම්පත
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","මෙම ලේඛනය අවලංගු කිරීමට කරුණාකර සේවකයා <a href=""#Form/Employee/{0}"">{0}</a> delete මකන්න"
 DocType: Item,Show in Website (Variant),වෙබ් අඩවිය තුල පෙන්වන්න (ප්රභේද්යයක්)
 DocType: Employee,Health Concerns,සෞඛ්ය කනස්සල්ල
 DocType: Payroll Entry,Select Payroll Period,වැටුප් කාලය තෝරන්න
@@ -1002,6 +1005,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,බදු රඳවා ගැනීමේ ගිණුම
 DocType: Pricing Rule,Sales Partner,විකුණුම් සහයෝගිතාකරු
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,සියලු සැපයුම්කරුවන්ගේ ලකුණු දර්ශක.
+DocType: Coupon Code,To be used to get discount,වට්ටම් ලබා ගැනීම සඳහා භාවිතා කිරීම
 DocType: Buying Settings,Purchase Receipt Required,මිලදී ගැනීම කුවිතාන්සිය අවශ්ය
 DocType: Sales Invoice,Rail,දුම්රිය
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,තථ්‍ය පිරිවැය
@@ -1049,6 +1053,7 @@
 DocType: Production Plan,Production Plan,නිෂ්පාදන සැලැස්ම
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,ආරම්භක ඉන්වොයිස් සෑදීම මෙවලම
 DocType: Salary Component,Round to the Nearest Integer,ආසන්නතම පූර්ණ සංඛ්‍යාවට වටය
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,තොගයේ නොමැති අයිතම කරත්තයට එක් කිරීමට ඉඩ දෙන්න
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,විකුණුම් ප්රතිලාභ
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,අනුක්රමික අංකයක් මත පදනම් වූ ගනුදෙනුවලදී Qty සකසන්න
 ,Total Stock Summary,මුළු කොටස් සාරාංශය
@@ -1175,6 +1180,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),මූලික හෝරාව අනුපාතිකය (සමාගම ව්යවහාර මුදල්)
 ,Qty To Be Billed,බිල් කිරීමට Qty
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,භාර මුදල
+DocType: Coupon Code,Gift Card,තෑගි කාඩ්පත
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,නිෂ්පාදනය සඳහා වෙන් කර ඇති ප්‍රමාණය: නිෂ්පාදන භාණ්ඩ සෑදීම සඳහා අමුද්‍රව්‍ය ප්‍රමාණය.
 DocType: Loyalty Point Entry Redemption,Redemption Date,මිදීමේ දිනය
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,මෙම බැංකු ගනුදෙනුව දැනටමත් සම්පුර්ණයෙන්ම සමගි වී ඇත
@@ -1263,6 +1269,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,ටයිම්ෂීට් සාදන්න
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,ගිණුම {0} වාර කිහිපයක් ඇතුලත් කර ඇත
 DocType: Account,Expenses Included In Valuation,ඇතුලත් තක්සේරු දී වියදම්
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,ඉන්වොයිසි මිලදී ගන්න
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,ඔබගේ සාමාජිකත්වය දින 30 ක් ඇතුලත කල් ඉකුත් වන්නේ නම් පමණක් ඔබ හට අලුත් කළ හැකිය
 DocType: Shopping Cart Settings,Show Stock Availability,කොටස් මිළ ලබාගන්න
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,As per section 17(5),17 (5) වගන්තියට අනුව
@@ -1802,6 +1809,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,අයිතම සහ UOM ආනයනය කිරීම
 DocType: Repayment Schedule,Balance Loan Amount,ඉතිරි ණය මුදල
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,විස්තර වලට එකතු කරන ලදි
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","කණගාටුයි, කූපන් කේතය අවසන් වී ඇත"
 DocType: Communication Medium,Catch All,සියල්ල අල්ලා ගන්න
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,උපෙල්ඛනෙය් පාඨමාලා
 DocType: Budget,Applicable on Material Request,ද්රව්ය ඉල්ලීම මත අදාළ වේ
@@ -1970,6 +1978,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,වලංගු නොවන Attribute
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} ඉදිරිපත් කළ යුතුය
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,ඊමේල් ව්‍යාපාර
+DocType: Sales Partner,To Track inbound purchase,රට තුළට මිලදී ගැනීම් සොයා ගැනීමට
 DocType: Buying Settings,Default Supplier Group,Default Supplier Group
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},ප්රමාණය අඩු හෝ {0} වෙත සමාන විය යුතුයි
 DocType: Department Approver,Department Approver,දෙපාර්තමේන්තු අනුමැතිය
@@ -2122,7 +2131,6 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,කොටස් ඇතුළත් කරන්න
 DocType: Hotel Room Reservation,Hotel Reservation User,හෝටල් වෙන් කිරීමේ පරිශීලක
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,තත්වය සකසන්න
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,කරුණාකර පැමිණීම සඳහා අංකනය කිරීමේ ශ්‍රේණිය සැකසුම&gt; අංකනය මාලාව හරහා සකසන්න
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,කරුණාකර පළමු උපසර්ගය තෝරා
 DocType: Contract,Fulfilment Deadline,ඉෂ්ඨ වේ
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,ඔබ අසල
@@ -2246,6 +2254,7 @@
 DocType: Quality Meeting Table,Under Review,සමාලෝචනය යටතේ
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,පිවිසීම අසාර්ථකයි
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Asset {0} නිර්මාණය කරන ලදි
+DocType: Coupon Code,Promotional,ප්‍රවර්ධන
 DocType: Special Test Items,Special Test Items,විශේෂ පරීක්ෂණ අයිතම
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,ඔබ Marketplace හි ලියාපදිංචි වීමට System Manager සහ අයිතම කළමනාකරුගේ භූමිකාවන් සමඟ භාවිතා කරන්නෙකු විය යුතුය.
 apps/erpnext/erpnext/config/buying.py,Key Reports,ප්රධාන වාර්තා
@@ -2284,6 +2293,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,ඩොක් වර්ගය
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,විකුණුම් කණ්ඩායමේ මුළු වෙන් ප්රතිශතය 100 විය යුතුයි
 DocType: Subscription Plan,Billing Interval Count,බිල්ගත කිරීමේ කාල ගණනය කිරීම
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","මෙම ලේඛනය අවලංගු කිරීමට කරුණාකර සේවකයා <a href=""#Form/Employee/{0}"">{0}</a> delete මකන්න"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,පත්වීම් සහ රෝගීන්ගේ ගැටුම්
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,වටිනාකම නැතිවෙයි
 DocType: Employee,Department and Grade,දෙපාර්තමේන්තුව සහ ශ්රේණිය
@@ -2384,6 +2395,7 @@
 DocType: Project,Start and End Dates,ආරම්භ කිරීම හා අවසන් දිනයන්
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,කොන්ත්රාත් ආකෘතිය සම්පූර්ණ කරන ලද කොන්දේසි
 ,Delivered Items To Be Billed,භාර අයිතම බිල්පතක්
+DocType: Coupon Code,Maximum Use,උපරිම භාවිතය
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},විවෘත ද්රව්ය ලේඛණය {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,පොත් ගබඩාව අනු අංකය වෙනස් කළ නොහැකි
 DocType: Authorization Rule,Average Discount,සාමාන්ය වට්ටම්
@@ -2543,6 +2555,7 @@
 DocType: Item,Inventory,බඩු තොග
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Json ලෙස බාගන්න
 DocType: Item,Sales Details,විකුණුම් විස්තර
+DocType: Coupon Code,Used,භාවිතා කර ඇත
 DocType: Opportunity,With Items,අයිතම සමග
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',{1} &#39;{2}&#39; සඳහා &#39;{0}&#39; ව්‍යාපාරය දැනටමත් පවතී.
 DocType: Asset Maintenance,Maintenance Team,නඩත්තු කණ්ඩායම
@@ -2669,7 +2682,7 @@
 						Serial No cannot be ensured",අයිතමයට {0} අයිතමය සඳහා සක්රීයව BOM කිසිවක් සොයාගත නොහැකි විය. \ Serial අංකය මගින් ලබා දීම සහතික කළ නොහැක
 DocType: Sales Partner,Sales Partner Target,විකුණුම් සහකරු ඉලක්ක
 DocType: Loan Type,Maximum Loan Amount,උපරිම ණය මුදල
-DocType: Pricing Rule,Pricing Rule,මිල ගණන් පාලනය
+DocType: Coupon Code,Pricing Rule,මිල ගණන් පාලනය
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},ශිෂ්ය {0} සඳහා රෝල් අංකය අනුපිටපත්
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},ශිෂ්ය {0} සඳහා රෝල් අංකය අනුපිටපත්
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,සාමය ලබා දීමට ද්රව්ය ඉල්ලීම්
@@ -2747,6 +2760,7 @@
 DocType: Payment Schedule,Payment Amount,ගෙවීමේ මුදල
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,අර්ධ දින දිනය දිනය හා වැඩ අවසන් දිනය අතර වැඩ අතර විය යුතුය
 DocType: Healthcare Settings,Healthcare Service Items,සෞඛ්ය සේවා භාණ්ඩ
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,වලංගු නොවන තීරු කේතය. මෙම තීරු කේතයට කිසිදු අයිතමයක් අමුණා නැත.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,පරිභෝජනය ප්රමාණය
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,මුදල් ශුද්ධ වෙනස්
 DocType: Assessment Plan,Grading Scale,ශ්රේණිගත පරිමාණ
@@ -2865,7 +2879,6 @@
 DocType: Share Transfer,Asset Account,වත්කම් ගිණුම
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,නව මුදාහැරීමේ දිනය අනාගතයේදී විය යුතුය
 DocType: Purchase Invoice,End date of current invoice's period,වත්මන් ඉන්වොයිස් ගේ කාලය අවසන් දිනය
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,කරුණාකර සේවක නම් කිරීමේ පද්ධතිය මානව සම්පත්&gt; මානව සම්පත් සැකසුම් තුළ සකසන්න
 DocType: Lab Test,Technician Name,කාර්මික ශිල්පී නම
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3146,7 +3159,6 @@
 DocType: Student,Student Mobile Number,ශිෂ්ය ජංගම දුරකතන අංකය
 DocType: Item,Has Variants,ප්රභේද ඇත
 DocType: Employee Benefit Claim,Claim Benefit For,හිමිකම් ප්රතිලාභය
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","{0} අයිතමය {1} ට වඩා {1} ට වඩා වැඩි ගණනකට වැඩි කළ නොහැක. වැඩි බිල්පත් කිරීමට ඉඩ දෙන්න, කරුණාකර කොටස් සැකසීම් සැකසීමට"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,ප්රතිචාර යාවත්කාලීන කරන්න
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},ඔබ මේ වන විටත් {0} {1} සිට භාණ්ඩ තෝරාගෙන ඇති
 DocType: Monthly Distribution,Name of the Monthly Distribution,මාසික බෙදාහැරීම් නම
@@ -3435,6 +3447,7 @@
 DocType: Vehicle,Fuel Type,ඉන්ධන වර්ගය
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,සමාගම මුදල් නියම කරන්න
 DocType: Workstation,Wages per hour,පැයට වැටුප්
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,පාරිභෝගික&gt; පාරිභෝගික කණ්ඩායම&gt; ප්‍රදේශය
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},කණ්ඩායම කොටස් ඉතිරි {0} ගබඩා {3} හි විෂය {2} සඳහා {1} සෘණ බවට පත් වනු
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,පහත සඳහන් ද්රව්ය ඉල්ලීම් අයිතමය යලි සඳහා මට්ටම මත පදනම්ව ස්වයංක්රීයව ඉහළ නංවා තිබෙනවා
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},ගිණුම {0} වලංගු නැත. ගිණුම ව්යවහාර මුදල් විය යුතුය {1}
@@ -3765,6 +3778,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,වැටුප පුරවා ඉදිරිපත්
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,රඳවා ගත්
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Qustion එකකට අවම වශයෙන් එක් නිවැරදි විකල්පයක්වත් තිබිය යුතුය
+apps/erpnext/erpnext/hooks.py,Purchase Orders,මිලදී ගැනීමේ ඇණවුම්
 DocType: Account,Inter Company Account,අන්තර් සමාගම් ගිණුම
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,තොග ආනයන
 DocType: Sales Partner,Address & Contacts,ලිපිනය සහ අප අමතන්න
@@ -3775,6 +3789,7 @@
 DocType: POS Profile,[Select],[තෝරන්න]
 DocType: Staffing Plan Detail,Number Of Positions,තනතුරු ගණන
 DocType: Vital Signs,Blood Pressure (diastolic),රුධිර පීඩනය (දූරකථන)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,කරුණාකර පාරිභෝගිකයා තෝරන්න.
 DocType: SMS Log,Sent To,කිරීම සඳහා යවා
 DocType: Agriculture Task,Holiday Management,නිවාඩු කළමනාකරණය
 DocType: Payment Request,Make Sales Invoice,විකුණුම් ඉන්වොයිසිය කරන්න
@@ -3981,7 +3996,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} ඉදිරිපත් කර නැත
 DocType: Subscription,Trialling,අභිධර්මය
 DocType: Sales Invoice Item,Deferred Revenue,විෙමෝචිත ආදායම්
-DocType: Bank Account,GL Account,ජීඑල් ගිණුම
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,විකුණුම් ඉන්වොයිස් නිර්මාණය සඳහා මුදල් ගිණුම භාවිතා කරනු ඇත
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,ඉවත් කිරීමේ උප පන්තිය
 DocType: Member,Membership Expiry Date,සාමාජිකත්ව කාලය කල් ඉකුත්වීම
@@ -4380,13 +4394,13 @@
 DocType: C-Form Invoice Detail,Territory,භූමි ප්රදේශය
 DocType: Pricing Rule,Apply Rule On Item Code,අයිතම කේතය මත රීතිය යොදන්න
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,අවශ්ය සංචාර ගැන කිසිදු සඳහනක් කරන්න
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,කොටස් ශේෂ වාර්තාව
 DocType: Stock Settings,Default Valuation Method,පෙරනිමි තක්සේරු ක්රමය
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,ගාස්තු
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,සමුච්චිත මුදල පෙන්වන්න
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,යාවත්කාලීන කරමින් පවතී. ටික කාලයක් ගත විය හැකියි.
 DocType: Production Plan Item,Produced Qty,නිෂ්පාදිත Qty
 DocType: Vehicle Log,Fuel Qty,ඉන්ධන යවන ලද
-DocType: Stock Entry,Target Warehouse Name,ඉලක්කගත ගබඩා නම
 DocType: Work Order Operation,Planned Start Time,සැලසුම් අරඹන්න කාල
 DocType: Course,Assessment,තක්සේරු
 DocType: Payment Entry Reference,Allocated,වෙන්
@@ -4452,10 +4466,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","සම්මත විකුණුම් හා මිලදී ගැනීම් එකතු කළ හැකි බව නියමයන් සහ කොන්දේසි. නිදසුන්: මෙම ප්රතිලාභය 1. වලංගු. 1. ගෙවීම් කොන්දේසි (උසස් දී, ණය මත, කොටසක් අත්තිකාරම් ආදිය). 1. අමතර (හෝ ගණුදෙනුකරු විසින් ගෙවිය යුතු) යනු කුමක්ද. 1. ආරක්ෂාව / භාවිතය අනතුරු ඇඟවීමක්. 1. නම් Warranty. 1. ප්රතිපත්ති ආයෙත්. 1. අදාල නම්, භාණ්ඩ ප්රවාහනය කිරීමේ කොන්දේසි. ආරවුල් අමතමින් 1. මාර්ග, හානි පුර්ණය, වගකීම්, ආදිය 1. ලිපිනය සහ ඔබගේ සමාගමේ අමතන්න."
 DocType: Homepage Section,Section Based On,කොටස පදනම් කරගෙන
+DocType: Shopping Cart Settings,Show Apply Coupon Code,අයදුම් කරන්න කූපන් කේතය පෙන්වන්න
 DocType: Issue,Issue Type,නිකුත් වර්ගය
 DocType: Attendance,Leave Type,වර්ගය තබන්න
 DocType: Purchase Invoice,Supplier Invoice Details,සැපයුම්කරු ගෙවීම් විස්තර
 DocType: Agriculture Task,Ignore holidays,නිවාඩු නොසලකා හරින්න
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,කූපන් කොන්දේසි එකතු කරන්න / සංස්කරණය කරන්න
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,වියදම් / වෙනස ගිණුම ({0}) වන &#39;ලාභය හෝ අලාභය&#39; ගිණුම් විය යුතුය
 DocType: Stock Entry Detail,Stock Entry Child,කොටස් ඇතුළත් කිරීමේ දරුවා
 DocType: Project,Copied From,සිට පිටපත්
@@ -4626,6 +4642,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,තක්සේරු සැලැස්ම නිර්ණායක
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,ගනුදෙනු
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,මිලදී ගැනීමේ නියෝග වැළැක්වීම
+DocType: Coupon Code,Coupon Name,කූපන් නම
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,සංවේදීයි
 DocType: Email Campaign,Scheduled,නියමිත
 DocType: Shift Type,Working Hours Calculation Based On,වැඩ කරන පැය ගණනය කිරීම මත පදනම්ව
@@ -4642,7 +4659,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,ප්‍රභේද සාදන්න
 DocType: Vehicle,Diesel,ඩීසල්
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,මිල ලැයිස්තුව ව්යවහාර මුදල් තෝරා ගෙන නොමැති
+DocType: Quick Stock Balance,Available Quantity,ලබා ගත හැකි ප්‍රමාණය
 DocType: Purchase Invoice,Availed ITC Cess,ITC සෙස් සඳහා උපකාරී විය
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,කරුණාකර අධ්‍යාපන&gt; අධ්‍යාපන සැකසුම් වල උපදේශක නම් කිරීමේ පද්ධතිය සකසන්න
 ,Student Monthly Attendance Sheet,ශිෂ්ය මාසික පැමිණීම පත්රය
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,නැව්ගත කිරීමේ නීතිය විකිණීම සඳහා පමණි
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,ක්ෂය කිරීම් පේළි {0}: ඉදිරි ක්ෂය කිරීම් දිනය මිලදී ගැනීමේ දිනයට පෙර නොවිය හැක
@@ -4711,6 +4730,7 @@
 DocType: Quality Meeting,Quality Meeting,තත්ත්ව රැස්වීම
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,නොවන සමූහ සමූහ
 DocType: Employee,ERPNext User,ERPNext පරිශීලක
+DocType: Coupon Code,Coupon Description,කූපන් විස්තරය
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},කණ්ඩායම පේළිය {0} අනිවාර්ය වේ
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},කණ්ඩායම පේළිය {0} අනිවාර්ය වේ
 DocType: Company,Default Buying Terms,පෙරනිමි මිලදී ගැනීමේ නියමයන්
@@ -4841,6 +4861,7 @@
 DocType: Training Event,Trainer Email,පුහුණුකරු විද්යුත්
 DocType: Sales Invoice,Transporter,ට්රාන්ස්පෝර්ට්
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Day Book Data,දින පොත් දත්ත ආයාත කරන්න
+apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Priority {0} has been repeated.,ප්‍රමුඛතා {0} නැවත නැවතත් කර ඇත.
 DocType: Restaurant Reservation,No of People,මිනිසුන් ගණන
 apps/erpnext/erpnext/config/buying.py,Template of terms or contract.,කොන්දේසි හෝ කොන්ත්රාත්තුව සැකිල්ල.
 DocType: Bank Account,Address and Contact,ලිපිනය සහ ඇමතුම්
@@ -4872,6 +4893,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,මත ලේඛන විස්තර නොමැත
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},රටකට මකාදැමීම රටට අවසර නැත {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,පක්ෂය වර්ගය අනිවාර්ය වේ
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,කූපන් කේතය යොදන්න
 DocType: Quality Inspection,Outgoing,ධූරයෙන් ඉවත්ව යන
 DocType: Customer Feedback Table,Customer Feedback Table,පාරිභෝගික ප්‍රතිපෝෂණ වගුව
 apps/erpnext/erpnext/config/support.py,Service Level Agreement.,සේවා මට්ටමේ ගිවිසුම.
@@ -5022,7 +5044,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,මිලදී ගැනීමේ ඇණවුම් ඉදිරිපත් කිරීමේදී
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,සියලු සැපයුම්කරුවන් එකතු කරන්න
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,පේළියේ # {0}: වෙන් කළ මුදල ගෙවීමට ඇති මුදල වඩා වැඩි විය නොහැක.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,පාරිභෝගික&gt; පාරිභෝගික කණ්ඩායම&gt; ප්‍රදේශය
 DocType: Tally Migration,Parties,පාර්ශවයන්
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,ගවේශක ද්රව්ය ලේඛණය
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,ආරක්ෂිත ණය
@@ -5053,7 +5074,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},අයිතමය සඳහා විකල්ප අයිතමයක් තැබීමට ඉඩ නොදේ. {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,දිනය නැවත නැවත
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,බලයලත් අත්සන්
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,කරුණාකර අධ්‍යාපනය&gt; අධ්‍යාපන සැකසුම් තුළ උපදේශක නම් කිරීමේ පද්ධතිය සකසන්න
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),ශුද්ධ ITC ලබා ගත හැකිය (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,ගාස්තු නිර්මාණය කරන්න
 DocType: Project,Total Purchase Cost (via Purchase Invoice),(මිලදී ගැනීමේ ඉන්වොයිසිය හරහා) මුළු මිලදී ගැනීම පිරිවැය
@@ -5077,6 +5097,7 @@
 DocType: Quiz Result,Wrong,වැරදි
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,මිල ලැයිස්තුව මුදල් පාරිභෝගික පදනම මුදල් බවට පරිවර්තනය වන අවස්ථාවේ අනුපාතය
 DocType: Purchase Invoice Item,Net Amount (Company Currency),ශුද්ධ මුදල (සමාගම ව්යවහාර මුදල්)
+DocType: Sales Partner,Referral Code,යොමු කේතය
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,සම්පූර්ණ අත්තිකාරම් මුදල මුළු අනුමත ප්රමාණයට වඩා වැඩි විය නොහැක
 DocType: Salary Slip,Hour Rate,පැය අනුපාත
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,ස්වයංක්‍රීය නැවත ඇණවුම සක්‍රීය කරන්න
@@ -5205,6 +5226,7 @@
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},අයිතමයට එරෙහිව BOM අයිතමය තෝරන්න. {0}
 DocType: Shopping Cart Settings,Show Stock Quantity,තොග ප්රමාණය පෙන්වන්න
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,මෙහෙයුම් වලින් ශුද්ධ මුදල්
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},අයිතමය සඳහා UOM පරිවර්තන සාධකය ({0} -&gt; {1}) හමු නොවීය: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,අයිතමය 4
 DocType: Student Admission,Admission End Date,ඇතුළත් කර අවසානය දිනය
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,උප-කොන්ත්රාත්
@@ -5227,6 +5249,7 @@
 DocType: Travel Request,Fully Sponsored,පූර්ණ අනුග්රහය
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,ප්රතිලෝම ජර්නල් ප්රවේශය
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,රැකියා කාඩ්පතක් සාදන්න
+DocType: Quotation,Referral Sales Partner,යොමු විකුණුම් සහකරු
 DocType: Quality Procedure Process,Process Description,ක්‍රියාවලි විස්තරය
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,පාරිභෝගිකයා {0} නිර්මාණය වේ.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,දැනට කිසිදු ගබඩාවක් නොමැත
@@ -5358,6 +5381,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,ද්රව්ය ලේඛණය අනුපාතිකය
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,උඩුගත කළ ගොනුව කියවීම
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel",නව වැඩ පිළිවෙළ නවතා දැමිය නොහැක
+DocType: Coupon Code,Coupon Code,කූපන් කේතය
 DocType: Asset,Journal Entry for Scrap,ලාංකික සඳහා ජර්නල් සටහන්
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,සැපයුම් සටහන භාණ්ඩ අදින්න කරුණාකර
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},පේළිය {0}: මෙහෙයුමට එරෙහිව පරිගණකය තෝරා ගන්න {1}
@@ -5441,6 +5465,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;දිනය&#39; අවශ්‍යයි
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},නිසා / යොමුව දිනය {0} පසු විය නොහැකි
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,දත්ත ආනයන හා අපනයන
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","කණගාටුයි, කූපන් කේත වලංගුභාවය කල් ඉකුත් වී ඇත"
 DocType: Bank Account,Account Details,ගිණුම් විස්තර
 DocType: Crop,Materials Required,අවශ්ය ද්රව්ය
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,සිසුන් හමු කිසිදු
@@ -5478,6 +5503,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,පරිශීලකයින් වෙත යන්න
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,ගෙවනු ලබන මුදල + ප්රමාණය මුළු එකතුව වඩා වැඩි විය නොහැකි Off ලියන්න
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} අයිතමය {1} සඳහා වලංගු කණ්ඩායම අංකය නොවේ
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,කරුණාකර වලංගු කූපන් කේතය ඇතුළත් කරන්න !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},සටහන: මෙහි නිවාඩු වර්ගය {0} සඳහා ප්රමාණවත් නිවාඩු ඉතිරි නොවේ
 DocType: Task,Task Description,කාර්ය විස්තරය
 DocType: Training Event,Seminar,සම්මන්ත්රණය
@@ -5743,6 +5769,7 @@
 ,TDS Payable Monthly,TDS මාසිකව ගෙවිය යුතුය
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,BOM ආදේශ කිරීම සඳහා පේළිය. විනාඩි කිහිපයක් ගත විය හැකිය.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',කාණ්ඩය තක්සේරු &#39;හෝ&#39; තක්සේරු හා පූර්ණ &#39;සඳහා වන විට අඩු කර නොහැකි
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,කරුණාකර සේවක නම් කිරීමේ පද්ධතිය මානව සම්පත්&gt; මානව සම්පත් සැකසුම් තුළ සකසන්න
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,මුළු ගෙවීම්
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serialized අයිතමය {0} සඳහා අනු අංක අවශ්ය
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,ඉන්වොයිසි සමග සසදන්න ගෙවීම්
@@ -5830,6 +5857,7 @@
 DocType: Production Plan,Get Raw Materials For Production,නිෂ්පාදනය සඳහා අමුද්රව්ය ලබා ගන්න
 DocType: Job Opening,Job Title,රැකියා තනතුර
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,අනාගත ගෙවීම් Ref
+DocType: Quotation,Additional Discount and Coupon Code,අතිරේක වට්ටම් සහ කූපන් කේතය
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} මගින් පෙන්නුම් කරන්නේ {1} සවිස්තරාත්මකව උපුටා නොදක්වන බවය, නමුත් සියලුම අයිතමයන් උපුටා ඇත. RFQ සවිස්තරාත්මකව යාවත්කාලීන කිරීම."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,උපරිම නියැදි - {0} දැනටමත් {1} සහ {{}} කාණ්ඩයේ {1} අයිතමය {2} සඳහා තබා ඇත.
@@ -6056,6 +6084,7 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,වෙබ් අඩවිය මුල්පිටුව සඳහා සැකසුම්
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} තෙක් {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},{0} සඳහා ලකුණු ලබා දීම සඳහා අවසර ලබා දී නොමැත {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,මිලදී ගැනීමේ ඉන්වොයිසියක් කරන්න
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,පාවිච්චි කළ කොළ
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,ද්‍රව්‍යමය ඉල්ලීම ඉදිරිපත් කිරීමට ඔබට අවශ්‍යද?
 DocType: Job Offer,Awaiting Response,බලා සිටින ප්රතිචාර
@@ -6070,6 +6099,7 @@
 DocType: Training Event Employee,Optional,විකල්පයකි
 DocType: Salary Slip,Earning & Deduction,උපයන සහ අඩු කිරීම්
 DocType: Agriculture Analysis Criteria,Water Analysis,ජල විශ්ලේෂණය
+DocType: Sales Order,Skip Delivery Note,බෙදා හැරීමේ සටහන මඟ හරින්න
 DocType: Price List,Price Not UOM Dependent,මිල UOM යැපෙන්නන් නොවේ
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} නිර්මාණය කර ඇත.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,පෙරනිමි සේවා මට්ටමේ ගිවිසුමක් දැනටමත් පවතී.
@@ -6276,7 +6306,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,බදු හා බදු ගාස්තු එකතු
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,ක්ෂය කිරීම් පේළි {0}: ඉදිරි ක්ෂය කිරීම් දිනය ලබා ගත හැකි දිනය සඳහා භාවිතා කල නොහැක
 ,Sales Funnel,විකුණුම් පොම්ප
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,අයිතම කේතය&gt; අයිතම සමූහය&gt; වෙළඳ නාමය
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,කෙටි යෙදුම් අනිවාර්ය වේ
 DocType: Project,Task Progress,කාර්ය සාධක ප්රගති
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,කරත්ත
@@ -6371,6 +6400,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS සටහන් කිරීමට අවශ්ය POS නරඹන්න
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","එකතු කළ අගය මත පදනම්ව, විකුණුම් ඉන්වොයිසිය මගින් සිදු කරනු ලබන වියදම් වලින් ලෙන්ගතු ලක්ෂ්යයන් ගණනය කරනු ලැබේ."
 DocType: Program Enrollment Tool,Enroll Students,ශිෂ්ය ලියාපදිංචි
+DocType: Pricing Rule,Coupon Code Based,කූපන් කේතය පදනම් කරගත්
 DocType: Company,HRA Settings,HRA සැකසුම්
 DocType: Homepage,Hero Section,වීර අංශය
 DocType: Employee Transfer,Transfer Date,පැවරුම් දිනය
@@ -6486,6 +6516,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',පිරිසක් විසින් &#39;සමාගම&#39; නම් හිස් පෙරීමට සමාගම සකස් කරන්න
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,"ගිය තැන, දිනය අනාගත දිනයක් විය නොහැකි"
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},ෙරෝ # {0}: අනු අංකය {1} {2} {3} සමග නොගැලපේ
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,කරුණාකර පැමිණීම සඳහා අංකනය කිරීමේ ශ්‍රේණිය සැකසුම&gt; අංකනය මාලාව හරහා සකසන්න
 DocType: Stock Entry,Target Warehouse Address,ඉලක්කගත ගබඩා ලිපිනය
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,අනියම් නිවාඩු
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,සේවක පිරික්සුම පැමිණීම සඳහා සලකා බලනු ලබන මාරුව ආරම්භක වේලාවට පෙර කාලය.
@@ -6520,7 +6551,6 @@
 DocType: Employee Grade,Employee Grade,සේවක ශ්රේණිය
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Piecework
 DocType: GSTR 3B Report,June,ජූනි
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,සැපයුම්කරු&gt; සැපයුම්කරු වර්ගය
 DocType: Share Balance,From No,අංක සිට
 DocType: Shift Type,Early Exit Grace Period,මුල් පිටවීමේ වර්‍ග කාලය
 DocType: Task,Actual Time (in Hours),සැබෑ කාලය (පැය දී)
@@ -6803,7 +6833,6 @@
 DocType: Warehouse,Warehouse Name,පොත් ගබඩාව නම
 DocType: Naming Series,Select Transaction,ගනුදෙනු තෝරන්න
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,කාර්යභාරය අනුමත හෝ පරිශීලක අනුමත ඇතුලත් කරන්න
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},අයිතමය සඳහා UOM පරිවර්තන සාධකය ({0} -&gt; {1}) හමු නොවීය: {2}
 DocType: Journal Entry,Write Off Entry,පිවිසුම් Off ලියන්න
 DocType: BOM,Rate Of Materials Based On,ද්රව්ය මත පදනම් මත අනුපාතය
 DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","සක්රීය නම්, වැඩසටහන් බඳවා ගැනීමේ මෙවලමෙහි ඇති ක්ෂේත්ර අධ්යයන වාරය අනිවාර්ය වේ."
@@ -6940,6 +6969,7 @@
 DocType: Budget,Warn,බිය ගන්වා අනතුරු අඟවනු
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,මෙම වැඩ පිළිවෙල සඳහා සියලුම අයිතම මේ වන විටත් මාරු කර ඇත.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","වෙනත් ඕනෑම ප්රකාශ, වාර්තාවන් යා යුතු බව විශේෂයෙන් සඳහන් කළ යුතු උත්සාහයක්."
+DocType: Bank Account,Company Account,සමාගම් ගිණුම
 DocType: Asset Maintenance,Manufacturing User,නිෂ්පාදන පරිශීලක
 DocType: Purchase Invoice,Raw Materials Supplied,"සපයා, අමු ද්රව්ය"
 DocType: Subscription Plan,Payment Plan,ගෙවීම් සැලැස්ම
@@ -6981,6 +7011,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) සැලසුම් කර ඇති ප්රමාණයට වඩා ({2}) වැඩ පිළිවෙළ {3}
 DocType: Certification Application,Name of Applicant,අයදුම් කරන්නාගේ නම
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,නිෂ්පාදන සඳහා කාලය පත්රය.
+DocType: Quick Stock Balance,Quick Stock Balance,ඉක්මන් කොටස් ශේෂය
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,උප ශීර්ෂයට
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,කොටස් ගනුදෙනු පසු ප්රභව ගුණාංග වෙනස් කළ නොහැක. මෙය කිරීමට නව අයිතමයක් ඔබට අවශ්ය වනු ඇත.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoAardless SEPA මැන්ඩේට්
@@ -7304,6 +7335,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} අක්රීය ශිෂ්යාවක්
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} අක්රීය ශිෂ්යාවක්
 DocType: Employee,Health Details,සෞඛ්ය තොරතුරු
+DocType: Coupon Code,Coupon Type,කූපන් වර්ගය
 DocType: Leave Encashment,Encashable days,ඇණවුම් කළ හැකි දින
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,ගෙවීම් ඉල්ලීම් යොමු ලියවිල්ලක් අවශ්ය නිර්මාණය කිරීමට
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,ගෙවීම් ඉල්ලීම් යොමු ලියවිල්ලක් අවශ්ය නිර්මාණය කිරීමට
@@ -7587,6 +7619,7 @@
 DocType: Hotel Room Package,Amenities,පහසුකම්
 DocType: Accounts Settings,Automatically Fetch Payment Terms,ගෙවීම් නියමයන් ස්වයංක්‍රීයව ලබා ගන්න
 DocType: QuickBooks Migrator,Undeposited Funds Account,නොබැඳි අරමුදල් ගිණුම
+DocType: Coupon Code,Uses,භාවිතයන්
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,ගෙවීමේදී බහුතරයේ පෙරනිමි ආකාරයේ ගෙවීම් කිරීමට අවසර නැත
 DocType: Sales Invoice,Loyalty Points Redemption,පක්ෂපාතීත්වයෙන් නිදහස් වීම
 ,Appointment Analytics,පත්වීම් විශ්ලේෂණය
@@ -7604,6 +7637,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,ඔබ වසරකට සිසුන් කණ්ඩායම් කරන්න නම් හිස්ව තබන්න
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,ඔබ වසරකට සිසුන් කණ්ඩායම් කරන්න නම් හිස්ව තබන්න
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","පරීක්ෂා, සමස්ත කිසිදු නම්. වැඩ කරන දින වල නිවාඩු දින ඇතුලත් වනු ඇත, සහ මෙම වැටුප එක් දිනය අගය අඩු වනු ඇත"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,වසම එක් කිරීමට අපොහොසත් විය
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","වැඩිපුර ලැබීම් / භාරදීමට ඉඩ දීම සඳහා, කොටස් සැකසීම් හෝ අයිතමයේ “ඕවර් රිසිට්පත / බෙදා හැරීමේ දීමනාව” යාවත්කාලීන කරන්න."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","වත්මන් යතුර භාවිතා කරන යෙදුම්වලට ප්රවේශ වීමට නොහැකි වනු ඇත, ඔබට විශ්වාසද?"
 DocType: Subscription Settings,Prorate,නොපෙනී
@@ -7617,6 +7651,7 @@
 ,BOM Stock Report,ද්රව්ය ලේඛණය කොටස් වාර්තාව
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","පවරා ඇති කාල සටහනක් නොමැති නම්, සන්නිවේදනය මෙම කණ්ඩායම විසින් මෙහෙයවනු ලැබේ"
 DocType: Stock Reconciliation Item,Quantity Difference,ප්රමාණ වෙනස
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,සැපයුම්කරු&gt; සැපයුම්කරු වර්ගය
 DocType: Opportunity Item,Basic Rate,මූලික අනුපාත
 DocType: GL Entry,Credit Amount,ක්රෙඩිට් මුදල
 ,Electronic Invoice Register,විද්‍යුත් ඉන්වොයිසි ලේඛනය
@@ -7868,6 +7903,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),අඩු කිරීමේ බදු හා ගාස්තු (සමාගම ව්යවහාර මුදල්)
 DocType: Item Group,General Settings,සාමාන්ය සැකසුම්
 DocType: Article,Article,ලිපිය
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,කරුණාකර කූපන් කේතය ඇතුළත් කරන්න !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,ව්යවහාර මුදල් හා ව්යවහාර මුදල් සඳහා සමාන විය නොහැකි
 DocType: Taxable Salary Slab,Percent Deduction,ප්රතිශතය අඩු කිරීම
 DocType: GL Entry,To Rename,නැවත නම් කිරීමට
diff --git a/erpnext/translations/sk.csv b/erpnext/translations/sk.csv
index ca28762..cb6990b 100644
--- a/erpnext/translations/sk.csv
+++ b/erpnext/translations/sk.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Zákaznícky kontakt
 DocType: Shift Type,Enable Auto Attendance,Povoliť automatickú účasť
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Zadajte sklad a dátum
 DocType: Lost Reason Detail,Opportunity Lost Reason,Príležitosť stratila dôvod
 DocType: Patient Appointment,Check availability,Skontrolovať dostupnosť
 DocType: Retention Bonus,Bonus Payment Date,Dátum výplaty bonusu
@@ -264,6 +265,7 @@
 ,Completed Work Orders,Dokončené pracovné príkazy
 DocType: Support Settings,Forum Posts,Fórum príspevky
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage",Úloha bola zadaná ako práca na pozadí. V prípade akýchkoľvek problémov so spracovaním na pozadí systém pridá komentár k chybe pri tomto zúčtovaní zásob a vráti sa do fázy Koncept.
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Ľutujeme, platnosť kódu kupónu sa nezačala"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Zdaniteľná čiastka
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Nejste oprávněni přidávat nebo aktualizovat údaje před {0}
 DocType: Leave Policy,Leave Policy Details,Nechajte detaily pravidiel
@@ -329,6 +331,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Spotrebný materiál
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,stupeň
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kód položky&gt; Skupina položiek&gt; Značka
 DocType: Restaurant Table,No of Seats,Počet sedadiel
 DocType: Sales Invoice,Overdue and Discounted,Omeškanie a zľava
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Hovor bol odpojený
@@ -506,6 +509,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,riadkovanie za čiastku v slovách
 DocType: Vehicle,Additional Details,Ďalšie podrobnosti
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Bez popisu
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Načítať položky zo skladu
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Žádost o koupi.
 DocType: POS Closing Voucher Details,Collected Amount,Zozbieraná suma
 DocType: Lab Test,Submitted Date,Dátum odoslania
@@ -613,6 +617,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Učenie
 ,Trial Balance (Simple),Skúšobný zostatok (jednoduchý)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Povolenie odloženého výdavku
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Kód použitého kupónu
 DocType: Asset,Next Depreciation Date,Vedľa Odpisy Dátum
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Náklady na činnosť na jedného zamestnanca
 DocType: Accounts Settings,Settings for Accounts,Nastavenie Účtovníctva
@@ -853,8 +858,6 @@
 DocType: Sales Invoice,Total Qty,Celkem Množství
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,ID e-mailu Guardian2
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,ID e-mailu Guardian2
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Ak chcete tento dokument zrušiť, odstráňte zamestnanca <a href=""#Form/Employee/{0}"">{0}</a> \"
 DocType: Item,Show in Website (Variant),Zobraziť na webstránke (Variant)
 DocType: Employee,Health Concerns,Zdravotní Obavy
 DocType: Payroll Entry,Select Payroll Period,Vyberte mzdové
@@ -1020,6 +1023,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Zrážkový účet
 DocType: Pricing Rule,Sales Partner,Partner predaja
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Všetky hodnotiace karty dodávateľa.
+DocType: Coupon Code,To be used to get discount,Používa sa na získanie zľavy
 DocType: Buying Settings,Purchase Receipt Required,Příjmka je vyžadována
 DocType: Sales Invoice,Rail,koľajnice
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Skutočné náklady
@@ -1070,6 +1074,7 @@
 DocType: Production Plan,Production Plan,Výrobný plán
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Otvorenie nástroja na tvorbu faktúr
 DocType: Salary Component,Round to the Nearest Integer,Zaokrúhlite na najbližšie celé číslo
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,"Nechajte položky, ktoré nie sú na sklade, pridať do košíka"
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Sales Return
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Voliť množstvo v transakciách na základe vybratého sériového čísla
 ,Total Stock Summary,Súhrnné zhrnutie zásob
@@ -1200,6 +1205,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Základňa hodinová sadzba (Company meny)
 ,Qty To Be Billed,Množstvo na vyúčtovanie
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Dodaná Čiastka
+DocType: Coupon Code,Gift Card,Darčeková karta
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Vyhradené množstvo pre výrobu: Množstvo surovín na výrobu výrobných položiek.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Dátum vykúpenia
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Táto banková transakcia je už úplne vyrovnaná
@@ -1289,6 +1295,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Vytvorenie časového rozvrhu
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Účet {0} bol zadaný viackrát
 DocType: Account,Expenses Included In Valuation,Náklady ceně oceňování
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Nákup faktúr
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,"Môžete obnoviť iba vtedy, ak vaše členstvo uplynie do 30 dní"
 DocType: Shopping Cart Settings,Show Stock Availability,Zobraziť dostupnosť zásob
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Nastavte {0} v kategórii majetku {1} alebo v spoločnosti {2}
@@ -1849,6 +1856,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Import položiek a UOM
 DocType: Repayment Schedule,Balance Loan Amount,Bilancia Výška úveru
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Pridané k podrobnostiam
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Ľutujeme, kód kupónu je vyčerpaný"
 DocType: Communication Medium,Catch All,Chytiť všetko
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,rozvrh
 DocType: Budget,Applicable on Material Request,Platí pre materiálové požiadavky
@@ -2019,6 +2027,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,neplatný Atribút
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} musí být odeslaný
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,E-mailové kampane
+DocType: Sales Partner,To Track inbound purchase,Ak chcete sledovať prichádzajúci nákup
 DocType: Buying Settings,Default Supplier Group,Predvolená skupina dodávateľov
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Množstvo musí byť menší ako alebo rovný {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Maximálna čiastka oprávnená pre komponent {0} presahuje {1}
@@ -2176,8 +2185,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Vykonajte zadanie zásob
 DocType: Hotel Room Reservation,Hotel Reservation User,Používateľ rezervácie hotelov
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Nastaviť stav
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Nastavte číslovacie série pre Účasť cez Nastavenie&gt; Číslovacie série
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,"Prosím, vyberte první prefix"
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Prosím pomenujte Series pre {0} cez Setup&gt; Settings&gt; Naming Series
 DocType: Contract,Fulfilment Deadline,Termín splnenia
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Vo vašom okolí
 DocType: Student,O-,O-
@@ -2301,6 +2310,7 @@
 DocType: Quality Meeting Table,Under Review,Prebieha kontrola
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Nepodarilo sa prihlásiť
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Bol vytvorený majetok {0}
+DocType: Coupon Code,Promotional,propagačné
 DocType: Special Test Items,Special Test Items,Špeciálne testovacie položky
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Musíte byť používateľom s funkciami Správca systému a Správca položiek na registráciu na trhu.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Kľúčové správy
@@ -2339,6 +2349,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,DokTyp
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Celkové přidělené procento prodejní tým by měl být 100
 DocType: Subscription Plan,Billing Interval Count,Počet fakturačných intervalov
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Ak chcete tento dokument zrušiť, odstráňte zamestnanca <a href=""#Form/Employee/{0}"">{0}</a> \"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Schôdzky a stretnutia s pacientmi
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Hodnota chýba
 DocType: Employee,Department and Grade,Oddelenie a trieda
@@ -2442,6 +2454,7 @@
 DocType: Project,Start and End Dates,Dátum začatia a ukončenia
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Zmluvné podmienky pre splnenie podmienok zmluvy
 ,Delivered Items To Be Billed,Dodávaných výrobků fakturovaných
+DocType: Coupon Code,Maximum Use,Maximálne použitie
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Otvorená BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Warehouse nemůže být změněn pro Serial No.
 DocType: Authorization Rule,Average Discount,Průměrná sleva
@@ -2604,6 +2617,7 @@
 DocType: Item,Inventory,Inventář
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Stiahnuť ako Json
 DocType: Item,Sales Details,Predajné podrobnosti
+DocType: Coupon Code,Used,použité
 DocType: Opportunity,With Items,S položkami
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Kampaň &#39;{0}&#39; už existuje pre {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Tím údržby
@@ -2733,7 +2747,7 @@
 						Serial No cannot be ensured",Pre položku {0} nebol nájdený aktívny kusovník. Dodanie pomocou sériového čísla nie je možné zabezpečiť
 DocType: Sales Partner,Sales Partner Target,Sales Partner Target
 DocType: Loan Type,Maximum Loan Amount,Maximálna výška úveru
-DocType: Pricing Rule,Pricing Rule,Cenové pravidlo
+DocType: Coupon Code,Pricing Rule,Cenové pravidlo
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplicitné číslo rolky pre študenta {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplicitné číslo rolky pre študentov {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Materiál Žiadosť o príkaze k nákupu
@@ -2813,6 +2827,7 @@
 DocType: Payment Schedule,Payment Amount,Částka platby
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Polovičný dátum by mal byť medzi prácou od dátumu a dátumom ukončenia práce
 DocType: Healthcare Settings,Healthcare Service Items,Položky zdravotníckych služieb
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Neplatný čiarový kód. K tomuto čiarovému kódu nie je pripojená žiadna položka.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Spotřebovaném množství
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Čistá zmena v hotovosti
 DocType: Assessment Plan,Grading Scale,stupnica
@@ -2934,7 +2949,6 @@
 DocType: Share Transfer,Asset Account,Asset Account
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Nový dátum vydania by mal byť v budúcnosti
 DocType: Purchase Invoice,End date of current invoice's period,Datum ukončení doby aktuální faktury je
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Nastavte systém pomenovávania zamestnancov v časti Ľudské zdroje&gt; Nastavenia ľudských zdrojov
 DocType: Lab Test,Technician Name,Názov technikov
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3046,6 +3060,7 @@
 DocType: Products Settings,Hide Variants,Skryť varianty
 DocType: Lead,Next Contact By,Další Kontakt By
 DocType: Compensatory Leave Request,Compensatory Leave Request,Žiadosť o kompenzačnú dovolenku
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Nie je možné preplatiť položku {0} v riadku {1} viac ako {2}. Ak chcete povoliť nadmernú fakturáciu, nastavte príspevok v nastaveniach účtov"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Množství požadované pro bodě {0} v řadě {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},"Sklad {0} nelze smazat, protože existuje množství k položce {1}"
 DocType: Blanket Order,Order Type,Typ objednávky
@@ -3218,7 +3233,6 @@
 DocType: Student,Student Mobile Number,Študent Číslo mobilného telefónu
 DocType: Item,Has Variants,Má varianty
 DocType: Employee Benefit Claim,Claim Benefit For,Nárok na dávku pre
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Nie je možné prepísať položku {0} v riadku {1} viac ako {2}. Ak chcete povoliť nadmerné fakturácie, nastavte prosím nastavenia v ponuke"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Aktualizácia odpovede
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Už ste vybrané položky z {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Názov mesačného rozdelenia
@@ -3512,6 +3526,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,"Uveďte prosím měnu, ve společnosti"
 DocType: Workstation,Wages per hour,Mzda za hodinu
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Konfigurovať {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Zákazník&gt; Skupina zákazníkov&gt; Územie
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Sklad bilance v dávce {0} se zhorší {1} k bodu {2} ve skladu {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Nasledujúci materiál žiadosti boli automaticky zvýšená na základe úrovni re-poradie položky
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Účet {0} je neplatná. Mena účtu musí byť {1}
@@ -3845,6 +3860,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Odeslat výplatní pásce
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Podržanie
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Spálenie musí mať aspoň jednu správnu voľbu
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Objednávky
 DocType: Account,Inter Company Account,Inter firemný účet
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Dovoz hromadnú
 DocType: Sales Partner,Address & Contacts,Adresa a kontakty
@@ -3855,6 +3871,7 @@
 DocType: POS Profile,[Select],[Vybrať]
 DocType: Staffing Plan Detail,Number Of Positions,Počet pozícií
 DocType: Vital Signs,Blood Pressure (diastolic),Krvný tlak (diastolický)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Vyberte zákazníka.
 DocType: SMS Log,Sent To,Odoslané na
 DocType: Agriculture Task,Holiday Management,Správa prázdnin
 DocType: Payment Request,Make Sales Invoice,Vytvoriť faktúru
@@ -4065,7 +4082,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} nie je odoslané
 DocType: Subscription,Trialling,skúšanie
 DocType: Sales Invoice Item,Deferred Revenue,Výnosy budúcich období
-DocType: Bank Account,GL Account,Účet GL
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Pokladničný účet sa použije na vytvorenie faktúry za predaj
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Výnimka Podkategória
 DocType: Member,Membership Expiry Date,Dátum ukončenia členstva
@@ -4491,13 +4507,13 @@
 DocType: C-Form Invoice Detail,Territory,Území
 DocType: Pricing Rule,Apply Rule On Item Code,Použiť pravidlo pre kód položky
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,"Prosím, uveďte počet požadovaných návštěv"
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Správa o stave zásob
 DocType: Stock Settings,Default Valuation Method,Výchozí metoda ocenění
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,poplatok
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Zobraziť kumulatívnu čiastku
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Prebieha aktualizácia. Môže to chvíľu trvať.
 DocType: Production Plan Item,Produced Qty,Vyrobené množstvo
 DocType: Vehicle Log,Fuel Qty,palivo Množstvo
-DocType: Stock Entry,Target Warehouse Name,Názov cieľového skladu
 DocType: Work Order Operation,Planned Start Time,Plánované Start Time
 DocType: Course,Assessment,posúdenie
 DocType: Payment Entry Reference,Allocated,Přidělené
@@ -4575,10 +4591,12 @@
  1. Způsoby řešení sporů, náhrady škody, odpovědnosti za škodu, atd 
  1. Adresa a kontakt na vaši společnost."
 DocType: Homepage Section,Section Based On,Časť založená na
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Zobraziť Použiť kód kupónu
 DocType: Issue,Issue Type,Typ vydania
 DocType: Attendance,Leave Type,Leave Type
 DocType: Purchase Invoice,Supplier Invoice Details,Detaily dodávateľskej faktúry
 DocType: Agriculture Task,Ignore holidays,Ignorovať dovolenku
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Pridať / upraviť podmienky kupónu
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Náklady / Rozdíl účtu ({0}), musí být ""zisk nebo ztráta"" účet"
 DocType: Stock Entry Detail,Stock Entry Child,Zásoby Dieťa
 DocType: Project,Copied From,Skopírované z
@@ -4754,6 +4772,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Plan Assessment Criteria
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,transakcie
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Zabráňte nákupným objednávkam
+DocType: Coupon Code,Coupon Name,Názov kupónu
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,vnímavý
 DocType: Email Campaign,Scheduled,Plánované
 DocType: Shift Type,Working Hours Calculation Based On,Výpočet pracovnej doby na základe
@@ -4770,7 +4789,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Vytvorenie variantov
 DocType: Vehicle,Diesel,Diesel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Mena pre cenník nie je vybratá
+DocType: Quick Stock Balance,Available Quantity,Dostupné množstvo
 DocType: Purchase Invoice,Availed ITC Cess,Využil ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Nastavte Pomenovací systém inštruktorov v časti Vzdelanie&gt; Nastavenia vzdelávania
 ,Student Monthly Attendance Sheet,Študent mesačná návštevnosť Sheet
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Pravidlo platia iba pre predaj
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Odpisový riadok {0}: Nasledujúci Dátum odpisovania nemôže byť pred dátumom nákupu
@@ -4838,8 +4859,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Riadok {0}: Advance proti zákazník musí byť úver
 DocType: Quality Meeting,Quality Meeting,Kvalitné stretnutie
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-skupiny k skupine
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Prosím pomenujte Series pre {0} cez Setup&gt; Settings&gt; Naming Series
 DocType: Employee,ERPNext User,ERPĎalší používateľ
+DocType: Coupon Code,Coupon Description,Popis kupónu
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Dávka je povinná v riadku {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Dávka je povinná v riadku {0}
 DocType: Company,Default Buying Terms,Predvolené nákupné podmienky
@@ -5004,6 +5025,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Proti Detail dokumentu č
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Vymazanie nie je povolené pre krajinu {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Typ strana je povinná
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Použite kód kupónu
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",V prípade karty pracovných miest {0} môžete vykonať len typ zásob typu „Transfer materiálu na výrobu“
 DocType: Quality Inspection,Outgoing,Vycházející
 DocType: Customer Feedback Table,Customer Feedback Table,Tabuľka spätnej väzby od zákazníkov
@@ -5156,7 +5178,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Pri zadávaní objednávky
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Pridať všetkých dodávateľov
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Riadok # {0}: Pridelená čiastka nemôže byť vyššia ako dlžná suma.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Zákazník&gt; Skupina zákazníkov&gt; Územie
 DocType: Tally Migration,Parties,strany
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Prechádzať BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Zajištěné úvěry
@@ -5188,7 +5209,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Nepovoliť nastavenie alternatívnej položky pre položku {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Dátum sa opakuje
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Prokurista
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Nastavte Pomenovací systém inštruktorov v časti Vzdelanie&gt; Nastavenia vzdelávania
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Dostupné čisté ITC (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Vytvorte poplatky
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Celkové obstarávacie náklady (cez nákupné faktúry)
@@ -5213,6 +5233,7 @@
 DocType: Quiz Result,Wrong,zle
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Sazba, za kterou Ceník měna je převeden na zákazníka základní měny"
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Čistá suma (Company Mena)
+DocType: Sales Partner,Referral Code,referenčný kód
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Celková výška zálohy nemôže byť vyššia ako celková výška sankcie
 DocType: Salary Slip,Hour Rate,Hodinová sadzba
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Povoliť automatické opätovné objednávanie
@@ -5343,6 +5364,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Zobraziť množstvo zásob
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Čistý peňažný tok z prevádzkovej
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},"Riadok č. {0}: Stav musí byť {1}, aby sa mohlo znížiť množstvo faktúr {2}"
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Prepočítavací faktor UOM ({0} -&gt; {1}) nenájdený pre položku: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Bod 4
 DocType: Student Admission,Admission End Date,Vstupné Dátum ukončenia
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,subdodávky
@@ -5365,6 +5387,7 @@
 DocType: Travel Request,Fully Sponsored,Plne sponzorované
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Zadanie reverzného denníka
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Vytvorte kartu práce
+DocType: Quotation,Referral Sales Partner,Sprostredkovateľský predajca
 DocType: Quality Procedure Process,Process Description,Popis procesu
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Zákazník {0} je vytvorený.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Momentálne niesu k dispozícii položky v žiadnom sklade
@@ -5499,6 +5522,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM Rate
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Čítanie nahraného súboru
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Zastavenú pracovnú objednávku nemožno zrušiť, najskôr ju zrušte zrušením"
+DocType: Coupon Code,Coupon Code,kód kupónu
 DocType: Asset,Journal Entry for Scrap,Zápis do denníka do šrotu
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,"Prosím, vytáhněte položky z dodací list"
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Riadok {0}: vyberte pracovnú stanicu proti operácii {1}
@@ -5583,6 +5607,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,Vyžaduje sa „dátum“
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Vzhledem / Referenční datum nemůže být po {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Import dát a export
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Ľutujeme, platnosť kódu kupónu vypršala"
 DocType: Bank Account,Account Details,Údaje o účtu
 DocType: Crop,Materials Required,Potrebné materiály
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Žiadni študenti Nájdené
@@ -5620,6 +5645,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Prejdite na položku Používatelia
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Placená částka + odepsat Částka nesmí být větší než Grand Total
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} nie je platné číslo Šarže pre Položku {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Zadajte platný kupónový kód !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Poznámka: Není k dispozici dostatek zůstatek dovolené dovolená za kalendářní typ {0}
 DocType: Task,Task Description,Popis úlohy
 DocType: Training Event,Seminar,seminár
@@ -5887,6 +5913,7 @@
 ,TDS Payable Monthly,TDS splatné mesačne
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Namiesto výmeny kusovníka. Môže to trvať niekoľko minút.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Nelze odečíst, pokud kategorie je určena pro ""ocenění"" nebo ""oceňování a celkový"""
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Nastavte systém pomenovávania zamestnancov v časti Ľudské zdroje&gt; Nastavenia ľudských zdrojov
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Celkové platby
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serial Nos Požadováno pro serializovaném bodu {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Spárovať úhrady s faktúrami
@@ -5977,6 +6004,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Získajte suroviny pre výrobu
 DocType: Job Opening,Job Title,Názov pozície
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Budúca platba Ref
+DocType: Quotation,Additional Discount and Coupon Code,Dodatočný zľavový a kupónový kód
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} znamená, že {1} neposkytne ponuku, ale boli citované všetky položky \. Aktualizácia stavu ponuky RFQ."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maximálne vzorky - {0} už boli zadržané pre dávku {1} a položku {2} v dávke {3}.
@@ -6205,7 +6233,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Nastavenie titulnej stránky webu
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} je pozastavená do {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ nie sú povolené pre {0} kvôli postaveniu skóre {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Proveďte nákupní faktury
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Použité listy
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Používa sa kupón {1}. Povolené množstvo je vyčerpané
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Chcete odoslať žiadosť o materiál
 DocType: Job Offer,Awaiting Response,Čaká odpoveď
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6219,6 +6249,7 @@
 DocType: Training Event Employee,Optional,voliteľný
 DocType: Salary Slip,Earning & Deduction,Príjem a odpočty
 DocType: Agriculture Analysis Criteria,Water Analysis,Analýza vody
+DocType: Sales Order,Skip Delivery Note,Preskočiť dodací list
 DocType: Price List,Price Not UOM Dependent,Cena nie je závislá od UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} vytvorené varianty.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Predvolená dohoda o úrovni služieb už existuje.
@@ -6326,6 +6357,7 @@
 DocType: Vehicle,Last Carbon Check,Posledné Carbon Check
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Výdavky na právne služby
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Vyberte prosím množstvo na riadku
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Pracovný príkaz {0}: karta úlohy nebola pre operáciu nájdená {1}
 DocType: Purchase Invoice,Posting Time,Čas zadání
 DocType: Timesheet,% Amount Billed,% Fakturovanej čiastky
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Telefonní Náklady
@@ -6428,7 +6460,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Daně a poplatky přidané
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Odpisový riadok {0}: Nasledujúci dátum odpisovania nemôže byť pred dátumom k dispozícii na použitie
 ,Sales Funnel,Predajný lievik
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kód položky&gt; Skupina položiek&gt; Značka
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Skratka je povinná
 DocType: Project,Task Progress,pokrok úloha
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Košík
@@ -6525,6 +6556,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,"POS Profile požadované, aby POS Vstup"
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",Vernostné body sa vypočítajú z vynaloženej hotovosti (prostredníctvom faktúry predaja) na základe zmieneného faktora zberu.
 DocType: Program Enrollment Tool,Enroll Students,zapísať študenti
+DocType: Pricing Rule,Coupon Code Based,Na základe kódu kupónu
 DocType: Company,HRA Settings,Nastavenia HRA
 DocType: Homepage,Hero Section,Sekcia hrdinov
 DocType: Employee Transfer,Transfer Date,Dátum prenosu
@@ -6641,6 +6673,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',"Filtrovanie spoločnosti nastavte prázdne, ak je položka Skupina pod skupinou &quot;Spoločnosť&quot;"
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Vysielanie dátum nemôže byť budúci dátum
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Riadok # {0}: Výrobné číslo {1} nezodpovedá {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Nastavte číslovacie série pre Účasť cez Nastavenie&gt; Číslovacie série
 DocType: Stock Entry,Target Warehouse Address,Adresa cieľového skladu
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Bežná priepustka
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,"Čas pred začiatkom zmeny, počas ktorého sa za účasť považuje registrácia zamestnancov."
@@ -6675,7 +6708,6 @@
 DocType: Employee Grade,Employee Grade,Zamestnanec stupeň
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Úkolová práce
 DocType: GSTR 3B Report,June,jún
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dodávateľ&gt; Typ dodávateľa
 DocType: Share Balance,From No,Od č
 DocType: Shift Type,Early Exit Grace Period,Predčasné ukončenie odkladu
 DocType: Task,Actual Time (in Hours),Skutočná doba (v hodinách)
@@ -6962,7 +6994,6 @@
 DocType: Warehouse,Warehouse Name,Názov skladu
 DocType: Naming Series,Select Transaction,Vybrat Transaction
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Zadejte Schvalování role nebo Schvalování Uživatel
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Prepočítavací faktor UOM ({0} -&gt; {1}) nebol nájdený pre položku: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Dohoda o úrovni služieb s typom entity {0} a entitou {1} už existuje.
 DocType: Journal Entry,Write Off Entry,Odepsat Vstup
 DocType: BOM,Rate Of Materials Based On,Hodnotit materiálů na bázi
@@ -7101,6 +7132,7 @@
 DocType: Budget,Warn,Varovat
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Všetky položky už boli prevedené na túto pracovnú objednávku.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Akékoľvek iné poznámky, pozoruhodné úsilie, ktoré by mali ísť v záznamoch."
+DocType: Bank Account,Company Account,Firemný účet
 DocType: Asset Maintenance,Manufacturing User,Používateľ výroby
 DocType: Purchase Invoice,Raw Materials Supplied,Suroviny dodané
 DocType: Subscription Plan,Payment Plan,Platobný plán
@@ -7142,6 +7174,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) nemôže byť väčšia ako plánované množstvo ({2}) v pracovnom poradí {3}
 DocType: Certification Application,Name of Applicant,Meno žiadateľa
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Čas list pre výrobu.
+DocType: Quick Stock Balance,Quick Stock Balance,Rýchla bilancia zásob
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,medzisúčet
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Nemožno zmeniť vlastnosti Variantu po transakcii s akciami. Budete musieť urobiť novú položku.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA mandát
@@ -7470,6 +7503,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} je neaktívnym študentom
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} je neaktívnym študentom
 DocType: Employee,Health Details,Zdravotní Podrobnosti
+DocType: Coupon Code,Coupon Type,Typ kupónu
 DocType: Leave Encashment,Encashable days,Zapamätateľné dni
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Vyžaduje sa vytvorenie referenčného dokumentu žiadosti o platbu
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Vyžaduje sa vytvorenie referenčného dokumentu žiadosti o platbu
@@ -7758,6 +7792,7 @@
 DocType: Hotel Room Package,Amenities,Vybavenie
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Automaticky načítať platobné podmienky
 DocType: QuickBooks Migrator,Undeposited Funds Account,Účet neukladaných finančných prostriedkov
+DocType: Coupon Code,Uses,použitie
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Nie je povolený viacnásobný predvolený spôsob platby
 DocType: Sales Invoice,Loyalty Points Redemption,Vernostné body Vykúpenie
 ,Appointment Analytics,Aplikácia Analytics
@@ -7775,6 +7810,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Nechajte prázdne, ak robíte študentské skupiny ročne"
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Nechajte prázdne, ak robíte študentské skupiny ročne"
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Pokud je zaškrtnuto, Total no. pracovních dnů bude zahrnovat dovolenou, a to sníží hodnotu platu za každý den"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Nepodarilo sa pridať doménu
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Ak chcete povoliť príjem / doručenie, aktualizujte položku „Príjem a príjem zásielok“ v nastaveniach zásob alebo v položke."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Aplikácie používajúce aktuálny kľúč nebudú mať prístup, určite?"
 DocType: Subscription Settings,Prorate,kľúčovanie
@@ -7788,6 +7824,7 @@
 ,BOM Stock Report,BOM Reklamné Report
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Ak nie je priradený žiadny časový rozvrh, komunikácia bude uskutočnená touto skupinou"
 DocType: Stock Reconciliation Item,Quantity Difference,Množstvo Rozdiel
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dodávateľ&gt; Typ dodávateľa
 DocType: Opportunity Item,Basic Rate,Základná sadzba
 DocType: GL Entry,Credit Amount,Výška úveru
 ,Electronic Invoice Register,Elektronický register faktúr
@@ -8041,6 +8078,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Daně a poplatky odečteny (Company měna)
 DocType: Item Group,General Settings,Všeobecné nastavenia
 DocType: Article,Article,článok
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Zadajte kód kupónu !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Z měny a měny nemůže být stejné
 DocType: Taxable Salary Slab,Percent Deduction,Percentuálna zrážka
 DocType: GL Entry,To Rename,Premenovať
diff --git a/erpnext/translations/sl.csv b/erpnext/translations/sl.csv
index e8e2409..9bfbe13 100644
--- a/erpnext/translations/sl.csv
+++ b/erpnext/translations/sl.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-YYYY-
 DocType: Purchase Order,Customer Contact,Stranka Kontakt
 DocType: Shift Type,Enable Auto Attendance,Omogoči samodejno udeležbo
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Vnesite skladišče in datum
 DocType: Lost Reason Detail,Opportunity Lost Reason,Priložnost izgubljen razlog
 DocType: Patient Appointment,Check availability,Preveri razpoložljivost
 DocType: Retention Bonus,Bonus Payment Date,Datum plačila bonusa
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Dokončana delovna naročila
 DocType: Support Settings,Forum Posts,Objave foruma
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Naloga je bila vključena v ozadje. Če obstaja kakšna težava pri obdelavi v ozadju, bo sistem dodal komentar o napaki na tej usklajevanju zalog in se vrnil v fazo osnutka."
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started",Veljavnost kode kupona se žal ni začela
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Davčna osnova
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Nimate dovoljenja za dodajanje ali posodobitev vnose pred {0}
 DocType: Leave Policy,Leave Policy Details,Pustite podrobnosti pravilnika
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Potrošni
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,razred
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Koda izdelka&gt; Skupina izdelkov&gt; Blagovna znamka
 DocType: Restaurant Table,No of Seats,Število sedežev
 DocType: Sales Invoice,Overdue and Discounted,Prepozno in znižano
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Klic prekinjen
@@ -507,6 +510,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Razmik med vrsticami za znesek z besedami
 DocType: Vehicle,Additional Details,Dodatne podrobnosti
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Opis ni dana
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Pridobivanje izdelkov iz skladišča
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Zaprosi za nakup.
 DocType: POS Closing Voucher Details,Collected Amount,Zbrani znesek
 DocType: Lab Test,Submitted Date,Datum predložitve
@@ -614,6 +618,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Naučite
 ,Trial Balance (Simple),Preizkusna bilanca (preprosto)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Omogoči odloženi strošek
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Uporabljena koda kupona
 DocType: Asset,Next Depreciation Date,Naslednja Amortizacija Datum
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Stroški dejavnost na zaposlenega
 DocType: Accounts Settings,Settings for Accounts,Nastavitve za račune
@@ -854,8 +859,6 @@
 DocType: Sales Invoice,Total Qty,Skupaj Kol
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Skrbnika2 E-ID
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Skrbnika2 E-ID
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Izbrišite zaposlenega <a href=""#Form/Employee/{0}"">{0}</a> \, če želite preklicati ta dokument"
 DocType: Item,Show in Website (Variant),Prikaži na spletni strani (Variant)
 DocType: Employee,Health Concerns,Zdravje
 DocType: Payroll Entry,Select Payroll Period,Izberite izplačane Obdobje
@@ -1020,6 +1023,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Davčni odtegljaj
 DocType: Pricing Rule,Sales Partner,Prodaja Partner
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Vse ocenjevalne table dobaviteljev.
+DocType: Coupon Code,To be used to get discount,Uporabiti za popust
 DocType: Buying Settings,Purchase Receipt Required,Potrdilo o nakupu Obvezno
 DocType: Sales Invoice,Rail,Železnica
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Dejanski stroški
@@ -1070,6 +1074,7 @@
 DocType: Production Plan,Production Plan,Načrt proizvodnje
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Odpiranje orodja za ustvarjanje računov
 DocType: Salary Component,Round to the Nearest Integer,Zaokrožite do najbližjega celega števila
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,"Dovoli, da se izdelki, ki niso na zalogi, dodajo v košarico"
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Prodaja Return
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Nastavite količino transakcij na podlagi serijskega vhoda
 ,Total Stock Summary,Skupaj Stock Povzetek
@@ -1201,6 +1206,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Osnovna urni tečaj (družba Valuta)
 ,Qty To Be Billed,"Količina, ki jo morate plačati"
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Delivered Znesek
+DocType: Coupon Code,Gift Card,Darilne kartice
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Količina pridržane za proizvodnjo: Količina surovin za izdelavo izdelkov.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Datum odkupa
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Ta bančna transakcija je že v celoti usklajena
@@ -1290,6 +1296,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Ustvari časopis
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Račun {0} je bil vpisan večkrat
 DocType: Account,Expenses Included In Valuation,Stroški Vključeno v vrednotenju
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Nakup računov
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,"Obnovite lahko le, če vaše članstvo poteče v 30 dneh"
 DocType: Shopping Cart Settings,Show Stock Availability,Prihranite sedaj null%!
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Nastavite {0} v kategoriji sredstev {1} ali podjetje {2}
@@ -1832,6 +1839,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Uvoz elementov in UOM-ov
 DocType: Repayment Schedule,Balance Loan Amount,Bilanca Znesek posojila
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Dodano v podrobnosti
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Oprostite, koda kupona je izčrpana"
 DocType: Communication Medium,Catch All,Ujemite vse
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,urnik predmeta
 DocType: Budget,Applicable on Material Request,Velja za materialno zahtevo
@@ -2001,6 +2009,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Neveljavna Lastnost
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} je potrebno vložiti
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,E-poštne oglaševalske akcije
+DocType: Sales Partner,To Track inbound purchase,Sledenje vhodnemu nakupu
 DocType: Buying Settings,Default Supplier Group,Privzeta dobaviteljska skupina
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Količina mora biti manjša ali enaka {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Najvišji znesek primernega za sestavino {0} presega {1}
@@ -2158,8 +2167,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Naredite vnos zalog
 DocType: Hotel Room Reservation,Hotel Reservation User,Uporabnik rezervacije hotela
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Nastavi stanje
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Nastavite serijsko številčenje za udeležbo prek Setup&gt; Seting Number
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,"Prosimo, izberite predpono najprej"
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,"Prosimo, nastavite Naming Series za {0} z nastavitvijo&gt; Settings&gt; Naming Series"
 DocType: Contract,Fulfilment Deadline,Rok izpolnjevanja
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Blizu vas
 DocType: Student,O-,O-
@@ -2283,6 +2292,7 @@
 DocType: Quality Meeting Table,Under Review,V pregledu
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Prijava ni uspel
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Sredstvo {0} je ustvarjeno
+DocType: Coupon Code,Promotional,Promocijska
 DocType: Special Test Items,Special Test Items,Posebni testni elementi
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Za registracijo v Marketplace morate biti uporabnik z vlogami upravitelja sistemov in upravitelja elementov.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Ključna poročila
@@ -2321,6 +2331,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc Type
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Skupna dodeljena odstotek za prodajne ekipe mora biti 100
 DocType: Subscription Plan,Billing Interval Count,Številka obračunavanja
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Izbrišite zaposlenega <a href=""#Form/Employee/{0}"">{0}</a> \, če želite preklicati ta dokument"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Imenovanja in srečanja s pacienti
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Manjka vrednost
 DocType: Employee,Department and Grade,Oddelek in razred
@@ -2424,6 +2436,7 @@
 DocType: Project,Start and End Dates,Začetni in končni datum
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Pogoji izpolnjevanja pogodbenih pogojev
 ,Delivered Items To Be Billed,Dobavljeni artikli placevali
+DocType: Coupon Code,Maximum Use,Največja uporaba
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Odprti BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Skladišče ni mogoče spremeniti za Serial No.
 DocType: Authorization Rule,Average Discount,Povprečen Popust
@@ -2585,6 +2598,7 @@
 DocType: Item,Inventory,Popis
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Prenesite kot Json
 DocType: Item,Sales Details,Prodajna Podrobnosti
+DocType: Coupon Code,Used,Rabljeni
 DocType: Opportunity,With Items,Z Items
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Kampanja &#39;{0}&#39; že obstaja za {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Vzdrževalna ekipa
@@ -2714,7 +2728,7 @@
 						Serial No cannot be ensured",Za element {0} ni najdena aktivna BOM. Dostava z \ Serial No ne more biti zagotovljena
 DocType: Sales Partner,Sales Partner Target,Prodaja Partner Target
 DocType: Loan Type,Maximum Loan Amount,Največja Znesek posojila
-DocType: Pricing Rule,Pricing Rule,Cen Pravilo
+DocType: Coupon Code,Pricing Rule,Cen Pravilo
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Podvojena številka rola študent {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Podvojena številka rola študent {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Material Zahteva za narocilo
@@ -2794,6 +2808,7 @@
 DocType: Payment Schedule,Payment Amount,Znesek Plačila
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Datum poldnevnega dneva mora biti med delovnim časom in končnim datumom dela
 DocType: Healthcare Settings,Healthcare Service Items,Točke zdravstvenega varstva
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Neveljavna črtna koda. Na tej črtni kodi ni nobenega predmeta.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Porabljeni znesek
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Neto sprememba v gotovini
 DocType: Assessment Plan,Grading Scale,Ocenjevalna lestvica
@@ -2915,7 +2930,6 @@
 DocType: Share Transfer,Asset Account,Račun sredstev
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Nov datum izida bi moral biti v prihodnosti
 DocType: Purchase Invoice,End date of current invoice's period,Končni datum obdobja tekočega faktura je
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Prosimo, nastavite sistem poimenovanja zaposlenih v kadrovski službi&gt; Nastavitve človeških virov"
 DocType: Lab Test,Technician Name,Ime tehnika
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3027,6 +3041,7 @@
 DocType: Products Settings,Hide Variants,Skrij variante
 DocType: Lead,Next Contact By,Naslednja Kontakt Z
 DocType: Compensatory Leave Request,Compensatory Leave Request,Zahtevek za kompenzacijski odhod
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Za postavko {0} v vrstici {1} več kot {2} ni mogoče preplačati. Če želite dovoliti preplačilo, nastavite dovoljenje v nastavitvah računov"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},"Količina, potrebna za postavko {0} v vrstici {1}"
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},"Skladišče {0} ni mogoče izbrisati, kot obstaja količina za postavko {1}"
 DocType: Blanket Order,Order Type,Tip naročila
@@ -3198,7 +3213,6 @@
 DocType: Student,Student Mobile Number,Študent mobilno številko
 DocType: Item,Has Variants,Ima različice
 DocType: Employee Benefit Claim,Claim Benefit For,Claim Benefit For
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Za postavko {0} v vrstici {1} ne moremo preseči več kot {2}. Če želite omogočiti prekomerno zaračunavanje, nastavite nastavitve zalog"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Posodobi odgovor
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Ste že izbrane postavke iz {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Ime mesečnim izplačilom
@@ -3490,6 +3504,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,"Prosimo, navedite valuto v družbi"
 DocType: Workstation,Wages per hour,Plače na uro
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Konfigurirajte {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Stranka&gt; Skupina kupcev&gt; Ozemlje
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Stock ravnotežje Serija {0} bo postal negativen {1} za postavko {2} v skladišču {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Po Material Zahteve so bile samodejno dvigne temelji na ravni re-naročilnico elementa
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Račun {0} ni veljaven. Valuta računa mora biti {1}
@@ -3823,6 +3838,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Predloži plačilni list
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Na čakanju
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Karakter mora imeti vsaj eno pravilno možnost
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Naročila
 DocType: Account,Inter Company Account,Inter Company račun
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Uvoz v večjih količinah
 DocType: Sales Partner,Address & Contacts,Naslov &amp; Kontakti
@@ -3833,6 +3849,7 @@
 DocType: POS Profile,[Select],[Izberite]
 DocType: Staffing Plan Detail,Number Of Positions,Število položajev
 DocType: Vital Signs,Blood Pressure (diastolic),Krvni tlak (diastolični)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Izberite stranko.
 DocType: SMS Log,Sent To,Poslano
 DocType: Agriculture Task,Holiday Management,Upravljanje praznikov
 DocType: Payment Request,Make Sales Invoice,Naredi račun
@@ -4042,7 +4059,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} ni vložen
 DocType: Subscription,Trialling,Trialling
 DocType: Sales Invoice Item,Deferred Revenue,Odloženi prihodki
-DocType: Bank Account,GL Account,GL račun
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Gotovinski račun se bo uporabil za ustvarjanje prodajne fakture
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Podskupina za izvzetje
 DocType: Member,Membership Expiry Date,Datum prenehanja članstva
@@ -4449,13 +4465,13 @@
 DocType: C-Form Invoice Detail,Territory,Ozemlje
 DocType: Pricing Rule,Apply Rule On Item Code,Uporabi pravilo za kodo predmeta
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Navedite ni obiskov zahtevanih
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Poročilo o stanju zalog
 DocType: Stock Settings,Default Valuation Method,Način Privzeto Vrednotenje
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Fee
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Prikaži skupni znesek
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Posodabljanje je v teku. Mogoče bo trajalo nekaj časa.
 DocType: Production Plan Item,Produced Qty,Proizvedeno količino
 DocType: Vehicle Log,Fuel Qty,gorivo Kol
-DocType: Stock Entry,Target Warehouse Name,Ime ciljne skladišča
 DocType: Work Order Operation,Planned Start Time,Načrtovano Start Time
 DocType: Course,Assessment,ocena
 DocType: Payment Entry Reference,Allocated,Razporejeni
@@ -4521,10 +4537,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","Standardni Pogoji, ki se lahko dodajajo prodaje in nakupe. Primeri: 1. Veljavnost ponudbe. 1. Plačilni pogoji (vnaprej, na kredit, del predujem itd). 1. Kaj je dodatno (ali ga je dolžan plačati davek). Opozorilo / uporaba 1. varnost. 1. Garancija če sploh. 1. Izjava zasebnosti. 1. Pogoji ladijskega prometa, če je to primerno. 1. načine reševanja sporov, jamstva, odgovornosti, itd 1. Naslov in kontaktne vašega podjetja."
 DocType: Homepage Section,Section Based On,Oddelek temelji na
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Prikaži Uporabi kodo kupona
 DocType: Issue,Issue Type,Vrsta izdaje
 DocType: Attendance,Leave Type,Zapusti Type
 DocType: Purchase Invoice,Supplier Invoice Details,Dobavitelj Podrobnosti računa
 DocType: Agriculture Task,Ignore holidays,Prezri praznike
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Dodaj / uredite pogoje kupona
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Expense / Razlika račun ({0}) mora biti račun &quot;poslovni izid&quot;
 DocType: Stock Entry Detail,Stock Entry Child,Zaloga Otrok
 DocType: Project,Copied From,Kopirano iz
@@ -4700,6 +4718,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Merila načrt ocenjevanja
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Transakcije
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Preprečevanje nakupnih naročil
+DocType: Coupon Code,Coupon Name,Ime kupona
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Občutljivo
 DocType: Email Campaign,Scheduled,Načrtovano
 DocType: Shift Type,Working Hours Calculation Based On,Izračun delovnega časa na podlagi
@@ -4716,7 +4735,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Ustvari različice
 DocType: Vehicle,Diesel,Diesel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Cenik Valuta ni izbran
+DocType: Quick Stock Balance,Available Quantity,Količina na voljo
 DocType: Purchase Invoice,Availed ITC Cess,Uporabil ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Nastavite sistem poimenovanja inštruktorjev v izobraževanju&gt; Nastavitve za izobraževanje
 ,Student Monthly Attendance Sheet,Študent Mesečni Udeležba Sheet
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Pravilo o dostavi velja samo za prodajo
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Amortizacijski vrstici {0}: Naslednji amortizacijski datum ne more biti pred datumom nakupa
@@ -4784,8 +4805,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Vrstica {0}: Advance proti naročniku mora biti kredit
 DocType: Quality Meeting,Quality Meeting,Kakovostno srečanje
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-Group skupini
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,"Prosimo, nastavite Naming Series za {0} z nastavitvijo&gt; Settings&gt; Naming Series"
 DocType: Employee,ERPNext User,Uporabnik ERPNext
+DocType: Coupon Code,Coupon Description,Opis kupona
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Serija je obvezna v vrstici {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Serija je obvezna v vrstici {0}
 DocType: Company,Default Buying Terms,Privzeti pogoji nakupa
@@ -4950,6 +4971,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Proti Podrobnosti dokumenta št
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Brisanje ni dovoljeno za državo {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Vrsta Party je obvezen
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Uporabi kodo kupona
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",Za delovno izkaznico {0} lahko vnesete samo zalogo vrste &quot;Prenos materiala za proizvodnjo&quot;
 DocType: Quality Inspection,Outgoing,Odhodni
 DocType: Customer Feedback Table,Customer Feedback Table,Tabela povratnih informacij kupcev
@@ -5100,7 +5122,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Ob oddaji naročilnice
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Dodaj vse dobavitelje
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Vrstica # {0}: Razporejeni vrednosti ne sme biti večja od neplačanega zneska.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Stranka&gt; Skupina kupcev&gt; Ozemlje
 DocType: Tally Migration,Parties,Pogodbenice
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Prebrskaj BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Secured Posojila
@@ -5132,7 +5153,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Ne dovolite nastavitve nadomestnega elementa za predmet {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Datum se ponovi
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Pooblaščeni podpisnik
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Nastavite sistem poimenovanja inštruktorjev v izobraževanju&gt; Nastavitve za izobraževanje
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Neto razpoložljivi ITC (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Ustvari pristojbine
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Skupaj Nakup Cost (via računu o nakupu)
@@ -5157,6 +5177,7 @@
 DocType: Quiz Result,Wrong,Napačno
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Obrestna mera, po kateri Cenik valuti se pretvorijo v osn stranke"
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Neto znesek (družba Valuta)
+DocType: Sales Partner,Referral Code,napotitvena koda
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Skupni znesek predplačila ne more biti večji od skupnega sankcioniranega zneska
 DocType: Salary Slip,Hour Rate,Urna postavka
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Omogoči samodejno ponovno naročilo
@@ -5286,6 +5307,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Prikaži dodatke skladno z RoHS
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Čisti denarni tok iz poslovanja
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Vrstica # {0}: za popust na računu mora biti stanje {1} {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Faktor konverzije za UOM ({0} -&gt; {1}) za element: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Postavka 4
 DocType: Student Admission,Admission End Date,Sprejem Končni datum
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Podizvajalcem
@@ -5308,6 +5330,7 @@
 DocType: Travel Request,Fully Sponsored,Popolnoma sponzorirani
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Reverse Journal Entry
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Ustvari Job Card
+DocType: Quotation,Referral Sales Partner,Referral Sales Partner
 DocType: Quality Procedure Process,Process Description,Opis postopka
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Stranka {0} je ustvarjena.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Trenutno ni na zalogi
@@ -5442,6 +5465,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM Rate
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Branje naložene datoteke
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Prenehanja delovnega naročila ni mogoče preklicati, jo najprej izključite"
+DocType: Coupon Code,Coupon Code,Koda kupona
 DocType: Asset,Journal Entry for Scrap,Journal Entry za pretep
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Prosimo povlecite predmete iz dobavnice
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Vrstica {0}: izberite delovno postajo proti operaciji {1}
@@ -5526,6 +5550,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;Datum&#39; je obvezen
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Zaradi / Referenčni datum ne more biti po {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Uvoz in izvoz podatkov
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired",Žal je veljavnost kode kupona potekla
 DocType: Bank Account,Account Details,podrobnosti računa
 DocType: Crop,Materials Required,Potrebni materiali
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Najdeno študenti
@@ -5563,6 +5588,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Pojdi na uporabnike
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Plačan znesek + odpis Znesek ne sme biti večja od Grand Skupaj
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} ni veljavna številka serije za postavko {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Vnesite veljavno kodo kupona !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Opomba: Ni dovolj bilanca dopust za dopust tipa {0}
 DocType: Task,Task Description,Opis naloge
 DocType: Training Event,Seminar,seminar
@@ -5830,6 +5856,7 @@
 ,TDS Payable Monthly,TDS se plača mesečno
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Vrstni red za zamenjavo BOM. Traja lahko nekaj minut.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Ne more odbiti, če je kategorija za &quot;vrednotenje&quot; ali &quot;Vrednotenje in Total&quot;"
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Prosimo, nastavite sistem poimenovanja zaposlenih v kadrovski službi&gt; Nastavitve človeških virov"
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Skupna plačila
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serijska št Zahtevano za zaporednimi postavki {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Match plačila z računov
@@ -5920,6 +5947,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Pridobite surovine za proizvodnjo
 DocType: Job Opening,Job Title,Job Naslov
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Prihodnje plačilo Ref
+DocType: Quotation,Additional Discount and Coupon Code,Dodatna koda popusta in kupona
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} označuje, da {1} ne bo podal ponudbe, ampak cene vseh postavk so navedene. Posodabljanje statusa ponudb RFQ."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Največji vzorci - {0} so bili že shranjeni za serijo {1} in element {2} v seriji {3}.
@@ -6148,7 +6176,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Nastavitve za spletni strani
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} je na čakanju do {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ-ji niso dovoljeni za {0} zaradi postavke ocene rezultatov {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Naredite račun za nakup
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Uporabljeni listi
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Uporabljeni kuponi so {1}. Dovoljena količina je izčrpana
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Ali želite oddati materialno zahtevo
 DocType: Job Offer,Awaiting Response,Čakanje na odgovor
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-YYYY-
@@ -6162,6 +6192,7 @@
 DocType: Training Event Employee,Optional,Neobvezno
 DocType: Salary Slip,Earning & Deduction,Zaslužek &amp; Odbitek
 DocType: Agriculture Analysis Criteria,Water Analysis,Analiza vode
+DocType: Sales Order,Skip Delivery Note,Preskočite dobavnico
 DocType: Price List,Price Not UOM Dependent,Cena ni odvisna od UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} ustvarjene različice.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Pogodba o ravni privzete storitve že obstaja.
@@ -6270,6 +6301,7 @@
 DocType: Vehicle,Last Carbon Check,Zadnja Carbon Check
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Pravni stroški
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Izberite količino na vrsti
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Delovni nalog {0}: službene izkaznice ni mogoče najti za operacijo {1}
 DocType: Purchase Invoice,Posting Time,Ura vnosa
 DocType: Timesheet,% Amount Billed,% Zaračunani znesek
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Telefonske Stroški
@@ -6372,7 +6404,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Davki in dajatve Dodano
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,"Amortizacijski vrstici {0}: Naslednji Amortizacijski datum ne sme biti pred datumom, ki je na voljo za uporabo"
 ,Sales Funnel,Prodaja toka
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Koda izdelka&gt; Skupina izdelkov&gt; Blagovna znamka
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Kratica je obvezna
 DocType: Project,Task Progress,naloga Progress
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Košarica
@@ -6468,6 +6499,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,"POS Profil zahteva, da POS Entry"
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",Točke zvestobe bodo izračunane na podlagi porabljenega zneska (prek prodajnega računa) na podlagi navedenega faktorja zbiranja.
 DocType: Program Enrollment Tool,Enroll Students,včlanite Študenti
+DocType: Pricing Rule,Coupon Code Based,Na osnovi kode kupona
 DocType: Company,HRA Settings,Nastavitve HRA
 DocType: Homepage,Hero Section,Oddelek za junake
 DocType: Employee Transfer,Transfer Date,Datum prenosa
@@ -6584,6 +6616,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',"Nastavite Podjetje filtriranje prazno, če skupina Z je &quot;Podjetje&quot;"
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Napotitev datum ne more biti prihodnji datum
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Vrstica # {0}: Serijska št {1} ne ujema z {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Nastavite serijsko številčenje za udeležbo prek Setup&gt; Seting Number
 DocType: Stock Entry,Target Warehouse Address,Naslov tarče skladišča
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Casual Zapusti
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,"Čas pred začetkom izmene, v katerem se šteje prijava zaposlenih za udeležbo."
@@ -6618,7 +6651,6 @@
 DocType: Employee Grade,Employee Grade,Razred zaposlenih
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Akord
 DocType: GSTR 3B Report,June,Junij
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dobavitelj&gt; Vrsta dobavitelja
 DocType: Share Balance,From No,Od št
 DocType: Shift Type,Early Exit Grace Period,Predčasno izstopno milostno obdobje
 DocType: Task,Actual Time (in Hours),Dejanski čas (v urah)
@@ -6905,7 +6937,6 @@
 DocType: Warehouse,Warehouse Name,Skladišče Ime
 DocType: Naming Series,Select Transaction,Izberite Transaction
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Vnesite Odobritev vloge ali Potrditev uporabnika
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Faktor konverzije UOM ({0} -&gt; {1}) za element: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Pogodba o ravni storitve s tipom entitete {0} in entiteto {1} že obstaja.
 DocType: Journal Entry,Write Off Entry,Napišite Off Entry
 DocType: BOM,Rate Of Materials Based On,Oceni materialov na osnovi
@@ -7044,6 +7075,7 @@
 DocType: Budget,Warn,Opozori
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Vsi elementi so bili že preneseni za ta delovni nalog.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Kakršne koli druge pripombe, omembe vredna napora, da bi moral iti v evidencah."
+DocType: Bank Account,Company Account,Račun podjetja
 DocType: Asset Maintenance,Manufacturing User,Proizvodnja Uporabnik
 DocType: Purchase Invoice,Raw Materials Supplied,"Surovin, dobavljenih"
 DocType: Subscription Plan,Payment Plan,Plačilni načrt
@@ -7085,6 +7117,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) ne more biti večja od načrtovane količine ({2}) v delovnem redu {3}
 DocType: Certification Application,Name of Applicant,Ime prosilca
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Čas List za proizvodnjo.
+DocType: Quick Stock Balance,Quick Stock Balance,Hitro stanje zalog
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Vmesni seštevek
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Lastnosti variant ni mogoče spremeniti po transakciji z delnicami. Za to morate narediti novo postavko.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless Mandat SEPA
@@ -7413,6 +7446,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} neaktiven študent
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} neaktiven študent
 DocType: Employee,Health Details,Podrobnosti zdravja
+DocType: Coupon Code,Coupon Type,Vrsta kupona
 DocType: Leave Encashment,Encashable days,Priloženi dnevi
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Če želite ustvariti zahtevek za plačilo je potrebno referenčni dokument
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Če želite ustvariti zahtevek za plačilo je potrebno referenčni dokument
@@ -7700,6 +7734,7 @@
 DocType: Hotel Room Package,Amenities,Amenities
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Samodejno prejmite plačilne pogoje
 DocType: QuickBooks Migrator,Undeposited Funds Account,Račun nedefiniranih skladov
+DocType: Coupon Code,Uses,Uporaba
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Večkratni način plačila ni dovoljen
 DocType: Sales Invoice,Loyalty Points Redemption,Odkupi točk zvestobe
 ,Appointment Analytics,Imenovanje Analytics
@@ -7717,6 +7752,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Pustite prazno, če bi študenti skupin na leto"
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Pustite prazno, če bi študenti skupin na leto"
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Če je označeno, Total no. delovnih dni bo vključeval praznike, in to se bo zmanjšala vrednost plač dan na"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Domene ni bilo mogoče dodati
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Če želite dovoliti prejem / dostavo, posodobite &quot;Over Prejem / Dovoljenje za dostavo&quot; v nastavitvah zaloge ali pošiljko."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Aplikacije, ki uporabljajo trenutni ključ, ne bodo imele dostopa, ali ste prepričani?"
 DocType: Subscription Settings,Prorate,Prorate
@@ -7729,6 +7765,7 @@
 ,BOM Stock Report,BOM Stock Poročilo
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Če ni določenega časovnega razporeda, bo komunikacija upravljala ta skupina"
 DocType: Stock Reconciliation Item,Quantity Difference,količina Razlika
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dobavitelj&gt; Vrsta dobavitelja
 DocType: Opportunity Item,Basic Rate,Osnovni tečaj
 DocType: GL Entry,Credit Amount,Credit Znesek
 ,Electronic Invoice Register,Register elektronskih računov
@@ -7983,6 +8020,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Davki in dajatve Odbitek (družba Valuta)
 DocType: Item Group,General Settings,Splošne nastavitve
 DocType: Article,Article,Člen
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,"Prosimo, vnesite kodo kupona !!"
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Od denarja in denarja ne more biti enaka
 DocType: Taxable Salary Slab,Percent Deduction,Odstotek odbitka
 DocType: GL Entry,To Rename,Če želite preimenovati
diff --git a/erpnext/translations/sq.csv b/erpnext/translations/sq.csv
index cf8e8fd..ee7b96e 100644
--- a/erpnext/translations/sq.csv
+++ b/erpnext/translations/sq.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Customer Contact
 DocType: Shift Type,Enable Auto Attendance,Aktivizoni pjesëmarrjen automatike
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Ju lutemi shkruani Magazinën dhe datën
 DocType: Lost Reason Detail,Opportunity Lost Reason,Arsyeja e Humbur e Mundësisë
 DocType: Patient Appointment,Check availability,Kontrolloni disponueshmërinë
 DocType: Retention Bonus,Bonus Payment Date,Data e Pagesës së Bonusit
@@ -263,6 +264,7 @@
 ,Completed Work Orders,Urdhrat e Kompletuara të Punës
 DocType: Support Settings,Forum Posts,Postimet në Forum
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Detyra është përmbledhur si një punë në sfond. Në rast se ka ndonjë çështje në përpunimin në sfond, sistemi do të shtojë një koment në lidhje me gabimin në këtë pajtim të aksioneve dhe të kthehet në fazën e Projektit"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Na vjen keq, vlefshmëria e kodit kupon nuk ka filluar"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Shuma e tatueshme
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,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: Leave Policy,Leave Policy Details,Lini Detajet e Politikave
@@ -327,6 +329,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Harxhuese
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,Gradë
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kodi i Artikullit&gt; Grupi i Artikujve&gt; Marka
 DocType: Restaurant Table,No of Seats,Jo e Vendeve
 DocType: Sales Invoice,Overdue and Discounted,E vonuar dhe e zbritur
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Thirrja është shkëputur
@@ -503,6 +506,7 @@
 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/templates/generators/bom.html,No description given,Nuk ka përshkrim dhënë
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Fetch Artikuj nga Magazina
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Kërkesë për blerje.
 DocType: POS Closing Voucher Details,Collected Amount,Shuma e mbledhur
 DocType: Lab Test,Submitted Date,Data e Dërguar
@@ -609,6 +613,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Mëso
 ,Trial Balance (Simple),Bilanci gjyqësor (i thjeshtë)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Aktivizo shpenzimin e shtyrë
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Kodi i Kuponit të Aplikuar
 DocType: Asset,Next Depreciation Date,Zhvlerësimi Data Next
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Aktiviteti Kosto për punonjës
 DocType: Accounts Settings,Settings for Accounts,Cilësimet për Llogaritë
@@ -845,8 +850,6 @@
 DocType: Sales Invoice,Total Qty,Gjithsej Qty
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 Email ID
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 Email ID
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Ju lutemi fshini punonjësin <a href=""#Form/Employee/{0}"">{0}</a> \ për të anulluar këtë dokument"
 DocType: Item,Show in Website (Variant),Show në Website (Variant)
 DocType: Employee,Health Concerns,Shqetësimet shëndetësore
 DocType: Payroll Entry,Select Payroll Period,Zgjidhni Periudha Payroll
@@ -1010,6 +1013,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Llogaria e Mbajtjes së Tatimit
 DocType: Pricing Rule,Sales Partner,Sales Partner
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Të gjitha tabelat e rezultateve të furnizuesit.
+DocType: Coupon Code,To be used to get discount,Për t’u përdorur për të marrë zbritje
 DocType: Buying Settings,Purchase Receipt Required,Pranimi Blerje kërkuar
 DocType: Sales Invoice,Rail,Rail
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Kostoja aktuale
@@ -1058,6 +1062,7 @@
 DocType: Production Plan,Production Plan,Plani i prodhimit
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Hapja e Faturave të Faturës
 DocType: Salary Component,Round to the Nearest Integer,Raundi për interesin më të afërt
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Lejoni artikujt që nuk janë në gjendje të shtohen në shportë
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Shitjet Kthehu
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Set Qty në Transaksionet bazuar në Serial No Input
 ,Total Stock Summary,Total Stock Përmbledhje
@@ -1184,6 +1189,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Base Hour Vlerësoni (Company Valuta)
 ,Qty To Be Billed,Qëllimi për t&#39;u faturuar
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Shuma Dorëzuar
+DocType: Coupon Code,Gift Card,Karta e Dhuratës
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Sasia e Rezervuar për Prodhim: Sasia e lëndëve të para për të bërë artikuj prodhues.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Data e riblerjes
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Ky transaksion bankar tashmë është barazuar plotësisht
@@ -1273,6 +1279,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Krijoni fletën e kohës
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,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/hooks.py,Purchase Invoices,Blerje Fatura
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,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: Shopping Cart Settings,Show Stock Availability,Trego disponueshmërinë e aksioneve
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Set {0} në kategorinë e aseteve {1} ose kompani {2}
@@ -1812,6 +1819,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Importimi i artikujve dhe UOM-ve
 DocType: Repayment Schedule,Balance Loan Amount,Bilanci Shuma e Kredisë
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Shtuar në detaje
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Na vjen keq, kodi kupon është i lodhur"
 DocType: Communication Medium,Catch All,Kap të gjitha
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Orari i kursit
 DocType: Budget,Applicable on Material Request,Aplikohet në Kërkesën Materiale
@@ -1982,6 +1990,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Atributi i pavlefshëm
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} duhet të dorëzohet
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Fushata me Email
+DocType: Sales Partner,To Track inbound purchase,Për të ndjekur blerjen hyrëse
 DocType: Buying Settings,Default Supplier Group,Grupi Furnizues i paracaktuar
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Sasia duhet të jetë më e vogël se ose e barabartë me {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Shuma maksimale e pranueshme për komponentin {0} tejkalon {1}
@@ -2136,8 +2145,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Bëni hyrjen e aksioneve
 DocType: Hotel Room Reservation,Hotel Reservation User,Përdoruesi i Rezervimit të Hoteleve
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Vendosni statusin
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Ju lutemi vendosni seritë e numrave për Pjesëmarrje përmes Konfigurimit&gt; Seritë e numrave
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,"Ju lutem, përzgjidhni prefiks parë"
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Ju lutemi vendosni Seritë e Emërtimit për {0} përmes Konfigurimit&gt; Cilësimet&gt; Seritë e Emrave
 DocType: Contract,Fulfilment Deadline,Afati i përmbushjes
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Pranë jush
 DocType: Student,O-,O-
@@ -2260,6 +2269,7 @@
 DocType: Quality Meeting Table,Under Review,Nën rishikim
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Dështoi të identifikohej
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Aseti {0} krijoi
+DocType: Coupon Code,Promotional,Promotional
 DocType: Special Test Items,Special Test Items,Artikujt e veçantë të testimit
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Duhet të jeni përdorues me role të Menaxhmentit të Sistemit dhe Menaxhimit të Arteve për t&#39;u regjistruar në Marketplace.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Raportet kryesore
@@ -2298,6 +2308,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc Type
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Gjithsej përqindje ndarë për shitjet e ekipit duhet të jetë 100
 DocType: Subscription Plan,Billing Interval Count,Numërimi i intervalit të faturimit
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Ju lutemi fshini punonjësin <a href=""#Form/Employee/{0}"">{0}</a> \ për të anulluar këtë dokument"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Emërimet dhe takimet e pacientëve
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Vlera mungon
 DocType: Employee,Department and Grade,Departamenti dhe Shkalla
@@ -2398,6 +2410,7 @@
 DocType: Project,Start and End Dates,Filloni dhe Fundi Datat
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Termat e përmbushjes së kushteve të kontratës
 ,Delivered Items To Be Billed,Items dorëzohet për t&#39;u faturuar
+DocType: Coupon Code,Maximum Use,Përdorimi maksimal
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Hapur BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Depo nuk mund të ndryshohet për të Serial Nr
 DocType: Authorization Rule,Average Discount,Discount mesatar
@@ -2557,6 +2570,7 @@
 DocType: Item,Inventory,Inventar
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Shkarkoni si Json
 DocType: Item,Sales Details,Shitjet Detajet
+DocType: Coupon Code,Used,të përdorura
 DocType: Opportunity,With Items,Me Items
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Fushata &#39;{0}&#39; tashmë ekziston për {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Ekipi i Mirëmbajtjes
@@ -2683,7 +2697,7 @@
 						Serial No cannot be ensured",Asnjë BOM aktive nuk u gjet për artikullin {0}. Dorëzimi nga \ Serial No nuk mund të sigurohet
 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
+DocType: Coupon Code,Pricing Rule,Rregulla e Çmimeve
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,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,Duplicate roll number for student {0},Numri Duplicate roll për nxënës {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Kërkesë materiale për të blerë Radhit
@@ -2761,6 +2775,7 @@
 DocType: Payment Schedule,Payment Amount,Shuma e pagesës
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Dita e Ditës së Pjesshme duhet të jetë në mes të Punës nga Data dhe Data e Përfundimit të Punës
 DocType: Healthcare Settings,Healthcare Service Items,Artikujt e shërbimit të kujdesit shëndetësor
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Barkodi i pavlefshëm. Nuk ka asnjë artikull të bashkangjitur në këtë barkod.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Shuma konsumuar
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Ndryshimi neto në para të gatshme
 DocType: Assessment Plan,Grading Scale,Scale Nota
@@ -2881,7 +2896,6 @@
 DocType: Share Transfer,Asset Account,Llogaria e Aseteve
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Data e re e lëshimit duhet të jetë në të ardhmen
 DocType: Purchase Invoice,End date of current invoice's period,Data e fundit e periudhës së fatura aktual
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Ju lutemi vendosni Sistemin e Emërtimit të Punonjësve në Burimet Njerëzore&gt; Cilësimet e BNJ
 DocType: Lab Test,Technician Name,Emri Teknik
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3160,7 +3174,6 @@
 DocType: Student,Student Mobile Number,Student Mobile Number
 DocType: Item,Has Variants,Ka Variantet
 DocType: Employee Benefit Claim,Claim Benefit For,Përfitoni nga kërkesa për
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Nuk mund të mbivlerësohet për Item {0} në rresht {1} më shumë se {2}. Për të lejuar mbi-faturimin, ju lutemi vendosni në Settings Stock"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Përditësoni përgjigjen
 apps/erpnext/erpnext/public/js/utils.js,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
@@ -3449,6 +3462,7 @@
 DocType: Vehicle,Fuel Type,Fuel Lloji
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Ju lutem specifikoni monedhës në Kompaninë
 DocType: Workstation,Wages per hour,Rrogat në orë
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Klienti&gt; Grupi i Klientëve&gt; Territori
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},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,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
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Llogari {0} është i pavlefshëm. Llogaria Valuta duhet të jetë {1}
@@ -3781,6 +3795,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Submit Kuponi pagave
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Ne pritje
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Një grindje duhet të ketë të paktën një mundësi të saktë
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Urdhrat e blerjes
 DocType: Account,Inter Company Account,Llogaria Inter Company
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Importi në Bulk
 DocType: Sales Partner,Address & Contacts,Adresa dhe Kontaktet
@@ -3791,6 +3806,7 @@
 DocType: POS Profile,[Select],[Zgjidh]
 DocType: Staffing Plan Detail,Number Of Positions,Numri i Pozicioneve
 DocType: Vital Signs,Blood Pressure (diastolic),Presioni i gjakut (diastolik)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Ju lutemi zgjidhni klientin.
 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ë
@@ -3998,7 +4014,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} nuk është dorëzuar
 DocType: Subscription,Trialling,trialling
 DocType: Sales Invoice Item,Deferred Revenue,Të Ardhurat e shtyra
-DocType: Bank Account,GL Account,Llogaria GL
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Llogaria e Parasë do të përdoret për krijimin e Faturës së Shitjes
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Nën Kategoria e Përjashtimit
 DocType: Member,Membership Expiry Date,Data e skadimit të anëtarësisë
@@ -4191,6 +4206,8 @@
 apps/erpnext/erpnext/accounts/utils.py,Allocated amount cannot be negative,Shuma e alokuar nuk mund të jetë negative
 DocType: Sales Order,Billing Status,Faturimi Statusi
 apps/erpnext/erpnext/public/js/conf.js,Report an Issue,Raportoni një çështje
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"If you {0} {1} quantities of the item <b>{2}</b>, the scheme <b>{3}</b>
+			will be applied on the item.","Nëse keni sasi {0} {1} të artikullit <b>{2}</b> , skema <b>{3}</b> do të aplikohet në artikull."
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Utility Expenses,Shpenzimet komunale
 apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,90-Above,90-Mbi
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Row # {0}: Ditari Hyrja {1} nuk ka llogari {2} ose tashmë krahasohen kundër një kupon
@@ -4395,13 +4412,13 @@
 DocType: C-Form Invoice Detail,Territory,Territor
 DocType: Pricing Rule,Apply Rule On Item Code,Aplikoni rregullin mbi kodin e artikullit
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Ju lutemi përmendni i vizitave të kërkuara
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Raporti i Bilancit të Aksioneve
 DocType: Stock Settings,Default Valuation Method,Gabim Vlerësimi Metoda
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,tarifë
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Trego Shuma Kumulative
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Përditësohet në progres. Mund të duhet një kohë.
 DocType: Production Plan Item,Produced Qty,Prodhuar Qty
 DocType: Vehicle Log,Fuel Qty,Fuel Qty
-DocType: Stock Entry,Target Warehouse Name,Emri i magazinës së synuar
 DocType: Work Order Operation,Planned Start Time,Planifikuar Koha e fillimit
 DocType: Course,Assessment,vlerësim
 DocType: Payment Entry Reference,Allocated,Ndarë
@@ -4467,10 +4484,12 @@
 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: Homepage Section,Section Based On,Seksioni i bazuar në
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Trego Apliko Kodin e Kuponit
 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/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Shto / Ndrysho Kushtet e Kuponit
 apps/erpnext/erpnext/controllers/stock_controller.py,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: Stock Entry Detail,Stock Entry Child,Fëmija i hyrjes së aksioneve
 DocType: Project,Copied From,kopjuar nga
@@ -4642,6 +4661,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Kriteret plan vlerësimi
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,transaksionet
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Parandalimi i urdhrave të blerjes
+DocType: Coupon Code,Coupon Name,Emri i kuponit
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,i prekshëm
 DocType: Email Campaign,Scheduled,Planifikuar
 DocType: Shift Type,Working Hours Calculation Based On,Llogaritja e orarit të punës bazuar në
@@ -4658,7 +4678,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Krijo Variantet
 DocType: Vehicle,Diesel,naftë
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Lista e Çmimeve Valuta nuk zgjidhet
+DocType: Quick Stock Balance,Available Quantity,Sasia e disponueshme
 DocType: Purchase Invoice,Availed ITC Cess,Availed ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Ju lutemi vendosni Sistemin e Emërtimit të Instruktorëve në Arsim&gt; Cilësimet e arsimit
 ,Student Monthly Attendance Sheet,Student Pjesëmarrja mujore Sheet
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Rregullat e transportit të aplikueshme vetëm për shitjen
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Rënia e amortizimit {0}: Data e zhvlerësimit tjetër nuk mund të jetë para datës së blerjes
@@ -4726,8 +4748,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Row {0}: Advance kundër Customer duhet të jetë krediti
 DocType: Quality Meeting,Quality Meeting,Takim cilësor
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Non-Group Grupit
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Ju lutemi vendosni Seritë e Emërtimit për {0} përmes Konfigurimit&gt; Cilësimet&gt; Seritë e Emrave
 DocType: Employee,ERPNext User,Përdoruesi ERPNext
+DocType: Coupon Code,Coupon Description,Përshkrimi i kuponit
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,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,Batch is mandatory in row {0},Grumbull është i detyrueshëm në rradhë {0}
 DocType: Company,Default Buying Terms,Kushtet e blerjes së paracaktuar
@@ -4891,6 +4913,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Kundër Document Detail Jo
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Largimi nuk lejohet për shtetin {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Lloji Party është e detyrueshme
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Aplikoni Kodin e Kuponit
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","Për kartën e punës {0}, ju mund të bëni hyrjen e stokut vetëm &quot;Transferimi i Materialit për Prodhim&quot;"
 DocType: Quality Inspection,Outgoing,Largohet
 DocType: Customer Feedback Table,Customer Feedback Table,Tabela e reagimeve të klientit
@@ -5041,7 +5064,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Për dorëzimin e urdhrit të blerjes
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Shto të Gjithë Furnizuesit
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,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/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Klienti&gt; Grupi i Klientëve&gt; Territori
 DocType: Tally Migration,Parties,palët
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Shfleto bom
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Kredi të siguruara
@@ -5073,7 +5095,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Mos lejoni të vendosni elementin alternativ për artikullin {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Data përsëritet
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Nënshkrues i autorizuar
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Ju lutemi vendosni Sistemin e Emërtimit të Instruktorëve në Arsim&gt; Cilësimet e arsimit
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),ITC Neto i disponueshëm (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Krijo tarifa
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Gjithsej Kosto Blerje (nëpërmjet Blerje Faturës)
@@ -5097,6 +5118,7 @@
 DocType: Quiz Result,Wrong,i gabuar
 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)
+DocType: Sales Partner,Referral Code,Kodi i Referimit
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,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
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Aktivizo Rirregullimin Auto
@@ -5225,6 +5247,7 @@
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},Ju lutem zgjidhni BOM kundër sendit {0}
 DocType: Shopping Cart Settings,Show Stock Quantity,Trego sasinë e stoqeve
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Paraja neto nga operacionet
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Faktori konvertimit i UOM ({0} -&gt; {1}) nuk u gjet për artikullin: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Pika 4
 DocType: Student Admission,Admission End Date,Pranimi End Date
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Nënkontraktimi
@@ -5246,6 +5269,7 @@
 DocType: Travel Request,Fully Sponsored,Plotësisht e sponsorizuar
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Hyrja Reverse Journal
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Krijoni Kartën e Punës
+DocType: Quotation,Referral Sales Partner,Partner Shitje Referimi
 DocType: Quality Procedure Process,Process Description,Përshkrimi i procesit
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Klienti {0} është krijuar.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Aktualisht nuk ka stoqe ne asnje depo
@@ -5377,6 +5401,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,Bom Rate
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Leximi i skedarit të ngarkuar
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Ndalohet Rendi i Punës nuk mund të anulohet, të anullohet së pari të anulohet"
+DocType: Coupon Code,Coupon Code,Kodi kupon
 DocType: Asset,Journal Entry for Scrap,Journal Hyrja për skrap
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Ju lutemi të tërheqë sendet nga i dorëzimit Shënim
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Rresht {0}: zgjidhni stacionin e punës kundër operacionit {1}
@@ -5458,6 +5483,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,Kërkohet &#39;data&#39;
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Për shkak / Referenca Data nuk mund të jetë pas {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Importi dhe Eksporti i të dhënave
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Na vjen keq, vlefshmëria e kodit kupon ka skaduar"
 DocType: Bank Account,Account Details,detajet e llogarise
 DocType: Crop,Materials Required,Materialet e kërkuara
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Nuk studentët Found
@@ -5495,6 +5521,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Shko te Përdoruesit
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,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,{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/shopping_cart/cart.py,Please enter valid coupon code !!,Ju lutemi shkruani kodin e vlefshëm të kuponit !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Shënim: Nuk ka bilanc mjaft leje për pushim Lloji {0}
 DocType: Task,Task Description,Përshkrimi i detyrës
 DocType: Training Event,Seminar,seminar
@@ -5756,6 +5783,7 @@
 ,TDS Payable Monthly,TDS paguhet çdo muaj
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Në pritje për zëvendësimin e BOM. Mund të duhen disa minuta.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,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/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Ju lutemi vendosni Sistemin e Emërtimit të Punonjësve në Burimet Njerëzore&gt; Cilësimet e BNJ
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Pagesat totale
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serial Nos kërkuar për Item serialized {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Pagesat ndeshje me faturat
@@ -5843,6 +5871,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Merrni lëndë të para për prodhim
 DocType: Job Opening,Job Title,Titulli Job
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Pagesa në të ardhmen Ref
+DocType: Quotation,Additional Discount and Coupon Code,Zbritje shtesë dhe kodi i kuponit
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} 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,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}.
@@ -6068,6 +6097,7 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Parametrat për faqen e internetit
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} është në pritje derisa {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},Kerkesat e kerkesave nuk lejohen per {0} per shkak te nje standarti te rezultateve te {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Bëni Blerje Faturë
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Lë të përdorura
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,A doni të paraqisni kërkesën materiale
 DocType: Job Offer,Awaiting Response,Në pritje të përgjigjes
@@ -6082,6 +6112,7 @@
 DocType: Training Event Employee,Optional,fakultativ
 DocType: Salary Slip,Earning & Deduction,Fituar dhe Zbritje
 DocType: Agriculture Analysis Criteria,Water Analysis,Analiza e ujit
+DocType: Sales Order,Skip Delivery Note,Kalo Shënimin e Dorëzimit
 DocType: Price List,Price Not UOM Dependent,Pricemimi jo i varur nga UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} variantet e krijuara.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Një marrëveshje e nivelit të shërbimit të paracaktuar tashmë ekziston.
@@ -6286,7 +6317,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Taksat dhe Tarifat Shtuar
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Rënia e zhvlerësimit {0}: Data e zhvlerësimit tjetër nuk mund të jetë para datës së disponueshme për përdorim
 ,Sales Funnel,Gyp Sales
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kodi i Artikullit&gt; Grupi i Artikujve&gt; Marka
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Shkurtim është i detyrueshëm
 DocType: Project,Task Progress,Task Progress
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Qerre
@@ -6380,6 +6410,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS Profilin nevojshme për të bërë POS Hyrja
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Pikat e Besnikërisë do të llogariten nga shpenzimet e kryera (nëpërmjet Faturës së Shitjes), bazuar në faktorin e grumbullimit të përmendur."
 DocType: Program Enrollment Tool,Enroll Students,regjistrohen Studentët
+DocType: Pricing Rule,Coupon Code Based,Bazuar në Kodin e Kuponit
 DocType: Company,HRA Settings,Cilësimet e HRA
 DocType: Homepage,Hero Section,Seksioni i Heroit
 DocType: Employee Transfer,Transfer Date,Data e transferimit
@@ -6493,6 +6524,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,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,Posting Date cannot be future date,Posting Data nuk mund të jetë data e ardhmja
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: serial {1} nuk përputhet me {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Ju lutemi vendosni seritë e numrave për Pjesëmarrje përmes Konfigurimit&gt; Seritë e numrave
 DocType: Stock Entry,Target Warehouse Address,Adresën e Objektit të Objektit
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Lini Rastesishme
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,"Koha para fillimit të ndërrimit, gjatë së cilës Kontrolli i Punonjësve konsiderohet për pjesëmarrje."
@@ -6527,7 +6559,6 @@
 DocType: Employee Grade,Employee Grade,Shkalla e punonjësve
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Punë me copë
 DocType: GSTR 3B Report,June,qershor
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Furnizuesi&gt; Lloji i furnizuesit
 DocType: Share Balance,From No,Nga Nr
 DocType: Shift Type,Early Exit Grace Period,Periudha e Hirit të Daljes së Hershme
 DocType: Task,Actual Time (in Hours),Koha aktuale (në orë)
@@ -6946,6 +6977,7 @@
 DocType: Budget,Warn,Paralajmëroj
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Të gjitha sendet tashmë janë transferuar për këtë Rendit të Punës.
 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: Bank Account,Company Account,Llogaria e ndërmarrjes
 DocType: Asset Maintenance,Manufacturing User,Prodhim i përdoruesit
 DocType: Purchase Invoice,Raw Materials Supplied,Lëndëve të para furnizuar
 DocType: Subscription Plan,Payment Plan,Plani i Pagesës
@@ -6987,6 +7019,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) nuk mund të jetë më i madh se sasia e planifikuar ({2}) në Urdhërin e Punës {3}
 DocType: Certification Application,Name of Applicant,Emri i aplikuesit
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Sheet Koha për prodhimin.
+DocType: Quick Stock Balance,Quick Stock Balance,Bilanci i Shitjes së Shpejtë
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Nëntotali
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Nuk mund të ndryshojë pronat e variantit pas transaksionit të aksioneve. Ju do të keni për të bërë një artikull të ri për ta bërë këtë.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,Mandati i SEPA për GoCardless
@@ -7309,6 +7342,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} është nxënës joaktiv
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} është nxënës joaktiv
 DocType: Employee,Health Details,Detajet Shëndeti
+DocType: Coupon Code,Coupon Type,Lloji i kuponit
 DocType: Leave Encashment,Encashable days,Ditët e kërcënueshme
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,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,To create a Payment Request reference document is required,Për të krijuar një kërkesë për pagesë dokument reference është e nevojshme
@@ -7591,6 +7625,7 @@
 DocType: Hotel Room Package,Amenities,pajisje
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Merr automatikisht Kushtet e Pagesës
 DocType: QuickBooks Migrator,Undeposited Funds Account,Llogaria e fondeve të papaguara
+DocType: Coupon Code,Uses,përdorimet
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Mënyra e parazgjedhur e pagesës nuk lejohet
 DocType: Sales Invoice,Loyalty Points Redemption,Pikëpamja e Besnikërisë
 ,Appointment Analytics,Analiza e emërimeve
@@ -7607,6 +7642,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Buxheti Total
 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"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Nuk arriti të shtojë domenin
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Për të lejuar marrjen / dorëzimin, azhurnoni &quot;Mbi lejimin / dorëzimin e lejimit&quot; në Cilësimet e Aksioneve ose Artikullit."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Aplikacionet që përdorin çelësin aktual nuk do të jenë në gjendje të hyjnë, jeni i sigurt?"
 DocType: Subscription Settings,Prorate,prorate
@@ -7620,6 +7656,7 @@
 ,BOM Stock Report,BOM Stock Raporti
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Nëse nuk ka një listë kohore të caktuar, atëherë komunikimi do të trajtohet nga ky grup"
 DocType: Stock Reconciliation Item,Quantity Difference,sasia Diferenca
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Furnizuesi&gt; Lloji i furnizuesit
 DocType: Opportunity Item,Basic Rate,Norma bazë
 DocType: GL Entry,Credit Amount,Shuma e kreditit
 ,Electronic Invoice Register,Regjistri elektronik i faturave
@@ -7872,6 +7909,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Taksat dhe Tarifat zbritet (Kompania Valuta)
 DocType: Item Group,General Settings,Cilësimet përgjithshme
 DocType: Article,Article,artikull
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Ju lutemi shkruani kodin kupon !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Nga Valuta dhe me monedhën nuk mund të jetë e njëjtë
 DocType: Taxable Salary Slab,Percent Deduction,Përqindja e zbritjes
 DocType: GL Entry,To Rename,Për ta riemëruar
diff --git a/erpnext/translations/sr.csv b/erpnext/translations/sr.csv
index 4bb3c26..bd2ca7d 100644
--- a/erpnext/translations/sr.csv
+++ b/erpnext/translations/sr.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,МАТ-ДТ-ИИИИ.-
 DocType: Purchase Order,Customer Contact,Кориснички Контакт
 DocType: Shift Type,Enable Auto Attendance,Омогући аутоматско присуство
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Унесите складиште и датум
 DocType: Lost Reason Detail,Opportunity Lost Reason,Прилика изгубљен разлог
 DocType: Patient Appointment,Check availability,Провери доступност
 DocType: Retention Bonus,Bonus Payment Date,Датум исплате бонуса
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Завршени радни налоги
 DocType: Support Settings,Forum Posts,Форум Постс
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Задатак је замишљен као позадински посао. У случају да у позадини постоји проблем са обрадом, систем ће додати коментар о грешци на овом усклађивању залиха и вратити се у фазу нацрта"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Нажалост, валидност кода купона није започела"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,опорезиви износ
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},"Вы не авторизованы , чтобы добавить или обновить записи до {0}"
 DocType: Leave Policy,Leave Policy Details,Оставите детаље о политици
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,потребляемый
 DocType: Student,B-,Б-
 DocType: Assessment Result,Grade,разред
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Код артикла&gt; Група артикала&gt; Марка
 DocType: Restaurant Table,No of Seats,Број седишта
 DocType: Sales Invoice,Overdue and Discounted,Закашњели и снижени
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Позив прекинути
@@ -507,6 +510,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Проред за износ у речима
 DocType: Vehicle,Additional Details,Додатни детаљи
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Не введено описание
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Дохваћање предмета из складишта
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Захтев за куповину.
 DocType: POS Closing Voucher Details,Collected Amount,Прикупљени износ
 DocType: Lab Test,Submitted Date,Датум подношења
@@ -614,6 +618,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Научити
 ,Trial Balance (Simple),Пробни баланс (једноставан)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Омогућите одложени трошак
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Примењени код купона
 DocType: Asset,Next Depreciation Date,Следећа Амортизација Датум
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Активност Трошкови по запосленом
 DocType: Accounts Settings,Settings for Accounts,Подешавања за рачуне
@@ -853,8 +858,6 @@
 DocType: BOM,Work Order,Радни налог
 DocType: Sales Invoice,Total Qty,Укупно ком
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Гуардиан2 маил ИД
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Избришите запосленика <a href=""#Form/Employee/{0}"">{0}</a> \ да бисте отказали овај документ"
 DocType: Item,Show in Website (Variant),Схов на сајту (Варијанта)
 DocType: Employee,Health Concerns,Здравље Забринутост
 DocType: Payroll Entry,Select Payroll Period,Изабери периода исплате
@@ -1020,6 +1023,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Порески налог за одузимање пореза
 DocType: Pricing Rule,Sales Partner,Продаја Партнер
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Све испоставне картице.
+DocType: Coupon Code,To be used to get discount,Да се користи за попуст
 DocType: Buying Settings,Purchase Receipt Required,Куповина Потврда Обавезно
 DocType: Sales Invoice,Rail,Раил
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Стварна цена
@@ -1070,6 +1074,7 @@
 DocType: Production Plan,Production Plan,План производње
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Отварање алата за креирање фактуре
 DocType: Salary Component,Round to the Nearest Integer,Заокружите на најближи цели број
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Дозволите да се додају у кошарицу артикли који нису на складишту
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Продаја Ретурн
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Поставите количину у трансакцијама на основу Серијски број улаза
 ,Total Stock Summary,Укупно Сток Преглед
@@ -1200,6 +1205,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),База час курс (Фирма валута)
 ,Qty To Be Billed,Количина за наплату
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Деливеред Износ
+DocType: Coupon Code,Gift Card,Поклон картица
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Количина резервисаног за производњу: Количина сировина за израду производних предмета.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Датум откупљења
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Ова је банкарска трансакција већ у потпуности усклађена
@@ -1289,6 +1295,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Направите часопис
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Рачун {0} је ушла више пута
 DocType: Account,Expenses Included In Valuation,Трошкови укључени у процене
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Куповина рачуна
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Можете обновити само ако ваше чланство истекне у року од 30 дана
 DocType: Shopping Cart Settings,Show Stock Availability,Схов Стоцк Аваилабилити
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Поставите {0} у категорији активе {1} или компанију {2}
@@ -1851,6 +1858,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Увоз предмета и УОМ-ова
 DocType: Repayment Schedule,Balance Loan Amount,Биланс Износ кредита
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Додато у детаље
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Извините, код купона је исцрпљен"
 DocType: Communication Medium,Catch All,Цатцх Алл
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Распоред курса
 DocType: Budget,Applicable on Material Request,Применљиво на захтев за материјал
@@ -2021,6 +2029,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,неважећи Атрибут
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} должны быть представлены
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Е-маил кампање
+DocType: Sales Partner,To Track inbound purchase,Да бисте пратили улазну куповину
 DocType: Buying Settings,Default Supplier Group,Подразумевана група добављача
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Количина мора бити мањи од или једнак {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Максимални износ који одговара компоненти {0} прелази {1}
@@ -2178,8 +2187,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Унесите залихе
 DocType: Hotel Room Reservation,Hotel Reservation User,Резервација корисника хотела
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Подесите статус
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Молимо вас да подесите серију нумерирања за Аттенданце путем Подешавање&gt; Серија бројања
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,"Пожалуйста, выберите префикс первым"
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Молимо поставите Наминг Сериес за {0} путем Подешавање&gt; Подешавања&gt; Именовање серије
 DocType: Contract,Fulfilment Deadline,Рок испуњења
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Близу вас
 DocType: Student,O-,О-
@@ -2303,6 +2312,7 @@
 DocType: Quality Meeting Table,Under Review,У разматрању
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Није успела да се пријавите
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Имовина {0} креирана
+DocType: Coupon Code,Promotional,Промотивни
 DocType: Special Test Items,Special Test Items,Специјалне тестне тачке
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Морате бити корисник са улогама Систем Манагер и Итем Манагер за пријављивање на Маркетплаце.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Кључни извештаји
@@ -2340,6 +2350,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Док Тип
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Всего выделено процент для отдела продаж должен быть 100
 DocType: Subscription Plan,Billing Interval Count,Броју интервала обрачуна
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Избришите запосленика <a href=""#Form/Employee/{0}"">{0}</a> \ да бисте отказали овај документ"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Именовања и сусрети са пацијентима
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Недостаје вредност
 DocType: Employee,Department and Grade,Одељење и разред
@@ -2443,6 +2455,7 @@
 DocType: Project,Start and End Dates,Почетни и завршни датуми
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Услови испуњавања обрасца уговора
 ,Delivered Items To Be Billed,Испоручени артикала буду наплаћени
+DocType: Coupon Code,Maximum Use,Максимална употреба
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Отворено БОМ {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Магацин не може да се промени за серијским бројем
 DocType: Authorization Rule,Average Discount,Просечна дисконтна
@@ -2605,6 +2618,7 @@
 DocType: Item,Inventory,Инвентар
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Преузми као Јсон
 DocType: Item,Sales Details,Детаљи продаје
+DocType: Coupon Code,Used,Користи се
 DocType: Opportunity,With Items,Са ставкама
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Кампања &#39;{0}&#39; већ постоји за {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Тим за одржавање
@@ -2734,7 +2748,7 @@
 						Serial No cannot be ensured",Није пронађена активна БОМ за ставку {0}. Достава са \ Сериал Но не може бити осигурана
 DocType: Sales Partner,Sales Partner Target,Продаја Партнер Циљна
 DocType: Loan Type,Maximum Loan Amount,Максимални износ кредита
-DocType: Pricing Rule,Pricing Rule,Цены Правило
+DocType: Coupon Code,Pricing Rule,Цены Правило
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Дупликат Д број за студента {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Дупликат Д број за студента {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Материјал захтјев за откуп Ордер
@@ -2814,6 +2828,7 @@
 DocType: Payment Schedule,Payment Amount,Плаћање Износ
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Датум полувремена треба да буде између рада од датума и датума рада
 DocType: Healthcare Settings,Healthcare Service Items,Ставке здравствене заштите
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Неважећи баркод. Ниједна ставка није приложена уз овај бар код.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Цонсумед Износ
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Нето промена на пари
 DocType: Assessment Plan,Grading Scale,скала оцењивања
@@ -2935,7 +2950,6 @@
 DocType: Share Transfer,Asset Account,Рачун имовине
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Нови датум изласка требао би бити у будућности
 DocType: Purchase Invoice,End date of current invoice's period,Крајњи датум периода актуелне фактуре за
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Молимо поставите систем именовања запосленика у људским ресурсима&gt; ХР подешавања
 DocType: Lab Test,Technician Name,Име техничара
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3046,6 +3060,7 @@
 DocType: Products Settings,Hide Variants,Сакриј варијанте
 DocType: Lead,Next Contact By,Следеће Контакт По
 DocType: Compensatory Leave Request,Compensatory Leave Request,Захтев за компензацијско одузимање
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Не могу се преплатити за ставку {0} у реду {1} више од {2}. Да бисте омогућили прекомерно наплаћивање, молимо подесите додатак у Поставке рачуна"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Кол-во для Пункт {0} в строке {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Магацин {0} не може бити обрисан јер постоји количина за Ставку {1}
 DocType: Blanket Order,Order Type,Врста поруџбине
@@ -3217,7 +3232,6 @@
 DocType: Student,Student Mobile Number,Студент Број мобилног телефона
 DocType: Item,Has Variants,Хас Варијанте
 DocType: Employee Benefit Claim,Claim Benefit For,Захтевај повластицу за
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Не могу претерати за ставку {0} у реду {1} више од {2}. Да бисте омогућили прекомерно плаћање, молимо вас поставите у опцију &quot;Поставке залиха&quot;"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Упдате Респонсе
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Који сте изабрали ставке из {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Назив мјесечни
@@ -3510,6 +3524,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Молимо наведите валуту у Друштву
 DocType: Workstation,Wages per hour,Сатнице
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Конфигуришите {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Купац&gt; Група купаца&gt; Територија
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Сток стање у батцх {0} ће постати негативна {1} за {2} тачком у складишту {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Следећи материјал захтеви су аутоматски подигнута на основу нивоа поновног реда ставке
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Рачун {0} је неважећа. Рачун валута мора да буде {1}
@@ -3843,6 +3858,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Пошаљи Слип платама
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,На чекању
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Куранце мора имати најмање једну исправну опцију
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Куповни налози
 DocType: Account,Inter Company Account,Интер Цомпани Аццоунт
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Увоз у расутом стању
 DocType: Sales Partner,Address & Contacts,Адреса и контакти
@@ -3853,6 +3869,7 @@
 DocType: POS Profile,[Select],[ Изаберите ]
 DocType: Staffing Plan Detail,Number Of Positions,Број позиција
 DocType: Vital Signs,Blood Pressure (diastolic),Крвни притисак (дијастолни)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Молимо одаберите купца.
 DocType: SMS Log,Sent To,Послат
 DocType: Agriculture Task,Holiday Management,Холидаи Манагемент
 DocType: Payment Request,Make Sales Invoice,Маке Салес фактура
@@ -4061,7 +4078,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} не представлено
 DocType: Subscription,Trialling,Триаллинг
 DocType: Sales Invoice Item,Deferred Revenue,Одложени приход
-DocType: Bank Account,GL Account,ГЛ налог
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Новчани рачун ће се користити за креирање продајне фактуре
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Изузетна подкатегорија
 DocType: Member,Membership Expiry Date,Датум истека чланства
@@ -4488,13 +4504,13 @@
 DocType: C-Form Invoice Detail,Territory,Територија
 DocType: Pricing Rule,Apply Rule On Item Code,Примените правило на код предмета
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,"Пожалуйста, укажите кол-во посещений , необходимых"
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Извештај о стању биланса
 DocType: Stock Settings,Default Valuation Method,Уобичајено Процена Метод
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,провизија
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Прикажи кумулативни износ
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,У току је ажурирање. Можда ће потрајати неко вријеме.
 DocType: Production Plan Item,Produced Qty,Продуцед Кти
 DocType: Vehicle Log,Fuel Qty,Гориво ком
-DocType: Stock Entry,Target Warehouse Name,Име циљне магацине
 DocType: Work Order Operation,Planned Start Time,Планирано Почетак Време
 DocType: Course,Assessment,процена
 DocType: Payment Entry Reference,Allocated,Додељена
@@ -4572,10 +4588,12 @@
  1. Начини баве споровима, одштета, одговорности итд 
  1. Адреса и контакт Ваше фирме."
 DocType: Homepage Section,Section Based On,Одељак на основу
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Прикажи Примени код купона
 DocType: Issue,Issue Type,врста издања
 DocType: Attendance,Leave Type,Оставите Вид
 DocType: Purchase Invoice,Supplier Invoice Details,Добављач Детаљи рачуна
 DocType: Agriculture Task,Ignore holidays,Игнориши празнике
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Додајте / измените услове купона
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Расходи / Разлика налог ({0}) мора бити ""Добитак или губитак 'налога"
 DocType: Stock Entry Detail,Stock Entry Child,Улаз у децу
 DocType: Project,Copied From,копиран из
@@ -4751,6 +4769,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Критеријуми процене План
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Трансакције
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Превент Ордер Ордерс
+DocType: Coupon Code,Coupon Name,Назив купона
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Осетљив
 DocType: Email Campaign,Scheduled,Планиран
 DocType: Shift Type,Working Hours Calculation Based On,Прорачун радног времена на основу
@@ -4767,7 +4786,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Направи Варијанте
 DocType: Vehicle,Diesel,дизел
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Прайс-лист Обмен не выбран
+DocType: Quick Stock Balance,Available Quantity,Доступна количина
 DocType: Purchase Invoice,Availed ITC Cess,Искористио ИТЦ Цесс
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Поставите систем именовања инструктора у Образовање&gt; Подешавања образовања
 ,Student Monthly Attendance Sheet,Студент Месечно Присуство лист
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Правило о испоруци примењује се само за продају
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Амортизацијски ред {0}: Следећи датум амортизације не може бити пре датума куповине
@@ -4835,8 +4856,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Ред {0}: Унапред против Купца мора бити кредит
 DocType: Quality Meeting,Quality Meeting,Састанак квалитета
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Нон-групе до групе
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Молимо поставите Наминг Сериес за {0} путем Подешавање&gt; Подешавања&gt; Именовање серије
 DocType: Employee,ERPNext User,ЕРПНект Усер
+DocType: Coupon Code,Coupon Description,Опис купона
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Серија је обавезна у реду {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Серија је обавезна у реду {0}
 DocType: Company,Default Buying Terms,Подразумевани услови за куповину
@@ -5001,6 +5022,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Против докумената детаља Нема
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Брисање није дозвољено за земљу {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Парти Тип је обавезно
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Примените код купона
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",За радну картицу {0} можете извршити само унос типа „Трансфер материјала за производњу“
 DocType: Quality Inspection,Outgoing,Друштвен
 DocType: Customer Feedback Table,Customer Feedback Table,Табела повратних информација корисника
@@ -5153,7 +5175,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,На основу наруџбине
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Додај све добављаче
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Ред # {0}: Додељени износ не може бити већи од преостали износ.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Купац&gt; Група купаца&gt; Територија
 DocType: Tally Migration,Parties,Журке
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Бровсе БОМ
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Обеспеченные кредиты
@@ -5185,7 +5206,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Не дозволите да поставите алтернативу за ставку {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Датум се понавља
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Овлашћени потписник
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Поставите систем именовања инструктора у Образовање&gt; Подешавања образовања
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Нето расположиви ИТЦ (А) - (Б)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Креирај накнаде
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Укупно набавној вредности (преко фактури)
@@ -5210,6 +5230,7 @@
 DocType: Quiz Result,Wrong,Погрешно
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Стопа по којој се Ценовник валута претвара у основну валуту купца
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Нето износ (Фирма валута)
+DocType: Sales Partner,Referral Code,Реферрал Цоде
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Укупан износ аванса не може бити већи од укупног санкционисаног износа
 DocType: Salary Slip,Hour Rate,Стопа час
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Омогући аутоматску поновну наруџбу
@@ -5339,6 +5360,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Схов Стоцк Куантити
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Нето готовина из пословања
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Ред # {0}: Статус мора бити {1} за дисконт са фактурама {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Фактор конверзије УОМ ({0} -&gt; {1}) није пронађен за ставку: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Тачка 4
 DocType: Student Admission,Admission End Date,Улаз Датум завршетка
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Подуговарање
@@ -5361,6 +5383,7 @@
 DocType: Travel Request,Fully Sponsored,Потпуно спонзорисани
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Реверсе Јоурнал Ентри
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Креирајте Јоб Цард
+DocType: Quotation,Referral Sales Partner,Препорука продајног партнера
 DocType: Quality Procedure Process,Process Description,Опис процеса
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Клијент {0} је креиран.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Тренутно нема доступних трговина на залихама
@@ -5495,6 +5518,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,БОМ курс
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Читање преузете датотеке
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Прекинуто радно поруџбање не може се отказати, Унстоп први да откаже"
+DocType: Coupon Code,Coupon Code,Код купона
 DocType: Asset,Journal Entry for Scrap,Јоурнал Ентри за отпад
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Пожалуйста вытяните элементов из накладной
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Ред {0}: изаберите радну станицу против операције {1}
@@ -5579,6 +5603,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;Датум&#39; је обавезан
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Због / Референтна Датум не може бити после {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Подаци Увоз и извоз
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Жао нам је, валидност кода купона је истекла"
 DocType: Bank Account,Account Details,Детаљи рачуна
 DocType: Crop,Materials Required,Потребни материјали
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Ниједан студент Фоунд
@@ -5616,6 +5641,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Иди на Кориснике
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,"Платные сумма + списания сумма не может быть больше, чем общий итог"
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} не является допустимым номер партии по пункту {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Молимо унесите важећи код купона !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Примечание: Существует не хватает отпуск баланс для отпуске Тип {0}
 DocType: Task,Task Description,Опис задатка
 DocType: Training Event,Seminar,семинар
@@ -5883,6 +5909,7 @@
 ,TDS Payable Monthly,ТДС се плаћа месечно
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Очекује се замена БОМ-а. Може потрајати неколико минута.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Не можете вычесть , когда категория для "" Оценка "" или "" Оценка и Всего"""
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Молимо поставите систем именовања запосленика у људским ресурсима&gt; ХР подешавања
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Укупна плаћања
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Серийный Нос Требуется для сериализованный элемент {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Утакмица плаћања са фактурама
@@ -5973,6 +6000,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Узмите сировине за производњу
 DocType: Job Opening,Job Title,Звање
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Будуће плаћање Реф
+DocType: Quotation,Additional Discount and Coupon Code,Додатни попуст и код купона
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} означава да {1} неће дати цитат, али су сви ставци \ цитирани. Ажурирање статуса РФК куоте."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Максимални узорци - {0} већ су задржани за Батцх {1} и Итем {2} у Батцх {3}.
@@ -6202,7 +6230,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Подешавања за интернет страницама
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} је на чекању до {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},РФК-ови нису дозвољени за {0} због стања стола за резултат {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Маке фактури
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Користи Леавес
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Купон се користи {1}. Дозвољена количина се исцрпљује
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Да ли желите да поднесете материјални захтев
 DocType: Job Offer,Awaiting Response,Очекујем одговор
 DocType: Course Schedule,EDU-CSH-.YYYY.-,ЕДУ-ЦСХ-.ИИИИ.-
@@ -6216,6 +6246,7 @@
 DocType: Training Event Employee,Optional,Опционо
 DocType: Salary Slip,Earning & Deduction,Зарада и дедукције
 DocType: Agriculture Analysis Criteria,Water Analysis,Анализа воде
+DocType: Sales Order,Skip Delivery Note,Прескочите доставницу
 DocType: Price List,Price Not UOM Dependent,Цена није УОМ зависна
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} креиране варијанте.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Уговор о нивоу услуге већ постоји.
@@ -6324,6 +6355,7 @@
 DocType: Vehicle,Last Carbon Check,Последња Угљен Одлазак
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,судебные издержки
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Молимо одаберите количину на реду
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Радни налог {0}: картица посла није пронађена за операцију {1}
 DocType: Purchase Invoice,Posting Time,Постављање Време
 DocType: Timesheet,% Amount Billed,% Фактурисаних износа
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Телефон Расходы
@@ -6426,7 +6458,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Порези и накнаде додавања
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Амортизацијски ред {0}: Следећи датум амортизације не може бити пре Датум расположивог за употребу
 ,Sales Funnel,Продаја Левак
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Код артикла&gt; Група артикала&gt; Марка
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Држава је обавезна
 DocType: Project,Task Progress,zadatak Напредак
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Колица
@@ -6523,6 +6554,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,ПОС Профил потребно да ПОС Ентри
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Точке лојалности ће се рачунати од потрошене (преко фактуре за продају), на основу наведеног фактора сакупљања."
 DocType: Program Enrollment Tool,Enroll Students,упис студената
+DocType: Pricing Rule,Coupon Code Based,На основу кода купона
 DocType: Company,HRA Settings,ХРА подешавања
 DocType: Homepage,Hero Section,Секција хероја
 DocType: Employee Transfer,Transfer Date,Датум преноса
@@ -6639,6 +6671,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Молимо поставите Фирма филтер празно ако Група По је &#39;Фирма&#39;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Датум постања не може бити будућност датум
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Ред # {0}: Серијски број {1} не одговара {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Молимо вас да подесите серију нумерирања за Аттенданце путем Подешавање&gt; Серија бројања
 DocType: Stock Entry,Target Warehouse Address,Адреса циљне магацине
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Повседневная Оставить
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,Време пре почетка смене током којег се одјава пријављује за присуство.
@@ -6673,7 +6706,6 @@
 DocType: Employee Grade,Employee Grade,Разред запослених
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,рад плаћен на акорд
 DocType: GSTR 3B Report,June,Јуна
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Добављач&gt; врста добављача
 DocType: Share Balance,From No,Од бр
 DocType: Shift Type,Early Exit Grace Period,Период раног изласка из милости
 DocType: Task,Actual Time (in Hours),Тренутно време (у сатима)
@@ -6958,7 +6990,6 @@
 DocType: Warehouse,Warehouse Name,Магацин Име
 DocType: Naming Series,Select Transaction,Изаберите трансакцију
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,"Пожалуйста, введите утверждении роли или утверждении Пользователь"
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Фактор конверзије УОМ ({0} -&gt; {1}) није пронађен за ставку: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Уговор о нивоу услуге са типом ентитета {0} и ентитетом {1} већ постоји.
 DocType: Journal Entry,Write Off Entry,Отпис Ентри
 DocType: BOM,Rate Of Materials Based On,Стопа материјала на бази
@@ -7097,6 +7128,7 @@
 DocType: Budget,Warn,Упозорити
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Сви предмети су већ пренети за овај радни налог.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Било који други примедбе, напоменути напор који треба да иде у евиденцији."
+DocType: Bank Account,Company Account,Рачун компаније
 DocType: Asset Maintenance,Manufacturing User,Производња Корисник
 DocType: Purchase Invoice,Raw Materials Supplied,Сировине комплету
 DocType: Subscription Plan,Payment Plan,План плаћања у ратама
@@ -7138,6 +7170,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) не може бити већа од планиране количине ({2}) у радном налогу {3}
 DocType: Certification Application,Name of Applicant,Име кандидата
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Време лист за производњу.
+DocType: Quick Stock Balance,Quick Stock Balance,Брзи биланс стања
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,сума ставке
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Не могу променити својства варијанте након трансакције са акцијама. За то ћете морати направити нову ставку.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,ГоЦардлесс СЕПА Мандат
@@ -7466,6 +7499,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} неактиван Студент
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} неактиван Студент
 DocType: Employee,Health Details,Здравље Детаљи
+DocType: Coupon Code,Coupon Type,Тип купона
 DocType: Leave Encashment,Encashable days,Енцасхабле даис
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Да бисте направили захтев за плаћање је потребан референтни документ
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Да бисте направили захтев за плаћање је потребан референтни документ
@@ -7753,6 +7787,7 @@
 DocType: Hotel Room Package,Amenities,Погодности
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Аутоматски преузми услове плаћања
 DocType: QuickBooks Migrator,Undeposited Funds Account,Рачун Ундепоситед Фундс
+DocType: Coupon Code,Uses,Користи
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Вишеструки начин плаћања није дозвољен
 DocType: Sales Invoice,Loyalty Points Redemption,Повраћај лојалности
 ,Appointment Analytics,Именовање аналитике
@@ -7770,6 +7805,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Оставите празно ако се студентима групе годишње
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Оставите празно ако се студентима групе годишње
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Уколико је означено, Укупно нема. радних дана ће се укључити празника, а то ће смањити вредност зараде по дану"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Није могуће додати Домен
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Да бисте омогућили прелаз / испоруку, ажурирајте „Овер Рецеипт / Дозвола за испоруку“ у подешавањима залиха или артикла."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Апликације које користе тренутни кључ неће моћи да приступе, да ли сте сигурни?"
 DocType: Subscription Settings,Prorate,Прорате
@@ -7782,6 +7818,7 @@
 ,BOM Stock Report,БОМ Сток Извештај
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Ако нема додељеног временског интервала, комуникација ће управљати овом групом"
 DocType: Stock Reconciliation Item,Quantity Difference,Количина Разлика
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Добављач&gt; врста добављача
 DocType: Opportunity Item,Basic Rate,Основна стопа
 DocType: GL Entry,Credit Amount,Износ кредита
 ,Electronic Invoice Register,Електронски регистар рачуна
@@ -8036,6 +8073,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Порези и накнаде одузима (Друштво валута)
 DocType: Item Group,General Settings,Генерал Сеттингс
 DocType: Article,Article,Члан
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Молимо унесите код купона !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Од Валуте и до валута не може да буде иста
 DocType: Taxable Salary Slab,Percent Deduction,Проценат одбијања
 DocType: GL Entry,To Rename,Да преименујете
diff --git a/erpnext/translations/sr_sp.csv b/erpnext/translations/sr_sp.csv
index fa21ea0..c1c1c92 100644
--- a/erpnext/translations/sr_sp.csv
+++ b/erpnext/translations/sr_sp.csv
@@ -483,7 +483,7 @@
 DocType: Item Tax Template Detail,Tax Rate,Poreska stopa
 DocType: GL Entry,Remarks,Napomena
 DocType: Opening Invoice Creation Tool,Sales,Prodaja
-DocType: Pricing Rule,Pricing Rule,Pravilnik za cijene
+DocType: Coupon Code,Pricing Rule,Pravilnik za cijene
 DocType: Products Settings,Products Settings,Podešavanje proizvoda
 DocType: Healthcare Practitioner,Mobile,Mobilni
 DocType: Purchase Invoice Item,Price List Rate,Cijena
diff --git a/erpnext/translations/sv.csv b/erpnext/translations/sv.csv
index bcd3129..8d81f25 100644
--- a/erpnext/translations/sv.csv
+++ b/erpnext/translations/sv.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Kundkontakt
 DocType: Shift Type,Enable Auto Attendance,Aktivera automatisk närvaro
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Vänligen ange lager och datum
 DocType: Lost Reason Detail,Opportunity Lost Reason,Möjlighet förlorad anledning
 DocType: Patient Appointment,Check availability,Kontrollera tillgänglighet
 DocType: Retention Bonus,Bonus Payment Date,Bonusbetalningsdatum
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Avslutade arbetsorder
 DocType: Support Settings,Forum Posts,Foruminlägg
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage",Uppgiften har antagits som ett bakgrundsjobb. Om det finns något problem med behandlingen i bakgrunden kommer systemet att lägga till en kommentar om felet i denna aktieavstämning och återgå till utkastet.
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Ledsen, giltighetskupongkoden har inte startat"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Skattepliktiga belopp
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Du har inte behörighet att lägga till eller uppdatera poster före {0}
 DocType: Leave Policy,Leave Policy Details,Lämna policy detaljer
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Förbrukningsartiklar
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,Kvalitet
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Produktkod&gt; Produktgrupp&gt; Märke
 DocType: Restaurant Table,No of Seats,Antal platser
 DocType: Sales Invoice,Overdue and Discounted,Försenade och rabatterade
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Samtalet bröts
@@ -507,6 +510,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Radavstånd för beloppet i ord
 DocType: Vehicle,Additional Details,ytterligare detaljer
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Ingen beskrivning ges
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Hämta objekt från lagret
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Begäran om köp.
 DocType: POS Closing Voucher Details,Collected Amount,Samlat belopp
 DocType: Lab Test,Submitted Date,Inlämnad Datum
@@ -614,6 +618,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Lär dig
 ,Trial Balance (Simple),Testbalans (enkel)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Aktivera uppskjuten kostnad
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Tillämpad kupongkod
 DocType: Asset,Next Depreciation Date,Nästa Av- Datum
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Aktivitet Kostnad per anställd
 DocType: Accounts Settings,Settings for Accounts,Inställningar för konton
@@ -853,8 +858,6 @@
 DocType: Sales Invoice,Total Qty,Totalt Antal
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 E-post-ID
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 E-post-ID
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Radera anställden <a href=""#Form/Employee/{0}"">{0}</a> \ för att avbryta detta dokument"
 DocType: Item,Show in Website (Variant),Visa på webbplatsen (Variant)
 DocType: Employee,Health Concerns,Hälsoproblem
 DocType: Payroll Entry,Select Payroll Period,Välj Payroll Period
@@ -1020,6 +1023,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Skatteavdragskonto
 DocType: Pricing Rule,Sales Partner,Försäljnings Partner
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Alla leverantörs scorecards.
+DocType: Coupon Code,To be used to get discount,Används för att få rabatt
 DocType: Buying Settings,Purchase Receipt Required,Inköpskvitto Krävs
 DocType: Sales Invoice,Rail,Järnväg
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Verklig kostnad
@@ -1070,6 +1074,7 @@
 DocType: Production Plan,Production Plan,Produktionsplan
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Öppnande av fakturaverktyg
 DocType: Salary Component,Round to the Nearest Integer,Runda till närmaste heltal
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Låt varor som inte finns i lagret läggas till i kundvagnen
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Sales Return
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Ange antal i transaktioner baserat på serienummeringång
 ,Total Stock Summary,Total lageröversikt
@@ -1200,6 +1205,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Base Hour Rate (Company valuta)
 ,Qty To Be Billed,Antal som ska faktureras
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Levererad Mängd
+DocType: Coupon Code,Gift Card,Present kort
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Reserverad antal för produktion: Råvarukvantitet för tillverkning av tillverkningsartiklar.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Inlösendatum
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Denna banktransaktion är redan helt avstämd
@@ -1289,6 +1295,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Skapa tidblad
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Konto {0} har angetts flera gånger
 DocType: Account,Expenses Included In Valuation,Kostnader ingår i rapporten
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Köp fakturor
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Du kan bara förnya om ditt medlemskap löper ut inom 30 dagar
 DocType: Shopping Cart Settings,Show Stock Availability,Visa lager tillgänglighet
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Ange {0} i tillgångskategori {1} eller företag {2}
@@ -1831,6 +1838,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Importera artiklar och UOM: er
 DocType: Repayment Schedule,Balance Loan Amount,Balans lånebelopp
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Tillagt till detaljer
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Ledsen, kupongkoden är slut"
 DocType: Communication Medium,Catch All,Fånga alla
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,schema Course
 DocType: Budget,Applicable on Material Request,Gäller på materialförfrågan
@@ -2001,6 +2009,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Ogiltig Attribut
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} måste skickas in
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,E-postkampanjer
+DocType: Sales Partner,To Track inbound purchase,Att spåra inkommande köp
 DocType: Buying Settings,Default Supplier Group,Standardleverantörsgrupp
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Kvantitet måste vara mindre än eller lika med {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Högsta belopp som är berättigat till komponenten {0} överstiger {1}
@@ -2158,8 +2167,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Gör lagerinmatning
 DocType: Hotel Room Reservation,Hotel Reservation User,Hotellbokningsanvändare
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Ställ in status
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Ställ in numreringsserien för närvaro via Setup&gt; Numbering Series
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Välj prefix först
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Ange Naming Series för {0} via Setup&gt; Inställningar&gt; Naming Series
 DocType: Contract,Fulfilment Deadline,Uppfyllnadsfristen
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Nära dig
 DocType: Student,O-,O-
@@ -2283,6 +2292,7 @@
 DocType: Quality Meeting Table,Under Review,Under granskning
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Kunde inte logga in
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Tillgång {0} skapad
+DocType: Coupon Code,Promotional,PR
 DocType: Special Test Items,Special Test Items,Särskilda testpunkter
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Du måste vara en användare med systemhanteraren och objekthanterarens roller för att registrera dig på Marketplace.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Viktiga rapporter
@@ -2320,6 +2330,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc Typ
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Totala fördelade procentsats för säljteam bör vara 100
 DocType: Subscription Plan,Billing Interval Count,Faktureringsintervallräkning
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Radera anställden <a href=""#Form/Employee/{0}"">{0}</a> \ för att avbryta detta dokument"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Möten och patientmöten
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Värdet saknas
 DocType: Employee,Department and Grade,Avdelning och betyg
@@ -2423,6 +2435,7 @@
 DocType: Project,Start and End Dates,Start- och slutdatum
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Kontraktsmall Uppfyllningsvillkor
 ,Delivered Items To Be Billed,Levererade artiklar att faktureras
+DocType: Coupon Code,Maximum Use,Maximal användning
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Öppen BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Lager kan inte ändras för serienummer
 DocType: Authorization Rule,Average Discount,Genomsnittlig rabatt
@@ -2584,6 +2597,7 @@
 DocType: Item,Inventory,Inventering
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Ladda ner som Json
 DocType: Item,Sales Details,Försäljnings Detaljer
+DocType: Coupon Code,Used,Begagnade
 DocType: Opportunity,With Items,Med artiklar
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Kampanjen &#39;{0}&#39; finns redan för {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Underhållsteam
@@ -2713,7 +2727,7 @@
 						Serial No cannot be ensured",Ingen aktiv BOM hittades för objektet {0}. Leverans med \ Serienummer kan inte garanteras
 DocType: Sales Partner,Sales Partner Target,Sales Partner Target
 DocType: Loan Type,Maximum Loan Amount,Maximala lånebeloppet
-DocType: Pricing Rule,Pricing Rule,Prissättning Regel
+DocType: Coupon Code,Pricing Rule,Prissättning Regel
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Dubbelnummer för student {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Dubbelnummer för student {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Material begäran om att inköpsorder
@@ -2793,6 +2807,7 @@
 DocType: Payment Schedule,Payment Amount,Betalningsbelopp
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Halvdag Datum ska vara mellan Arbete från datum och arbets slutdatum
 DocType: Healthcare Settings,Healthcare Service Items,Hälso- och sjukvårdstjänster
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Ogiltig streckkod. Det finns ingen artikel bifogad denna streckkod.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Förbrukad mängd
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Nettoförändring i Cash
 DocType: Assessment Plan,Grading Scale,Betygsskala
@@ -2914,7 +2929,6 @@
 DocType: Share Transfer,Asset Account,Tillgångskonto
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Nytt släppdatum borde vara i framtiden
 DocType: Purchase Invoice,End date of current invoice's period,Slutdatum för aktuell faktura period
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Installera anställdes namngivningssystem i personalresurser&gt; HR-inställningar
 DocType: Lab Test,Technician Name,Tekniker namn
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3026,6 +3040,7 @@
 DocType: Products Settings,Hide Variants,Dölj varianter
 DocType: Lead,Next Contact By,Nästa Kontakt Vid
 DocType: Compensatory Leave Request,Compensatory Leave Request,Kompensationsförfrågan
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Det går inte att överbeställa för artikel {0} i rad {1} mer än {2}. För att tillåta överfakturering, ange tillåtelse i Kontoinställningar"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Kvantitet som krävs för artikel {0} i rad {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Lager {0} kan inte tas bort då kvantitet existerar för artiklar {1}
 DocType: Blanket Order,Order Type,Beställ Type
@@ -3198,7 +3213,6 @@
 DocType: Student,Student Mobile Number,Student Mobilnummer
 DocType: Item,Has Variants,Har Varianter
 DocType: Employee Benefit Claim,Claim Benefit For,Erfordra förmån för
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Kan inte överföras för punkt {0} i rad {1} mer än {2}. För att tillåta överfakturering, var god ange i lagerinställningar"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Uppdatera svar
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Du har redan valt objekt från {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Namn på månadens distribution
@@ -3490,6 +3504,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Ange valuta i bolaget
 DocType: Workstation,Wages per hour,Löner per timme
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Konfigurera {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Kund&gt; Kundgrupp&gt; Territorium
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Lagersaldo i Batch {0} kommer att bli negativ {1} till punkt {2} på Warehouse {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Efter Material Framställningar har höjts automatiskt baserat på punkt re-order nivå
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Konto {0} är ogiltig. Konto Valuta måste vara {1}
@@ -3823,6 +3838,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Skicka lönebeskedet
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Placerad i kö
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,En fråga måste ha åtminstone ett korrekt alternativ
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Beställning
 DocType: Account,Inter Company Account,Inter Company Account
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Import av Bulk
 DocType: Sales Partner,Address & Contacts,Adress och kontakter
@@ -3833,6 +3849,7 @@
 DocType: POS Profile,[Select],[Välj]
 DocType: Staffing Plan Detail,Number Of Positions,Antal positioner
 DocType: Vital Signs,Blood Pressure (diastolic),Blodtryck (diastoliskt)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Välj kund.
 DocType: SMS Log,Sent To,Skickat Till
 DocType: Agriculture Task,Holiday Management,Holiday Management
 DocType: Payment Request,Make Sales Invoice,Skapa fakturan
@@ -4043,7 +4060,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} är inte skickad
 DocType: Subscription,Trialling,testar
 DocType: Sales Invoice Item,Deferred Revenue,Uppskjuten intäkt
-DocType: Bank Account,GL Account,GL-konto
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Kontantkonto används för att skapa försäljningsfaktura
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Undantag underkategori
 DocType: Member,Membership Expiry Date,Medlemskapets utgångsdatum
@@ -4450,13 +4466,13 @@
 DocType: C-Form Invoice Detail,Territory,Territorium
 DocType: Pricing Rule,Apply Rule On Item Code,Tillämpa regel om artikelkod
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Ange antal besökare (krävs)
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Aktiebalansrapport
 DocType: Stock Settings,Default Valuation Method,Standardvärderingsmetod
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Avgift
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Visa kumulativ mängd
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Uppdatering pågår. Det kan ta ett tag.
 DocType: Production Plan Item,Produced Qty,Producerad mängd
 DocType: Vehicle Log,Fuel Qty,bränsle Antal
-DocType: Stock Entry,Target Warehouse Name,Target Lagernamn
 DocType: Work Order Operation,Planned Start Time,Planerad starttid
 DocType: Course,Assessment,Värdering
 DocType: Payment Entry Reference,Allocated,Tilldelad
@@ -4522,10 +4538,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","Standard Villkor som kan läggas till försäljning och inköp. Exempel: 1. giltighet erbjudandet. 1. Betalningsvillkor (på förhand på kredit, del förskott etc). 1. Vad är extra (eller betalas av kunden). 1. Säkerhet / användning varning. 1. Garanti om något. 1. Returer Policy. 1. Villkor för leverans, om tillämpligt. 1. Sätt att hantera konflikter, ersättning, ansvar, etc. 1. Adresser och kontaktinformation för ditt företag."
 DocType: Homepage Section,Section Based On,Avsnitt baserat på
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Visa Använd kupongkod
 DocType: Issue,Issue Type,Typ av utgåva
 DocType: Attendance,Leave Type,Ledighetstyp
 DocType: Purchase Invoice,Supplier Invoice Details,Detaljer leverantörsfaktura
 DocType: Agriculture Task,Ignore holidays,Ignorera semester
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Lägg till / redigera kupongvillkor
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Utgift / Differens konto ({0}) måste vara ett ""vinst eller förlust"" konto"
 DocType: Stock Entry Detail,Stock Entry Child,Lagerinförande barn
 DocType: Project,Copied From,Kopierad från
@@ -4701,6 +4719,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Bedömningsplanskriterier
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,transaktioner
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Förhindra köporder
+DocType: Coupon Code,Coupon Name,Kupongnamn
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Mottaglig
 DocType: Email Campaign,Scheduled,Planerad
 DocType: Shift Type,Working Hours Calculation Based On,Beräkningar av arbetstid baserat på
@@ -4717,7 +4736,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Skapa Varianter
 DocType: Vehicle,Diesel,Diesel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Prislista Valuta inte valt
+DocType: Quick Stock Balance,Available Quantity,tillgänglig kvantitet
 DocType: Purchase Invoice,Availed ITC Cess,Utnyttjade ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Installera instruktörens namngivningssystem i utbildning&gt; Utbildningsinställningar
 ,Student Monthly Attendance Sheet,Student Monthly Närvaro Sheet
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Fraktregeln gäller endast för Försäljning
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Avskrivningsraden {0}: Nästa avskrivningsdatum kan inte vara före inköpsdatum
@@ -4785,8 +4806,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Rad {0}: Advance mot Kunden måste vara kredit
 DocType: Quality Meeting,Quality Meeting,Kvalitetsmöte
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Icke-grupp till grupp
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Ange Naming Series för {0} via Setup&gt; Inställningar&gt; Naming Series
 DocType: Employee,ERPNext User,ERPNext User
+DocType: Coupon Code,Coupon Description,Kupongbeskrivning
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Batch är obligatorisk i rad {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Batch är obligatorisk i rad {0}
 DocType: Company,Default Buying Terms,Standardköpvillkor
@@ -4951,6 +4972,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Mot Dokument Detalj nr
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Radering är inte tillåtet för land {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Party Type är obligatorisk
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Tillämpa kupongkod
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",För jobbkort {0} kan du bara skriva in materialmaterialöverföringen
 DocType: Quality Inspection,Outgoing,Utgående
 DocType: Customer Feedback Table,Customer Feedback Table,Kundens feedbacktabell
@@ -5103,7 +5125,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Vid inlämning av inköpsorder
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Lägg till alla leverantörer
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Rad # {0}: Tilldelad mängd kan inte vara större än utestående belopp.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Kund&gt; Kundgrupp&gt; Territorium
 DocType: Tally Migration,Parties,parterna
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Bläddra BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Säkrade lån
@@ -5135,7 +5156,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Tillåt inte att ange alternativ objekt för objektet {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Datum upprepas
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Firmatecknare
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Installera instruktörens namngivningssystem i utbildning&gt; Utbildningsinställningar
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Net ITC tillgängligt (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Skapa avgifter
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Totala inköpskostnaden (via inköpsfaktura)
@@ -5160,6 +5180,7 @@
 DocType: Quiz Result,Wrong,Fel
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,I takt med vilket Prislistans valuta omvandlas till kundens basvaluta
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Nettobelopp (Företagsvaluta)
+DocType: Sales Partner,Referral Code,Hänvisningskod
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Det totala förskottsbeloppet får inte vara större än det totala sanktionerade beloppet
 DocType: Salary Slip,Hour Rate,Tim värde
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Aktivera automatisk ombeställning
@@ -5290,6 +5311,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Visa lager Antal
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Netto kassaflöde från rörelsen
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Rad # {0}: Status måste vara {1} för fakturabidrag {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM-omvandlingsfaktor ({0} -&gt; {1}) hittades inte för artikeln: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Produkt  4
 DocType: Student Admission,Admission End Date,Antagning Slutdatum
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Underleverantörer
@@ -5312,6 +5334,7 @@
 DocType: Travel Request,Fully Sponsored,Fullt sponsrad
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Reverse Journal Entry
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Skapa jobbkort
+DocType: Quotation,Referral Sales Partner,Referensförsäljningspartner
 DocType: Quality Procedure Process,Process Description,Metodbeskrivning
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Kund {0} är skapad.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,För närvarande finns inget på lager i något lager.
@@ -5446,6 +5469,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM betyg
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Läser uppladdad fil
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Stoppad Arbetsorder kan inte avbrytas, Avbryt den först för att avbryta"
+DocType: Coupon Code,Coupon Code,kupongskod
 DocType: Asset,Journal Entry for Scrap,Journal Entry för skrot
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Vänligen hämta artikel från följesedel
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Rad {0}: välj arbetsstation mot operationen {1}
@@ -5530,6 +5554,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&quot;Datum&quot; krävs
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},På grund / Referens Datum kan inte vara efter {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Data Import och export
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Ledsen, giltighetskupongkoden har gått ut"
 DocType: Bank Account,Account Details,Kontouppgifter
 DocType: Crop,Materials Required,Material krävs
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Inga studenter Funnet
@@ -5567,6 +5592,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Gå till Användare
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Betald belopp + Avskrivningsbelopp kan inte vara större än Totalsumma
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} är inte ett giltigt batchnummer för objekt {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Ange giltig kupongkod !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Obs: Det finns inte tillräckligt med ledighetdagar för ledighet typ {0}
 DocType: Task,Task Description,Uppgifts beskrivning
 DocType: Training Event,Seminar,Seminarium
@@ -5833,6 +5859,7 @@
 ,TDS Payable Monthly,TDS betalas månadsvis
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Köpt för att ersätta BOM. Det kan ta några minuter.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Det går inte att dra bort när kategorin är angedd ""Värdering"" eller ""Värdering och Total"""
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Installera anställdes namngivningssystem i mänskliga resurser&gt; HR-inställningar
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Totala betalningar
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serial Nos krävs för Serialiserad Punkt {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Match Betalningar med fakturor
@@ -5923,6 +5950,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Få råmaterial för produktion
 DocType: Job Opening,Job Title,Jobbtitel
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Framtida betalning ref
+DocType: Quotation,Additional Discount and Coupon Code,Ytterligare rabatt- och kupongkod
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} indikerar att {1} inte kommer att ge en offert, men alla artiklar \ har offererats. Uppdaterar status för offertförfrågan."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maximala prov - {0} har redan behållits för Batch {1} och Item {2} i Batch {3}.
@@ -6152,7 +6180,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Inställningar för webbplats hemsida
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} är i vänteläge till {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ är inte tillåtna för {0} på grund av ett styrkort som står för {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Skapa inköpsfaktura
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Använda löv
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Kupongen som används är {1}. Tillåten kvantitet är slut
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Vill du skicka in materialförfrågan
 DocType: Job Offer,Awaiting Response,Väntar på svar
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6166,6 +6196,7 @@
 DocType: Training Event Employee,Optional,Frivillig
 DocType: Salary Slip,Earning & Deduction,Vinst &amp; Avdrag
 DocType: Agriculture Analysis Criteria,Water Analysis,Vattenanalys
+DocType: Sales Order,Skip Delivery Note,Hoppa över leveransanteckning
 DocType: Price List,Price Not UOM Dependent,Pris ej UOM beroende
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} varianter skapade.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Ett standardavtal om servicenivå finns redan.
@@ -6274,6 +6305,7 @@
 DocType: Vehicle,Last Carbon Check,Sista Carbon Check
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Rättsskydds
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Var god välj antal på rad
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Arbetsorder {0}: jobbkort hittades inte för operationen {1}
 DocType: Purchase Invoice,Posting Time,Boknings Tid
 DocType: Timesheet,% Amount Billed,% Belopp fakturerat
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Telefon Kostnader
@@ -6376,7 +6408,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Skatter och avgifter Added
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Avskrivningsraden {0}: Nästa avskrivningsdatum kan inte vara före tillgängliga datum
 ,Sales Funnel,Försäljning tratt
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Produktkod&gt; Produktgrupp&gt; Märke
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Förkortning är obligatorisk
 DocType: Project,Task Progress,Task framsteg
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Kundvagn
@@ -6472,6 +6503,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS profil som krävs för att göra POS inlägg
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Lojalitetspoäng kommer att beräknas utifrån den förbrukade gjorda (via försäljningsfakturaen), baserat på nämnda samlingsfaktor."
 DocType: Program Enrollment Tool,Enroll Students,registrera studenter
+DocType: Pricing Rule,Coupon Code Based,Baserad på kupongkod
 DocType: Company,HRA Settings,HRA-inställningar
 DocType: Homepage,Hero Section,Hjältesektion
 DocType: Employee Transfer,Transfer Date,Överföringsdatum
@@ -6588,6 +6620,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Vänligen ange Företagets filter tomt om Group By är &quot;Company&quot;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Publiceringsdatum kan inte vara framtida tidpunkt
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Rad # {0}: Löpnummer {1} inte stämmer överens med {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Ställ in numreringsserien för närvaro via Setup&gt; Numbering Series
 DocType: Stock Entry,Target Warehouse Address,Mållageradress
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Tillfällig ledighet
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,Tiden före skiftets starttid under vilken anställdens incheckning övervägs för närvaro.
@@ -6622,7 +6655,6 @@
 DocType: Employee Grade,Employee Grade,Anställd grad
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Ackord
 DocType: GSTR 3B Report,June,juni
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Leverantör&gt; Leverantörstyp
 DocType: Share Balance,From No,Från nr
 DocType: Shift Type,Early Exit Grace Period,Period för tidig utgång
 DocType: Task,Actual Time (in Hours),Faktisk tid (i timmar)
@@ -6908,7 +6940,6 @@
 DocType: Warehouse,Warehouse Name,Lager Namn
 DocType: Naming Series,Select Transaction,Välj transaktion
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Ange Godkännande roll eller godkänna Användare
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM-omvandlingsfaktor ({0} -&gt; {1}) hittades inte för artikeln: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Servicenivåavtal med entitetstyp {0} och enhet {1} finns redan.
 DocType: Journal Entry,Write Off Entry,Avskrivningspost
 DocType: BOM,Rate Of Materials Based On,Hastighet av material baserade på
@@ -7046,6 +7077,7 @@
 DocType: Budget,Warn,Varna
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Alla objekt har redan överförts för denna arbetsorder.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Alla andra anmärkningar, anmärkningsvärt ansträngning som ska gå i registren."
+DocType: Bank Account,Company Account,Företagskonto
 DocType: Asset Maintenance,Manufacturing User,Tillverkningsanvändare
 DocType: Purchase Invoice,Raw Materials Supplied,Råvaror Levereras
 DocType: Subscription Plan,Payment Plan,Betalningsplan
@@ -7087,6 +7119,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) kan inte vara större än den planerade kvantiteten ({2}) i arbetsorder {3}
 DocType: Certification Application,Name of Applicant,Sökandes namn
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Tidrapportering för tillverkning.
+DocType: Quick Stock Balance,Quick Stock Balance,Snabb lagerbalans
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Delsumma
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Kan inte ändra Variantegenskaper efter aktiehandel. Du måste skapa ett nytt objekt för att göra detta.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA-mandat
@@ -7414,6 +7447,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} är inaktiv student
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} är inaktiv student
 DocType: Employee,Health Details,Hälsa Detaljer
+DocType: Coupon Code,Coupon Type,Kupongtyp
 DocType: Leave Encashment,Encashable days,Encashable dagar
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,För att skapa en betalningsförfrågan krävs referensdokument
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,För att skapa en betalningsförfrågan krävs referensdokument
@@ -7702,6 +7736,7 @@
 DocType: Hotel Room Package,Amenities,Bekvämligheter
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Hämta automatiskt betalningsvillkor
 DocType: QuickBooks Migrator,Undeposited Funds Account,Oavsett fondkonto
+DocType: Coupon Code,Uses,användningsområden
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Multipla standard betalningssätt är inte tillåtet
 DocType: Sales Invoice,Loyalty Points Redemption,Lojalitetspoäng Inlösen
 ,Appointment Analytics,Utnämningsanalys
@@ -7719,6 +7754,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Lämna tomma om du gör elever grupper per år
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Lämna tomma om du gör elever grupper per år
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Om markerad, Totalt antal. arbetsdagar kommer att omfatta helgdagar, och detta kommer att minska värdet av lönen per dag"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Det gick inte att lägga till domän
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","För att tillåta över mottagning / leverans, uppdatera &quot;Över kvitto / leveransbidrag&quot; i lagerinställningar eller artikeln."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Appar som använder nuvarande nyckel kommer inte att kunna komma åt, är du säker?"
 DocType: Subscription Settings,Prorate,prorata
@@ -7732,6 +7768,7 @@
 ,BOM Stock Report,BOM Stock Report
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group",Om det inte finns någon tilldelad tidslucka kommer kommunikationen att hanteras av denna grupp
 DocType: Stock Reconciliation Item,Quantity Difference,kvantitet Skillnad
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Leverantör&gt; Leverantörstyp
 DocType: Opportunity Item,Basic Rate,Baskurs
 DocType: GL Entry,Credit Amount,Kreditbelopp
 ,Electronic Invoice Register,Elektroniskt fakturaregister
@@ -7986,6 +8023,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Skatter och avgifter Avgår (Company valuta)
 DocType: Item Group,General Settings,Allmänna Inställningar
 DocType: Article,Article,Artikel
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Ange kupongkod !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Från valuta och till valuta kan inte vara samma
 DocType: Taxable Salary Slab,Percent Deduction,Procentavdrag
 DocType: GL Entry,To Rename,Att byta namn
diff --git a/erpnext/translations/sw.csv b/erpnext/translations/sw.csv
index fcc0c12..cfe805f 100644
--- a/erpnext/translations/sw.csv
+++ b/erpnext/translations/sw.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT -YYYY.-
 DocType: Purchase Order,Customer Contact,Mawasiliano ya Wateja
 DocType: Shift Type,Enable Auto Attendance,Washa Kuhudhuria Moja kwa moja
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Tafadhali ingiza Ghala na Tarehe
 DocType: Lost Reason Detail,Opportunity Lost Reason,Fursa waliopotea Sababu
 DocType: Patient Appointment,Check availability,Angalia upatikanaji
 DocType: Retention Bonus,Bonus Payment Date,Tarehe ya Malipo ya Bonasi
@@ -264,6 +265,7 @@
 ,Completed Work Orders,Maagizo ya Kazi Iliyokamilishwa
 DocType: Support Settings,Forum Posts,Ujumbe wa Vikao
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Kazi imejumuishwa kama kazi ya msingi. Ila ikiwa kuna suala lolote juu ya usindikaji nyuma, mfumo utaongeza maoni juu ya kosa kwenye Maridhiano haya ya Hisa na kurudi kwenye hatua ya Rasimu."
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Samahani, uhalali wa msimbo wa kuponi haujaanza"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Kiwango cha Ushuru
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Huna mamlaka ya kuongeza au kusasisha safu kabla ya {0}
 DocType: Leave Policy,Leave Policy Details,Acha maelezo ya Sera
@@ -329,6 +331,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Inatumiwa
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,Daraja
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Nambari ya Bidhaa&gt; Kikundi cha bidhaa&gt; Brand
 DocType: Restaurant Table,No of Seats,Hakuna Viti
 DocType: Sales Invoice,Overdue and Discounted,Imepitwa na kupunguzwa
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Simu Imekataliwa
@@ -505,6 +508,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Upeo wa mstari wa kiasi kwa maneno
 DocType: Vehicle,Additional Details,Maelezo ya ziada
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Hakuna maelezo yaliyotolewa
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Chukua Vitu kutoka Ghala
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Omba la ununuzi.
 DocType: POS Closing Voucher Details,Collected Amount,Kukusanya Kiasi
 DocType: Lab Test,Submitted Date,Tarehe iliyotolewa
@@ -612,6 +616,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Jifunze
 ,Trial Balance (Simple),Mizani ya jaribio (Rahisi)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Wezesha gharama zilizofanywa
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Nambari ya Coupon iliyotumiwa
 DocType: Asset,Next Depreciation Date,Tarehe ya Uzito ya pili
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Shughuli ya Gharama kwa Wafanyakazi
 DocType: Accounts Settings,Settings for Accounts,Mipangilio ya Akaunti
@@ -847,8 +852,6 @@
 DocType: BOM,Work Order,Kazi ya Kazi
 DocType: Sales Invoice,Total Qty,Uchina wa jumla
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 Barua ya barua pepe
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Tafadhali futa Mfanyikazi <a href=""#Form/Employee/{0}"">{0}</a> \ ili kughairi hati hii"
 DocType: Item,Show in Website (Variant),Onyesha kwenye tovuti (Tofauti)
 DocType: Employee,Health Concerns,Mateso ya Afya
 DocType: Payroll Entry,Select Payroll Period,Chagua Kipindi cha Mishahara
@@ -1011,6 +1014,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Akaunti ya Kuzuia Ushuru
 DocType: Pricing Rule,Sales Partner,Mshirika wa Mauzo
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Mapendekezo yote ya Wasambazaji.
+DocType: Coupon Code,To be used to get discount,Kutumika kupata kipunguzi
 DocType: Buying Settings,Purchase Receipt Required,Receipt ya Ununuzi inahitajika
 DocType: Sales Invoice,Rail,Reli
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Gharama halisi
@@ -1061,6 +1065,7 @@
 DocType: Production Plan,Production Plan,Mpango wa Uzalishaji
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Kufungua Chombo cha Uumbaji wa Invoice
 DocType: Salary Component,Round to the Nearest Integer,Kuzunguka kwa Inayo Karibu
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Ruhusu vitu visivyo kwenye hisa kuongezwa kwa gari
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Kurudi kwa Mauzo
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Weka Uchina katika Shughuli kulingana na Serial No Input
 ,Total Stock Summary,Jumla ya muhtasari wa hisa
@@ -1190,6 +1195,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Kiwango cha saa ya msingi (Fedha la Kampuni)
 ,Qty To Be Billed,Qty Kujazwa
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Kiasi kilichotolewa
+DocType: Coupon Code,Gift Card,Kadi ya Zawadi
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Qty iliyohifadhiwa kwa Uzalishaji: Wingi wa malighafi kutengeneza vitu vya utengenezaji.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Tarehe ya ukombozi
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Uuzaji huu wa benki tayari umepatanishwa
@@ -1277,6 +1283,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Unda Timesheet
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Akaunti {0} imeingizwa mara nyingi
 DocType: Account,Expenses Included In Valuation,Malipo Pamoja na Valuation
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Ankara za ununuzi
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Unaweza tu upya kama wanachama wako muda wake ndani ya siku 30
 DocType: Shopping Cart Settings,Show Stock Availability,Onyesha Upatikanaji wa hisa
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Weka {0} katika kiwanja cha mali {1} au kampuni {2}
@@ -1816,6 +1823,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Kuingiza Vitu na UOM
 DocType: Repayment Schedule,Balance Loan Amount,Kiwango cha Mikopo
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Imeongezwa kwa maelezo
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Samahani, nambari za kuponi zimekamilika"
 DocType: Communication Medium,Catch All,Chukua Zote
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Ratiba ya Kozi
 DocType: Budget,Applicable on Material Request,Inahitajika kwenye Ombi la Nyenzo
@@ -1983,6 +1991,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Attribute batili
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} lazima iwasilishwa
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Kampeni za barua pepe
+DocType: Sales Partner,To Track inbound purchase,Kufuatilia ununuzi wa ndani
 DocType: Buying Settings,Default Supplier Group,Kikundi cha Wasambazaji cha Default
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Wingi lazima iwe chini au sawa na {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Kiwango cha juu kinafaa kwa sehemu {0} zaidi ya {1}
@@ -2138,8 +2147,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Fanya Uingilio wa Hisa
 DocType: Hotel Room Reservation,Hotel Reservation User,User Reservation User
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Weka Hali
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Tafadhali sasisha safu za nambari za Kuhudhuria kupitia Usanidi&gt; Mfululizo wa hesabu
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Tafadhali chagua kiambatisho kwanza
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Tafadhali weka Mfululizo wa Jina la {0} kupitia Kusanidi&gt; Mipangilio&gt; Mfululizo wa Kumtaja
 DocType: Contract,Fulfilment Deadline,Utekelezaji wa Mwisho
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Karibu na wewe
 DocType: Student,O-,O-
@@ -2263,6 +2272,7 @@
 DocType: Quality Meeting Table,Under Review,Chini ya Mapitio
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Imeshindwa kuingia
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Malipo {0} yameundwa
+DocType: Coupon Code,Promotional,Uendelezaji
 DocType: Special Test Items,Special Test Items,Vipimo vya Mtihani maalum
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Unahitaji kuwa mtumiaji na Meneja wa Mfumo na Majukumu ya Meneja wa Item kujiandikisha kwenye Soko.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Ripoti muhimu
@@ -2300,6 +2310,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Aina ya Doc
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Asilimia ya jumla iliyotengwa kwa timu ya mauzo inapaswa kuwa 100
 DocType: Subscription Plan,Billing Interval Count,Muda wa Kipaji cha Hesabu
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Tafadhali futa Mfanyikazi <a href=""#Form/Employee/{0}"">{0}</a> \ ili kughairi hati hii"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Uteuzi na Mkutano wa Wagonjwa
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Thamani haipo
 DocType: Employee,Department and Grade,Idara na Daraja
@@ -2400,6 +2412,7 @@
 DocType: Project,Start and End Dates,Anza na Mwisho Dates
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Masharti ya Ukamilifu wa Mkataba
 ,Delivered Items To Be Billed,Vitu vilivyopakiwa Kufanywa
+DocType: Coupon Code,Maximum Use,Upeo wa Matumizi
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Fungua BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Ghala haiwezi kubadilishwa kwa Nambari ya Serial.
 DocType: Authorization Rule,Average Discount,Average Discount
@@ -2561,6 +2574,7 @@
 DocType: Item,Inventory,Uuzaji
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Pakua kama Json
 DocType: Item,Sales Details,Maelezo ya Mauzo
+DocType: Coupon Code,Used,Imetumika
 DocType: Opportunity,With Items,Na Vitu
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Kampeni &#39;{0}&#39; tayari inapatikana kwa {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Timu ya Matengenezo
@@ -2690,7 +2704,7 @@
 						Serial No cannot be ensured",Hakuna BOM ya kazi iliyopatikana kwa kipengee {0}. Utoaji kwa \ Serial Hakuna haiwezi kuhakikisha
 DocType: Sales Partner,Sales Partner Target,Lengo la Mshirika wa Mauzo
 DocType: Loan Type,Maximum Loan Amount,Kiwango cha Mikopo Kikubwa
-DocType: Pricing Rule,Pricing Rule,Kanuni ya bei
+DocType: Coupon Code,Pricing Rule,Kanuni ya bei
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Duplicate roll idadi kwa mwanafunzi {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Nambari ya Nyenzo ya Ununuzi wa Utaratibu
 DocType: Company,Default Selling Terms,Masharti ya Kuuza Default
@@ -2769,6 +2783,7 @@
 DocType: Payment Schedule,Payment Amount,Kiwango cha Malipo
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Siku ya Nusu ya Siku lazima iwe kati ya Kazi Kutoka Tarehe na Tarehe ya Mwisho Kazi
 DocType: Healthcare Settings,Healthcare Service Items,Vitu vya Huduma za Afya
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Msimbo batili. Hakuna Kitu kilichojumuishwa kwenye barcode hii.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Kiwango kilichotumiwa
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Mabadiliko ya Net katika Fedha
 DocType: Assessment Plan,Grading Scale,Kuweka Scale
@@ -2888,7 +2903,6 @@
 DocType: Share Transfer,Asset Account,Akaunti ya Mali
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Tarehe mpya ya kutolewa inapaswa kuwa katika siku zijazo
 DocType: Purchase Invoice,End date of current invoice's period,Tarehe ya mwisho ya kipindi cha ankara ya sasa
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Tafadhali sasisha Mfumo wa Kumtaja Mfanyikazi katika Rasilimali Watu&gt; Mipangilio ya HR
 DocType: Lab Test,Technician Name,Jina la mafundi
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -2999,6 +3013,7 @@
 DocType: Products Settings,Hide Variants,Ficha anuwai
 DocType: Lead,Next Contact By,Kuwasiliana Nafuatayo
 DocType: Compensatory Leave Request,Compensatory Leave Request,Ombi la Kuondoa Rufaa
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Haiwezi kulipiza zaidi ya Bidhaa {0} katika safu {1} zaidi ya {2}. Kuruhusu malipo ya juu, tafadhali weka posho katika Mipangilio ya Akaunti"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Kiasi kinachohitajika kwa Item {0} mfululizo {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Ghala {0} haiwezi kufutwa kama kiasi kilichopo kwa Bidhaa {1}
 DocType: Blanket Order,Order Type,Aina ya Utaratibu
@@ -3168,7 +3183,6 @@
 DocType: Student,Student Mobile Number,Namba ya Simu ya Wanafunzi
 DocType: Item,Has Variants,Ina tofauti
 DocType: Employee Benefit Claim,Claim Benefit For,Faida ya kudai Kwa
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Haiwezi kupindua kwa Item {0} katika mstari {1} zaidi ya {2}. Ili kuruhusu kulipia zaidi, tafadhali pangilia kwenye Mipangilio ya Hifadhi"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Sasisha jibu
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Tayari umechagua vitu kutoka {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Jina la Usambazaji wa Kila mwezi
@@ -3457,6 +3471,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Tafadhali taja fedha katika Kampuni
 DocType: Workstation,Wages per hour,Mshahara kwa saa
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Sanidi {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Mteja&gt; Kikundi cha Wateja&gt; Wilaya
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Usawa wa hisa katika Batch {0} utakuwa hasi {1} kwa Bidhaa {2} kwenye Ghala {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Ufuatiliaji wa Nyenzo zifuatayo umefufuliwa kwa moja kwa moja kulingana na ngazi ya re-order ya Item
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Akaunti {0} ni batili. Fedha ya Akaunti lazima iwe {1}
@@ -3786,6 +3801,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Tuma Slip ya Mshahara
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Inashikilia
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Qustion lazima iwe na chaguzi angalau moja sahihi
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Amri za Ununuzi
 DocType: Account,Inter Company Account,Akaunti ya Kampuni ya Inter
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Ingiza katika Bonde
 DocType: Sales Partner,Address & Contacts,Anwani na Mawasiliano
@@ -3796,6 +3812,7 @@
 DocType: POS Profile,[Select],[Chagua]
 DocType: Staffing Plan Detail,Number Of Positions,Idadi ya Vyeo
 DocType: Vital Signs,Blood Pressure (diastolic),Shinikizo la damu (diastoli)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Tafadhali chagua mteja.
 DocType: SMS Log,Sent To,Imepelekwa
 DocType: Agriculture Task,Holiday Management,Usimamizi wa Likizo
 DocType: Payment Request,Make Sales Invoice,Fanya ankara ya Mauzo
@@ -4004,7 +4021,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} haijawasilishwa
 DocType: Subscription,Trialling,Inakuja
 DocType: Sales Invoice Item,Deferred Revenue,Mapato yaliyotengwa
-DocType: Bank Account,GL Account,Akaunti ya GL
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Akaunti ya Fedha itatumika kwa uundaji wa ankara za Mauzo
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Kutoa Kundi Kundi
 DocType: Member,Membership Expiry Date,Tarehe ya Kumalizika kwa Uanachama
@@ -4408,13 +4424,13 @@
 DocType: C-Form Invoice Detail,Territory,Nchi
 DocType: Pricing Rule,Apply Rule On Item Code,Tumia Nambari ya Bidhaa
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Tafadhali angalia hakuna wa ziara zinazohitajika
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Ripoti ya Mizani ya Hisa
 DocType: Stock Settings,Default Valuation Method,Njia ya Hifadhi ya Kimaadili
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Malipo
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Onyesha Kiasi Kikubwa
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Mwisho unaendelea. Inaweza kuchukua muda.
 DocType: Production Plan Item,Produced Qty,Uchina uliotayarishwa
 DocType: Vehicle Log,Fuel Qty,Uchina wa mafuta
-DocType: Stock Entry,Target Warehouse Name,Jina la Ghala la Taraka
 DocType: Work Order Operation,Planned Start Time,Muda wa Kuanza
 DocType: Course,Assessment,Tathmini
 DocType: Payment Entry Reference,Allocated,Imewekwa
@@ -4480,10 +4496,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","Masharti na Masharti ya kawaida ambayo yanaweza kuongezwa kwa Mauzo na Ununuzi. Mifano: 1. Uthibitisho wa utoaji. Masharti ya Malipo (Katika Advance, Kwa Mikopo, sehemu ya mapema nk). 1. Ni nini ziada (au kulipwa na Wateja). 1. Usalama / onyo la matumizi. 1. dhamana kama yoyote. 1. Inarudi Sera. 1. Masharti ya usafirishaji, ikiwa yanafaa. 1. Njia za kukabiliana na migogoro, malipo, dhima, nk 1. Anwani na Mawasiliano ya Kampuni yako."
 DocType: Homepage Section,Section Based On,Sehemu Kulingana na
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Onyesha Tuma nambari ya Coupon
 DocType: Issue,Issue Type,Aina ya Suala
 DocType: Attendance,Leave Type,Acha Aina
 DocType: Purchase Invoice,Supplier Invoice Details,Maelezo ya Invoice ya Wasambazaji
 DocType: Agriculture Task,Ignore holidays,Puuza sikukuu
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Ongeza / Hariri Masharti ya Coupon
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Akaunti ya gharama na tofauti ({0}) lazima iwe akaunti ya &#39;Faida au Kupoteza&#39;
 DocType: Stock Entry Detail,Stock Entry Child,Mtoto wa Kuingia
 DocType: Project,Copied From,Ilikosa Kutoka
@@ -4658,6 +4676,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Vigezo vya Mpango wa Tathmini
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Shughuli
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Zuia Maagizo ya Ununuzi
+DocType: Coupon Code,Coupon Name,Jina la Coupon
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Inapotosha
 DocType: Email Campaign,Scheduled,Imepangwa
 DocType: Shift Type,Working Hours Calculation Based On,Kufanya kazi Mahesabu kwa msingi wa
@@ -4674,7 +4693,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Unda anuwai
 DocType: Vehicle,Diesel,Dizeli
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Orodha ya Bei Fedha isiyochaguliwa
+DocType: Quick Stock Balance,Available Quantity,Wingi Unaopatikana
 DocType: Purchase Invoice,Availed ITC Cess,Imepata ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Tafadhali wasanidi Mfumo wa Kumtaja Mtaalam katika Elimu&gt; Mipangilio ya elimu
 ,Student Monthly Attendance Sheet,Karatasi ya Wahudumu wa Mwezi kila mwezi
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Sheria ya usafirishaji inatumika tu kwa Kuuza
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Upungufu wa Row {0}: Tarehe ya Utoaji wa Dhamana haiwezi kuwa kabla ya Tarehe ya Ununuzi
@@ -4741,8 +4762,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Row {0}: Upendeleo dhidi ya Wateja lazima uwe mkopo
 DocType: Quality Meeting,Quality Meeting,Mkutano wa Ubora
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Siyo Kikundi kwa Kundi
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Tafadhali weka Mfululizo wa Jina la {0} kupitia Kusanidi&gt; Mipangilio&gt; Mfululizo wa Kumtaja
 DocType: Employee,ERPNext User,ERPNext User
+DocType: Coupon Code,Coupon Description,Maelezo ya Coupon
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Kundi ni lazima katika mstari {0}
 DocType: Company,Default Buying Terms,Masharti ya Kununua chaguo msingi
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Ununuzi wa Receipt Item Inayolewa
@@ -4905,6 +4926,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Dhidi ya Detail Document No
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Ufuta hauruhusiwi kwa nchi {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Aina ya Chama ni lazima
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Tuma Nambari ya Coupon
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","Kwa kadi ya kazi {0}, unaweza tu kutengeneza &#39;Transfer ya Nyenzo kwa kuingia kwa aina ya Uuzaji&#39;"
 DocType: Quality Inspection,Outgoing,Inatoka
 DocType: Customer Feedback Table,Customer Feedback Table,Meza ya Maoni ya Wateja
@@ -5053,7 +5075,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Juu ya Uwasilishaji wa Agizo la Ununuzi
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Ongeza Wauzaji Wote
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Mstari # {0}: Kiasi kilichowekwa hawezi kuwa kikubwa zaidi kuliko kiasi kikubwa.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Mteja&gt; Kikundi cha Wateja&gt; Wilaya
 DocType: Tally Migration,Parties,Vyama
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Tafuta BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Mikopo ya Salama
@@ -5085,7 +5106,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Usiruhusu kuweka kitu mbadala kwa kipengee {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Tarehe inarudiwa
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Ishara iliyoidhinishwa
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Tafadhali wasanidi Mfumo wa Kumtaja Mtaalam katika Elimu&gt; Mipangilio ya elimu
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),ITC Inapatikana (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Unda ada
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Gharama ya Jumla ya Ununuzi (kupitia Invoice ya Ununuzi)
@@ -5110,6 +5130,7 @@
 DocType: Quiz Result,Wrong,Mbaya
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Kiwango ambacho sarafu ya orodha ya Bei inabadilishwa kwa sarafu ya msingi ya mteja
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Kiasi cha Fedha (Kampuni ya Fedha)
+DocType: Sales Partner,Referral Code,Nambari ya Uelekezaji
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Jumla ya kiasi cha mapema haiwezi kuwa kubwa zaidi kuliko kiasi cha jumla kilichowekwa
 DocType: Salary Slip,Hour Rate,Kiwango cha Saa
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Washa Agizo la Kuunda upya kiotomatiki
@@ -5238,6 +5259,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Onyesha Stock Wingi
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Fedha Nacho kutoka kwa Uendeshaji
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Njia # {0}: Hali lazima iwe {1} kwa Toleo la ankara {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Sababu ya ubadilishaji wa UOM ({0} -&gt; {1}) haipatikani kwa kipengee: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Item 4
 DocType: Student Admission,Admission End Date,Tarehe ya Mwisho ya Kuingia
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Kwenye mkataba
@@ -5259,6 +5281,7 @@
 DocType: Travel Request,Fully Sponsored,Inasaidiwa kikamilifu
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Rejea Kuingia kwa Jarida
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Unda Kadi ya Kazi
+DocType: Quotation,Referral Sales Partner,Mshirika wa Uuzaji wa Uhamishaji
 DocType: Quality Procedure Process,Process Description,Maelezo ya Mchakato
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Mteja {0} ameundwa.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Hivi sasa hakuna hisa zinazopatikana katika ghala lolote
@@ -5393,6 +5416,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,Kiwango cha BOM
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Kusoma Faili Iliyopakiwa
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Hifadhi ya Kazi iliyozuiwa haiwezi kufutwa, Fungua kwa kwanza kufuta"
+DocType: Coupon Code,Coupon Code,Nambari ya Coupon
 DocType: Asset,Journal Entry for Scrap,Jarida la Kuingia kwa Scrap
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Tafadhali puta vitu kutoka kwa Kumbuka Utoaji
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Row {0}: chagua kituo cha kazi dhidi ya uendeshaji {1}
@@ -5475,6 +5499,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;Tarehe&#39; inahitajika
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Kutokana / Tarehe ya Kumbukumbu haiwezi kuwa baada ya {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Kuingiza Data na Kuagiza
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Samahani, uhalali wa msimbo wa kuponi umekwisha"
 DocType: Bank Account,Account Details,Maelezo ya Akaunti
 DocType: Crop,Materials Required,Vifaa vinahitajika
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Hakuna wanafunzi waliopatikana
@@ -5512,6 +5537,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Nenda kwa Watumiaji
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Kiasi kilicholipwa + Andika Kiasi hawezi kuwa kubwa zaidi kuliko Jumla ya Jumla
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} si Nambari ya Batch halali ya Bidhaa {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Tafadhali ingiza msimbo wa kuponi halali !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Kumbuka: Hakuna usawa wa kutosha wa kuondoka kwa Aina ya Kuondoka {0}
 DocType: Task,Task Description,Maelezo ya Kazi
 DocType: Training Event,Seminar,Semina
@@ -5775,6 +5801,7 @@
 ,TDS Payable Monthly,TDS kulipwa kila mwezi
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Iliyotokana na nafasi ya kuchukua nafasi ya BOM. Inaweza kuchukua dakika chache.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Haiwezi kufuta wakati kiwanja ni kwa &#39;Valuation&#39; au &#39;Valuation na Jumla&#39;
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Tafadhali wasanidi Mfumo wa Kumtaja Mfanyikazi katika Rasilimali Watu&gt; Mipangilio ya HR
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Malipo ya Jumla
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serial Nos Inahitajika kwa Bidhaa Serialized {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Malipo ya mechi na ankara
@@ -5864,6 +5891,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Pata Malighafi Kwa Uzalishaji
 DocType: Job Opening,Job Title,Jina la kazi
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Malipo ya baadaye Ref
+DocType: Quotation,Additional Discount and Coupon Code,Nambari ya Punguzo ya ziada na Msimbo wa kuponi
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} inaonyesha kuwa {1} haitoi quotation, lakini vitu vyote vimeukuliwa. Inasasisha hali ya quote ya RFQ."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Sampuli za Upeo - {0} tayari zimehifadhiwa kwa Batch {1} na Item {2} katika Kipande {3}.
@@ -6091,7 +6119,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Mipangilio ya ukurasa wa nyumbani wa wavuti
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} imeshikilia hadi {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQs haziruhusiwi kwa {0} kutokana na msimamo wa alama ya {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Tengeneza ankara ya Ununuzi
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Majani yaliyotumika
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Coupon inayotumiwa ni {1}. Wingi ulioruhusiwa umechoka
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Je! Unataka kupeleka ombi la nyenzo
 DocType: Job Offer,Awaiting Response,Inasubiri Jibu
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH -YYYY.-
@@ -6105,6 +6135,7 @@
 DocType: Training Event Employee,Optional,Hiari
 DocType: Salary Slip,Earning & Deduction,Kufikia &amp; Kupunguza
 DocType: Agriculture Analysis Criteria,Water Analysis,Uchambuzi wa Maji
+DocType: Sales Order,Skip Delivery Note,Skip Kumbuka
 DocType: Price List,Price Not UOM Dependent,Bei sio Mtegemezi wa UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} vigezo vimeundwa.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Mkataba wa Kiwango cha Huduma ya Chaguzi tayari ipo.
@@ -6209,6 +6240,7 @@
 DocType: Vehicle,Last Carbon Check,Check Carbon Mwisho
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Gharama za Kisheria
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Tafadhali chagua kiasi kwenye mstari
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Agizo la kazi {0}: kadi ya kazi haipatikani kwa operesheni {1}
 DocType: Purchase Invoice,Posting Time,Wakati wa Kuchapa
 DocType: Timesheet,% Amount Billed,Kiasi kinachojazwa
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Malipo ya Simu
@@ -6311,7 +6343,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Kodi na Malipo Aliongeza
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Upungufu Row {0}: Tarehe ya Utoaji wa Dhamana haiwezi kuwa kabla ya Tarehe ya kupatikana
 ,Sales Funnel,Funnel ya Mauzo
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Nambari ya Bidhaa&gt; Kikundi cha bidhaa&gt; Brand
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Hali ni lazima
 DocType: Project,Task Progress,Maendeleo ya Kazi
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Kadi
@@ -6406,6 +6437,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,Profaili ya POS inahitajika ili ufanye POS Entry
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Vidokezo vya uaminifu vitahesabiwa kutoka kwa alitumia kufanyika (kwa njia ya ankara za Mauzo), kulingana na sababu ya kukusanya iliyotajwa."
 DocType: Program Enrollment Tool,Enroll Students,Jiandikisha Wanafunzi
+DocType: Pricing Rule,Coupon Code Based,Msimbo wa Coupon
 DocType: Company,HRA Settings,Mipangilio ya HRA
 DocType: Homepage,Hero Section,Sehemu ya shujaa
 DocType: Employee Transfer,Transfer Date,Tarehe ya Uhamisho
@@ -6521,6 +6553,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Tafadhali weka Chujio cha Kampuni kikiwa tupu ikiwa Kundi Na &#39;Kampuni&#39;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Tarehe ya Kuchapisha haiwezi kuwa tarehe ya baadaye
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: Serial No {1} hailingani na {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Tafadhali sasisha safu za nambari za Kuhudhuria kupitia Usanidi&gt; Mfululizo wa hesabu
 DocType: Stock Entry,Target Warehouse Address,Anwani ya Wakala ya Ghala
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Kuondoka kwa kawaida
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,Wakati kabla ya kuanza kwa wakati ambapo Kuingia kwa Wafanyakazi kunazingatiwa kwa mahudhurio.
@@ -6555,7 +6588,6 @@
 DocType: Employee Grade,Employee Grade,Wafanyakazi wa darasa
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Piecework
 DocType: GSTR 3B Report,June,Juni
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Mtoaji&gt; Aina ya wasambazaji
 DocType: Share Balance,From No,Kutoka Hapana
 DocType: Shift Type,Early Exit Grace Period,Tarehe ya mapema ya Neema
 DocType: Task,Actual Time (in Hours),Muda halisi (katika Masaa)
@@ -6839,7 +6871,6 @@
 DocType: Warehouse,Warehouse Name,Jina la Ghala
 DocType: Naming Series,Select Transaction,Chagua Shughuli
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Tafadhali ingiza Uwezeshaji au Kuidhinisha Mtumiaji
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Sababu ya ubadilishaji wa UOM ({0} -&gt; {1}) haipatikani kwa kipengee: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Mkataba wa Kiwango cha Huduma na Aina ya Taasisi {0} na Taasisi {1} tayari ipo.
 DocType: Journal Entry,Write Off Entry,Andika Entry Entry
 DocType: BOM,Rate Of Materials Based On,Kiwango cha Vifaa vya msingi
@@ -6977,6 +7008,7 @@
 DocType: Budget,Warn,Tahadhari
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Vitu vyote vimehamishwa tayari kwa Kazi hii ya Kazi.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Maneno mengine yoyote, jitihada zinazostahili ambazo zinapaswa kuingia kwenye rekodi."
+DocType: Bank Account,Company Account,Akaunti ya Kampuni
 DocType: Asset Maintenance,Manufacturing User,Mtengenezaji wa Viwanda
 DocType: Purchase Invoice,Raw Materials Supplied,Vifaa vya Malighafi hutolewa
 DocType: Subscription Plan,Payment Plan,Mpango wa Malipo
@@ -7018,6 +7050,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) haiwezi kuwa kubwa kuliko kiasi kilichopangwa ({2}) katika Kazi ya Kazi {3}
 DocType: Certification Application,Name of Applicant,Jina la Mombaji
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Karatasi ya Muda kwa ajili ya utengenezaji.
+DocType: Quick Stock Balance,Quick Stock Balance,Mizani ya Hisa ya haraka
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,jumla ndogo
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Haiwezi kubadilisha mali tofauti baada ya shughuli za hisa. Utahitaji kufanya kitu kipya cha kufanya hivyo.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,Mandhari ya SEPA ya GoCardless
@@ -7343,6 +7376,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},Tafadhali weka {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} ni mwanafunzi asiye na kazi
 DocType: Employee,Health Details,Maelezo ya Afya
+DocType: Coupon Code,Coupon Type,Aina ya Coupon
 DocType: Leave Encashment,Encashable days,Siku isiyoweza
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Ili kuunda hati ya kumbukumbu ya Rufaa ya Malipo inahitajika
 DocType: Soil Texture,Sandy Clay,Mchanga wa Mchanga
@@ -7625,6 +7659,7 @@
 DocType: Hotel Room Package,Amenities,Huduma
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Chukua moja kwa moja Masharti ya Malipo
 DocType: QuickBooks Migrator,Undeposited Funds Account,Akaunti ya Mfuko usiopuuzwa
+DocType: Coupon Code,Uses,Matumizi
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Njia ya malipo ya malipo ya kuruhusiwa haiwezi kuruhusiwa
 DocType: Sales Invoice,Loyalty Points Redemption,Ukombozi wa Ukweli wa Ukweli
 ,Appointment Analytics,Uchambuzi wa Uteuzi
@@ -7641,6 +7676,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Jumla ya Bajeti
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Acha tupu ikiwa unafanya makundi ya wanafunzi kwa mwaka
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Ikiwa hunakiliwa, Jumla ya. ya siku za kazi zitajumuisha likizo, na hii itapunguza thamani ya mshahara kwa siku"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Imeshindwa kuongeza Kikoa
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Kuruhusu kupokea / utoaji, sasisha &quot;Risiti zaidi ya / risiti ya Utoaji&quot; katika Mipangilio ya Hisa au Bidhaa."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Programu za kutumia kitufe cha sasa hazitaweza kufikia, una uhakika?"
 DocType: Subscription Settings,Prorate,Pendeza
@@ -7653,6 +7689,7 @@
 ,BOM Stock Report,Ripoti ya hisa ya BOM
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Ikiwa hakuna nyara aliyopewa, basi mawasiliano yatashughulikiwa na kikundi hiki"
 DocType: Stock Reconciliation Item,Quantity Difference,Tofauti Tofauti
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Mtoaji&gt; Aina ya wasambazaji
 DocType: Opportunity Item,Basic Rate,Kiwango cha Msingi
 DocType: GL Entry,Credit Amount,Mikopo
 ,Electronic Invoice Register,Usajili wa ankara ya elektroniki
@@ -7906,6 +7943,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Kodi na Malipo yamefutwa (Fedha la Kampuni)
 DocType: Item Group,General Settings,Mazingira ya Jumla
 DocType: Article,Article,Kifungu
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Tafadhali ingiza msimbo wa kuponi !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Kutoka kwa Fedha na Fedha haiwezi kuwa sawa
 DocType: Taxable Salary Slab,Percent Deduction,Kupunguza kwa asilimia
 DocType: GL Entry,To Rename,Kubadilisha jina
diff --git a/erpnext/translations/ta.csv b/erpnext/translations/ta.csv
index 56d1681..34c430a 100644
--- a/erpnext/translations/ta.csv
+++ b/erpnext/translations/ta.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-டிடி-.YYYY.-
 DocType: Purchase Order,Customer Contact,வாடிக்கையாளர் தொடர்பு
 DocType: Shift Type,Enable Auto Attendance,ஆட்டோ வருகையை இயக்கு
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,கிடங்கு மற்றும் தேதியை உள்ளிடவும்
 DocType: Lost Reason Detail,Opportunity Lost Reason,வாய்ப்பு இழந்த காரணம்
 DocType: Patient Appointment,Check availability,கிடைக்கும் என்பதை சரிபார்க்கவும்
 DocType: Retention Bonus,Bonus Payment Date,போனஸ் கொடுக்கும் தேதி
@@ -261,6 +262,7 @@
 ,Completed Work Orders,முடிக்கப்பட்ட வேலை ஆணைகள்
 DocType: Support Settings,Forum Posts,கருத்துக்களம் இடுகைகள்
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","பணி ஒரு பின்னணி வேலையாக இணைக்கப்பட்டுள்ளது. பின்னணியில் செயலாக்குவதில் ஏதேனும் சிக்கல் இருந்தால், இந்த பங்கு நல்லிணக்கத்தில் உள்ள பிழை குறித்து கணினி ஒரு கருத்தைச் சேர்த்து வரைவு நிலைக்குத் திரும்பும்"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","மன்னிக்கவும், கூப்பன் குறியீடு செல்லுபடியாகும் தன்மை தொடங்கப்படவில்லை"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,வரிவிதிக்கத்தக்க தொகை
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},நீங்கள் முன் உள்ளீடுகளை சேர்க்க அல்லது மேம்படுத்தல் அங்கீகாரம் இல்லை {0}
 DocType: Leave Policy,Leave Policy Details,கொள்கை விவரங்களை விடு
@@ -325,6 +327,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,நுகர்வோர்
 DocType: Student,B-,பி-
 DocType: Assessment Result,Grade,தரம்
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,பொருள் குறியீடு&gt; பொருள் குழு&gt; பிராண்ட்
 DocType: Restaurant Table,No of Seats,இடங்கள் இல்லை
 DocType: Sales Invoice,Overdue and Discounted,மிகை மற்றும் தள்ளுபடி
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,அழைப்பு துண்டிக்கப்பட்டது
@@ -502,6 +505,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,வார்த்தைகளில் அளவு வரி இடைவெளி
 DocType: Vehicle,Additional Details,கூடுதல் விவரங்கள்
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,கொடுக்கப்பட்ட விளக்கம் இல்லை
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,கிடங்கிலிருந்து பொருட்களைப் பெறுங்கள்
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,வாங்குவதற்கு கோரிக்கை.
 DocType: POS Closing Voucher Details,Collected Amount,சேகரிக்கப்பட்ட தொகை
 DocType: Lab Test,Submitted Date,சமர்ப்பிக்கப்பட்ட தேதி
@@ -609,6 +613,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,அறிய
 ,Trial Balance (Simple),சோதனை இருப்பு (எளிய)
 DocType: Purchase Invoice Item,Enable Deferred Expense,ஒத்திவைக்கப்பட்ட செலவை இயக்கு
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,அப்ளைடு கூப்பன் குறியீடு
 DocType: Asset,Next Depreciation Date,அடுத்த தேய்மானம் தேதி
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,பணியாளர் ஒன்றுக்கு நடவடிக்கை செலவு
 DocType: Accounts Settings,Settings for Accounts,கணக்குகளைத் அமைப்புகள்
@@ -844,8 +849,6 @@
 DocType: Sales Invoice,Total Qty,மொத்த அளவு
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 மின்னஞ்சல் ஐடி
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 மின்னஞ்சல் ஐடி
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","இந்த ஆவணத்தை ரத்து செய்ய பணியாளர் <a href=""#Form/Employee/{0}"">{0}</a> delete ஐ நீக்கவும்"
 DocType: Item,Show in Website (Variant),இணையதளத்தில் அமைந்துள்ள ஷோ (மாற்று)
 DocType: Employee,Health Concerns,சுகாதார கவலைகள்
 DocType: Payroll Entry,Select Payroll Period,சம்பளப்பட்டியல் காலம் தேர்ந்தெடுக்கவும்
@@ -1007,6 +1010,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,வரி விலக்கு கணக்கு
 DocType: Pricing Rule,Sales Partner,விற்பனை வரன்வாழ்க்கை துணை
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,எல்லா சப்ளையர் ஸ்கார்கார்டுகளும்.
+DocType: Coupon Code,To be used to get discount,தள்ளுபடி பெற பயன்படுத்தப்பட வேண்டும்
 DocType: Buying Settings,Purchase Receipt Required,கொள்முதல் ரசீது தேவை
 DocType: Sales Invoice,Rail,ரயில்
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,சரியான விலை
@@ -1054,6 +1058,7 @@
 DocType: Production Plan,Production Plan,உற்பத்தி திட்டம்
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,விலைப்பட்டியல் உருவாக்கம் கருவியைத் திறக்கிறது
 DocType: Salary Component,Round to the Nearest Integer,அருகிலுள்ள முழு எண்ணுக்கு சுற்று
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,கையிருப்பில் இல்லாத உருப்படிகளை வண்டியில் சேர்க்க அனுமதிக்கவும்
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,விற்பனை Return
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,சீரியல் இல்லை உள்ளீடு அடிப்படையிலான பரிமாற்றங்களில் Qty ஐ அமைக்கவும்
 ,Total Stock Summary,மொத்த பங்கு சுருக்கம்
@@ -1180,6 +1185,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),பேஸ் ஹவர் மதிப்பீடு (நிறுவனத்தின் நாணய)
 ,Qty To Be Billed,கட்டணம் செலுத்தப்பட வேண்டும்
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,வழங்கப்படுகிறது தொகை
+DocType: Coupon Code,Gift Card,பரிசு அட்டை
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,உற்பத்திக்கு ஒதுக்கப்பட்ட அளவு: உற்பத்தி பொருட்களை தயாரிக்க மூலப்பொருட்களின் அளவு.
 DocType: Loyalty Point Entry Redemption,Redemption Date,மீட்பு தேதி
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,இந்த வங்கி பரிவர்த்தனை ஏற்கனவே முழுமையாக சமரசம் செய்யப்பட்டுள்ளது
@@ -1268,6 +1274,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,டைம்ஷீட்டை உருவாக்கவும்
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,கணக்கு {0} பல முறை உள்ளிட்ட வருகிறது
 DocType: Account,Expenses Included In Valuation,செலவுகள் மதிப்பீட்டு சேர்க்கப்பட்டுள்ளது
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,விலைப்பட்டியல் வாங்கவும்
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,உங்கள் உறுப்பினர் 30 நாட்களுக்குள் காலாவதியாகிவிட்டால் மட்டுமே புதுப்பிக்க முடியும்
 DocType: Shopping Cart Settings,Show Stock Availability,பங்கு கிடைக்கும் என்பதைக் காட்டு
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,As per section 17(5),பிரிவு 17 (5) படி
@@ -1822,6 +1829,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,பொருட்கள் மற்றும் UOM களை இறக்குமதி செய்கிறது
 DocType: Repayment Schedule,Balance Loan Amount,இருப்பு கடன் தொகை
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,விவரங்கள் சேர்க்கப்பட்டது
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","மன்னிக்கவும், கூப்பன் குறியீடு தீர்ந்துவிட்டது"
 DocType: Communication Medium,Catch All,அனைத்தையும் ப
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,அட்டவணை பாடநெறி
 DocType: Budget,Applicable on Material Request,பொருள் கோரிக்கைக்கு பொருந்துகிறது
@@ -1988,6 +1996,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,தவறான கற்பிதம்
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} சமர்ப்பிக்க வேண்டும்
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,மின்னஞ்சல் பிரச்சாரங்கள்
+DocType: Sales Partner,To Track inbound purchase,உள்வரும் கொள்முதலைக் கண்காணிக்க
 DocType: Buying Settings,Default Supplier Group,Default Supplier Group
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},அளவு குறைவாக அல்லது சமமாக இருக்க வேண்டும் {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},உறுப்புக்கு தகுதியுடைய அதிகபட்ச தொகை {0} {1}
@@ -2140,7 +2149,6 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,பங்கு நுழைவு செய்யுங்கள்
 DocType: Hotel Room Reservation,Hotel Reservation User,ஹோட்டல் முன்பதிவு பயனர்
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,நிலையை அமைக்கவும்
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,அமைவு&gt; எண்ணைத் தொடர் வழியாக வருகைக்கான எண்ணைத் தொடரை அமைக்கவும்
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,முதல் முன்னொட்டு தேர்வு செய்க
 DocType: Contract,Fulfilment Deadline,பூர்த்தி நிறைவேற்றுதல்
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,உன் அருகே
@@ -2264,6 +2272,7 @@
 DocType: Quality Meeting Table,Under Review,மதிப்பாய்வின் கீழ்
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,உள்நுழைய முடியவில்லை
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,சொத்து {0} உருவாக்கப்பட்டது
+DocType: Coupon Code,Promotional,ஊக்குவிப்பு
 DocType: Special Test Items,Special Test Items,சிறப்பு டெஸ்ட் பொருட்கள்
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Marketplace இல் பதிவு செய்ய நீங்கள் கணினி மேலாளர் மற்றும் பொருள் நிர்வாக மேலாளர்களுடன் ஒரு பயனர் இருக்க வேண்டும்.
 apps/erpnext/erpnext/config/buying.py,Key Reports,முக்கிய அறிக்கைகள்
@@ -2300,6 +2309,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc வகை
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,விற்பனை குழு மொத்த ஒதுக்கீடு சதவீதம் 100 இருக்க வேண்டும்
 DocType: Subscription Plan,Billing Interval Count,பில்லிங் இடைவெளி எண்ணிக்கை
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","இந்த ஆவணத்தை ரத்து செய்ய பணியாளர் <a href=""#Form/Employee/{0}"">{0}</a> delete ஐ நீக்கவும்"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,நியமனங்கள் மற்றும் நோயாளி சந்திப்புகள்
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,மதிப்பு காணவில்லை
 DocType: Employee,Department and Grade,துறை மற்றும் தரம்
@@ -2401,6 +2412,7 @@
 DocType: Project,Start and End Dates,தொடக்கம் மற்றும் தேதிகள் End
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,ஒப்பந்த வார்ப்புரு பூர்த்தி செய்தல் விதிமுறைகள்
 ,Delivered Items To Be Billed,கட்டணம் வழங்கப்படும் பொருட்கள்
+DocType: Coupon Code,Maximum Use,அதிகபட்ச பயன்பாடு
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},BOM திறந்த {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,கிடங்கு சீரியல் எண் மாற்றப்பட கூடாது
 DocType: Authorization Rule,Average Discount,சராசரி தள்ளுபடி
@@ -2561,6 +2573,7 @@
 DocType: Item,Inventory,சரக்கு
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Json ஆக பதிவிறக்கவும்
 DocType: Item,Sales Details,விற்பனை விவரம்
+DocType: Coupon Code,Used,பயன்படுத்திய
 DocType: Opportunity,With Items,பொருட்களை கொண்டு
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',&#39;{0}&#39; பிரச்சாரம் ஏற்கனவே {1} &#39;{2}&#39; க்கு உள்ளது
 DocType: Asset Maintenance,Maintenance Team,பராமரிப்பு குழு
@@ -2687,7 +2700,7 @@
 						Serial No cannot be ensured",உருப்படிக்கு {0} செயலில் BOM எதுவும் இல்லை. \ சீரியல் வழங்கல் வழங்குவதை உறுதி செய்ய முடியாது
 DocType: Sales Partner,Sales Partner Target,விற்பனை வரன்வாழ்க்கை துணை இலக்கு
 DocType: Loan Type,Maximum Loan Amount,அதிகபட்ச கடன் தொகை
-DocType: Pricing Rule,Pricing Rule,விலை விதி
+DocType: Coupon Code,Pricing Rule,விலை விதி
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},மாணவர் க்கான பிரதி ரோல் எண்ணை {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},மாணவர் க்கான பிரதி ரோல் எண்ணை {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,ஆணை வாங்க பொருள் வேண்டுதல்
@@ -2765,6 +2778,7 @@
 DocType: Payment Schedule,Payment Amount,கட்டணம் அளவு
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,தேதி மற்றும் பணி முடிவு தேதி ஆகியவற்றிற்கு இடையேயான அரை நாள் தேதி இருக்க வேண்டும்
 DocType: Healthcare Settings,Healthcare Service Items,சுகாதார சேவை பொருட்கள்
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,தவறான பார்கோடு. இந்த பார்கோடு இணைக்கப்பட்ட பொருள் எதுவும் இல்லை.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,உட்கொள்ளுகிறது தொகை
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,பண நிகர மாற்றம்
 DocType: Assessment Plan,Grading Scale,தரம் பிரித்தல் ஸ்கேல்
@@ -2882,7 +2896,6 @@
 DocType: Share Transfer,Asset Account,சொத்து கணக்கு
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,புதிய வெளியீட்டு தேதி எதிர்காலத்தில் இருக்க வேண்டும்
 DocType: Purchase Invoice,End date of current invoice's period,தற்போதைய விலைப்பட்டியல் நேரத்தில் முடிவு தேதி
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,மனிதவள&gt; மனிதவள அமைப்புகளில் பணியாளர் பெயரிடும் முறையை அமைக்கவும்
 DocType: Lab Test,Technician Name,தொழில்நுட்ப பெயர்
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3160,7 +3173,6 @@
 DocType: Student,Student Mobile Number,மாணவர் மொபைல் எண்
 DocType: Item,Has Variants,வகைகள் உண்டு
 DocType: Employee Benefit Claim,Claim Benefit For,கோரிக்கை பயன்
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","{2} விட {0} வரிசையில் {0} க்கு மேலாக அதிகரிக்க முடியாது. அதிக பில்லிங் அனுமதிக்க, பங்கு அமைப்புகளில் அமைக்கவும்"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,பதில் புதுப்பிக்கவும்
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},நீங்கள் ஏற்கனவே இருந்து பொருட்களை தேர்ந்தெடுத்த {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,மாதாந்திர விநியோகம் பெயர்
@@ -3449,6 +3461,7 @@
 DocType: Vehicle,Fuel Type,எரிபொருள் வகை
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,நிறுவனத்தின் நாணய குறிப்பிடவும்
 DocType: Workstation,Wages per hour,ஒரு மணி நேரத்திற்கு ஊதியங்கள்
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,வாடிக்கையாளர்&gt; வாடிக்கையாளர் குழு&gt; பிரதேசம்
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},தொகுதி பங்குச் சமநிலை {0} மாறும் எதிர்மறை {1} கிடங்கு உள்ள பொருள் {2} ஐந்து {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,பொருள் கோரிக்கைகள் தொடர்ந்து பொருள் மறு ஒழுங்கு நிலை அடிப்படையில் தானாக எழுப்பினார்
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},கணக்கு {0} தவறானது. கணக்கு நாணய இருக்க வேண்டும் {1}
@@ -3779,6 +3792,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,சம்பளம் ஸ்லிப் &#39;to
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,பிடி
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,ஒரு குவாஷனுக்கு குறைந்தபட்சம் ஒரு சரியான விருப்பங்கள் இருக்க வேண்டும்
+apps/erpnext/erpnext/hooks.py,Purchase Orders,கொள்முதல் ஆணைகள்
 DocType: Account,Inter Company Account,இண்டர் கம்பெனி கணக்கு
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,மொத்த  இறக்குமதி
 DocType: Sales Partner,Address & Contacts,முகவரி மற்றும் தொடர்புகள்
@@ -3789,6 +3803,7 @@
 DocType: POS Profile,[Select],[ தேர்ந்தெடு ]
 DocType: Staffing Plan Detail,Number Of Positions,பதவிகள் எண்ணிக்கை
 DocType: Vital Signs,Blood Pressure (diastolic),இரத்த அழுத்தம் (சிறுநீர்ப்பை)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,வாடிக்கையாளரைத் தேர்ந்தெடுக்கவும்.
 DocType: SMS Log,Sent To,அனுப்பப்படும்
 DocType: Agriculture Task,Holiday Management,விடுமுறை மேலாண்மை
 DocType: Payment Request,Make Sales Invoice,விற்பனை விலைப்பட்டியல் செய்ய
@@ -3995,7 +4010,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} சமர்ப்பிக்கப்படவில்லை
 DocType: Subscription,Trialling,Trialling
 DocType: Sales Invoice Item,Deferred Revenue,ஒத்திவைக்கப்பட்ட வருவாய்
-DocType: Bank Account,GL Account,ஜி.எல் கணக்கு
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,பணக் கணக்கு விற்பனை விலைப்பட்டியல் உருவாக்கம் பயன்படுத்தப்படும்
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,விலக்கு துணை வகை
 DocType: Member,Membership Expiry Date,உறுப்பினர் காலாவதி தேதி
@@ -4414,13 +4428,13 @@
 DocType: C-Form Invoice Detail,Territory,மண்டலம்
 DocType: Pricing Rule,Apply Rule On Item Code,பொருள் குறியீட்டில் விதியைப் பயன்படுத்துங்கள்
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,குறிப்பிட தயவுசெய்து தேவையான வருகைகள் எந்த
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,பங்கு இருப்பு அறிக்கை
 DocType: Stock Settings,Default Valuation Method,முன்னிருப்பு மதிப்பீட்டு முறை
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,கட்டணம்
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,மொத்த தொகை காட்டு
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,மேம்படுத்தல் முன்னேற்றம். இது சிறிது நேரம் ஆகலாம்.
 DocType: Production Plan Item,Produced Qty,தயாரிக்கப்பட்ட Qty
 DocType: Vehicle Log,Fuel Qty,எரிபொருள் அளவு
-DocType: Stock Entry,Target Warehouse Name,இலக்கு கிடங்கு பெயர்
 DocType: Work Order Operation,Planned Start Time,திட்டமிட்ட தொடக்க நேரம்
 DocType: Course,Assessment,மதிப்பீடு
 DocType: Payment Entry Reference,Allocated,ஒதுக்கீடு
@@ -4498,10 +4512,12 @@
  1. முதலியன உரையாற்றும் மோதல்களில், ஈட்டுறுதி, பொறுப்பு, 
  1 வழிகள். முகவரி மற்றும் உங்கள் நிறுவனத்தின் தொடர்பு."
 DocType: Homepage Section,Section Based On,பிரிவு அடிப்படையில்
+DocType: Shopping Cart Settings,Show Apply Coupon Code,கூப்பன் குறியீட்டைப் பயன்படுத்து என்பதைக் காட்டு
 DocType: Issue,Issue Type,வெளியீடு வகை
 DocType: Attendance,Leave Type,வகை விட்டு
 DocType: Purchase Invoice,Supplier Invoice Details,சப்ளையர் விவரப்பட்டியல் விவரங்கள்
 DocType: Agriculture Task,Ignore holidays,விடுமுறைகளை புறக்கணியுங்கள்
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,கூப்பன் நிபந்தனைகளைச் சேர்க்கவும் / திருத்தவும்
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,செலவு / வித்தியாசம் கணக்கு ({0}) ஒரு 'லாபம் அல்லது நஷ்டம்' கணக்கு இருக்க வேண்டும்
 DocType: Stock Entry Detail,Stock Entry Child,பங்கு நுழைவு குழந்தை
 DocType: Project,Copied From,இருந்து நகலெடுத்து
@@ -4671,6 +4687,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,மதிப்பீடு திட்டம் தகுதி
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,பரிவர்த்தனைகள்
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,வாங்குவதற்கான ஆர்டர்களைத் தடு
+DocType: Coupon Code,Coupon Name,கூப்பன் பெயர்
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,பாதிக்கப்படுகின்றன
 DocType: Email Campaign,Scheduled,திட்டமிடப்பட்ட
 DocType: Shift Type,Working Hours Calculation Based On,வேலை நேரம் கணக்கீடு அடிப்படையில்
@@ -4687,7 +4704,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,வகைகள் உருவாக்க
 DocType: Vehicle,Diesel,டீசல்
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,விலை பட்டியல் நாணய தேர்வு
+DocType: Quick Stock Balance,Available Quantity,கிடைக்கும் அளவு
 DocType: Purchase Invoice,Availed ITC Cess,ITC செஸ் ஐப் பிடித்தது
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,கல்வி&gt; கல்வி அமைப்புகளில் பயிற்றுவிப்பாளர் பெயரிடும் முறையை அமைக்கவும்
 ,Student Monthly Attendance Sheet,மாணவர் மாதாந்திர வருகை தாள்
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,விற்பனைக்கு மட்டுமே பொருந்தக்கூடிய கப்பல் விதி
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,தேய்மானம் வரிசை {0}: அடுத்த தேதியிட்ட தேதி கொள்முதல் தேதிக்கு முன் இருக்க முடியாது
@@ -4755,6 +4774,7 @@
 DocType: Quality Meeting,Quality Meeting,தரக் கூட்டம்
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,குழு அல்லாத குழு
 DocType: Employee,ERPNext User,ERPNext பயனர்
+DocType: Coupon Code,Coupon Description,கூப்பன் விளக்கம்
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},தொகுதி வரிசையில் கட்டாயமாகிறது {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},தொகுதி வரிசையில் கட்டாயமாகிறது {0}
 DocType: Company,Default Buying Terms,இயல்புநிலை வாங்குதல் விதிமுறைகள்
@@ -4915,6 +4935,7 @@
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py,Lab Test(s) ,ஆய்வக டெஸ்ட் (கள்)
 DocType: Maintenance Visit Purpose,Against Document Detail No,ஆவண விபரம் எண் எதிராக
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,கட்சி வகை அத்தியாவசியமானதாகும்
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,கூப்பன் குறியீட்டைப் பயன்படுத்துக
 DocType: Quality Inspection,Outgoing,வெளிச்செல்லும்
 DocType: Customer Feedback Table,Customer Feedback Table,வாடிக்கையாளர் கருத்து அட்டவணை
 apps/erpnext/erpnext/config/support.py,Service Level Agreement.,சேவை நிலை ஒப்பந்தம்.
@@ -5065,7 +5086,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,கொள்முதல் ஆணை சமர்ப்பிப்பில்
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,அனைத்து சப்ளையர்களை சேர்க்கவும்
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,ரோ # {0}: ஒதுக்கப்பட்டவை தொகை நிலுவையில் தொகையை விட அதிகமாக இருக்க முடியாது.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,வாடிக்கையாளர்&gt; வாடிக்கையாளர் குழு&gt; பிரதேசம்
 DocType: Tally Migration,Parties,கட்சிகள்
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,"உலவ BOM,"
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,பிணை கடன்கள்
@@ -5096,7 +5116,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},உருப்படிக்கு மாற்று உருப்படியை அமைக்க அனுமதிக்க மாட்டோம் {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,தேதி மீண்டும்
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,அங்கீகரிக்கப்பட்ட கையொப்பதாரரால்
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,கல்வி&gt; கல்வி அமைப்புகளில் பயிற்றுவிப்பாளர் பெயரிடும் முறையை அமைக்கவும்
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),நிகர ஐடிசி கிடைக்கிறது (ஏ) - (பி)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,கட்டணம் உருவாக்கவும்
 DocType: Project,Total Purchase Cost (via Purchase Invoice),மொத்த கொள்முதல் விலை (கொள்முதல் விலைப்பட்டியல் வழியாக)
@@ -5120,6 +5139,7 @@
 DocType: Quiz Result,Wrong,தவறான
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,விலை பட்டியல் நாணய வாடிக்கையாளர் அடிப்படை நாணய மாற்றப்படும் விகிதத்தை
 DocType: Purchase Invoice Item,Net Amount (Company Currency),நிகர விலை (நிறுவனத்தின் நாணயம்)
+DocType: Sales Partner,Referral Code,பரிந்துரை குறியீடு
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,மொத்த ஒப்புதலுக்கான தொகையை விட மொத்த முன்கூட்டி தொகை அதிகமாக இருக்க முடியாது
 DocType: Salary Slip,Hour Rate,மணி விகிதம்
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,ஆட்டோ மறு-ஆர்டரை இயக்கு
@@ -5248,6 +5268,7 @@
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},உருப்படிக்கு எதிராக BOM ஐத் தேர்ந்தெடுக்கவும் {0}
 DocType: Shopping Cart Settings,Show Stock Quantity,பங்கு அளவு காட்டு
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,செயல்பாடுகள் இருந்து நிகர பண
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},உருப்படிக்கு UOM மாற்று காரணி ({0} -&gt; {1}) காணப்படவில்லை: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,பொருள் 4
 DocType: Student Admission,Admission End Date,சேர்க்கை முடிவு தேதி
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,துணை ஒப்பந்த
@@ -5270,6 +5291,7 @@
 DocType: Travel Request,Fully Sponsored,முழுமையாக ஸ்பான்சர்
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,ஜர்னல் நுழைவுத் தலைகீழ்
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,வேலை அட்டையை உருவாக்கவும்
+DocType: Quotation,Referral Sales Partner,பரிந்துரை விற்பனை கூட்டாளர்
 DocType: Quality Procedure Process,Process Description,செயல்முறை விளக்கம்
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,வாடிக்கையாளர் {0} உருவாக்கப்பட்டது.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,தற்போது எந்த கிடங்கிலும் கையிருப்பு  இல்லை
@@ -5401,6 +5423,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM விகிதம்
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,பதிவேற்றிய கோப்பைப் படித்தல்
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","நிறுத்தி பணி ஆணை ரத்து செய்ய முடியாது, ரத்து செய்ய முதலில் அதை நீக்கு"
+DocType: Coupon Code,Coupon Code,கூப்பன் குறியீடு
 DocType: Asset,Journal Entry for Scrap,ஸ்கிராப் பத்திரிகை நுழைவு
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,"டெலிவரி குறிப்பு இருந்து உருப்படிகள் இழுக்க , தயவு செய்து"
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},வரிசை {0}: நடவடிக்கைக்கு எதிராக பணிநிலையத்தைத் தேர்ந்தெடுக்கவும் {1}
@@ -5482,6 +5505,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;தேதி&#39; தேவை
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},காரணமாக / குறிப்பு தேதி பின்னர் இருக்க முடியாது {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,தரவு இறக்குமதி மற்றும் ஏற்றுமதி
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","மன்னிக்கவும், கூப்பன் குறியீடு செல்லுபடியாகும் காலாவதியானது"
 DocType: Bank Account,Account Details,கணக்கு விவரம்
 DocType: Crop,Materials Required,தேவையான பொருட்கள்
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,மாணவர்கள் காணப்படவில்லை.
@@ -5519,6 +5543,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,பயனர்களிடம் செல்க
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,பணம் அளவு + அளவு தள்ளுபடி கிராண்ட் மொத்த விட முடியாது
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} உருப்படி ஒரு செல்லுபடியாகும் தொகுதி எண் அல்ல {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,செல்லுபடியாகும் கூப்பன் குறியீட்டை உள்ளிடவும் !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},குறிப்பு: விடுப்பு வகை போதுமான விடுப்பு சமநிலை இல்லை {0}
 DocType: Task,Task Description,பணி விளக்கம்
 DocType: Training Event,Seminar,கருத்தரங்கு
@@ -5784,6 +5809,7 @@
 ,TDS Payable Monthly,மாதாந்தம் TDS செலுத்த வேண்டும்
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,BOM ஐ மாற்றுவதற்காக வரிசைப்படுத்தப்பட்டது. சில நிமிடங்கள் ஆகலாம்.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',வகை ' மதிப்பீட்டு ' அல்லது ' மதிப்பீடு மற்றும் மொத்த ' உள்ளது போது கழித்து முடியாது
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,மனிதவள&gt; மனிதவள அமைப்புகளில் பணியாளர் பெயரிடும் முறையை அமைக்கவும்
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,மொத்த கொடுப்பனவுகள்
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},தொடராக பொருள் தொடர் இலக்கங்கள் தேவையான {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,பொருள் கொண்ட போட்டி கொடுப்பனவு
@@ -5869,6 +5895,7 @@
 DocType: Production Plan,Get Raw Materials For Production,உற்பத்திக்கு மூலப்பொருட்கள் கிடைக்கும்
 DocType: Job Opening,Job Title,வேலை தலைப்பு
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,எதிர்கால கொடுப்பனவு குறிப்பு
+DocType: Quotation,Additional Discount and Coupon Code,கூடுதல் தள்ளுபடி மற்றும் கூப்பன் குறியீடு
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} {1} மேற்கோள் வழங்காது என்பதைக் குறிக்கிறது, ஆனால் அனைத்து உருப்படிகளும் மேற்கோள் காட்டப்பட்டுள்ளன. RFQ மேற்கோள் நிலையை புதுப்பிக்கிறது."
 DocType: Manufacturing Settings,Update BOM Cost Automatically,தானாக BOM செலவு புதுப்பிக்கவும்
@@ -6094,6 +6121,7 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,இணைய முகப்பு அமைப்புகள்
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},{0} என்ற ஸ்கோர் கார்டு தரவரிசை காரணமாக RFQ கள் {0}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,கொள்முதல் விலைப்பட்டியல் செய்ய
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,பயன்படுத்திய இலைகள்
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,பொருள் கோரிக்கையை சமர்ப்பிக்க விரும்புகிறீர்களா?
 DocType: Job Offer,Awaiting Response,பதிலை எதிர்பார்த்திருப்பதாகவும்
@@ -6107,6 +6135,7 @@
 DocType: Training Event Employee,Optional,விருப்ப
 DocType: Salary Slip,Earning & Deduction,சம்பாதிக்கும் & விலக்கு
 DocType: Agriculture Analysis Criteria,Water Analysis,நீர் பகுப்பாய்வு
+DocType: Sales Order,Skip Delivery Note,டெலிவரி குறிப்பைத் தவிர்
 DocType: Price List,Price Not UOM Dependent,விலை UOM சார்ந்தது அல்ல
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} வகைகள் உருவாக்கப்பட்டன.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,இயல்புநிலை சேவை நிலை ஒப்பந்தம் ஏற்கனவே உள்ளது.
@@ -6315,7 +6344,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,வரிகள் மற்றும் கட்டணங்கள் சேர்க்கப்பட்டது
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,தேய்மானம் வரிசை {0}: அடுத்த தேதியிட்ட தேதி கிடைக்கக்கூடிய தேதிக்கு முன்பாக இருக்க முடியாது
 ,Sales Funnel,விற்பனை நீக்க
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,பொருள் குறியீடு&gt; பொருள் குழு&gt; பிராண்ட்
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,சுருக்கம் கட்டாயமாகும்
 DocType: Project,Task Progress,டாஸ்க் முன்னேற்றம்
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,வண்டியில்
@@ -6409,6 +6437,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,பிஓஎஸ் செய்தது பிஓஎஸ் நுழைவு செய்ய வேண்டும்
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",நம்பகத்தன்மை புள்ளிகள் குறிப்பிடப்பட்ட சேகரிப்பு காரணியை அடிப்படையாகக் கொண்டு (விற்பனை விலைப்பட்டியல் வழியாக) கணக்கிடப்படும்.
 DocType: Program Enrollment Tool,Enroll Students,மாணவர்கள் பதிவுசெய்யவும்
+DocType: Pricing Rule,Coupon Code Based,கூப்பன் குறியீடு அடிப்படையிலானது
 DocType: Company,HRA Settings,HRA அமைப்புகள்
 DocType: Homepage,Hero Section,ஹீரோ பிரிவு
 DocType: Employee Transfer,Transfer Date,பரிமாற்ற தேதி
@@ -6522,6 +6551,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',நிறுவனத்தின் வெற்று வடிகட்ட அமைக்கவும் என்றால் குழுவினராக &#39;நிறுவனத்தின்&#39; ஆகும்
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,பதிவுசெய்ய தேதி எதிர்கால தேதியில் இருக்க முடியாது
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},ரோ # {0}: தொ.எ. {1} பொருந்தவில்லை {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,அமைவு&gt; எண்ணைத் தொடர் வழியாக வருகைக்கான எண்ணைத் தொடரை அமைக்கவும்
 DocType: Stock Entry,Target Warehouse Address,இலக்கு கிடங்கு முகவரி
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,தற்செயல் விடுப்பு
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,பணியாளர் செக்-இன் வருகைக்காக கருதப்படும் ஷிப்ட் தொடக்க நேரத்திற்கு முந்தைய நேரம்.
@@ -6556,7 +6586,6 @@
 DocType: Employee Grade,Employee Grade,பணியாளர் தரம்
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,சிறுதுண்டு வேலைக்கு
 DocType: GSTR 3B Report,June,ஜூன்
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,சப்ளையர்&gt; சப்ளையர் வகை
 DocType: Share Balance,From No,இல்லை
 DocType: Shift Type,Early Exit Grace Period,ஆரம்பகால வெளியேறும் கிரேஸ் காலம்
 DocType: Task,Actual Time (in Hours),(மணிகளில்) உண்மையான நேரம்
@@ -6838,7 +6867,6 @@
 DocType: Warehouse,Warehouse Name,சேமிப்பு கிடங்கு பெயர்
 DocType: Naming Series,Select Transaction,பரிவர்த்தனை தேர்வு
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,பங்கு அங்கீகரிக்கிறது அல்லது பயனர் அனுமதி உள்ளிடவும்
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},உருப்படிக்கு UOM மாற்று காரணி ({0} -&gt; {1}) காணப்படவில்லை: {2}
 DocType: Journal Entry,Write Off Entry,நுழைவு ஆஃப் எழுத
 DocType: BOM,Rate Of Materials Based On,ஆனால் அடிப்படையில் பொருட்களின் விகிதம்
 DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","இயக்கப்பட்டிருந்தால், படிப்படியான நுழைவுக் கருவியில் துறையில் கல்வி கட்டாயம் கட்டாயமாக இருக்கும்."
@@ -6974,6 +7002,7 @@
 DocType: Budget,Warn,எச்சரிக்கை
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,இந்த பணிக்கான அனைத்து பொருட்களும் ஏற்கெனவே மாற்றப்பட்டுள்ளன.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","வேறு எந்த கருத்துக்கள், பதிவுகள் செல்ல வேண்டும் என்று குறிப்பிடத்தக்கது முயற்சியாகும்."
+DocType: Bank Account,Company Account,நிறுவனத்தின் கணக்கு
 DocType: Asset Maintenance,Manufacturing User,உற்பத்தி பயனர்
 DocType: Purchase Invoice,Raw Materials Supplied,மூலப்பொருட்கள் வழங்கியது
 DocType: Subscription Plan,Payment Plan,கொடுப்பனவு திட்டம்
@@ -7014,6 +7043,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) பணி வரிசையில் திட்டமிடப்பட்ட அளவுக்கு ({2}) அதிகமாக இருக்க முடியாது {3}
 DocType: Certification Application,Name of Applicant,விண்ணப்பதாரரின் பெயர்
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,உற்பத்தி நேரம் தாள்.
+DocType: Quick Stock Balance,Quick Stock Balance,விரைவான பங்கு இருப்பு
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,கூட்டுத்தொகை
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,பங்கு பரிவர்த்தனைக்குப் பிறகு மாறுபட்ட பண்புகள் மாற்ற முடியாது. இதை செய்ய நீங்கள் ஒரு புதிய உருப்படியை உருவாக்க வேண்டும்.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA ஆணை
@@ -7336,6 +7366,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},அமைக்கவும் {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} செயல்பாட்டில் இல்லாத மாணவர்
 DocType: Employee,Health Details,சுகாதார விவரம்
+DocType: Coupon Code,Coupon Type,கூப்பன் வகை
 DocType: Leave Encashment,Encashable days,உண்டாக்கக்கூடிய நாட்கள்
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,ஒரு கொடுப்பனவு வேண்டுகோள் குறிப்பு ஆவணம் தேவை உருவாக்க
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,ஒரு கொடுப்பனவு வேண்டுகோள் குறிப்பு ஆவணம் தேவை உருவாக்க
@@ -7619,6 +7650,7 @@
 DocType: Hotel Room Package,Amenities,வசதிகள்
 DocType: Accounts Settings,Automatically Fetch Payment Terms,கட்டண விதிமுறைகளை தானாகவே பெறுங்கள்
 DocType: QuickBooks Migrator,Undeposited Funds Account,Undeposited நிதி கணக்கு
+DocType: Coupon Code,Uses,பயன்கள்
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,கட்டணம் செலுத்திய பல இயல்புநிலை முறை அனுமதிக்கப்படவில்லை
 DocType: Sales Invoice,Loyalty Points Redemption,விசுவாச புள்ளிகள் மீட்பு
 ,Appointment Analytics,நியமனம் அனலிட்டிக்ஸ்
@@ -7636,6 +7668,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,நீங்கள் வருடத்திற்கு மாணவர்கள் குழுக்கள் செய்தால் காலியாக விடவும்
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,நீங்கள் வருடத்திற்கு மாணவர்கள் குழுக்கள் செய்தால் காலியாக விடவும்
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","சரி என்றால், மொத்த இல்லை. வேலை நாட்கள் விடுமுறை அடங்கும், இந்த நாள் ஒன்றுக்கு சம்பளம் மதிப்பு குறையும்"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,டொமைனைச் சேர்ப்பதில் தோல்வி
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","மேல் ரசீது / விநியோகத்தை அனுமதிக்க, பங்கு அமைப்புகள் அல்லது உருப்படிகளில் &quot;ஓவர் ரசீது / விநியோக கொடுப்பனவு&quot; புதுப்பிக்கவும்."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","தற்போதைய விசைகளைப் பயன்படுத்தி பயன்பாடுகள் அணுக முடியாது, உறுதியாக இருக்கிறீர்களா?"
 DocType: Subscription Settings,Prorate,prorate
@@ -7649,6 +7682,7 @@
 ,BOM Stock Report,பொருள் பட்டியல் கையிருப்பு அறிக்கை
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","ஒதுக்கப்பட்ட நேர அட்டவணை இல்லை என்றால், தகவல் தொடர்பு இந்த குழுவால் கையாளப்படும்"
 DocType: Stock Reconciliation Item,Quantity Difference,அளவு வேறுபாடு
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,சப்ளையர்&gt; சப்ளையர் வகை
 DocType: Opportunity Item,Basic Rate,அடிப்படை விகிதம்
 DocType: GL Entry,Credit Amount,கடன் தொகை
 ,Electronic Invoice Register,மின்னணு விலைப்பட்டியல் பதிவு
@@ -7902,6 +7936,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),வரிகள் மற்றும் கட்டணங்கள் கழிக்கப்படும் (நிறுவனத்தின் கரன்சி)
 DocType: Item Group,General Settings,பொது அமைப்புகள்
 DocType: Article,Article,கட்டுரை
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,கூப்பன் குறியீட்டை உள்ளிடவும் !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,நாணய மற்றும் நாணயத்தை அதே இருக்க முடியாது
 DocType: Taxable Salary Slab,Percent Deduction,சதவீதம் துப்பறியும்
 DocType: GL Entry,To Rename,மறுபெயரிட
diff --git a/erpnext/translations/te.csv b/erpnext/translations/te.csv
index 25e0925..b0a8ade 100644
--- a/erpnext/translations/te.csv
+++ b/erpnext/translations/te.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-డిటి .YYYY.-
 DocType: Purchase Order,Customer Contact,కస్టమర్ సంప్రదించండి
 DocType: Shift Type,Enable Auto Attendance,ఆటో హాజరును ప్రారంభించండి
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,దయచేసి గిడ్డంగి మరియు తేదీని నమోదు చేయండి
 DocType: Lost Reason Detail,Opportunity Lost Reason,అవకాశం కోల్పోయిన కారణం
 DocType: Patient Appointment,Check availability,లభ్యతను తనిఖీలు చేయండి
 DocType: Retention Bonus,Bonus Payment Date,బోనస్ చెల్లింపు తేదీ
@@ -260,6 +261,7 @@
 ,Completed Work Orders,పూర్తయింది వర్క్ ఆర్డర్స్
 DocType: Support Settings,Forum Posts,ఫోరమ్ పోస్ట్లు
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","ఈ పని నేపథ్య ఉద్యోగంగా ఎన్క్యూ చేయబడింది. ఒకవేళ నేపథ్యంలో ప్రాసెసింగ్‌లో ఏదైనా సమస్య ఉంటే, సిస్టమ్ ఈ స్టాక్ సయోధ్యపై లోపం గురించి వ్యాఖ్యను జోడిస్తుంది మరియు డ్రాఫ్ట్ దశకు తిరిగి వస్తుంది"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","క్షమించండి, కూపన్ కోడ్ చెల్లుబాటు ప్రారంభం కాలేదు"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,పన్ను పరిధిలోకి వచ్చే మొత్తం
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},మీరు ముందు ఎంట్రీలు జోడించడానికి లేదా నవీకరణ అధికారం లేదు {0}
 DocType: Leave Policy,Leave Policy Details,విధాన వివరాలు వదిలివేయండి
@@ -324,6 +326,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,వినిమయ
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,గ్రేడ్
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,ఐటెమ్ కోడ్&gt; ఐటెమ్ గ్రూప్&gt; బ్రాండ్
 DocType: Restaurant Table,No of Seats,సీట్ల సంఖ్య
 DocType: Sales Invoice,Overdue and Discounted,మీరిన మరియు రాయితీ
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,కాల్ డిస్‌కనెక్ట్ చేయబడింది
@@ -500,6 +503,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,పదాలు లో మొత్తం కోసం పంక్తి అంతరం
 DocType: Vehicle,Additional Details,అదనపు వివరాలు
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,ఇచ్చిన వివరణను
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,గిడ్డంగి నుండి వస్తువులను పొందండి
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,కొనుగోలు కోసం అభ్యర్థన.
 DocType: POS Closing Voucher Details,Collected Amount,సేకరించిన మొత్తం
 DocType: Lab Test,Submitted Date,సమర్పించిన తేదీ
@@ -606,6 +610,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,తెలుసుకోండి
 ,Trial Balance (Simple),ట్రయల్ బ్యాలెన్స్ (సింపుల్)
 DocType: Purchase Invoice Item,Enable Deferred Expense,వాయిదాపడిన ఖర్చుని ప్రారంభించండి
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,అప్లైడ్ కూపన్ కోడ్
 DocType: Asset,Next Depreciation Date,తదుపరి అరుగుదల తేదీ
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,ఉద్యోగి ప్రతి కార్యాచరణ ఖర్చు
 DocType: Accounts Settings,Settings for Accounts,అకౌంట్స్ కోసం సెట్టింగులు
@@ -838,8 +843,6 @@
 DocType: Sales Invoice,Total Qty,మొత్తం ప్యాక్ చేసిన అంశాల
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 ఇమెయిల్ ID
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 ఇమెయిల్ ID
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","ఈ పత్రాన్ని రద్దు చేయడానికి దయచేసి ఉద్యోగి <a href=""#Form/Employee/{0}"">{0}</a> delete ను తొలగించండి"
 DocType: Item,Show in Website (Variant),లో వెబ్సైట్ షో (వేరియంట్)
 DocType: Employee,Health Concerns,ఆరోగ్య కారణాల
 DocType: Payroll Entry,Select Payroll Period,పేరోల్ కాలం ఎంచుకోండి
@@ -1002,6 +1005,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,పన్ను అక్రమ హోల్డింగ్ ఖాతా
 DocType: Pricing Rule,Sales Partner,సేల్స్ భాగస్వామి
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,అన్ని సరఫరాదారు స్కోర్కార్డులు.
+DocType: Coupon Code,To be used to get discount,డిస్కౌంట్ పొందడానికి ఉపయోగించబడుతుంది
 DocType: Buying Settings,Purchase Receipt Required,కొనుగోలు రసీదులు అవసరం
 DocType: Sales Invoice,Rail,రైల్
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,అసలు ఖరీదు
@@ -1049,6 +1053,7 @@
 DocType: Production Plan,Production Plan,ఉత్పత్తి ప్రణాళిక
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,వాయిస్ సృష్టి సాధనాన్ని తెరవడం
 DocType: Salary Component,Round to the Nearest Integer,సమీప పూర్ణాంకానికి రౌండ్
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,స్టాక్‌లో లేని అంశాలను కార్ట్‌కు జోడించడానికి అనుమతించండి
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,సేల్స్ చూపించు
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,సీరియల్ నో ఇన్పుట్ ఆధారంగా లావాదేవీల్లో Qty సెట్ చేయండి
 ,Total Stock Summary,మొత్తం స్టాక్ సారాంశం
@@ -1175,6 +1180,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),బేస్ అవర్ రేటు (కంపెనీ కరెన్సీ)
 ,Qty To Be Billed,Qty To Bill
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,పంపిణీ మొత్తం
+DocType: Coupon Code,Gift Card,బహుమతి కార్డు
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,ఉత్పత్తి కోసం రిజర్వు చేయబడిన Qty: తయారీ వస్తువులను తయారు చేయడానికి ముడి పదార్థాల పరిమాణం.
 DocType: Loyalty Point Entry Redemption,Redemption Date,విముక్తి తేదీ
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,ఈ బ్యాంక్ లావాదేవీ ఇప్పటికే పూర్తిగా రాజీ పడింది
@@ -1263,6 +1269,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,టైమ్‌షీట్‌ను సృష్టించండి
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,ఖాతా {0} అనేకసార్లు నమోదు చేసిన
 DocType: Account,Expenses Included In Valuation,ఖర్చులు విలువలో
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,ఇన్వాయిస్లు కొనండి
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,మీ సభ్యత్వం 30 రోజుల్లో ముగుస్తుంది ఉంటే మీరు మాత్రమే పునరుద్ధరించవచ్చు
 DocType: Shopping Cart Settings,Show Stock Availability,స్టాక్ లభ్యతను చూపించు
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},ఆస్తి వర్గం {0} లేదా సంస్థ {0} లో {0}
@@ -1800,6 +1807,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,అంశాలు మరియు UOM లను దిగుమతి చేస్తోంది
 DocType: Repayment Schedule,Balance Loan Amount,సంతులనం రుణ మొత్తం
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,వివరాలకు జోడించబడింది
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","క్షమించండి, కూపన్ కోడ్ అయిపోయింది"
 DocType: Communication Medium,Catch All,అన్నింటినీ క్యాచ్ చేయండి
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,షెడ్యూల్ కోర్సు
 DocType: Budget,Applicable on Material Request,మెటీరియల్ అభ్యర్థనపై వర్తింపజేయండి
@@ -1966,6 +1974,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,చెల్లని లక్షణం
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} సమర్పించాలి
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,ఇమెయిల్ ప్రచారాలు
+DocType: Sales Partner,To Track inbound purchase,ఇన్‌బౌండ్ కొనుగోలును ట్రాక్ చేయడానికి
 DocType: Buying Settings,Default Supplier Group,డిఫాల్ట్ సరఫరాదారు సమూహం
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},పరిమాణం కంటే తక్కువ లేదా సమానంగా ఉండాలి {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},భాగం కొరకు అర్హత పొందిన గరిష్ట మొత్తం {0} {1}
@@ -2118,7 +2127,6 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,స్టాక్ ఎంట్రీ చేయండి
 DocType: Hotel Room Reservation,Hotel Reservation User,హోటల్ రిజర్వేషన్ వినియోగదారు
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,స్థితిని సెట్ చేయండి
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,దయచేసి సెటప్&gt; నంబరింగ్ సిరీస్ ద్వారా హాజరు కోసం నంబరింగ్ సిరీస్‌ను సెటప్ చేయండి
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,మొదటి ఉపసర్గ దయచేసి ఎంచుకోండి
 DocType: Contract,Fulfilment Deadline,నెరవేరడం గడువు
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,నీ దగ్గర
@@ -2242,6 +2250,7 @@
 DocType: Quality Meeting Table,Under Review,పరిశీలన లో ఉన్నది
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,లాగిన్ చేయడంలో విఫలమైంది
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,ఆస్తి {0} సృష్టించబడింది
+DocType: Coupon Code,Promotional,ప్రచార
 DocType: Special Test Items,Special Test Items,ప్రత్యేక టెస్ట్ అంశాలు
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Marketplace పై రిజిస్టర్ చేయడానికి మీరు సిస్టమ్ మేనేజర్ మరియు Item మేనేజర్ పాత్రలతో ఒక యూజర్గా ఉండాలి.
 apps/erpnext/erpnext/config/buying.py,Key Reports,కీ నివేదికలు
@@ -2280,6 +2289,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc టైప్
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,అమ్మకాలు జట్టు మొత్తం కేటాయించింది శాతం 100 ఉండాలి
 DocType: Subscription Plan,Billing Interval Count,బిల్లింగ్ విరామం కౌంట్
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","ఈ పత్రాన్ని రద్దు చేయడానికి దయచేసి ఉద్యోగి <a href=""#Form/Employee/{0}"">{0}</a> delete ను తొలగించండి"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,నియామకాలు మరియు పేషెంట్ ఎన్కౌన్టర్స్
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,విలువ లేదు
 DocType: Employee,Department and Grade,శాఖ మరియు గ్రేడ్
@@ -2380,6 +2391,7 @@
 DocType: Project,Start and End Dates,ప్రారంభం మరియు తేదీలు ఎండ్
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,ఒప్పందం మూస నెరవేర్చు నిబంధనలు
 ,Delivered Items To Be Billed,పంపిణీ అంశాలు బిల్ టు
+DocType: Coupon Code,Maximum Use,గరిష్ట ఉపయోగం
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},ఓపెన్ BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,వేర్హౌస్ సీరియల్ నం కోసం మారలేదు
 DocType: Authorization Rule,Average Discount,సగటు డిస్కౌంట్
@@ -2539,6 +2551,7 @@
 DocType: Item,Inventory,ఇన్వెంటరీ
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Json గా డౌన్‌లోడ్ చేయండి
 DocType: Item,Sales Details,సేల్స్ వివరాలు
+DocType: Coupon Code,Used,ఉపయోగించబడిన
 DocType: Opportunity,With Items,అంశాలు తో
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',ప్రచారం {{0} &#39;ఇప్పటికే {1}&#39; {2} &#39;కోసం ఉంది
 DocType: Asset Maintenance,Maintenance Team,నిర్వహణ బృందం
@@ -2665,7 +2678,7 @@
 						Serial No cannot be ensured",అంశం {0} కోసం క్రియాశీల BOM కనుగొనబడలేదు. \ Serial No ద్వారా డెలివరీ అందించబడదు
 DocType: Sales Partner,Sales Partner Target,సేల్స్ భాగస్వామిలో టార్గెట్
 DocType: Loan Type,Maximum Loan Amount,గరిష్ఠ రుణ మొత్తం
-DocType: Pricing Rule,Pricing Rule,ధర రూల్
+DocType: Coupon Code,Pricing Rule,ధర రూల్
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},విద్యార్థి కోసం నకిలీ రోల్ నంబర్ {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},విద్యార్థి కోసం నకిలీ రోల్ నంబర్ {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,ఆర్డర్ కొనుగోలు మెటీరియల్ అభ్యర్థన
@@ -2743,6 +2756,7 @@
 DocType: Payment Schedule,Payment Amount,చెల్లింపు మొత్తం
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,తేదీ మరియు పని ముగింపు తేదీ నుండి పని మధ్యలో అర్ధ రోజు ఉండాలి
 DocType: Healthcare Settings,Healthcare Service Items,హెల్త్కేర్ సర్వీస్ అంశాలు
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,చెల్లని బార్‌కోడ్. ఈ బార్‌కోడ్‌కు ఏ అంశం జోడించబడలేదు.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,వినియోగించిన మొత్తం
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,నగదు నికర మార్పు
 DocType: Assessment Plan,Grading Scale,గ్రేడింగ్ స్కేల్
@@ -2859,7 +2873,6 @@
 DocType: Share Transfer,Asset Account,ఆస్తి ఖాతా
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,కొత్త విడుదల తేదీ భవిష్యత్తులో ఉండాలి
 DocType: Purchase Invoice,End date of current invoice's period,ప్రస్తుత ఇన్వాయిస్ పిరియడ్ ముగింపు తేదీ
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,దయచేసి మానవ వనరులు&gt; హెచ్ ఆర్ సెట్టింగులలో ఉద్యోగుల నామకరణ వ్యవస్థను సెటప్ చేయండి
 DocType: Lab Test,Technician Name,టెక్నీషియన్ పేరు
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3137,7 +3150,6 @@
 DocType: Student,Student Mobile Number,స్టూడెంట్ మొబైల్ నంబర్
 DocType: Item,Has Variants,రకాల్లో
 DocType: Employee Benefit Claim,Claim Benefit For,దావా బెనిఫిట్ కోసం
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","{2} కంటే {2} కంటే ఎక్కువ {0} వస్తువు కోసం overbill చేయలేము. అధిక బిల్లింగ్ను అనుమతించడానికి, దయచేసి స్టాక్ సెట్టింగ్ల్లో సెట్ చేయండి"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,ప్రతిస్పందనని నవీకరించండి
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},మీరు ఇప్పటికే ఎంపిక నుండి అంశాలను రోజులో {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,మంత్లీ పంపిణీ పేరు
@@ -3424,6 +3436,7 @@
 DocType: Vehicle,Fuel Type,ఇంధన పద్ధతి
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,కంపెనీ లో కరెన్సీ రాయండి
 DocType: Workstation,Wages per hour,గంటకు వేతనాలు
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,కస్టమర్&gt; కస్టమర్ గ్రూప్&gt; భూభాగం
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},బ్యాచ్ లో స్టాక్ సంతులనం {0} అవుతుంది ప్రతికూల {1} Warehouse వద్ద అంశం {2} కోసం {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,మెటీరియల్ అభ్యర్థనలను తరువాత అంశం యొక్క క్రమాన్ని స్థాయి ఆధారంగా స్వయంచాలకంగా బడ్డాయి
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},ఖాతా {0} చెల్లదు. ఖాతా కరెన్సీ ఉండాలి {1}
@@ -3755,6 +3768,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,వేతనం స్లిప్ సమర్పించండి
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,హోల్డ్ ఆన్
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,ఒక ప్రశ్నకు కనీసం ఒక సరైన ఎంపికలు ఉండాలి
+apps/erpnext/erpnext/hooks.py,Purchase Orders,కొనుగోలు ఆర్డర్లు
 DocType: Account,Inter Company Account,ఇంటర్ కంపెనీ ఖాతా
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,పెద్దమొత్తంలో దిగుమతి
 DocType: Sales Partner,Address & Contacts,చిరునామా &amp; కాంటాక్ట్స్
@@ -3765,6 +3779,7 @@
 DocType: POS Profile,[Select],[ఎంచుకోండి]
 DocType: Staffing Plan Detail,Number Of Positions,స్థానాల సంఖ్య
 DocType: Vital Signs,Blood Pressure (diastolic),రక్తపోటు (డయాస్టొలిక్)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,దయచేసి కస్టమర్‌ను ఎంచుకోండి.
 DocType: SMS Log,Sent To,పంపిన
 DocType: Agriculture Task,Holiday Management,హాలిడే మేనేజ్మెంట్
 DocType: Payment Request,Make Sales Invoice,సేల్స్ వాయిస్ చేయండి
@@ -3971,7 +3986,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} సమర్పించిన లేదు
 DocType: Subscription,Trialling,జమ చేస్తున్నారు
 DocType: Sales Invoice Item,Deferred Revenue,వాయిదా వేసిన ఆదాయం
-DocType: Bank Account,GL Account,జిఎల్ ఖాతా
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,నగదు ఖాతా సేల్స్ వాయిస్ సృష్టికి ఉపయోగించబడుతుంది
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,మినహాయింపు ఉప వర్గం
 DocType: Member,Membership Expiry Date,సభ్యత్వం గడువు తేదీ
@@ -4369,13 +4383,13 @@
 DocType: C-Form Invoice Detail,Territory,భూభాగం
 DocType: Pricing Rule,Apply Rule On Item Code,ఐటెమ్ కోడ్‌లో నిబంధనను వర్తించండి
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,అవసరం సందర్శనల సంఖ్య చెప్పలేదు దయచేసి
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,స్టాక్ బ్యాలెన్స్ రిపోర్ట్
 DocType: Stock Settings,Default Valuation Method,డిఫాల్ట్ లెక్కింపు విధానం
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,ఫీజు
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,సంచిత మొత్తం చూపించు
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,నవీకరణ పురోగమనంలో ఉంది. కొంత సమయం పట్టవచ్చు.
 DocType: Production Plan Item,Produced Qty,ఉత్పత్తి Qty
 DocType: Vehicle Log,Fuel Qty,ఇంధన ప్యాక్ చేసిన అంశాల
-DocType: Stock Entry,Target Warehouse Name,టార్గెట్ వేర్హౌస్ పేరు
 DocType: Work Order Operation,Planned Start Time,అనుకున్న ప్రారంభ సమయం
 DocType: Course,Assessment,అసెస్మెంట్
 DocType: Payment Entry Reference,Allocated,కేటాయించిన
@@ -4441,10 +4455,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","ప్రామాణిక నిబంధనలు మరియు సేల్స్ అండ్ కొనుగోళ్లు చేర్చవచ్చు పరిస్థితిలు. ఉదాహరణలు: ఆఫర్ 1. చెల్లుబాటు. 1. చెల్లింపు నిబంధనలు (క్రెడిట్ న అడ్వాన్సు భాగం పంచుకున్నారు ముందుగానే etc). 1. అదనపు (లేదా కస్టమర్ ద్వారా చెల్లించవలసిన) ఏమిటి. 1. భద్రత / వాడుక హెచ్చరిక. 1. వారంటీ ఏదైనా ఉంటే. 1. విధానం రిటర్న్స్. షిప్పింగ్ 1. నిబంధనలు వర్తిస్తే. వివాదాలు ప్రసంగిస్తూ నష్టపరిహారం, బాధ్యత 1. వేస్, మొదలైనవి 1. చిరునామా మరియు మీ సంస్థ సంప్రదించండి."
 DocType: Homepage Section,Section Based On,విభాగం ఆధారంగా
+DocType: Shopping Cart Settings,Show Apply Coupon Code,వర్తించు కూపన్ కోడ్ చూపించు
 DocType: Issue,Issue Type,ఇష్యూ పద్ధతి
 DocType: Attendance,Leave Type,లీవ్ టైప్
 DocType: Purchase Invoice,Supplier Invoice Details,సరఫరాదారు ఇన్వాయిస్ వివరాలు
 DocType: Agriculture Task,Ignore holidays,సెలవులు విస్మరించండి
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,కూపన్ షరతులను జోడించండి / సవరించండి
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,ఖర్చుల / తేడా ఖాతా ({0}) ఒక &#39;లాభం లేదా నష్టం ఖాతా ఉండాలి
 DocType: Stock Entry Detail,Stock Entry Child,స్టాక్ ఎంట్రీ చైల్డ్
 DocType: Project,Copied From,నుండి కాపీ
@@ -4614,6 +4630,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,అసెస్మెంట్ ప్రణాళిక ప్రమాణం
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,ట్రాన్సాక్షన్స్
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,కొనుగోలు ఆర్డర్లు అడ్డుకో
+DocType: Coupon Code,Coupon Name,కూపన్ పేరు
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,అనుమానాస్పదం
 DocType: Email Campaign,Scheduled,షెడ్యూల్డ్
 DocType: Shift Type,Working Hours Calculation Based On,పని గంటలు లెక్కింపు ఆధారంగా
@@ -4630,7 +4647,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,వైవిధ్యాలను సృష్టించండి
 DocType: Vehicle,Diesel,డీజిల్
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,ధర జాబితా కరెన్సీ ఎంపిక లేదు
+DocType: Quick Stock Balance,Available Quantity,అందుబాటులో ఉన్న పరిమాణం
 DocType: Purchase Invoice,Availed ITC Cess,ITC సెస్ను ఉపయోగించింది
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,దయచేసి విద్య&gt; విద్యా సెట్టింగులలో బోధకుడు నామకరణ వ్యవస్థను సెటప్ చేయండి
 ,Student Monthly Attendance Sheet,స్టూడెంట్ మంత్లీ హాజరు షీట్
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,సెల్లింగ్ కోసం మాత్రమే షిప్పింగ్ నియమం వర్తిస్తుంది
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,తరుగుదల వరుస {0}: తదుపరి తరుగుదల తేదీ కొనుగోలు తేదీకి ముందు ఉండకూడదు
@@ -4697,6 +4716,7 @@
 DocType: Quality Meeting,Quality Meeting,నాణ్యమైన సమావేశం
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,కాని గ్రూపుకు గ్రూప్
 DocType: Employee,ERPNext User,ERPNext వాడుకరి
+DocType: Coupon Code,Coupon Description,కూపన్ వివరణ
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},బ్యాచ్ వరుసగా తప్పనిసరి {0}
 DocType: Company,Default Buying Terms,డిఫాల్ట్ కొనుగోలు నిబంధనలు
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,కొనుగోలు రసీదులు అంశం పంపినవి
@@ -4857,6 +4877,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,డాక్యుమెంట్ వివరాలు వ్యతిరేకంగా ఏ
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},దేశం {0} కోసం తొలగింపు అనుమతించబడదు
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,పార్టీ టైప్ తప్పనిసరి
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,కూపన్ కోడ్‌ను వర్తించండి
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","జాబ్ కార్డ్ {0} కోసం, మీరు &#39;తయారీకి మెటీరియల్ బదిలీ&#39; రకం స్టాక్ ఎంట్రీని మాత్రమే చేయవచ్చు"
 DocType: Quality Inspection,Outgoing,అవుట్గోయింగ్
 DocType: Customer Feedback Table,Customer Feedback Table,కస్టమర్ అభిప్రాయ పట్టిక
@@ -5005,7 +5026,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,కొనుగోలు ఆర్డర్ సమర్పణలో
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,అన్ని సరఫరాదారులను జోడించండి
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,రో # {0}: కేటాయించిన సొమ్ము బాకీ మొత్తం కంటే ఎక్కువ ఉండకూడదు.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,కస్టమర్&gt; కస్టమర్ గ్రూప్&gt; భూభాగం
 DocType: Tally Migration,Parties,పార్టీలు
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,బ్రౌజ్ BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,సెక్యూర్డ్ లోన్స్
@@ -5036,7 +5056,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},అంశం కోసం ప్రత్యామ్నాయ అంశం సెట్ చేయడానికి అనుమతించవద్దు {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,తేదీ పునరావృతమవుతుంది
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,సంతకం పెట్టడానికి అధికారం
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,దయచేసి విద్య&gt; విద్య సెట్టింగులలో బోధకుడు నామకరణ వ్యవస్థను సెటప్ చేయండి
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),నికర ఐటిసి అందుబాటులో ఉంది (ఎ) - (బి)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,ఫీజులను సృష్టించండి
 DocType: Project,Total Purchase Cost (via Purchase Invoice),మొత్తం కొనుగోలు ఖర్చు (కొనుగోలు వాయిస్ ద్వారా)
@@ -5060,6 +5079,7 @@
 DocType: Quiz Result,Wrong,తప్పు
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,రేటు ధర జాబితా కరెన్సీ కస్టమర్ యొక్క బేస్ కరెన్సీ మార్చబడుతుంది
 DocType: Purchase Invoice Item,Net Amount (Company Currency),నికర మొత్తం (కంపెనీ కరెన్సీ)
+DocType: Sales Partner,Referral Code,రెఫరల్ కోడ్
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,పూర్తి మంజూరు మొత్తం కంటే మొత్తం ముందస్తు మొత్తం ఎక్కువ కాదు
 DocType: Salary Slip,Hour Rate,గంట రేట్
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,ఆటో రీ-ఆర్డర్‌ను ప్రారంభించండి
@@ -5186,6 +5206,7 @@
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},దయచేసి అంశానికి వ్యతిరేకంగా BOM ను ఎంచుకోండి {0}
 DocType: Shopping Cart Settings,Show Stock Quantity,స్టాక్ పరిమాణం చూపించు
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,ఆపరేషన్స్ నుండి నికర నగదు
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},అంశం కోసం UOM మార్పిడి కారకం ({0} -&gt; {1}) కనుగొనబడలేదు: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,అంశం 4
 DocType: Student Admission,Admission End Date,అడ్మిషన్ ముగింపు తేదీ
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,సబ్ కాంట్రాక్టు
@@ -5208,6 +5229,7 @@
 DocType: Travel Request,Fully Sponsored,పూర్తిగా ప్రాయోజితం
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,రివర్స్ జర్నల్ ఎంట్రీ
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,జాబ్ కార్డ్ సృష్టించండి
+DocType: Quotation,Referral Sales Partner,రెఫరల్ సేల్స్ భాగస్వామి
 DocType: Quality Procedure Process,Process Description,ప్రాసెస్ వివరణ
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,కస్టమర్ {0} సృష్టించబడింది.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,ఏ గిడ్డంగిలో ప్రస్తుతం స్టాక్ లేదు
@@ -5339,6 +5361,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,బిఒఎం రేటు
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,అప్‌లోడ్ చేసిన ఫైల్‌ను చదవడం
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","నిలిపివేయబడింది వర్క్ ఆర్డర్ రద్దు చేయబడదు, రద్దు చేయడానికి ముందుగా దాన్ని అన్స్టాప్ చేయండి"
+DocType: Coupon Code,Coupon Code,కూపన్ కోడ్
 DocType: Asset,Journal Entry for Scrap,స్క్రాప్ జర్నల్ ఎంట్రీ
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,డెలివరీ గమనిక అంశాలను తీసి దయచేసి
 apps/erpnext/erpnext/accounts/utils.py,Journal Entries {0} are un-linked,జర్నల్ ఎంట్రీలు {0}-అన్ జత చేయబడినాయి
@@ -5417,6 +5440,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;తేదీ&#39; అవసరం
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},కారణంగా / సూచన తేదీ తర్వాత ఉండకూడదు {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,డేటా దిగుమతి మరియు ఎగుమతి
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","క్షమించండి, కూపన్ కోడ్ చెల్లుబాటు గడువు ముగిసింది"
 DocType: Bank Account,Account Details,ఖాతా వివరాలు
 DocType: Crop,Materials Required,అవసరమైన మెటీరియల్స్
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,తోబుట్టువుల విద్యార్థులు దొరకలేదు
@@ -5454,6 +5478,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,వినియోగదారులకు వెళ్లండి
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,చెల్లించిన మొత్తం పరిమాణం గ్రాండ్ మొత్తం కంటే ఎక్కువ ఉండకూడదు ఆఫ్ వ్రాయండి +
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} అంశం కోసం ఒక చెల్లుబాటులో బ్యాచ్ సంఖ్య కాదు {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,దయచేసి చెల్లుబాటు అయ్యే కూపన్ కోడ్‌ను నమోదు చేయండి !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},గమనిక: లీవ్ పద్ధతి కోసం తగినంత సెలవు సంతులనం లేదు {0}
 DocType: Task,Task Description,టాస్క్ వివరణ
 DocType: Training Event,Seminar,సెమినార్
@@ -5542,6 +5567,7 @@
 DocType: Vehicle,Insurance Company,ఇన్సూరెన్స్ కంపెనీ
 DocType: Asset Category Account,Fixed Asset Account,స్థిర ఆస్తి ఖాతా
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Variable,వేరియబుల్
+apps/erpnext/erpnext/regional/italy/utils.py,"Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}","ద్రవ్య పాలన తప్పనిసరి, దయతో సంస్థలో ఆర్థిక పాలనను సెట్ చేయండి {0}"
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js,From Delivery Note,డెలివరీ గమనిక
 DocType: Chapter,Members,సభ్యులు
 DocType: Student,Student Email Address,స్టూడెంట్ ఇమెయిల్ అడ్రస్
@@ -5718,6 +5744,7 @@
 ,TDS Payable Monthly,మంజూరు టిడిఎస్
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,BOM ను భర్తీ చేయడానికి క్యూ. దీనికి కొన్ని నిమిషాలు పట్టవచ్చు.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',వర్గం &#39;వాల్యువేషన్&#39; లేదా &#39;వాల్యుయేషన్ మరియు సంపూర్ణమైనది&#39; కోసం ఉన్నప్పుడు తీసివేయు కాదు
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,దయచేసి మానవ వనరులు&gt; హెచ్ ఆర్ సెట్టింగులలో ఉద్యోగుల నామకరణ వ్యవస్థను సెటప్ చేయండి
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,మొత్తం చెల్లింపులు
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},సీరియల్ అంశం కోసం సీరియల్ మేము అవసరం {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,రసీదులు చెల్లింపుల మ్యాచ్
@@ -5805,6 +5832,7 @@
 DocType: Production Plan,Get Raw Materials For Production,ఉత్పత్తికి ముడిపదార్థాలను పొందండి
 DocType: Job Opening,Job Title,ఉద్యోగ శీర్షిక
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,భవిష్యత్ చెల్లింపు Ref
+DocType: Quotation,Additional Discount and Coupon Code,అదనపు డిస్కౌంట్ మరియు కూపన్ కోడ్
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} {1} ఉల్లేఖనాన్ని అందించదు అని సూచిస్తుంది, కానీ అన్ని అంశాలు \ కోట్ చెయ్యబడ్డాయి. RFQ కోట్ స్థితిని నవీకరిస్తోంది."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,గరిష్ట నమూనాలు - {0} బ్యాచ్ {1} మరియు బ్యాచ్ {3} లో అంశం {2} కోసం ఇప్పటికే ఉంచబడ్డాయి.
@@ -6032,6 +6060,7 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,వెబ్సైట్ హోమ్ కోసం సెట్టింగులు
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},{0} స్కోర్కార్డ్ స్టాండింగ్ కారణంగా {0} కోసం RFQ లు అనుమతించబడవు
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,కొనుగోలు ఇన్వాయిస్ చేయండి
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,వాడిన ఆకులు
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,మీరు మెటీరియల్ అభ్యర్థనను సమర్పించాలనుకుంటున్నారా
 DocType: Job Offer,Awaiting Response,రెస్పాన్స్ వేచిఉండి
@@ -6045,6 +6074,7 @@
 DocType: Training Event Employee,Optional,ఐచ్ఛికము
 DocType: Salary Slip,Earning & Deduction,ఎర్నింగ్ &amp; తీసివేత
 DocType: Agriculture Analysis Criteria,Water Analysis,నీటి విశ్లేషణ
+DocType: Sales Order,Skip Delivery Note,డెలివరీ గమనికను దాటవేయి
 DocType: Price List,Price Not UOM Dependent,ధర UOM డిపెండెంట్ కాదు
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} వైవిధ్యాలు సృష్టించబడ్డాయి.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,డిఫాల్ట్ సేవా స్థాయి ఒప్పందం ఇప్పటికే ఉంది.
@@ -6252,7 +6282,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,పన్నులు మరియు ఆరోపణలు చేర్చబడింది
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,తరుగుదల వరుస {0}: అప్రస్తుత తేదీ అందుబాటులో ఉండకపోవటానికి ముందు తేదీ ఉండకూడదు
 ,Sales Funnel,అమ్మకాల గరాటు
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,ఐటెమ్ కోడ్&gt; ఐటెమ్ గ్రూప్&gt; బ్రాండ్
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,సంక్షిప్త తప్పనిసరి
 DocType: Project,Task Progress,టాస్క్ ప్రోగ్రెస్
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,కార్ట్
@@ -6346,6 +6375,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS ప్రొఫైల్ POS ఎంట్రీ చేయడానికి అవసరం
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",విశ్వసనీయ పాయింట్లు పేర్కొన్న సేకరణ కారకం ఆధారంగా (అమ్మకాల వాయిస్ ద్వారా) పూర్తి చేసిన ఖర్చు నుండి లెక్కించబడుతుంది.
 DocType: Program Enrollment Tool,Enroll Students,విద్యార్ధులను నమోదు
+DocType: Pricing Rule,Coupon Code Based,కూపన్ కోడ్ ఆధారిత
 DocType: Company,HRA Settings,HRA సెట్టింగులు
 DocType: Homepage,Hero Section,హీరో విభాగం
 DocType: Employee Transfer,Transfer Date,బదిలీ తేదీ
@@ -6460,6 +6490,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',కంపెనీ ఖాళీ ఫిల్టర్ సెట్ చేయండి బృందంచే &#39;కంపెనీ&#39; ఉంది
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,పోస్ట్ చేసిన తేదీ భవిష్య తేదీలో ఉండకూడదు
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},రో # {0}: సీరియల్ లేవు {1} తో సరిపోలడం లేదు {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,దయచేసి సెటప్&gt; నంబరింగ్ సిరీస్ ద్వారా హాజరు కోసం నంబరింగ్ సిరీస్‌ను సెటప్ చేయండి
 DocType: Stock Entry,Target Warehouse Address,టార్గెట్ వేర్హౌస్ చిరునామా
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,సాధారణం లీవ్
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,ఉద్యోగుల చెక్-ఇన్ హాజరు కోసం పరిగణించబడే షిఫ్ట్ ప్రారంభ సమయానికి ముందు సమయం.
@@ -6494,7 +6525,6 @@
 DocType: Employee Grade,Employee Grade,ఉద్యోగి గ్రేడ్
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Piecework
 DocType: GSTR 3B Report,June,జూన్
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,సరఫరాదారు&gt; సరఫరాదారు రకం
 DocType: Share Balance,From No,సంఖ్య నుండి
 DocType: Shift Type,Early Exit Grace Period,ప్రారంభ నిష్క్రమణ గ్రేస్ కాలం
 DocType: Task,Actual Time (in Hours),(గంటల్లో) వాస్తవ సమయం
@@ -6776,7 +6806,6 @@
 DocType: Warehouse,Warehouse Name,వేర్హౌస్ పేరు
 DocType: Naming Series,Select Transaction,Select లావాదేవీ
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,రోల్ ఆమోదిస్తోంది లేదా వాడుకరి ఆమోదిస్తోంది నమోదు చేయండి
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},అంశం కోసం UOM మార్పిడి కారకం ({0} -&gt; {1}) కనుగొనబడలేదు: {2}
 DocType: Journal Entry,Write Off Entry,ఎంట్రీ ఆఫ్ వ్రాయండి
 DocType: BOM,Rate Of Materials Based On,రేటు పదార్థాల బేస్డ్ న
 DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","ప్రారంభించబడితే, ఫీల్డ్ అకాడెమిక్ టర్మ్ ప్రోగ్రామ్ ఎన్రాల్మెంట్ టూల్లో తప్పనిసరి అవుతుంది."
@@ -6913,6 +6942,7 @@
 DocType: Budget,Warn,హెచ్చరించు
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,ఈ వర్క్ ఆర్డర్ కోసం అన్ని అంశాలు ఇప్పటికే బదిలీ చేయబడ్డాయి.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.",ఏ ఇతర స్టర్ రికార్డులలో వెళ్ళాలి అని చెప్పుకోదగిన ప్రయత్నం.
+DocType: Bank Account,Company Account,కంపెనీ ఖాతా
 DocType: Asset Maintenance,Manufacturing User,తయారీ వాడుకరి
 DocType: Purchase Invoice,Raw Materials Supplied,రా మెటీరియల్స్ పంపినవి
 DocType: Subscription Plan,Payment Plan,చెల్లింపు ప్రణాళిక
@@ -6954,6 +6984,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) వర్క్ ఆర్డరులో అనుకున్న పరిమాణము ({2}) కంటే ఎక్కువగా ఉండకూడదు {3}
 DocType: Certification Application,Name of Applicant,దరఖాస్తుదారు పేరు
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,తయారీ కోసం సమయం షీట్.
+DocType: Quick Stock Balance,Quick Stock Balance,త్వరిత స్టాక్ బ్యాలెన్స్
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,పూర్తికాని
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,స్టాక్ లావాదేవీ తర్వాత వేరియంట్ లక్షణాలను మార్చలేరు. దీన్ని చేయటానికి మీరు క్రొత్త వస్తువును తయారు చేసుకోవాలి.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA ఆదేశం
@@ -7278,6 +7309,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} క్రియారహితంగా విద్యార్థి
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} క్రియారహితంగా విద్యార్థి
 DocType: Employee,Health Details,ఆరోగ్యం వివరాలు
+DocType: Coupon Code,Coupon Type,కూపన్ రకం
 DocType: Leave Encashment,Encashable days,ఉత్తేజకరమైన రోజులు
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,ఒక చెల్లింపు అభ్యర్థన సూచన పత్రం అవసరం సృష్టించడానికి
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,ఒక చెల్లింపు అభ్యర్థన సూచన పత్రం అవసరం సృష్టించడానికి
@@ -7561,6 +7593,7 @@
 DocType: Hotel Room Package,Amenities,సదుపాయాలు
 DocType: Accounts Settings,Automatically Fetch Payment Terms,చెల్లింపు నిబంధనలను స్వయంచాలకంగా పొందండి
 DocType: QuickBooks Migrator,Undeposited Funds Account,Undeposited ఫండ్స్ ఖాతా
+DocType: Coupon Code,Uses,ఉపయోగాలు
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,చెల్లింపు యొక్క బహుళ డిఫాల్ట్ మోడ్ అనుమతించబడదు
 DocType: Sales Invoice,Loyalty Points Redemption,విశ్వసనీయ పాయింట్లు రిడంప్షన్
 ,Appointment Analytics,నియామకం విశ్లేషణలు
@@ -7578,6 +7611,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,మీరు సంవత్సరానికి విద్యార్థులు సమూహాలు చేస్తే ఖాళీ వదిలి
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,మీరు సంవత్సరానికి విద్యార్థులు సమూహాలు చేస్తే ఖాళీ వదిలి
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","ఎంచుకుంటే, మొత్తం no. వర్కింగ్ డేస్ సెలవులు కలిగి ఉంటుంది, మరియు ఈ జీతం రోజుకి విలువ తగ్గిస్తుంది"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,డొమైన్‌ను జోడించడంలో విఫలమైంది
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","ఓవర్ రసీదు / డెలివరీని అనుమతించడానికి, స్టాక్ సెట్టింగులు లేదా ఐటెమ్‌లో &quot;ఓవర్ రసీదు / డెలివరీ అలవెన్స్&quot; ను నవీకరించండి."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","ప్రస్తుత కీని ఉపయోగించి అనువర్తనాలు ప్రాప్యత చేయలేవు, మీరు ఖచ్చితంగా ఉన్నారా?"
 DocType: Subscription Settings,Prorate,prorate
@@ -7590,6 +7624,7 @@
 ,BOM Stock Report,బిఒఎం స్టాక్ రిపోర్ట్
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","కేటాయించిన టైమ్‌స్లాట్ లేకపోతే, అప్పుడు కమ్యూనికేషన్ ఈ గుంపుచే నిర్వహించబడుతుంది"
 DocType: Stock Reconciliation Item,Quantity Difference,పరిమాణం తేడా
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,సరఫరాదారు&gt; సరఫరాదారు రకం
 DocType: Opportunity Item,Basic Rate,ప్రాథమిక రేటు
 DocType: GL Entry,Credit Amount,క్రెడిట్ మొత్తం
 ,Electronic Invoice Register,ఎలక్ట్రానిక్ ఇన్వాయిస్ రిజిస్టర్
@@ -7843,6 +7878,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),పన్నులు మరియు ఆరోపణలు తగ్గించబడుతూ (కంపెనీ కరెన్సీ)
 DocType: Item Group,General Settings,సాధారణ సెట్టింగులు
 DocType: Article,Article,వ్యాసం
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,దయచేసి కూపన్ కోడ్‌ను నమోదు చేయండి !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,కరెన్సీ నుండి మరియు కరెన్సీ అదే ఉండకూడదు
 DocType: Taxable Salary Slab,Percent Deduction,శాతం మినహాయింపు
 DocType: GL Entry,To Rename,పేరు మార్చడానికి
diff --git a/erpnext/translations/th.csv b/erpnext/translations/th.csv
index 350db28..3b32053 100644
--- a/erpnext/translations/th.csv
+++ b/erpnext/translations/th.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,ติดต่อลูกค้า
 DocType: Shift Type,Enable Auto Attendance,เปิดใช้งานการเข้าร่วมอัตโนมัติ
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,กรุณาใส่คลังสินค้าและวันที่
 DocType: Lost Reason Detail,Opportunity Lost Reason,โอกาสสูญเสียเหตุผล
 DocType: Patient Appointment,Check availability,ตรวจสอบความพร้อมใช้งาน
 DocType: Retention Bonus,Bonus Payment Date,วันที่ชำระเงินโบนัส
@@ -265,6 +266,7 @@
 ,Completed Work Orders,ใบสั่งงานที่เสร็จสมบูรณ์
 DocType: Support Settings,Forum Posts,กระทู้จากฟอรัม
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage",งานได้รับการจัดคิวให้เป็นงานพื้นหลัง ในกรณีที่มีปัญหาใด ๆ ในการประมวลผลในพื้นหลังระบบจะเพิ่มความคิดเห็นเกี่ยวกับข้อผิดพลาดในการกระทบยอดหุ้นนี้และกลับสู่ขั้นตอนการร่าง
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started",ขออภัยความถูกต้องของรหัสคูปองยังไม่เริ่ม
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,จำนวนเงินที่ต้องเสียภาษี
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},คุณยังไม่ได้รับอนุญาตให้ เพิ่มหรือปรับปรุง รายการ ก่อน {0}
 DocType: Leave Policy,Leave Policy Details,ปล่อยรายละเอียดนโยบาย
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,วัสดุสิ้นเปลือง
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,เกรด
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,รหัสรายการ&gt; กลุ่มรายการ&gt; แบรนด์
 DocType: Restaurant Table,No of Seats,ไม่มีที่นั่ง
 DocType: Sales Invoice,Overdue and Discounted,เกินกำหนดและลดราคา
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,การโทรถูกตัดการเชื่อมต่อ
@@ -507,6 +510,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,ระยะห่างระหว่างบรรทัดสำหรับจำนวนเงินในคำพูด
 DocType: Vehicle,Additional Details,รายละเอียดเพิ่มเติม
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,ให้ คำอธิบาย
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,ดึงรายการจากคลังสินค้า
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,ขอซื้อ
 DocType: POS Closing Voucher Details,Collected Amount,จำนวนที่สะสม
 DocType: Lab Test,Submitted Date,วันที่ส่ง
@@ -614,6 +618,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,เรียนรู้
 ,Trial Balance (Simple),งบทดลอง (ง่าย)
 DocType: Purchase Invoice Item,Enable Deferred Expense,เปิดใช้งานค่าใช้จ่ายรอตัดบัญชี
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,รหัสคูปองที่ใช้แล้ว
 DocType: Asset,Next Depreciation Date,ถัดไปวันที่ค่าเสื่อมราคา
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,ค่าใช้จ่ายในกิจกรรมต่อพนักงาน
 DocType: Accounts Settings,Settings for Accounts,การตั้งค่าสำหรับบัญชี
@@ -854,8 +859,6 @@
 DocType: Sales Invoice,Total Qty,จำนวนรวม
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,รหัสอีเมล Guardian2
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,รหัสอีเมล Guardian2
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","โปรดลบพนักงาน <a href=""#Form/Employee/{0}"">{0}</a> \ เพื่อยกเลิกเอกสารนี้"
 DocType: Item,Show in Website (Variant),แสดงในเว็บไซต์ (Variant)
 DocType: Employee,Health Concerns,ความกังวลเรื่องสุขภาพ
 DocType: Payroll Entry,Select Payroll Period,เลือกระยะเวลาการจ่ายเงินเดือน
@@ -1021,6 +1024,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,บัญชีหักภาษี
 DocType: Pricing Rule,Sales Partner,พันธมิตรการขาย
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,ดัชนีชี้วัดทั้งหมดของ Supplier
+DocType: Coupon Code,To be used to get discount,เพื่อใช้ในการรับส่วนลด
 DocType: Buying Settings,Purchase Receipt Required,รับซื้อที่จำเป็น
 DocType: Sales Invoice,Rail,ทางรถไฟ
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,ต้นทุนที่แท้จริง
@@ -1071,6 +1075,7 @@
 DocType: Production Plan,Production Plan,แผนการผลิต
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,เปิดเครื่องมือสร้างใบแจ้งหนี้
 DocType: Salary Component,Round to the Nearest Integer,ปัดเศษให้เป็นจำนวนเต็มที่ใกล้ที่สุด
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,อนุญาตให้เพิ่มสินค้าที่ไม่มีในสต็อค
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,ขายกลับ
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,ตั้งค่าจำนวนในรายการตาม Serial Input ไม่มี
 ,Total Stock Summary,สรุปสต็อคทั้งหมด
@@ -1202,6 +1207,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),อัตราฐานชั่วโมง (สกุลเงินบริษัท)
 ,Qty To Be Billed,จำนวนที่จะเรียกเก็บเงิน
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,จัดส่งจํานวนเงิน
+DocType: Coupon Code,Gift Card,บัตรของขวัญ
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,ปริมาณที่สงวนไว้สำหรับการผลิต: ปริมาณวัตถุดิบเพื่อผลิตรายการ
 DocType: Loyalty Point Entry Redemption,Redemption Date,วันที่ไถ่ถอน
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,ธุรกรรมธนาคารนี้ได้รับการกระทบยอดอย่างสมบูรณ์แล้ว
@@ -1291,6 +1297,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,สร้าง Timesheet
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,บัญชี {0} ได้รับการป้อนหลายครั้ง
 DocType: Account,Expenses Included In Valuation,ค่าใช้จ่ายรวมอยู่ในการประเมินมูลค่า
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,ซื้อใบแจ้งหนี้
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,คุณสามารถต่ออายุได้เฉพาะเมื่อสมาชิกของคุณหมดอายุภายใน 30 วันเท่านั้น
 DocType: Shopping Cart Settings,Show Stock Availability,แสดงสต็อคที่ใช้ได้
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},ตั้ง {0} ในหมวดสินทรัพย์ {1} หรือ บริษัท {2}
@@ -1852,6 +1859,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,การนำเข้ารายการและ UOM
 DocType: Repayment Schedule,Balance Loan Amount,ยอดคงเหลือวงเงินกู้
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,เพิ่มในรายละเอียด
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted",ขออภัยคูปองหมดแล้ว
 DocType: Communication Medium,Catch All,จับทั้งหมด
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,ตารางเรียน
 DocType: Budget,Applicable on Material Request,ใช้ได้กับคำขอ Material
@@ -2022,6 +2030,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,แอตทริบิวต์ไม่ถูกต้อง
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} จำเป็นต้องส่ง
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,แคมเปญอีเมล
+DocType: Sales Partner,To Track inbound purchase,เพื่อติดตามการซื้อขาเข้า
 DocType: Buying Settings,Default Supplier Group,กลุ่มผู้จัดจำหน่ายเริ่มต้น
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},ปริมาณต้องน้อยกว่าหรือเท่ากับ {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},จำนวนเงินสูงสุดที่มีสิทธิ์สำหรับคอมโพเนนต์ {0} เกินกว่า {1}
@@ -2179,8 +2188,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,ทำรายการสินค้า
 DocType: Hotel Room Reservation,Hotel Reservation User,ผู้จองโรงแรม
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,กำหนดสถานะ
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,โปรดตั้งค่าหมายเลขลำดับสำหรับการเข้าร่วมผ่านการตั้งค่า&gt; ลำดับเลข
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,กรุณาเลือก คำนำหน้า เป็นครั้งแรก
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,โปรดตั้ง Naming Series สำหรับ {0} ผ่านการตั้งค่า&gt; การตั้งค่า&gt; Naming Series
 DocType: Contract,Fulfilment Deadline,Fulfillment Deadline
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,ใกล้คุณ
 DocType: Student,O-,O-
@@ -2304,6 +2313,7 @@
 DocType: Quality Meeting Table,Under Review,ภายใต้การทบทวน
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,ไม่สามารถเข้าสู่ระบบได้
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,สร้างเนื้อหา {0} แล้ว
+DocType: Coupon Code,Promotional,โปรโมชั่น
 DocType: Special Test Items,Special Test Items,รายการทดสอบพิเศษ
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,คุณต้องเป็นผู้ใช้ที่มีบทบาท System Manager และ Item Manager เพื่อลงทะเบียนใน Marketplace
 apps/erpnext/erpnext/config/buying.py,Key Reports,รายงานสำคัญ
@@ -2342,6 +2352,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,ประเภท Doc
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,ร้อยละ จัดสรร รวม สำหรับทีม ขายควร เป็น 100
 DocType: Subscription Plan,Billing Interval Count,ช่วงเวลาการเรียกเก็บเงิน
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","โปรดลบพนักงาน <a href=""#Form/Employee/{0}"">{0}</a> \ เพื่อยกเลิกเอกสารนี้"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,การนัดหมายและการพบปะของผู้ป่วย
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,มูลค่าหายไป
 DocType: Employee,Department and Grade,ภาควิชาและเกรด
@@ -2445,6 +2457,7 @@
 DocType: Project,Start and End Dates,เริ่มต้นและสิ้นสุดวันที่
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,ข้อกำหนดการปฏิบัติตามเทมเพลตสัญญา
 ,Delivered Items To Be Billed,รายการที่ส่งไปถูกเรียกเก็บเงิน
+DocType: Coupon Code,Maximum Use,การใช้งานสูงสุด
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},เปิด BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,คลังสินค้า ไม่สามารถ เปลี่ยนเป็น เลข อนุกรม
 DocType: Authorization Rule,Average Discount,ส่วนลดโดยเฉลี่ย
@@ -2607,6 +2620,7 @@
 DocType: Item,Inventory,รายการสินค้า
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,ดาวน์โหลดเป็น Json
 DocType: Item,Sales Details,รายละเอียดการขาย
+DocType: Coupon Code,Used,มือสอง
 DocType: Opportunity,With Items,กับรายการ
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',แคมเปญ &#39;{0}&#39; มีอยู่แล้วสำหรับ {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,ทีมซ่อมบำรุง
@@ -2736,7 +2750,7 @@
 						Serial No cannot be ensured",ไม่มีรายการที่ใช้งานอยู่สำหรับรายการ {0} ไม่สามารถมั่นใจได้ว่าจะมีการส่งมอบโดย \ Serial No
 DocType: Sales Partner,Sales Partner Target,เป้าหมายยอดขายพันธมิตร
 DocType: Loan Type,Maximum Loan Amount,จำนวนเงินกู้สูงสุด
-DocType: Pricing Rule,Pricing Rule,กฎ การกำหนดราคา
+DocType: Coupon Code,Pricing Rule,กฎ การกำหนดราคา
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},หมายเลขม้วนซ้ำสำหรับนักเรียน {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},หมายเลขม้วนซ้ำสำหรับนักเรียน {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,สร้างคำขอวัสดุไปเป็นใบสั่งซื้อ
@@ -2816,6 +2830,7 @@
 DocType: Payment Schedule,Payment Amount,จำนวนเงินที่ชำระ
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Half Day Date ควรอยู่ระหว่าง Work From Date กับ Work End Date
 DocType: Healthcare Settings,Healthcare Service Items,รายการบริการด้านการดูแลสุขภาพ
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,บาร์โค้ดไม่ถูกต้อง ไม่มีรายการติดอยู่กับบาร์โค้ดนี้
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,บริโภคจํานวนเงิน
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,เปลี่ยนเป็นเงินสดสุทธิ
 DocType: Assessment Plan,Grading Scale,ระดับคะแนน
@@ -2937,7 +2952,6 @@
 DocType: Share Transfer,Asset Account,บัญชีสินทรัพย์
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,วันที่วางจำหน่ายใหม่ควรจะเป็นในอนาคต
 DocType: Purchase Invoice,End date of current invoice's period,วันที่สิ้นสุดของรอบระยะเวลาใบแจ้งหนี้ปัจจุบัน
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,โปรดตั้งค่าระบบการตั้งชื่อพนักงานในทรัพยากรมนุษย์&gt; การตั้งค่าทรัพยากรบุคคล
 DocType: Lab Test,Technician Name,ชื่อช่างเทคนิค
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3049,6 +3063,7 @@
 DocType: Products Settings,Hide Variants,ซ่อนสายพันธุ์
 DocType: Lead,Next Contact By,ติดต่อถัดไป
 DocType: Compensatory Leave Request,Compensatory Leave Request,ขอรับการชดเชย
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings",ไม่สามารถเรียกเก็บเงินเกินขนาดสำหรับรายการ {0} ในแถว {1} มากกว่า {2} หากต้องการอนุญาตการเรียกเก็บเงินมากเกินไปโปรดตั้งค่าเผื่อในการตั้งค่าบัญชี
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},จำนวน รายการ ที่จำเป็นสำหรับ {0} ในแถว {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},คลังสินค้า {0} ไม่สามารถลบได้ เนื่องจากมีรายการ {1}
 DocType: Blanket Order,Order Type,ประเภทสั่งซื้อ
@@ -3221,7 +3236,6 @@
 DocType: Student,Student Mobile Number,หมายเลขโทรศัพท์มือถือของนักเรียน
 DocType: Item,Has Variants,มีหลากหลายรูปแบบ
 DocType: Employee Benefit Claim,Claim Benefit For,ขอรับสวัสดิการสำหรับ
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings",ไม่สามารถทำให้รายการ {0} ในแถว {1} เกินกว่า {2} หากต้องการอนุญาตให้เรียกเก็บเงินเกินโปรดตั้งค่าในการตั้งค่าสต็อก
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,อัปเดตการตอบกลับ
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},คุณได้เลือกแล้วรายการจาก {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,ชื่อของการกระจายรายเดือน
@@ -3515,6 +3529,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,โปรดระบุสกุลเงินใน บริษัท
 DocType: Workstation,Wages per hour,ค่าจ้างต่อชั่วโมง
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},กำหนดค่า {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,ลูกค้า&gt; กลุ่มลูกค้า&gt; อาณาเขต
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},สมดุลหุ้นใน Batch {0} จะกลายเป็นเชิงลบ {1} สำหรับรายการ {2} ที่โกดัง {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,ต่อไปนี้ขอวัสดุได้รับการยกโดยอัตโนมัติตามระดับสั่งซื้อใหม่ของรายการ
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},บัญชี {0} ไม่ถูกต้อง สกุลเงินในบัญชีจะต้องเป็น {1}
@@ -3848,6 +3863,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,ส่งสลิปเงินเดือน
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,ระงับ
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,qustion ต้องมีตัวเลือกที่ถูกต้องอย่างน้อยหนึ่งตัว
+apps/erpnext/erpnext/hooks.py,Purchase Orders,คำสั่งซื้อ
 DocType: Account,Inter Company Account,บัญชี บริษัท ระหว่าง
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,การนำเข้าสินค้าในกลุ่ม
 DocType: Sales Partner,Address & Contacts,ที่อยู่ติดต่อ &amp;
@@ -3858,6 +3874,7 @@
 DocType: POS Profile,[Select],[เลือก ]
 DocType: Staffing Plan Detail,Number Of Positions,จำนวนตำแหน่ง
 DocType: Vital Signs,Blood Pressure (diastolic),ความดันโลหิต (diastolic)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,กรุณาเลือกลูกค้า
 DocType: SMS Log,Sent To,ส่งไปยัง
 DocType: Agriculture Task,Holiday Management,การจัดการวันหยุด
 DocType: Payment Request,Make Sales Invoice,สร้างใบแจ้งหนี้
@@ -4068,7 +4085,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} ยังไม่ได้ส่ง
 DocType: Subscription,Trialling,trialling
 DocType: Sales Invoice Item,Deferred Revenue,รายได้รอตัดบัญชี
-DocType: Bank Account,GL Account,บัญชีแยกประเภท
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,บัญชีเงินสดจะใช้ในการสร้างใบแจ้งหนี้การขาย
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,ยกเว้นหมวดย่อย
 DocType: Member,Membership Expiry Date,วันหมดอายุของสมาชิก
@@ -4495,13 +4511,13 @@
 DocType: C-Form Invoice Detail,Territory,อาณาเขต
 DocType: Pricing Rule,Apply Rule On Item Code,ใช้กฎบนรหัสสินค้า
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,กรุณาระบุ ไม่ จำเป็นต้องมี การเข้าชม
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,รายงานยอดคงเหลือในสต็อค
 DocType: Stock Settings,Default Valuation Method,วิธีการประเมินค่าเริ่มต้น
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,ค่าธรรมเนียม
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,แสดงจำนวนเงินสะสม
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,กำลังอัปเดตอยู่ระหว่างดำเนินการ มันอาจจะใช้เวลาสักครู่.
 DocType: Production Plan Item,Produced Qty,จำนวนที่ผลิต
 DocType: Vehicle Log,Fuel Qty,น้ำมันเชื้อเพลิงจำนวน
-DocType: Stock Entry,Target Warehouse Name,ชื่อคลังปลายทาง
 DocType: Work Order Operation,Planned Start Time,เวลาเริ่มต้นการวางแผน
 DocType: Course,Assessment,การประเมินผล
 DocType: Payment Entry Reference,Allocated,จัดสรร
@@ -4579,10 +4595,12 @@
  1 วิธีของข้อพิพาทที่อยู่, การชดใช้หนี้สิน ฯลฯ 
  1 ที่อยู่และการติดต่อของ บริษัท ของคุณ"
 DocType: Homepage Section,Section Based On,ตามส่วน
+DocType: Shopping Cart Settings,Show Apply Coupon Code,แสดงใช้รหัสคูปอง
 DocType: Issue,Issue Type,ประเภทการออก
 DocType: Attendance,Leave Type,ฝากประเภท
 DocType: Purchase Invoice,Supplier Invoice Details,ผู้ผลิตรายละเอียดใบแจ้งหนี้
 DocType: Agriculture Task,Ignore holidays,ละเว้นวันหยุด
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,เพิ่ม / แก้ไขเงื่อนไขคูปอง
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,ค่าใช้จ่ายบัญชี / แตกต่าง ({0}) จะต้องเป็นบัญชี 'กำไรหรือขาดทุน'
 DocType: Stock Entry Detail,Stock Entry Child,เด็กเข้าหุ้น
 DocType: Project,Copied From,คัดลอกจาก
@@ -4758,6 +4776,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,เกณฑ์การประเมินผลแผน
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,การทำธุรกรรม
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,ป้องกันคำสั่งซื้อ
+DocType: Coupon Code,Coupon Name,ชื่อคูปอง
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,อ่อนแอ
 DocType: Email Campaign,Scheduled,กำหนด
 DocType: Shift Type,Working Hours Calculation Based On,การคำนวณชั่วโมงการทำงานขึ้นอยู่กับ
@@ -4774,7 +4793,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,สร้างสายพันธุ์
 DocType: Vehicle,Diesel,ดีเซล
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,สกุลเงิน ราคา ไม่ได้เลือก
+DocType: Quick Stock Balance,Available Quantity,ปริมาณที่มี
 DocType: Purchase Invoice,Availed ITC Cess,มี ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,โปรดตั้งค่าระบบการตั้งชื่อผู้สอนในด้านการศึกษา&gt; การตั้งค่าการศึกษา
 ,Student Monthly Attendance Sheet,นักศึกษาแผ่นเข้าร่วมประชุมรายเดือน
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,กฎการจัดส่งสำหรับการขายเท่านั้น
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,แถวค่าเสื่อมราคา {0}: วันที่คิดค่าเสื่อมราคาต่อไปต้องไม่ก่อนวันที่ซื้อ
@@ -4842,8 +4863,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,แถว {0}: ล่วงหน้ากับลูกค้าจะต้องมีเครดิต
 DocType: Quality Meeting,Quality Meeting,การประชุมคุณภาพ
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,ที่ไม่ใช่กลุ่มกลุ่ม
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,โปรดตั้ง Naming Series สำหรับ {0} ผ่านการตั้งค่า&gt; การตั้งค่า&gt; Naming Series
 DocType: Employee,ERPNext User,ผู้ใช้ ERPNext
+DocType: Coupon Code,Coupon Description,รายละเอียดคูปอง
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},แบทช์มีผลบังคับในแถว {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},แบทช์มีผลบังคับในแถว {0}
 DocType: Company,Default Buying Terms,เงื่อนไขการซื้อเริ่มต้น
@@ -5008,6 +5029,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,กับรายละเอียดของเอกสารเลขที่
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},ไม่อนุญาตให้มีการลบประเทศ {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,ประเภทของบุคคลที่มีผลบังคับใช้
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,ใช้รหัสคูปอง
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",สำหรับบัตรงาน {0} คุณสามารถป้อนรายการสต็อคประเภท &#39;การโอนวัสดุเพื่อการผลิต&#39; ได้เท่านั้น
 DocType: Quality Inspection,Outgoing,ขาออก
 DocType: Customer Feedback Table,Customer Feedback Table,ตารางความคิดเห็นของลูกค้า
@@ -5160,7 +5182,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,ในการส่งคำสั่งซื้อ
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,เพิ่มซัพพลายเออร์ทั้งหมด
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,แถว # {0}: จำนวนที่จัดสรรไว้ต้องไม่เกินยอดค้างชำระ
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,ลูกค้า&gt; กลุ่มลูกค้า&gt; อาณาเขต
 DocType: Tally Migration,Parties,คู่กรณี
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,ดู BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,เงินให้กู้ยืม ที่มีหลักประกัน
@@ -5192,7 +5213,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},ไม่อนุญาตให้ตั้งค่ารายการอื่นสำหรับรายการ {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,วันที่ซ้ำแล้วซ้ำอีก
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,ผู้มีอำนาจลงนาม
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,โปรดตั้งค่าระบบการตั้งชื่อผู้สอนในด้านการศึกษา&gt; การตั้งค่าการศึกษา
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Net ITC Available (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,สร้างค่าธรรมเนียม
 DocType: Project,Total Purchase Cost (via Purchase Invoice),ค่าใช้จ่ายในการจัดซื้อรวม (ผ่านการซื้อใบแจ้งหนี้)
@@ -5217,6 +5237,7 @@
 DocType: Quiz Result,Wrong,ไม่ถูกต้อง
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,อัตราที่สกุลเงินรายการราคาจะถูกแปลงเป็นสกุลเงินหลักของลูกค้า
 DocType: Purchase Invoice Item,Net Amount (Company Currency),ปริมาณสุทธิ (บริษัท สกุลเงิน)
+DocType: Sales Partner,Referral Code,รหัสอ้างอิง
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,จำนวนเงินที่ต้องชำระล่วงหน้าทั้งหมดต้องไม่เกินจำนวนเงินที่ได้รับอนุมัติทั้งหมด
 DocType: Salary Slip,Hour Rate,อัตราชั่วโมง
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,เปิดใช้งานการสั่งซื้ออัตโนมัติอีกครั้ง
@@ -5347,6 +5368,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,แสดงจำนวนสต็อค
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,เงินสดจากการดำเนินงานสุทธิ
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},แถว # {0}: สถานะต้องเป็น {1} สำหรับการลดใบแจ้งหนี้ {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},ไม่พบปัจจัยการแปลง UOM ({0} -&gt; {1}) สำหรับรายการ: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,วาระที่ 4
 DocType: Student Admission,Admission End Date,การรับสมัครวันที่สิ้นสุด
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,ย่อยทำสัญญา
@@ -5369,6 +5391,7 @@
 DocType: Travel Request,Fully Sponsored,สนับสนุนอย่างเต็มที่
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Reverse Journal Entry
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,สร้างการ์ดงาน
+DocType: Quotation,Referral Sales Partner,พันธมิตรการขายอ้างอิง
 DocType: Quality Procedure Process,Process Description,คำอธิบายกระบวนการ
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,สร้างลูกค้า {0} แล้ว
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,ไม่มีคลังสินค้าในคลังสินค้าใด ๆ
@@ -5503,6 +5526,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,อัตรา BOM
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,กำลังอ่านไฟล์ที่อัพโหลด
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel",หยุดการทำงานสั่งซื้อสินค้าไม่สามารถยกเลิกได้ยกเลิกการยกเลิกก่อนจึงจะยกเลิก
+DocType: Coupon Code,Coupon Code,รหัสคูปอง
 DocType: Asset,Journal Entry for Scrap,วารสารรายการเศษ
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,กรุณา ดึง รายการจาก การจัดส่งสินค้า หมายเหตุ
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},แถว {0}: เลือกเวิร์กสเตชั่นจากการดำเนินงาน {1}
@@ -5587,6 +5611,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,ต้องระบุ &#39;วันที่&#39;
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},เนื่องจาก / วันอ้างอิงต้องไม่อยู่หลัง {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,ข้อมูลนำเข้าและส่งออก
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired",ขออภัยความถูกต้องของรหัสคูปองหมดอายุ
 DocType: Bank Account,Account Details,รายละเอียดบัญชี
 DocType: Crop,Materials Required,ต้องใช้วัสดุ
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,ไม่พบนักเรียน
@@ -5624,6 +5649,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,ไปที่ผู้ใช้
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,ชำระ เงิน + เขียน ปิด จำนวน ไม่สามารถ จะสูงกว่า แกรนด์ รวม
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} ไม่ได้เป็น จำนวน ชุดที่ถูกต้องสำหรับ รายการ {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,กรุณาใส่รหัสคูปองที่ถูกต้อง !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},หมายเหตุ : มี ไม่ สมดุล เพียงพอสำหรับ การลา ออกจาก ประเภท {0}
 DocType: Task,Task Description,คำอธิบายงาน
 DocType: Training Event,Seminar,สัมมนา
@@ -5890,6 +5916,7 @@
 ,TDS Payable Monthly,TDS จ่ายรายเดือน
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,จัดคิวสำหรับการเปลี่ยน BOM อาจใช้เวลาสักครู่
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',ไม่ สามารถหัก เมื่อ เป็น หมวดหมู่ สำหรับ ' ประเมิน ' หรือ ' การประเมิน และการ รวม
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,โปรดตั้งค่าระบบการตั้งชื่อพนักงานในทรัพยากรมนุษย์&gt; การตั้งค่าทรัพยากรบุคคล
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,รวมการจ่ายเงิน
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},อนุกรม Nos จำเป็นสำหรับ รายการ เนื่อง {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,การชำระเงินการแข่งขันกับใบแจ้งหนี้
@@ -5980,6 +6007,7 @@
 DocType: Production Plan,Get Raw Materials For Production,รับวัตถุดิบสำหรับการผลิต
 DocType: Job Opening,Job Title,ตำแหน่งงาน
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,การจ่ายเงินในอนาคต
+DocType: Quotation,Additional Discount and Coupon Code,ส่วนลดเพิ่มเติมและรหัสคูปอง
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.",{0} ระบุว่า {1} จะไม่ให้ใบเสนอราคา แต่มีการยกรายการทั้งหมด \ quot กำลังอัปเดตสถานะใบเสนอราคา RFQ
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,ตัวอย่างสูงสุด - {0} ถูกเก็บไว้สำหรับ Batch {1} และ Item {2} ใน Batch {3} แล้ว
@@ -6209,7 +6237,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,การตั้งค่าสำหรับหน้าแรกของเว็บไซต์
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} ค้างไว้จนถึง {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQs ไม่ได้รับอนุญาตสำหรับ {0} เนื่องจากสถานะการจดแต้ม {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,ให้ ซื้อ ใบแจ้งหนี้
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,ใบที่ใช้แล้ว
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} คูปองที่ใช้คือ {1} ปริมาณที่อนุญาตหมดแล้ว
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,คุณต้องการส่งคำขอวัสดุหรือไม่
 DocType: Job Offer,Awaiting Response,รอการตอบสนอง
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6223,6 +6253,7 @@
 DocType: Training Event Employee,Optional,ไม่จำเป็น
 DocType: Salary Slip,Earning & Deduction,รายได้และการหัก
 DocType: Agriculture Analysis Criteria,Water Analysis,การวิเคราะห์น้ำ
+DocType: Sales Order,Skip Delivery Note,ข้ามหมายเหตุการส่งมอบ
 DocType: Price List,Price Not UOM Dependent,ราคาไม่ขึ้นอยู่กับ UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} ตัวแปรที่สร้างขึ้น
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,ข้อตกลงระดับบริการเริ่มต้นมีอยู่แล้ว
@@ -6331,6 +6362,7 @@
 DocType: Vehicle,Last Carbon Check,ตรวจสอบคาร์บอนล่าสุด
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,ค่าใช้จ่ายทางกฎหมาย
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,โปรดเลือกปริมาณในแถว
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},สั่งทำงาน {0}: ไม่พบการ์ดงานสำหรับการดำเนินการ {1}
 DocType: Purchase Invoice,Posting Time,โพสต์เวลา
 DocType: Timesheet,% Amount Billed,% ของยอดเงินที่เรียกเก็บแล้ว
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,ค่าใช้จ่าย โทรศัพท์
@@ -6433,7 +6465,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,ภาษีและค่าบริการเพิ่ม
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,แถวค่าเสื่อมราคา {0}: วันที่คิดค่าเสื่อมราคาต่อไปไม่ได้ก่อนวันที่ที่พร้อมใช้งาน
 ,Sales Funnel,ช่องทาง ขาย
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,รหัสรายการ&gt; กลุ่มรายการ&gt; แบรนด์
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,ชื่อย่อมีผลบังคับใช้
 DocType: Project,Task Progress,ความคืบหน้าของงาน
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,เกวียน
@@ -6529,6 +6560,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,รายละเอียด จุดขาย จำเป็นต้องทำให้ จุดขาย บันทึกได้
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",คะแนนความภักดีจะคำนวณจากการใช้จ่ายที่ทำ (ผ่านทางใบแจ้งหนี้การขาย) ตามปัจจัยการเรียกเก็บเงินที่กล่าวถึง
 DocType: Program Enrollment Tool,Enroll Students,รับสมัครนักเรียน
+DocType: Pricing Rule,Coupon Code Based,ตามรหัสคูปอง
 DocType: Company,HRA Settings,การตั้งค่า HRA
 DocType: Homepage,Hero Section,หมวดฮีโร่
 DocType: Employee Transfer,Transfer Date,วันโอน
@@ -6645,6 +6677,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',โปรดตั้งค่าตัวกรอง บริษัท หาก Group By เป็น &#39;Company&#39;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,โพสต์วันที่ไม่สามารถเป็นวันที่ในอนาคต
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},แถว # {0}: ไม่มี Serial {1} ไม่ตรงกับ {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,โปรดตั้งค่าหมายเลขลำดับสำหรับการเข้าร่วมผ่านการตั้งค่า&gt; ลำดับเลข
 DocType: Stock Entry,Target Warehouse Address,ที่อยู่คลังเป้าหมาย
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,สบาย ๆ ออก
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,เวลาก่อนเวลาเริ่มต้นกะในระหว่างที่การเช็คอินของพนักงานได้รับการพิจารณาสำหรับการเข้าร่วม
@@ -6679,7 +6712,6 @@
 DocType: Employee Grade,Employee Grade,เกรดพนักงาน
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,งานเหมา
 DocType: GSTR 3B Report,June,มิถุนายน
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,ผู้ผลิต&gt; ประเภทผู้จัดจำหน่าย
 DocType: Share Balance,From No,จากไม่มี
 DocType: Shift Type,Early Exit Grace Period,ช่วงเวลาผ่อนผันออกก่อนกำหนด
 DocType: Task,Actual Time (in Hours),เวลาที่เกิดขึ้นจริง (ในชั่วโมง)
@@ -6966,7 +6998,6 @@
 DocType: Warehouse,Warehouse Name,ชื่อคลังสินค้า
 DocType: Naming Series,Select Transaction,เลือกรายการ
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,กรุณากรอก บทบาท การอนุมัติ หรือ ให้ความเห็นชอบ ผู้ใช้
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},ไม่พบปัจจัยการแปลง UOM ({0} -&gt; {1}) สำหรับรายการ: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,ข้อตกลงระดับการให้บริการที่มีประเภทเอนทิตี {0} และเอนทิตี {1} มีอยู่แล้ว
 DocType: Journal Entry,Write Off Entry,เขียนปิดเข้า
 DocType: BOM,Rate Of Materials Based On,อัตราวัสดุตาม
@@ -7105,6 +7136,7 @@
 DocType: Budget,Warn,เตือน
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,รายการทั้งหมดได้รับการโอนไปแล้วสำหรับใบสั่งงานนี้
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.",ใด ๆ ข้อสังเกตอื่น ๆ ความพยายามที่น่าสังเกตว่าควรจะไปในบันทึก
+DocType: Bank Account,Company Account,บัญชี บริษัท
 DocType: Asset Maintenance,Manufacturing User,ผู้ใช้การผลิต
 DocType: Purchase Invoice,Raw Materials Supplied,วัตถุดิบ
 DocType: Subscription Plan,Payment Plan,แผนการชำระเงิน
@@ -7146,6 +7178,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) ต้องไม่เกินจำนวนที่วางแผนไว้ ({2}) ใน Work Order {3}
 DocType: Certification Application,Name of Applicant,ชื่อผู้สมัคร
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,ใบบันทึกเวลาการผลิต
+DocType: Quick Stock Balance,Quick Stock Balance,ยอดสต็อคด่วน
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,ไม่ทั้งหมด
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,ไม่สามารถเปลี่ยนแปลงคุณสมบัติ Variant ภายหลังการทำธุรกรรมหุ้น คุณจะต้องทำรายการใหม่เพื่อทำสิ่งนี้
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,mandate SEPA GoCardless
@@ -7474,6 +7507,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} เป็นนักเรียนที่ไม่ได้ใช้งาน
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} เป็นนักเรียนที่ไม่ได้ใช้งาน
 DocType: Employee,Health Details,รายละเอียดสุขภาพ
+DocType: Coupon Code,Coupon Type,ประเภทคูปอง
 DocType: Leave Encashment,Encashable days,วันที่เป็น Encashable
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,ในการสร้างเอกสารอ้างอิงคำขอการชำระเงินต้องระบุ
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,ในการสร้างเอกสารอ้างอิงคำขอการชำระเงินต้องระบุ
@@ -7763,6 +7797,7 @@
 DocType: Hotel Room Package,Amenities,สิ่งอำนวยความสะดวก
 DocType: Accounts Settings,Automatically Fetch Payment Terms,ดึงข้อมูลเงื่อนไขการชำระเงินอัตโนมัติ
 DocType: QuickBooks Migrator,Undeposited Funds Account,บัญชีกองทุนสำรองเลี้ยงชีพ
+DocType: Coupon Code,Uses,การใช้ประโยชน์
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,โหมดการชำระเงินเริ่มต้นหลายรูปแบบไม่ได้รับอนุญาต
 DocType: Sales Invoice,Loyalty Points Redemption,แลกคะแนนความภักดี
 ,Appointment Analytics,การแต่งตั้ง Analytics
@@ -7780,6 +7815,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,เว้นว่างไว้ถ้าคุณทำกลุ่มนักเรียนต่อปี
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,เว้นว่างไว้ถ้าคุณทำกลุ่มนักเรียนต่อปี
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day",ถ้าการตรวจสอบรวมกัน ของวันทําการจะรวมถึงวันหยุดและนี้จะช่วยลดค่าของเงินเดือนที่ต้องการต่อวัน
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,ไม่สามารถเพิ่มโดเมน
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.",หากต้องการอนุญาตการรับ / ส่งเกินให้อัปเดต &quot;Over Receipt / Delivery Allowance&quot; ในการตั้งค่าสต็อกหรือรายการ
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?",แอปที่ใช้คีย์ปัจจุบันจะไม่สามารถเข้าถึงได้คุณแน่ใจหรือ?
 DocType: Subscription Settings,Prorate,แบ่งสันปันส่วน
@@ -7793,6 +7829,7 @@
 ,BOM Stock Report,รายงานแจ้ง BOM
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group",หากไม่มีช่วงเวลาที่กำหนดกลุ่มนี้จะจัดการการสื่อสาร
 DocType: Stock Reconciliation Item,Quantity Difference,ปริมาณความแตกต่าง
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,ผู้ผลิต&gt; ประเภทผู้จำหน่าย
 DocType: Opportunity Item,Basic Rate,อัตราขั้นพื้นฐาน
 DocType: GL Entry,Credit Amount,จำนวนเครดิต
 ,Electronic Invoice Register,ลงทะเบียนใบแจ้งหนี้อิเล็กทรอนิกส์
@@ -8047,6 +8084,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),ภาษีและค่าใช้จ่ายหัก (สกุลเงิน บริษัท )
 DocType: Item Group,General Settings,การตั้งค่าทั่วไป
 DocType: Article,Article,บทความ
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,กรุณาใส่รหัสคูปอง !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,สกุลเงินจากสกุลเงินและไม่สามารถเดียวกัน
 DocType: Taxable Salary Slab,Percent Deduction,เปอร์เซ็นต์หักล้าง
 DocType: GL Entry,To Rename,เพื่อเปลี่ยนชื่อ
diff --git a/erpnext/translations/tr.csv b/erpnext/translations/tr.csv
index 3b0d6e6..7a5cc76 100644
--- a/erpnext/translations/tr.csv
+++ b/erpnext/translations/tr.csv
@@ -49,6 +49,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Müşteri İrtibatı
 DocType: Shift Type,Enable Auto Attendance,Otomatik Katılımı Etkinleştir
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Lütfen Depo ve Tarihi giriniz
 DocType: Lost Reason Detail,Opportunity Lost Reason,Fırsat Kayıp Sebep
 DocType: Patient Appointment,Check availability,Uygunluğu kontrol et
 DocType: Retention Bonus,Bonus Payment Date,Bonus Ödeme Tarihi
@@ -289,6 +290,7 @@
 ,Completed Work Orders,Tamamlanmış İş Emri
 DocType: Support Settings,Forum Posts,Forum Mesajları
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Görev, arka plan işi olarak yapıldı. Arka planda işleme konusunda herhangi bir sorun olması durumunda, sistem bu Stok Mutabakatı ile ilgili bir yorum ekler ve Taslak aşamasına geri döner"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started",Maalesef kupon kodu geçerliliği başlamadı
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Vergilendirilebilir Tutar
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},{0} dan önceki girdileri ekleme veya güncelleme yetkiniz yok
 DocType: Leave Policy,Leave Policy Details,İlke Ayrıntılarını Bırak
@@ -358,6 +360,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Tüketilir
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,sınıf
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Ürün Kodu&gt; Ürün Grubu&gt; Marka
 DocType: Restaurant Table,No of Seats,Koltuk Sayısı
 DocType: Sales Invoice,Overdue and Discounted,Gecikmiş ve İndirimli
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Çağrı kesildi
@@ -548,6 +551,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,sözleriyle miktarı için satır aralığı
 DocType: Vehicle,Additional Details,ek detaylar
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Açıklama verilmemiştir
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Depodan Eşya Al
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Satın alma talebi
 DocType: POS Closing Voucher Details,Collected Amount,Toplanan Tutar
 DocType: Lab Test,Submitted Date,Teslim Tarihi
@@ -664,6 +668,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Öğrenin
 ,Trial Balance (Simple),Deneme Dengesi (Basit)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Ertelenmiş Gider&#39;i Etkinleştir
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Uygulamalı Kupon Kodu
 DocType: Asset,Next Depreciation Date,Bir sonraki değer kaybı tarihi
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Çalışan başına Etkinlik Maliyeti
 DocType: Accounts Settings,Settings for Accounts,Hesaplar için Ayarlar
@@ -924,8 +929,6 @@
 DocType: Sales Invoice,Total Qty,Toplam Adet
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 E-posta Kimliği
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 E-posta Kimliği
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Lütfen bu dokümanı iptal etmek için <a href=""#Form/Employee/{0}"">{0}</a> \ Çalışanını silin."
 DocType: Item,Show in Website (Variant),Web Sitesi göster (Varyant)
 DocType: Employee,Health Concerns,Sağlık Sorunları
 DocType: Payroll Entry,Select Payroll Period,Bordro Dönemi seçin
@@ -1108,6 +1111,7 @@
 DocType: Pricing Rule,Sales Partner,Satış Ortağı
 DocType: Pricing Rule,Sales Partner,Satış Ortağı
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Tüm Tedarikçi puan kartları.
+DocType: Coupon Code,To be used to get discount,İndirim almak için kullanılmak üzere
 DocType: Buying Settings,Purchase Receipt Required,Gerekli Satın alma makbuzu
 DocType: Sales Invoice,Rail,Demiryolu
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Asıl maliyet
@@ -1161,6 +1165,7 @@
 DocType: Production Plan,Production Plan,Üretim Planı
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Fatura Yaratma Aracını Açma
 DocType: Salary Component,Round to the Nearest Integer,En Yakın Tamsayıya Yuvarlak
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Stokta olmayan öğelerin sepete eklenmesine izin ver
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Satış İade
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Seri No Girdisine Göre İşlemlerde Miktar Ayarla
 ,Total Stock Summary,Toplam Stok Özeti
@@ -1304,6 +1309,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Baz Saat Hızı (Şirket Para Birimi)
 ,Qty To Be Billed,Faturalandırılacak Miktar
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Teslim Tutar
+DocType: Coupon Code,Gift Card,Hediye kartı
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Üretim İçin Ayrılmış Miktar: İmalat kalemlerini yapmak için hammadde miktarı.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Kefalet Tarihi
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Bu banka işlemi zaten tamamen mutabık kılındı
@@ -1402,6 +1408,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Zaman Çizelgesi Oluştur
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Hesap {0} birden çok kez girilmiş
 DocType: Account,Expenses Included In Valuation,Değerlemeye dahil giderler
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Satınalma Faturaları
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Üyeliğinizin süresi 30 gün içinde dolarsa yenileyebilirsiniz
 DocType: Shopping Cart Settings,Show Stock Availability,Stok Uygunluğunu Göster
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},{1} varlık kategorisinde veya {2} şirkette {0} ayarlayın
@@ -1999,6 +2006,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Öğeleri ve UOM&#39;leri İçe Aktarma
 DocType: Repayment Schedule,Balance Loan Amount,Bakiye Kredi Miktarı
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Ayrıntılara eklendi
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted",Maalesef kupon kodu tükendi
 DocType: Communication Medium,Catch All,Tümünü Yakala
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Program Ders
 DocType: Budget,Applicable on Material Request,Malzeme Talebi Uygulanabilir
@@ -2180,6 +2188,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,geçersiz Özellik
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} teslim edilmelidir
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,E-posta Kampanyaları
+DocType: Sales Partner,To Track inbound purchase,Gelen alımları takip etmek
 DocType: Buying Settings,Default Supplier Group,Varsayılan Tedarikçi Grubu
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Miktara göre daha az veya ona eşit olmalıdır {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},{0} bileşenine uygun maksimum tutar {1} değerini aşıyor
@@ -2349,8 +2358,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Stok Girişi Yap
 DocType: Hotel Room Reservation,Hotel Reservation User,Otel Rezervasyonu Kullanıcısı
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Durumu Ayarla
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Lütfen Kurulum&gt; Numaralandırma Serisi ile Devam için numaralandırma serilerini ayarlayın
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Önce Ön ek seçiniz
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Lütfen Ayarlama&gt; Ayarlar&gt; Adlandırma Serisi ile {0} için Adlandırma Serisi&#39;ni ayarlayın.
 DocType: Contract,Fulfilment Deadline,Son teslim tarihi
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Sana yakın
 DocType: Student,O-,O-
@@ -2484,6 +2493,7 @@
 DocType: Quality Meeting Table,Under Review,İnceleme altında
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Giriş yapılamadı
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Öğe {0} oluşturuldu
+DocType: Coupon Code,Promotional,Promosyon
 DocType: Special Test Items,Special Test Items,Özel Test Öğeleri
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Marketplace&#39;e kayıt olmak için Sistem Yöneticisi ve Ürün Yöneticisi rolleri olan bir kullanıcı olmanız gerekir.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Anahtar Raporlar
@@ -2527,6 +2537,8 @@
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Satış ekibi için ayrılan toplam yüzde 100 olmalıdır
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Satış ekibi için ayrılan toplam yüzde 100 olmalıdır
 DocType: Subscription Plan,Billing Interval Count,Faturalama Aralığı Sayısı
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Bu dokümanı iptal etmek için lütfen <a href=""#Form/Employee/{0}"">{0}</a> \ Çalışanını silin"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Randevular ve Hasta Buluşmaları
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Değer eksik
 DocType: Employee,Department and Grade,Bölüm ve sınıf
@@ -2639,6 +2651,7 @@
 DocType: Project,Start and End Dates,Başlangıç ve Tarihler End
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Sözleşme Şablonu Yerine Getirilmesi Şartları
 ,Delivered Items To Be Billed,Faturalanacak Teslim edilen Ürünler
+DocType: Coupon Code,Maximum Use,Maksimum kullanım
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Açık BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Depo Seri No için değiştirilemez
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Depo Seri No için değiştirilemez
@@ -2823,6 +2836,7 @@
 DocType: Item,Inventory,Stok
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Json olarak indir
 DocType: Item,Sales Details,Satış Ayrıntılar
+DocType: Coupon Code,Used,Kullanılmış
 DocType: Opportunity,With Items,Öğeler ile
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',"&#39;{0}&#39; Kampanyası, {1} &#39;{2}&#39; için zaten var"
 DocType: Asset Maintenance,Maintenance Team,Bakım ekibi
@@ -2961,7 +2975,7 @@
 						Serial No cannot be ensured",{0} öğesi için aktif BOM bulunamadı. Teslimat \ Seri No ile sağlanamaz
 DocType: Sales Partner,Sales Partner Target,Satış Ortağı Hedefi
 DocType: Loan Type,Maximum Loan Amount,Maksimum Kredi Miktarı
-DocType: Pricing Rule,Pricing Rule,Fiyatlandırma Kuralı
+DocType: Coupon Code,Pricing Rule,Fiyatlandırma Kuralı
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},{0} öğrencisi için yinelenen rulo numarası
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},{0} öğrencisi için yinelenen rulo numarası
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Satınalma Siparişi Malzeme Talebi
@@ -3044,6 +3058,7 @@
 DocType: Payment Schedule,Payment Amount,Ödeme Tutarı
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,"Yarım Gün Tarih, İş Başlangıç Tarihi ile İş Bitiş Tarihi arasında olmalıdır."
 DocType: Healthcare Settings,Healthcare Service Items,Sağlık Hizmet Öğeleri
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Geçersiz Barkod Bu barkoda ekli bir ürün yok.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Tüketilen Tutar
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Nakit Net Değişim
 DocType: Assessment Plan,Grading Scale,Notlandırma ölçeği
@@ -3170,7 +3185,6 @@
 DocType: Share Transfer,Asset Account,Öğe Hesabı
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Yeni çıkış tarihi gelecekte olmalı
 DocType: Purchase Invoice,End date of current invoice's period,Cari fatura döneminin bitiş tarihi
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Lütfen İnsan Kaynağında Çalışan Adlandırma Sistemini kurun&gt; İK Ayarları
 DocType: Lab Test,Technician Name,Teknisyen Adı
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3290,6 +3304,7 @@
 DocType: Products Settings,Hide Variants,Varyantları Gizle
 DocType: Lead,Next Contact By,Sonraki İrtibat
 DocType: Compensatory Leave Request,Compensatory Leave Request,Telafi Bırakma Talebi
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","{1} satırındaki {0} öğesi için {2} &#39;den fazla öğe fazla faturalandırılamıyor. Fazla faturalandırmaya izin vermek için, lütfen Hesap Ayarlarında ödenek ayarlayın."
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Satır {1} deki Ürün {0} için gereken miktar
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Ürün {1} için miktar mevcut olduğundan depo {0} silinemez
 DocType: Blanket Order,Order Type,Sipariş Türü
@@ -3474,7 +3489,6 @@
 DocType: Student,Student Mobile Number,Öğrenci Cep Numarası
 DocType: Item,Has Variants,Varyasyoları var
 DocType: Employee Benefit Claim,Claim Benefit For,Için hak talebi
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","{1} Satırındaki {0} Öğe için {2} öğeden fazla tahsil edilemez. Üzerinde faturalandırmaya izin vermek için, lütfen Stok Ayarları&#39;nda ayarlayın."
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Yanıt Güncelle
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Zaten öğeleri seçtiniz {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Aylık Dağıtım Adı
@@ -3793,6 +3807,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Şirket para belirtiniz
 DocType: Workstation,Wages per hour,Saatlik ücret
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},{0} yapılandırın
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Müşteri&gt; Müşteri Grubu&gt; Bölge
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Toplu stok bakiyesi {0} olacak olumsuz {1} Warehouse Ürün {2} için {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Malzeme İstekleri ardından öğesinin yeniden sipariş seviyesine göre otomatik olarak gündeme gelmiş
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Hesap {0} geçersiz. Hesap Para olmalıdır {1}
@@ -4147,6 +4162,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Bordro Gönder
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Beklemede
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Bir soru en az bir doğru seçeneğe sahip olmalıdır
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Satın alma siparişleri
 DocType: Account,Inter Company Account,Şirket Hesabı
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Toplu İçe Aktar
 DocType: Sales Partner,Address & Contacts,Adresler ve Kontaklar
@@ -4159,6 +4175,7 @@
 DocType: POS Profile,[Select],[Seç]
 DocType: Staffing Plan Detail,Number Of Positions,Pozisyon Sayısı
 DocType: Vital Signs,Blood Pressure (diastolic),Kan Basıncı (diyastolik)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Lütfen müşteriyi seçiniz.
 DocType: SMS Log,Sent To,Gönderildiği Kişi
 DocType: Agriculture Task,Holiday Management,Tatil Yönetimi
 DocType: Payment Request,Make Sales Invoice,Satış Faturası Oluştur
@@ -4384,7 +4401,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} teslim edilmedi
 DocType: Subscription,Trialling,trialling
 DocType: Sales Invoice Item,Deferred Revenue,Ertelenmiş Gelir
-DocType: Bank Account,GL Account,GL Hesabı
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Satış Faturası oluşturma için Nakit Hesabı kullanılacaktır
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Exemption Alt Kategorisi
 DocType: Member,Membership Expiry Date,Üyelik Sona Erme Tarihi
@@ -4846,6 +4862,7 @@
 DocType: C-Form Invoice Detail,Territory,Bölge
 DocType: Pricing Rule,Apply Rule On Item Code,Madde Kodunda Kural Uygula
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Lütfen gerekli ziyaretlerin sayısını belirtin
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Borsa Dengesi Raporu
 DocType: Stock Settings,Default Valuation Method,Standart Değerleme Yöntemi
 DocType: Stock Settings,Default Valuation Method,Standart Değerleme Yöntemi
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,ücret
@@ -4853,7 +4870,6 @@
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Güncelleme devam ediyor. Bu biraz zaman alabilir.
 DocType: Production Plan Item,Produced Qty,Üretilen Adet
 DocType: Vehicle Log,Fuel Qty,yakıt Adet
-DocType: Stock Entry,Target Warehouse Name,Hedef Depo Adı
 DocType: Work Order Operation,Planned Start Time,Planlanan Başlangıç Zamanı
 DocType: Course,Assessment,Değerlendirme
 DocType: Payment Entry Reference,Allocated,Ayrılan
@@ -4932,10 +4948,12 @@
  1. Vb adresleme uyuşmazlıkların, tazminat, sorumluluk, 
  1 Yolları. Adres ve Şirket İletişim."
 DocType: Homepage Section,Section Based On,Dayalı Bölüm
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Kupon Kodunu Uygula&#39;yı göster
 DocType: Issue,Issue Type,Sorun Tipi
 DocType: Attendance,Leave Type,İzin Tipi
 DocType: Purchase Invoice,Supplier Invoice Details,Tedarikçi Fatura Ayrıntıları
 DocType: Agriculture Task,Ignore holidays,Tatilleri göz ardı et
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Kupon Koşulları Ekle / Düzenle
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Gider / Fark hesabı({0}), bir 'Kar veya Zarar' hesabı olmalıdır"
 DocType: Stock Entry Detail,Stock Entry Child,Stok girişi
 DocType: Project,Copied From,Kopyalanacak
@@ -5126,6 +5144,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Değerlendirme Planı Kriterleri
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,işlemler
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Satınalma Siparişlerini Önleme
+DocType: Coupon Code,Coupon Name,Kupon Adı
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Duyarlı
 DocType: Email Campaign,Scheduled,Planlandı
 DocType: Shift Type,Working Hours Calculation Based On,Mesai Saatine Göre Hesaplama
@@ -5143,7 +5162,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Varyantları Oluştur
 DocType: Vehicle,Diesel,Dizel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Fiyat Listesi para birimi seçilmemiş
+DocType: Quick Stock Balance,Available Quantity,Mevcut Miktarı
 DocType: Purchase Invoice,Availed ITC Cess,Bilinen ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Lütfen Eğitimde Eğitimci Adlandırma Sistemini kurun&gt; Eğitim Ayarları
 ,Student Monthly Attendance Sheet,Öğrenci Aylık Hazirun Cetveli
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Nakliye kuralı yalnızca Satış için geçerlidir
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,"Amortisör Satırı {0}: Sonraki Amortisman Tarihi, Satın Alma Tarihinden önce olamaz"
@@ -5217,8 +5238,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Satır {0}: Müşteriye karşı Advance kredi olmalı
 DocType: Quality Meeting,Quality Meeting,Kalite Toplantısı
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Grup grup dışı
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Lütfen Ayarlama&gt; Ayarlar&gt; Adlandırma Serisi ile {0} için Adlandırma Serisi&#39;ni ayarlayın.
 DocType: Employee,ERPNext User,ERPNext Kullanıcı
+DocType: Coupon Code,Coupon Description,Kupon açıklaması
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Parti {0}. satırda zorunludur
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Parti {0}. satırda zorunludur
 DocType: Company,Default Buying Terms,Varsayılan Satın Alma Koşulları
@@ -5395,6 +5416,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Karşılık Belge Detay No.
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},{0} ülke için silme işlemine izin verilmiyor
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Parti Tipi zorunludur
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,kupon kodunu uygula
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","{0} kartvizitinde, yalnızca &#39;Üretim İçin Malzeme Transferi&#39; tipi stok girişini yapabilirsiniz."
 DocType: Quality Inspection,Outgoing,Giden
 DocType: Quality Inspection,Outgoing,Giden
@@ -5557,7 +5579,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Satınalma Siparişi Gönderme İşleminde
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Tüm Tedarikçiler Ekleyin
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,"Sıra # {0}: Tahsis Edilen Miktar, ödenmemiş tutardan büyük olamaz."
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Müşteri&gt; Müşteri Grubu&gt; Bölge
 DocType: Tally Migration,Parties,Taraflar
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,BOM Araştır
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Teminatlı Krediler
@@ -5590,7 +5611,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},{0} öğesi için alternatif öğe ayarlamaya izin verilmez
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Tarih tekrarlanır
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Yetkili imza
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Lütfen Eğitimde Eğitimci Adlandırma Sistemini kurun&gt; Eğitim Ayarları
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Net ITC Mevcut (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Ücret Yarat
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Toplam Satınalma Maliyeti (Satın Alma Fatura üzerinden)
@@ -5616,6 +5636,7 @@
 DocType: Quiz Result,Wrong,Yanlış
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Fiyat listesi para biriminin müşterinin temel para birimine dönüştürülme oranı
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Net Tutar (Şirket Para)
+DocType: Sales Partner,Referral Code,Yönlendirme Kodu
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,"Toplam avans miktarı, toplam onaylanan tutardan fazla olamaz"
 DocType: Salary Slip,Hour Rate,Saat Hızı
 DocType: Salary Slip,Hour Rate,Saat Hızı
@@ -5754,6 +5775,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Hisse Miktarını Göster
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Faaliyetlerden Kaynaklanan Net Nakit
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Satır # {0}: Fatura İndirimi {2} için durum {1} olmalı
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},{2} öğesi için UOM Dönüşüm faktörü ({0} -&gt; {1}) bulunamadı:
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Madde 4
 DocType: Student Admission,Admission End Date,Kabul Bitiş Tarihi
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Taşeronluk
@@ -5777,6 +5799,7 @@
 DocType: Travel Request,Fully Sponsored,Tamamen Sponsorlu
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Ters Günlük Girişi
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,İş kartı oluştur
+DocType: Quotation,Referral Sales Partner,Tavsiye Satış Ortağı
 DocType: Quality Procedure Process,Process Description,Süreç açıklaması
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Müşteri {0} oluşturuldu.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Şu an herhangi bir depoda stok yok
@@ -5917,6 +5940,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,Ürün Ağacı Oranı
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Yüklenen Dosyayı Okumak
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Durdurulan İş Emri iptal edilemez, İptal etmeden önce kaldır"
+DocType: Coupon Code,Coupon Code,Kupon Kodu
 DocType: Asset,Journal Entry for Scrap,Hurda için kayıt girişi
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,İrsaliyeden Ürünleri çekin
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},{0} satırı: {1} işlemine karşı iş istasyonunu seçin
@@ -6004,6 +6028,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;Tarih&#39; gerekli
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Due / Referans Tarihi sonra olamaz {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,İçeri/Dışarı Aktar
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Maalesef, kupon kodunun geçerliliği sona erdi"
 DocType: Bank Account,Account Details,Hesap Detayları
 DocType: Bank Account,Account Details,Hesap Detayları
 DocType: Crop,Materials Required,Gerekli malzemeler
@@ -6043,6 +6068,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Kullanıcılara Git
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Ödenen Tutar ve Şüpheli Alacak Tutarı toplamı Genel Toplamdan fazla olamaz
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} Ürün {1} için geçerli bir parti numarası değildir
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Lütfen geçerli bir kupon kodu giriniz!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Not: İzin tipi {0} için yeterli izin günü kalmamış
 DocType: Task,Task Description,Görev tanımı
 DocType: Training Event,Seminar,seminer
@@ -6335,6 +6361,7 @@
 ,TDS Payable Monthly,TDS Aylık Ücretli
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,BOM&#39;u değiştirmek için sıraya alındı. Birkaç dakika sürebilir.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Kategori 'Değerleme' veya 'Toplam ve Değerleme' olduğu zaman çıkarılamaz
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Lütfen İnsan Kaynağında Çalışan Adlandırma Sistemini kurun&gt; İK Ayarları
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Toplam tutar
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Seri Ürün{0} için Seri numaraları gereklidir
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Faturalar ile maç Ödemeleri
@@ -6432,6 +6459,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Üretim İçin Hammaddeleri Alın
 DocType: Job Opening,Job Title,İş Unvanı
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Gelecekteki Ödeme Ref
+DocType: Quotation,Additional Discount and Coupon Code,Ek İndirim ve Kupon Kodu
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0}, {1} &#39;in teklif vermeyeceğini, ancak tüm maddelerin \ teklif edildiğini belirtir. RFQ teklif durumu güncelleniyor."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,"Maksimum Örnekler - {0}, Toplu İş {1} ve Öğe {2} için Toplu İş Alma İşlemi {3} içinde zaten tutuldu."
@@ -6674,7 +6702,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Web sitesi ana sayfası için Ayarlar
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},"{0}, {1} tarihine kadar beklemede"
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},{1} puan kartının statüsü nedeniyle {0} için tekliflere izin verilmiyor.
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Satın Alma Faturası Oluştur
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Kullanılan yapraklar
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Kullanılan kupon {1}. İzin verilen miktar tükendi
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Malzeme talebini göndermek ister misiniz
 DocType: Job Offer,Awaiting Response,Cevap Bekliyor
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6688,6 +6718,7 @@
 DocType: Training Event Employee,Optional,İsteğe bağlı
 DocType: Salary Slip,Earning & Deduction,Kazanma & Kesintisi
 DocType: Agriculture Analysis Criteria,Water Analysis,Su Analizi
+DocType: Sales Order,Skip Delivery Note,Teslim Notunu Atla
 DocType: Price List,Price Not UOM Dependent,Fiyat UOM Bağımlı Değil
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} varyant oluşturuldu.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Varsayılan Servis Seviyesi Sözleşmesi zaten var.
@@ -6803,6 +6834,7 @@
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Yasal Giderler
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Yasal Giderler
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Lütfen satırdaki miktarı seçin
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},{0} İş Emri: {1} işlemi için kartvizit bulunamadı
 DocType: Purchase Invoice,Posting Time,Gönderme Zamanı
 DocType: Purchase Invoice,Posting Time,Gönderme Zamanı
 DocType: Timesheet,% Amount Billed,% Faturalanan Tutar
@@ -6916,7 +6948,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Eklenen Vergi ve Harçlar
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,"Amortisör Satırı {0}: Sonraki Amortisman Tarihi, Kullanıma hazır Tarih&#39;ten önce olamaz"
 ,Sales Funnel,Satış Yolu
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Ürün Kodu&gt; Ürün Grubu&gt; Marka
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Kısaltma zorunludur
 DocType: Project,Task Progress,görev İlerleme
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Araba
@@ -7020,6 +7051,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS Profil POS Girişi yapmak için gerekli
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Sadakat Puanları, belirtilen tahsilat faktörüne göre harcanan tutardan (Satış Faturası aracılığıyla) hesaplanacaktır."
 DocType: Program Enrollment Tool,Enroll Students,Öğrenciler kayıt
+DocType: Pricing Rule,Coupon Code Based,Kupon Koduna Dayalı
 DocType: Company,HRA Settings,İHRA Ayarları
 DocType: Homepage,Hero Section,Kahraman Bölümü
 DocType: Employee Transfer,Transfer Date,Transfer tarihi
@@ -7148,6 +7180,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Gruplandırılmış &#39;Şirket&#39; ise lütfen şirket filtresini boş olarak ayarlayın.
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Gönderme Tarihi gelecek tarih olamaz
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Satır # {0}: Seri No {1} ile eşleşmiyor {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Lütfen Kurulum&gt; Numaralandırma Serisi ile Devam için numaralandırma serilerini ayarlayın
 DocType: Stock Entry,Target Warehouse Address,Hedef Depo Adresi
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Mazeret İzni
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,Çalışan Check-in&#39;in katılım için dikkate alındığı vardiya başlama saatinden önceki zaman.
@@ -7184,7 +7217,6 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Parça başı iş
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Parça başı iş
 DocType: GSTR 3B Report,June,Haziran
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Tedarikçi&gt; Tedarikçi Tipi
 DocType: Share Balance,From No,Hayır&#39;dan
 DocType: Shift Type,Early Exit Grace Period,Erken Çıkış Grace Dönemi
 DocType: Task,Actual Time (in Hours),Gerçek Zaman (Saat olarak)
@@ -7494,7 +7526,6 @@
 DocType: Naming Series,Select Transaction,İşlem Seçin
 DocType: Naming Series,Select Transaction,İşlem Seçin
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Onaylayıcı Rol veya Onaylayıcı Kullanıcı Giriniz
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},{2} öğesi için UOM Dönüşüm faktörü ({0} -&gt; {1}) bulunamadı:
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,{0} Varlığı ve {1} Varlığı ile Hizmet Seviyesi Anlaşması zaten var.
 DocType: Journal Entry,Write Off Entry,Şüpheli Alacak Girdisi
 DocType: BOM,Rate Of Materials Based On,Dayalı Ürün Br. Fiyatı
@@ -7641,6 +7672,7 @@
 DocType: Budget,Warn,Uyarmak
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Bu İş Emri için tüm öğeler zaten aktarıldı.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Başka bir konuşmasında, kayıtlarda gitmeli kayda değer çaba."
+DocType: Bank Account,Company Account,Şirket hesabı
 DocType: Asset Maintenance,Manufacturing User,Üretim Kullanıcı
 DocType: Purchase Invoice,Raw Materials Supplied,Tedarik edilen Hammaddeler
 DocType: Subscription Plan,Payment Plan,Ödeme planı
@@ -7685,6 +7717,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},"{0} ({1}), İş Emrinde {3} planlanan miktardan ({2}) fazla olamaz"
 DocType: Certification Application,Name of Applicant,Başvuru sahibinin adı
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Üretim için Mesai Kartı.
+DocType: Quick Stock Balance,Quick Stock Balance,Hızlı Stok Bakiyesi
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,ara toplam
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Stok işleminden sonra Varyant özellikleri değiştirilemez. Bunu yapmak için yeni bir öğe yapmanız gerekecek.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA Mandate
@@ -8044,6 +8077,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} öğrencisi aktif değildir
 DocType: Employee,Health Details,Sağlık Bilgileri
 DocType: Employee,Health Details,Sağlık Bilgileri
+DocType: Coupon Code,Coupon Type,Kupon Türü
 DocType: Leave Encashment,Encashable days,Kapanabilir günler
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Bir Ödeme Talebi oluşturmak için referans belgesi gerekiyor
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Bir Ödeme Talebi oluşturmak için referans belgesi gerekiyor
@@ -8358,6 +8392,7 @@
 DocType: Hotel Room Package,Amenities,Kolaylıklar
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Ödeme Koşullarını Otomatik Olarak Al
 DocType: QuickBooks Migrator,Undeposited Funds Account,Belirtilmemiş Fon Hesabı
+DocType: Coupon Code,Uses,Kullanımları
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Birden fazla varsayılan ödeme moduna izin verilmiyor
 DocType: Sales Invoice,Loyalty Points Redemption,Sadakat Puanları Redemption
 ,Appointment Analytics,Randevu Analizi
@@ -8375,6 +8410,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Toplam bütçe
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Öğrenci gruplarını yılda bir kere yaparsanız boş bırakın.
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Seçili ise,toplam çalışma günleri sayısı tatilleri içerecektir ve bu da Günlük ücreti düşürecektir"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Etki Alanı eklenemedi
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Alınan / teslimin aşırı yapılmasına izin vermek için, Stok Ayarları veya Öğe&#39;deki &quot;Aşırı Alındı / Teslimat Ödeneği&quot; ni güncelleyin."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Geçerli anahtarı kullanan uygulamalar erişemez, emin misiniz?"
 DocType: Subscription Settings,Prorate,eşit olarak dağıtmak
@@ -8388,6 +8424,7 @@
 ,BOM Stock Report,Ürün Ağacı Stok Raporu
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Atanan zaman dilimi yoksa, iletişim bu grup tarafından gerçekleştirilecektir."
 DocType: Stock Reconciliation Item,Quantity Difference,Miktar Farkı
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Tedarikçi&gt; Tedarikçi Tipi
 DocType: Opportunity Item,Basic Rate,Temel Oran
 DocType: Opportunity Item,Basic Rate,Temel Oran
 DocType: GL Entry,Credit Amount,Kredi miktarı
@@ -8663,6 +8700,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Mahsup Vergi ve Harçlar (Şirket Para Biriminde)
 DocType: Item Group,General Settings,Genel Ayarlar
 DocType: Article,Article,makale
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Lütfen kupon kodunu giriniz!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Para biriminden ve para birimine aynı olamaz
 DocType: Taxable Salary Slab,Percent Deduction,Yüzde kesinti
 DocType: GL Entry,To Rename,Yeniden adlandırmak için
diff --git a/erpnext/translations/uk.csv b/erpnext/translations/uk.csv
index 59f57b6..7e1eb60 100644
--- a/erpnext/translations/uk.csv
+++ b/erpnext/translations/uk.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Контакти з клієнтами
 DocType: Shift Type,Enable Auto Attendance,Увімкнути автоматичне відвідування
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Введіть склад і дату
 DocType: Lost Reason Detail,Opportunity Lost Reason,Можливість втрачена причина
 DocType: Patient Appointment,Check availability,Перевірте наявність
 DocType: Retention Bonus,Bonus Payment Date,Бонусна дата оплати
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Завершені робочі замовлення
 DocType: Support Settings,Forum Posts,Повідомлення форуму
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Завдання було включено як фонове завдання. У разі виникнення проблеми з обробкою у фоновому режимі, система додасть коментар про помилку на цьому примиренні запасів та повернеться до етапу чернетки."
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","На жаль, дійсність коду купона не розпочалася"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Оподатковувана сума
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},"У Вас немає прав, щоб додавати або оновлювати записи до {0}"
 DocType: Leave Policy,Leave Policy Details,Залиште детальну інформацію про політику
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Витратні
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,клас
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Код товару&gt; Група предметів&gt; Бренд
 DocType: Restaurant Table,No of Seats,Кількість місць
 DocType: Sales Invoice,Overdue and Discounted,Прострочена та знижена
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Виклик відключений
@@ -507,6 +510,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Інтервал між рядками для суми прописом
 DocType: Vehicle,Additional Details,додаткові подробиці
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Не введене опис
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Отримати елементи зі складу
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Запит на покупку.
 DocType: POS Closing Voucher Details,Collected Amount,Зібрана сума
 DocType: Lab Test,Submitted Date,Дата відправлення
@@ -614,6 +618,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Навчитися
 ,Trial Balance (Simple),Пробний баланс (простий)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Увімкнути відстрочені витрати
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Прикладний купонний код
 DocType: Asset,Next Depreciation Date,Наступна дата амортизації
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Діяльність Вартість одного працівника
 DocType: Accounts Settings,Settings for Accounts,Налаштування для рахунків
@@ -854,8 +859,6 @@
 DocType: Sales Invoice,Total Qty,Всього Кількість
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,ІД епошти охоронця 2
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,ІД епошти охоронця 2
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Видаліть працівника <a href=""#Form/Employee/{0}"">{0}</a> \, щоб скасувати цей документ"
 DocType: Item,Show in Website (Variant),Показати в веб-сайт (варіант)
 DocType: Employee,Health Concerns,Проблеми Здоров&#39;я
 DocType: Payroll Entry,Select Payroll Period,Виберіть Період нарахування заробітної плати
@@ -1021,6 +1024,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Податковий рахунок утримання
 DocType: Pricing Rule,Sales Partner,Торговий партнер
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Усі постачальники показників.
+DocType: Coupon Code,To be used to get discount,Для використання для отримання знижки
 DocType: Buying Settings,Purchase Receipt Required,Потрібна прихідна накладна
 DocType: Sales Invoice,Rail,Залізниця
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Фактична вартість
@@ -1071,6 +1075,7 @@
 DocType: Production Plan,Production Plan,План виробництва
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Інструмент створення відкритого рахунку-фактури
 DocType: Salary Component,Round to the Nearest Integer,Кругніть до найближчого цілого
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,"Дозволити додавати до кошика предмети, які не є в наявності"
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Продажі Повернутися
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Вкажіть кількість в операціях на основі послідовного введення
 ,Total Stock Summary,Всі Резюме Фото
@@ -1201,6 +1206,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Базовий годину Rate (Компанія Валюта)
 ,Qty To Be Billed,"Кількість, яку потрібно виставити на рахунку"
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Доставлено на суму
+DocType: Coupon Code,Gift Card,Подарункова картка
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Кількість зарезервованих для виробництва: кількість сировини для виготовлення виробів.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Дата викупу
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Ця банківська операція вже повністю узгоджена
@@ -1289,6 +1295,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Створення розкладу
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Рахунок {0} був введений кілька разів
 DocType: Account,Expenses Included In Valuation,"Витрати, що включаються в оцінку"
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Купівля-фактура
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Ви можете оновити лише якщо членство закінчується протягом 30 днів
 DocType: Shopping Cart Settings,Show Stock Availability,Показати доступність на складі
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Встановити {0} в категорії активів {1} або компанії {2}
@@ -1832,6 +1839,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Імпорт елементів та UOM
 DocType: Repayment Schedule,Balance Loan Amount,Баланс Сума кредиту
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Додано до подробиць
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","На жаль, код купона вичерпано"
 DocType: Communication Medium,Catch All,Ловити всіх
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Розклад курсу
 DocType: Budget,Applicable on Material Request,Застосовується за запитом про матеріал
@@ -2002,6 +2010,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,неправильний атрибут
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} повинен бути проведений
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Кампанії електронної пошти
+DocType: Sales Partner,To Track inbound purchase,Відстежувати вхідні покупки
 DocType: Buying Settings,Default Supplier Group,Група постачальників за умовчанням
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Кількість повинна бути менше або дорівнює {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},"Максимальна сума, що відповідає компоненту {0}, перевищує {1}"
@@ -2159,8 +2168,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Зробіть запис на складі
 DocType: Hotel Room Reservation,Hotel Reservation User,Бронювання готелів користувачем
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Встановити статус
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Установіть серію нумерації для відвідування через Налаштування&gt; Серія нумерації
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,"Будь ласка, виберіть префікс в першу чергу"
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,"Будь ласка, встановіть назву серії для {0} за допомогою пункту Налаштування&gt; Налаштування&gt; Іменування серії"
 DocType: Contract,Fulfilment Deadline,Термін виконання
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Поруч з вами
 DocType: Student,O-,О
@@ -2284,6 +2293,7 @@
 DocType: Quality Meeting Table,Under Review,У стадії перегляду
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Не вдалося ввійти
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Актив {0} створено
+DocType: Coupon Code,Promotional,Рекламні
 DocType: Special Test Items,Special Test Items,Спеціальні тестові елементи
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,"Щоб зареєструватися в Marketplace, вам потрібно бути користувачем з Роль менеджера системи та менеджера елементів."
 apps/erpnext/erpnext/config/buying.py,Key Reports,Основні звіти
@@ -2322,6 +2332,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Док Тип
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Всього виділено відсоток для відділу продажів повинна бути 100
 DocType: Subscription Plan,Billing Interval Count,Графік інтервалу платежів
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Видаліть працівника <a href=""#Form/Employee/{0}"">{0}</a> \, щоб скасувати цей документ"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Призначення та зустрічі з пацієнтами
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Значення відсутнє
 DocType: Employee,Department and Grade,Кафедра і клас
@@ -2425,6 +2437,7 @@
 DocType: Project,Start and End Dates,Дати початку і закінчення
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Умови виконання умовних угод щодо шаблону
 ,Delivered Items To Be Billed,"Поставлені товари, на які не виставлені рахунки"
+DocType: Coupon Code,Maximum Use,Максимальне використання
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Відкрити ВВП {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Склад не може бути змінений для серійним номером
 DocType: Authorization Rule,Average Discount,Середня Знижка
@@ -2586,6 +2599,7 @@
 DocType: Item,Inventory,Інвентаризація
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Завантажити як Json
 DocType: Item,Sales Details,Продажі Детальніше
+DocType: Coupon Code,Used,Б / в
 DocType: Opportunity,With Items,З номенклатурними позиціями
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Кампанія &quot;{0}&quot; вже існує для {1} &quot;{2}&quot;
 DocType: Asset Maintenance,Maintenance Team,Технічна команда
@@ -2715,7 +2729,7 @@
 						Serial No cannot be ensured",Немає активної мітки для елемента {0}. Доставка від \ Serial No не може бути забезпечена
 DocType: Sales Partner,Sales Partner Target,Цілі торгового партнеру
 DocType: Loan Type,Maximum Loan Amount,Максимальна сума кредиту
-DocType: Pricing Rule,Pricing Rule,Цінове правило
+DocType: Coupon Code,Pricing Rule,Цінове правило
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Дублікат номер рулону для студента {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Дублікат номер рулону для студента {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Замовлення матеріалів у Замовлення на придбання
@@ -2795,6 +2809,7 @@
 DocType: Payment Schedule,Payment Amount,Сума оплати
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Дата півдня має бути між роботою від дати та датою завершення роботи
 DocType: Healthcare Settings,Healthcare Service Items,Сервісні пункти охорони здоров&#39;я
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Недійсний штрих-код. До цього штрих-коду не додано жодного предмета.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Споживана Сума
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Чиста зміна грошових коштів
 DocType: Assessment Plan,Grading Scale,оціночна шкала
@@ -2916,7 +2931,6 @@
 DocType: Share Transfer,Asset Account,Рахунок активів
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Нова дата випуску повинна бути в майбутньому
 DocType: Purchase Invoice,End date of current invoice's period,Кінцева дата періоду виставлення рахунків
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Будь ласка, налаштуйте Систему іменування співробітників у Людських ресурсах&gt; Налаштування HR"
 DocType: Lab Test,Technician Name,Ім&#39;я техніки
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3028,6 +3042,7 @@
 DocType: Products Settings,Hide Variants,Сховати варіанти
 DocType: Lead,Next Contact By,Наступний контакт від
 DocType: Compensatory Leave Request,Compensatory Leave Request,Запит на відшкодування компенсації
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Неможливо перерахувати рахунок за пункт {0} у рядку {1} більше {2}. Щоб дозволити перевитрати, установіть надбавку у Налаштуваннях акаунтів"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Кількість для Пункт {0} в рядку {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},"Склад {0} не може бути вилучений, поки існує кількість для позиції {1}"
 DocType: Blanket Order,Order Type,Тип замовлення
@@ -3200,7 +3215,6 @@
 DocType: Student,Student Mobile Number,Студент Мобільний телефон
 DocType: Item,Has Variants,Має Варіанти
 DocType: Employee Benefit Claim,Claim Benefit For,Поскаржитися на виплату
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Не можна переоформити для пункту {0} у рядку {1} більше {2}. Щоб дозволити надмірну оплату, встановіть у налаштуваннях запасів"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Оновити відповідь
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Ви вже вибрали елементи з {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Назва помісячного розподілу
@@ -3493,6 +3507,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,"Будь ласка, сформулюйте валюту в Компанії"
 DocType: Workstation,Wages per hour,Заробітна плата на годину
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Налаштування {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Клієнт&gt; Група клієнтів&gt; Територія
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Залишок в партії {0} стане негативним {1} для позиції {2} на складі {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Наступне Замовлення матеріалів буде створено автоматично згідно рівня дозамовлення для даної позиції
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Рахунок {0} є неприпустимим. Валюта рахунку повинні бути {1}
@@ -3826,6 +3841,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Провести Зарплатний розрахунок
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,На утриманні
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Зіткнення має мати принаймні один правильний варіант
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Замовлення на купівлю
 DocType: Account,Inter Company Account,Інтер &quot;
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Імпорт наливом
 DocType: Sales Partner,Address & Contacts,Адреса та контакти
@@ -3836,6 +3852,7 @@
 DocType: POS Profile,[Select],[Виберіть]
 DocType: Staffing Plan Detail,Number Of Positions,Кількість позицій
 DocType: Vital Signs,Blood Pressure (diastolic),Артеріальний тиск (діастолічний)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Виберіть клієнта.
 DocType: SMS Log,Sent To,Відправлено
 DocType: Agriculture Task,Holiday Management,Holiday Management
 DocType: Payment Request,Make Sales Invoice,Зробити вихідний рахунок
@@ -4046,7 +4063,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} не проведений
 DocType: Subscription,Trialling,Тріаллінг
 DocType: Sales Invoice Item,Deferred Revenue,Відстрочений дохід
-DocType: Bank Account,GL Account,Рахунок GL
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Готівковий рахунок буде використовуватися для створення рахунку-фактури продажу
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Звільнення під категорію
 DocType: Member,Membership Expiry Date,Дата закінчення членства
@@ -4452,13 +4468,13 @@
 DocType: C-Form Invoice Detail,Territory,Територія
 DocType: Pricing Rule,Apply Rule On Item Code,Застосувати правило щодо коду предмета
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,"Не кажучи вже про НЕ ласка відвідувань, необхідних"
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Звіт про баланс акцій
 DocType: Stock Settings,Default Valuation Method,Метод оцінка за замовчуванням
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,плата
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Показати сукупну суму
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Оновлення в процесі Це може зайняти деякий час.
 DocType: Production Plan Item,Produced Qty,Вироблена кількість
 DocType: Vehicle Log,Fuel Qty,Паливо Кількість
-DocType: Stock Entry,Target Warehouse Name,Назва цільового складу
 DocType: Work Order Operation,Planned Start Time,Плановані Час
 DocType: Course,Assessment,оцінка
 DocType: Payment Entry Reference,Allocated,Розподілено
@@ -4524,10 +4540,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","Стандартні положення та умови, які можуть бути додані до документів продажу та закупівлі. Приклади: 1. Термін дії пропозиції. 1. Умови оплати (передоплата, в кредит, часткова попередня і т.д.). 1. Щось додаткове (або підлягає сплаті клієнтом). 1. Безпека / Попередження при використанні. 1. Гарантії якщо такі є. 1. політика повернень. 1. Умови доставки, якщо це доречно. 1. Способи адресації спорів, відшкодування, відповідальності і т.д. 1. Адреса та контактна інформація Вашої компанії."
 DocType: Homepage Section,Section Based On,Розділ на основі
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Показати Застосувати код купона
 DocType: Issue,Issue Type,Тип проблеми
 DocType: Attendance,Leave Type,Тип відпустки
 DocType: Purchase Invoice,Supplier Invoice Details,Детальна інформація про постачальника рахунку
 DocType: Agriculture Task,Ignore holidays,Ігнорувати свята
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Додати / змінити умови купона
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Витрати / рахунок різниці ({0}) повинен бути &quot;прибуток або збиток» рахунок
 DocType: Stock Entry Detail,Stock Entry Child,Запас дитини дитини
 DocType: Project,Copied From,скопійовано з
@@ -4703,6 +4721,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Критерії оцінки плану
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Операції
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Запобігати замовленням на купівлю
+DocType: Coupon Code,Coupon Name,Назва купона
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Чутливий
 DocType: Email Campaign,Scheduled,Заплановане
 DocType: Shift Type,Working Hours Calculation Based On,Розрахунок робочих годин на основі
@@ -4719,7 +4738,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Створюйте варіанти
 DocType: Vehicle,Diesel,дизель
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Валюту прайс-листа не вибрано
+DocType: Quick Stock Balance,Available Quantity,Доступна кількість
 DocType: Purchase Invoice,Availed ITC Cess,Отримав ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,"Будь ласка, налаштуйте систему іменування інструкторів у програмі Education&gt; Settings Settings"
 ,Student Monthly Attendance Sheet,Student Щомісячна відвідуваність Sheet
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Правило доставки застосовується тільки для продажу
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Рядок амортизації {0}: Далі Датою амортизації не може бути перед датою придбання
@@ -4787,8 +4808,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Ряд {0}: Аванси по клієнту повинні бути у кредиті
 DocType: Quality Meeting,Quality Meeting,Якісна зустріч
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Перетворити елемент у групу
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,"Будь ласка, встановіть назву серії для {0} за допомогою пункту Налаштування&gt; Налаштування&gt; Іменування серії"
 DocType: Employee,ERPNext User,ERPNext Користувач
+DocType: Coupon Code,Coupon Description,Опис купона
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Пакетний є обов&#39;язковим в рядку {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Пакетний є обов&#39;язковим в рядку {0}
 DocType: Company,Default Buying Terms,Умови купівлі за замовчуванням
@@ -4953,6 +4974,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,На деталях документа немає
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Видалення заборонено для країни {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Тип контрагента є обов'язковим
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Застосовуйте купонний код
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",Для картки роботи {0} ви можете зробити лише запас типу &quot;Передача матеріалів на виробництво&quot;
 DocType: Quality Inspection,Outgoing,Вихідний
 DocType: Customer Feedback Table,Customer Feedback Table,Таблиця відгуків клієнтів
@@ -5105,7 +5127,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Під час подання замовлення
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Додати всіх постачальників
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Рядок # {0}: Виділена сума не може бути більше суми заборгованості.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Клієнт&gt; Група клієнтів&gt; Територія
 DocType: Tally Migration,Parties,Сторони
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,Переглянути норми
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Забезпечені кредити
@@ -5137,7 +5158,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Не дозволяється встановлювати альтернативний елемент для елемента {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Дата повторюється
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,"Особа, яка має право підпису"
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,"Будь ласка, налаштуйте систему іменування інструкторів у програмі Освіта&gt; Налаштування освіти"
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Чистий доступний ITC (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Створіть комісії
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Загальна вартість покупки (через рахунок покупки)
@@ -5162,6 +5182,7 @@
 DocType: Quiz Result,Wrong,Неправильно
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Курс, за яким валюта прайс-листа конвертується у базову валюту покупця"
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Чиста сума (Компанія валют)
+DocType: Sales Partner,Referral Code,Промо-Код
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Сума авансового платежу не може перевищувати загальної санкціонованої суми
 DocType: Salary Slip,Hour Rate,Тарифна ставка
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Увімкнути автоматичне повторне замовлення
@@ -5292,6 +5313,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Показувати кількість запасів
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Чисті грошові кошти від операційної
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Рядок № {0}: статус повинен бути {1} для знижок за рахунками {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Коефіцієнт конверсії UOM ({0} -&gt; {1}) не знайдено для елемента: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Пункт 4
 DocType: Student Admission,Admission End Date,Дата закінчення прийому
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Субпідряд
@@ -5314,6 +5336,7 @@
 DocType: Travel Request,Fully Sponsored,Повністю спонсорований
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Вступ до зворотного журналу
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Створіть карту роботи
+DocType: Quotation,Referral Sales Partner,Реферальний партнер з продажу
 DocType: Quality Procedure Process,Process Description,Опис процесу
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Клієнт {0} створено.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,На даний момент немає запасів на будь-якому складі
@@ -5448,6 +5471,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,Вартість згідно норми
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Читання завантаженого файлу
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Завершений робочий ордер не може бути скасований, перш ніж скасувати, зупинити його"
+DocType: Coupon Code,Coupon Code,Купонний код
 DocType: Asset,Journal Entry for Scrap,Проводка для брухту
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,"Ласка, витягнути речі з накладної"
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Рядок {0}: виберіть робочу станцію проти операції {1}
@@ -5532,6 +5556,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&quot;Дата&quot; обов&#39;язкова
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Через / Довідник Дата не може бути після {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Імпорт та експорт даних
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","На жаль, термін дії купона закінчився"
 DocType: Bank Account,Account Details,Деталі облікового запису
 DocType: Crop,Materials Required,Необхідні матеріали
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,"Немає студентів, не знайдено"
@@ -5570,6 +5595,7 @@
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,"Оплачена сума + Сума списання не може бути більше, ніж загальний підсумок"
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},"{0} не є допустимим номером партії 
 для товару {1}"
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Введіть дійсний код купона !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Примітка: Недостатньо днів залишилося для типу відпусток {0}
 DocType: Task,Task Description,Опис завдання
 DocType: Training Event,Seminar,семінар
@@ -5837,6 +5863,7 @@
 ,TDS Payable Monthly,TDS виплачується щомісяця
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Очікується заміщення BOM. Це може зайняти кілька хвилин.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Не можете відняти, коли категорія для &quot;Оцінка&quot; або &quot;Оцінка і Total &#39;"
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Будь ласка, налаштуйте Систему іменування співробітників у Людських ресурсах&gt; Налаштування HR"
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Загальна сума виплат
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Серійні номери обов'язкові для серіалізованої позиції номенклатури {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Зв'язати платежі з рахунками-фактурами
@@ -5927,6 +5954,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Отримайте сировину для виробництва
 DocType: Job Opening,Job Title,Професія
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Майбутня оплата Ref
+DocType: Quotation,Additional Discount and Coupon Code,Додатковий код знижки та купон
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} вказує на те, що {1} не буде надавати котирування, але котируються всі елементи \. Оновлення стану цитати RFQ."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Максимальна кількість зразків - {0} вже збережено для партії {1} та елемента {2} у пакеті {3}.
@@ -6156,7 +6184,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Налаштування домашньої сторінки веб-сайту
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} призупинено до {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},Запити на RFQ не дозволені для {0} через показник показника показника {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Зробіть рахунок-фактуру за купівлю
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Використовувані листи
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Купон використовується {1}. Дозволена кількість вичерпується
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Ви хочете надіслати матеріальний запит
 DocType: Job Offer,Awaiting Response,В очікуванні відповіді
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6170,6 +6200,7 @@
 DocType: Training Event Employee,Optional,Необов&#39;язково
 DocType: Salary Slip,Earning & Deduction,Нарахування та відрахування
 DocType: Agriculture Analysis Criteria,Water Analysis,Аналіз води
+DocType: Sales Order,Skip Delivery Note,Пропустити довідку про доставку
 DocType: Price List,Price Not UOM Dependent,Ціна не залежить від UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,Створено {0} варіанти.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Угода про рівень обслуговування за замовчуванням вже існує.
@@ -6277,6 +6308,7 @@
 DocType: Vehicle,Last Carbon Check,Останній Carbon Перевірити
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Судові витрати
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,"Будь ласка, виберіть кількість по ряду"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Робочий наказ {0}: службова картка не знайдена для операції {1}
 DocType: Purchase Invoice,Posting Time,Час запису
 DocType: Timesheet,% Amount Billed,Виставлено рахунків на %
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Телефон Витрати
@@ -6379,7 +6411,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Податки та збори додано
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Рядок амортизації {0}: Далі Датою амортизації не може бути до Дати доступної для використання
 ,Sales Funnel,Воронка продажів
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Код товару&gt; Група предметів&gt; Бренд
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Скорочення є обов'язковим
 DocType: Project,Task Progress,Завдання про хід роботи
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Візок
@@ -6475,6 +6506,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,"Необхідний POS-профіль, щоб зробити POS-операцію"
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",Оригінали лояльності будуть розраховуватися з витрачених витрат (через рахунок-фактуру з продажів) на основі вказаного коефіцієнту збору.
 DocType: Program Enrollment Tool,Enroll Students,зарахувати студентів
+DocType: Pricing Rule,Coupon Code Based,На основі коду купона
 DocType: Company,HRA Settings,Налаштування HRA
 DocType: Homepage,Hero Section,Розділ героїв
 DocType: Employee Transfer,Transfer Date,Дата передачі
@@ -6591,6 +6623,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',"Будь ласка, встановіть фільтр компанії порожнім, якщо група До є «Компанія»"
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Дата розміщення не може бути майбутня дата
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},"Ряд # {0}: Серійний номер {1}, не відповідає {2} {3}"
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Установіть серію нумерації для відвідування через Налаштування&gt; Серія нумерації
 DocType: Stock Entry,Target Warehouse Address,Адреса цільового складу
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Непланована відпустка
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,"Час перед початком часу зміни, протягом якого реєстрація відвідувачів вважається для відвідування."
@@ -6625,7 +6658,6 @@
 DocType: Employee Grade,Employee Grade,Оцінка працівників
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Відрядна робота
 DocType: GSTR 3B Report,June,Червень
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Постачальник&gt; Тип постачальника
 DocType: Share Balance,From No,Від №
 DocType: Shift Type,Early Exit Grace Period,Період дострокового виходу з вигоди
 DocType: Task,Actual Time (in Hours),Фактичний час (в годинах)
@@ -6912,7 +6944,6 @@
 DocType: Warehouse,Warehouse Name,Назва складу
 DocType: Naming Series,Select Transaction,Виберіть операцію
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,"Будь ласка, введіть затвердження роль або затвердження Користувач"
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Коефіцієнт конверсії UOM ({0} -&gt; {1}) не знайдено для елемента: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Договір про рівень обслуговування з типом {0} та об&#39;єктом {1} вже існує.
 DocType: Journal Entry,Write Off Entry,Списання запис
 DocType: BOM,Rate Of Materials Based On,Вартість матеріалів базується на
@@ -7051,6 +7082,7 @@
 DocType: Budget,Warn,Попереджати
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Всі предмети вже були передані для цього робочого замовлення.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Будь-які інші зауваження, відзначити зусилля, які повинні йти в записах."
+DocType: Bank Account,Company Account,Рахунок компанії
 DocType: Asset Maintenance,Manufacturing User,Виробництво користувача
 DocType: Purchase Invoice,Raw Materials Supplied,Давальна сировина
 DocType: Subscription Plan,Payment Plan,План платежів
@@ -7092,6 +7124,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) не може перевищувати заплановану кількість ({2}) у робочому замовленні {3}
 DocType: Certification Application,Name of Applicant,Ім&#39;я заявника
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Час Лист для виготовлення.
+DocType: Quick Stock Balance,Quick Stock Balance,Швидкий балансовий баланс
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,проміжний підсумок
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,"Не вдається змінити властивості Variant після транзакції з цінними паперами. Щоб зробити це, вам доведеться створити новий елемент."
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless Mandate SEPA
@@ -7420,6 +7453,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} неактивний студент
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} неактивний студент
 DocType: Employee,Health Details,Детальніше Здоров&#39;я
+DocType: Coupon Code,Coupon Type,Тип купона
 DocType: Leave Encashment,Encashable days,Encashable дні
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Для створення запиту платежу потрібно посилання на документ
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Для створення запиту платежу потрібно посилання на документ
@@ -7707,6 +7741,7 @@
 DocType: Hotel Room Package,Amenities,Зручності
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Автоматично отримати умови оплати
 DocType: QuickBooks Migrator,Undeposited Funds Account,Непогашений рахунок Фонду
+DocType: Coupon Code,Uses,Використання
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Кілька типовий спосіб оплати за замовчуванням заборонено
 DocType: Sales Invoice,Loyalty Points Redemption,Виплати балів лояльності
 ,Appointment Analytics,Призначення Analytics
@@ -7724,6 +7759,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Залиште поле порожнім, якщо ви робите груп студентів на рік"
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Залиште поле порожнім, якщо ви робите груп студентів на рік"
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Якщо позначено, ""Загальна кількість робочих днів"" буде включати в себе свята, і це призведе до зниження розміру ""Зарплати за день"""
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Не вдалося додати домен
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Щоб дозволити надходження / доставку, оновіть &quot;За надходження / надходження дозволу&quot; в Налаштуваннях запасів або Товар."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Програми, які використовують поточний ключ, не зможуть отримати доступ, чи впевнені ви?"
 DocType: Subscription Settings,Prorate,Прорат
@@ -7737,6 +7773,7 @@
 ,BOM Stock Report,BOM Stock Report
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Якщо немає призначеного часового інтервалу, то ця група здійснюватиметься зв’язком"
 DocType: Stock Reconciliation Item,Quantity Difference,Кількісна різниця
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Постачальник&gt; Тип постачальника
 DocType: Opportunity Item,Basic Rate,Базова ціна
 DocType: GL Entry,Credit Amount,Сума кредиту
 ,Electronic Invoice Register,Реєстр електронних рахунків-фактур
@@ -7991,6 +8028,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Відраховані податки та збори (Валюта компанії)
 DocType: Item Group,General Settings,Загальні налаштування
 DocType: Article,Article,Стаття
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Введіть код купона !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,З валюти і валюти не може бути таким же
 DocType: Taxable Salary Slab,Percent Deduction,Вирахування відсотків
 DocType: GL Entry,To Rename,Перейменувати
diff --git a/erpnext/translations/ur.csv b/erpnext/translations/ur.csv
index c3e4e72..5187789 100644
--- a/erpnext/translations/ur.csv
+++ b/erpnext/translations/ur.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,میٹ - ڈی ٹی - .YYYY-
 DocType: Purchase Order,Customer Contact,اپرنٹسشپس
 DocType: Shift Type,Enable Auto Attendance,آٹو اٹینڈینس کو قابل بنائیں۔
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,برائے مہربانی گودام اور تاریخ درج کریں
 DocType: Lost Reason Detail,Opportunity Lost Reason,موقع کھو دیا وجہ
 DocType: Patient Appointment,Check availability,دستیابی کی جانچ پڑتال کریں
 DocType: Retention Bonus,Bonus Payment Date,بونس ادائیگی کی تاریخ
@@ -259,6 +260,7 @@
 ,Completed Work Orders,مکمل کام کے حکم
 DocType: Support Settings,Forum Posts,فورم کے مراسلے
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage",اس کام کو پس منظر کی نوکری کے طور پر ترتیب دیا گیا ہے۔ اگر پس منظر میں پروسیسنگ کے سلسلے میں کوئی مسئلہ پیش آرہا ہے تو ، یہ اسٹاک مفاہمت سے متعلق غلطی کے بارے میں کوئی تبصرہ شامل کرے گا اور مسودہ مرحلے میں واپس آجائے گا۔
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started",معذرت ، کوپن کوڈ کی توثیق شروع نہیں ہوئی ہے
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,قابل ٹیکس رقم
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},تم سے پہلے اندراجات شامل کرنے یا اپ ڈیٹ کرنے کی اجازت نہیں ہے {0}
 DocType: Leave Policy,Leave Policy Details,پالیسی کی تفصیلات چھوڑ دو
@@ -323,6 +325,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,فراہمی
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,گریڈ
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,آئٹم کوڈ&gt; آئٹم گروپ&gt; برانڈ
 DocType: Restaurant Table,No of Seats,نشستوں کی تعداد
 DocType: Sales Invoice,Overdue and Discounted,ضرورت سے زیادہ اور چھوٹ
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,کال منقطع۔
@@ -499,6 +502,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,الفاظ میں رقم کے لئے سطر میں خالی جگہ
 DocType: Vehicle,Additional Details,ایڈیشنل تفصیلات
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,دی کوئی وضاحت
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,گودام سے سامان لائیں
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,خریداری کے لئے درخواست.
 DocType: POS Closing Voucher Details,Collected Amount,جمع کردہ رقم
 DocType: Lab Test,Submitted Date,پیش کردہ تاریخ
@@ -605,6 +609,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,جانیے
 ,Trial Balance (Simple),آزمائشی بیلنس (آسان)
 DocType: Purchase Invoice Item,Enable Deferred Expense,منتقل شدہ اخراج کو فعال کریں
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,لاگو کوپن کوڈ
 DocType: Asset,Next Depreciation Date,اگلا ہراس تاریخ
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,فی ملازم سرگرمی لاگت
 DocType: Accounts Settings,Settings for Accounts,اکاؤنٹس کے لئے ترتیبات
@@ -838,8 +843,6 @@
 DocType: Sales Invoice,Total Qty,کل مقدار
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 ای میل آئی ڈی
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 ای میل آئی ڈی
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","براہ کرم اس دستاویز کو منسوخ کرنے کے لئے ملازم <a href=""#Form/Employee/{0}"">{0}</a> delete کو حذف کریں۔"
 DocType: Item,Show in Website (Variant),ویب سائٹ میں دکھائیں (مختلف)
 DocType: Employee,Health Concerns,صحت کے خدشات
 DocType: Payroll Entry,Select Payroll Period,پے رول کی مدت کو منتخب
@@ -1002,6 +1005,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,ٹیکس کو روکنے کے اکاؤنٹ
 DocType: Pricing Rule,Sales Partner,سیلز پارٹنر
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,تمام سپلائر سکور کارڈ.
+DocType: Coupon Code,To be used to get discount,رعایت حاصل کرنے کے لئے استعمال کیا جا
 DocType: Buying Settings,Purchase Receipt Required,خریداری کی رسید کی ضرورت ہے
 DocType: Sales Invoice,Rail,ریل
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,اصل قیمت
@@ -1050,6 +1054,7 @@
 DocType: Production Plan,Production Plan,پیداوار کی منصوبہ بندی
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,افتتاحی انوائس تخلیق کا آلہ
 DocType: Salary Component,Round to the Nearest Integer,قریب ترین عدد کے لئے گول
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,اسٹاک میں موجود اشیا کو ٹوکری میں شامل کرنے کی اجازت دیں
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,سیلز واپس
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,سیریل نمبر ان پٹ پر مبنی ٹرانزیکشن میں مقدار مقرر کریں
 ,Total Stock Summary,کل اسٹاک خلاصہ
@@ -1178,6 +1183,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),بیس گھنٹے کی شرح (کمپنی کرنسی)
 ,Qty To Be Billed,بل کی مقدار میں
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,ہونے والا رقم
+DocType: Coupon Code,Gift Card,تحفہ والا کارڈ
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,پیداوار کے لئے محفوظ مقدار: مینوفیکچرنگ آئٹمز بنانے کے لئے خام مال کی مقدار۔
 DocType: Loyalty Point Entry Redemption,Redemption Date,چھٹکارا کی تاریخ
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,بینک کے اس لین دین میں پہلے ہی مکمل طور پر صلح ہوگئی ہے۔
@@ -1266,6 +1272,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,ٹائم شیٹ بنائیں۔
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,اکاؤنٹ {0} کئی بار داخل کیا گیا ہے
 DocType: Account,Expenses Included In Valuation,اخراجات تشخیص میں شامل
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,انوائسز خریدیں
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,اگر آپ کی رکنیت 30 دن کے اندر ختم ہوتی ہے تو آپ صرف تجدید کرسکتے ہیں
 DocType: Shopping Cart Settings,Show Stock Availability,اسٹاک کی دستیابی دکھائیں
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},{0} اثاثہ کی قسم {1} یا کمپنی {2} میں سیٹ کریں
@@ -1804,6 +1811,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,آئٹمز اور UOMs کی درآمد۔
 DocType: Repayment Schedule,Balance Loan Amount,بیلنس قرض کی رقم
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,تفصیلات میں شامل
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted",معذرت ، کوپن کوڈ ختم ہوگیا
 DocType: Communication Medium,Catch All,سب کو پکڑو۔
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,شیڈول کورس
 DocType: Budget,Applicable on Material Request,مواد کی درخواست پر لاگو
@@ -1974,6 +1982,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,غلط خاصیت
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} پیش کرنا ضروری ہے
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,ای میل مہمات۔
+DocType: Sales Partner,To Track inbound purchase,باؤنڈ خریداری کو ٹریک کرنے کے ل
 DocType: Buying Settings,Default Supplier Group,ڈیفالٹ سپلائر گروپ
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},مقدار {0} سے کم یا برابر ہونا ضروری ہے
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},اجزاء {0} سے زیادہ {1} سے زائد زیادہ رقم اہل ہے
@@ -2129,7 +2138,6 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,اسٹاک اندراج کریں۔
 DocType: Hotel Room Reservation,Hotel Reservation User,ہوٹل ریزرویشن صارف
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,حیثیت طے کریں۔
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,براہ کرم حاضری کے لئے نمبر بندی سیریز سیٹ اپ&gt; نمبرنگ سیریز کے ذریعے ترتیب دیں۔
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,پہلے سابقہ براہ مہربانی منتخب کریں
 DocType: Contract,Fulfilment Deadline,مکمل آخری وقت
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,آپ کے قریب
@@ -2253,6 +2261,7 @@
 DocType: Quality Meeting Table,Under Review,زیر جائزہ
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,لاگ ان کرنے میں ناکام
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,پیدا کردہ {0}
+DocType: Coupon Code,Promotional,پروموشنل
 DocType: Special Test Items,Special Test Items,خصوصی ٹیسٹ اشیا
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,مارکیٹ میں رجسٹر کرنے کے لئے آپ کو سسٹم مینیجر اور آئٹم مینیجر کے کردار کے ساتھ ایک صارف بنانا ہوگا.
 apps/erpnext/erpnext/config/buying.py,Key Reports,کلیدی رپورٹیں۔
@@ -2290,6 +2299,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,ڈاکٹر قسم
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,فروخت کی ٹیم کے لئے مختص کل فی صد 100 ہونا چاہئے
 DocType: Subscription Plan,Billing Interval Count,بلنگ انٹراول شمار
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","براہ کرم اس دستاویز کو منسوخ کرنے کے لئے ملازم <a href=""#Form/Employee/{0}"">{0}</a> delete کو حذف کریں"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,اپیلمنٹ اور مریض کے اختتام
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,قیمت لاپتہ ہے
 DocType: Employee,Department and Grade,محکمہ اور گریڈ
@@ -2389,6 +2400,7 @@
 DocType: Project,Start and End Dates,شروع کریں اور تواریخ اختتام
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,معاہدے کے سانچہ کی مکمل شرائط
 ,Delivered Items To Be Billed,ہونے والا اشیا بل بھیجا جائے کرنے کے لئے
+DocType: Coupon Code,Maximum Use,زیادہ سے زیادہ استعمال
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},کھولیں بوم {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,گودام سیریل نمبر کے لئے تبدیل کر دیا گیا نہیں کیا جا سکتا
 DocType: Authorization Rule,Average Discount,اوسط ڈسکاؤنٹ
@@ -2547,6 +2559,7 @@
 DocType: Item,Inventory,انوینٹری
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Json کی طرح ڈاؤن لوڈ کریں۔
 DocType: Item,Sales Details,سیلز کی تفصیلات
+DocType: Coupon Code,Used,استعمال کیا جاتا ہے
 DocType: Opportunity,With Items,اشیاء کے ساتھ
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',مہم &#39;{0}&#39; پہلے ہی {1} &#39;{2}&#39; کیلئے موجود ہے
 DocType: Asset Maintenance,Maintenance Team,بحالی کی ٹیم
@@ -2673,7 +2686,7 @@
 						Serial No cannot be ensured",آئٹم {0} کے لئے کوئی فعال BOM نہیں ملا۔ \ سیریل نمبر کے ذریعہ ترسیل کو یقینی نہیں بنایا جاسکتا۔
 DocType: Sales Partner,Sales Partner Target,سیلز پارٹنر ہدف
 DocType: Loan Type,Maximum Loan Amount,زیادہ سے زیادہ قرض کی رقم
-DocType: Pricing Rule,Pricing Rule,قیمتوں کا تعین اصول
+DocType: Coupon Code,Pricing Rule,قیمتوں کا تعین اصول
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},طالب علم کے لئے ڈوپلیکیٹ رول نمبر {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},طالب علم کے لئے ڈوپلیکیٹ رول نمبر {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,آرڈر خریداری کے لئے مواد کی درخواست
@@ -2753,6 +2766,7 @@
 DocType: Payment Schedule,Payment Amount,ادائیگی کی رقم
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,نصف دن کی تاریخ تاریخ اور کام کے اختتام کی تاریخ کے درمیان ہونا چاہئے
 DocType: Healthcare Settings,Healthcare Service Items,ہیلتھ کیئر سروس اشیاء
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,غلط بار کوڈ۔ اس بار کوڈ کے ساتھ کوئی آئٹم منسلک نہیں ہے۔
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,بسم رقم
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,کیش میں خالص تبدیلی
 DocType: Assessment Plan,Grading Scale,گریڈنگ پیمانے
@@ -2871,7 +2885,6 @@
 DocType: Share Transfer,Asset Account,اکاؤنٹ اثاثہ
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,نئی رہائی کی تاریخ مستقبل میں ہونی چاہئے۔
 DocType: Purchase Invoice,End date of current invoice's period,موجودہ انوائس کی مدت کے ختم ہونے کی تاریخ
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,برائے کرم انسانی وسائل&gt; HR کی ترتیبات میں ملازمین کے نام دینے کا نظام مرتب کریں۔
 DocType: Lab Test,Technician Name,ٹیکنشین کا نام
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3428,6 +3441,7 @@
 DocType: Vehicle,Fuel Type,ایندھن کی قسم
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,کمپنی میں کرنسی کی وضاحت کریں
 DocType: Workstation,Wages per hour,فی گھنٹہ اجرت
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,کسٹمر&gt; کسٹمر گروپ&gt; علاقہ
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},بیچ میں اسٹاک توازن {0} بن جائے گا منفی {1} گودام شے {2} کے لئے {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,مواد درخواست درج ذیل آئٹم کی دوبارہ آرڈر کی سطح کی بنیاد پر خود کار طریقے سے اٹھایا گیا ہے
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},اکاؤنٹ {0} باطل ہے. اکاؤنٹ کی کرنسی ہونا ضروری ہے {1}
@@ -3760,6 +3774,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,تنخواہ پرچی جمع کرائیں
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,پکڑو
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,ایک حصہ کے پاس کم از کم ایک صحیح اختیارات ہونے چاہ.۔
+apps/erpnext/erpnext/hooks.py,Purchase Orders,خریداری کے احکامات
 DocType: Account,Inter Company Account,انٹر کمپنی اکاؤنٹ
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,بلک میں درآمد
 DocType: Sales Partner,Address & Contacts,ایڈریس اور رابطے
@@ -3770,6 +3785,7 @@
 DocType: POS Profile,[Select],[چونے]
 DocType: Staffing Plan Detail,Number Of Positions,پوزیشنوں کی تعداد
 DocType: Vital Signs,Blood Pressure (diastolic),بلڈ پریشر (ڈائاسولک)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,براہ کرم گاہک کو منتخب کریں۔
 DocType: SMS Log,Sent To,کو بھیجا
 DocType: Agriculture Task,Holiday Management,چھٹیوں کا انتظام
 DocType: Payment Request,Make Sales Invoice,فروخت انوائس بنائیں
@@ -3976,7 +3992,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} جمع نہیں ہے
 DocType: Subscription,Trialling,ٹرائلنگ
 DocType: Sales Invoice Item,Deferred Revenue,معاوضہ آمدنی
-DocType: Bank Account,GL Account,جی ایل اکاؤنٹ۔
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,سیلز انوائس تخلیق کے لئے نقد اکاؤنٹ استعمال کیا جائے گا
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,چھوٹ ذیلی زمرہ
 DocType: Member,Membership Expiry Date,رکنیت ختم ہونے کی تاریخ
@@ -4376,13 +4391,13 @@
 DocType: C-Form Invoice Detail,Territory,علاقہ
 DocType: Pricing Rule,Apply Rule On Item Code,آئٹم کوڈ پر قاعدہ کا اطلاق کریں۔
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,ضرورت دوروں کا کوئی ذکر کریں
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,اسٹاک بیلنس رپورٹ
 DocType: Stock Settings,Default Valuation Method,پہلے سے طے شدہ تشخیص کا طریقہ
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,فیس
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,مجموعی رقم دکھائیں
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,اپ ڈیٹ جاری ہے. یہ تھوڑی دیر لگتی ہے.
 DocType: Production Plan Item,Produced Qty,تیار مقدار
 DocType: Vehicle Log,Fuel Qty,ایندھن کی مقدار
-DocType: Stock Entry,Target Warehouse Name,ہدف گودام کا نام
 DocType: Work Order Operation,Planned Start Time,منصوبہ بندی کے آغاز کا وقت
 DocType: Course,Assessment,اسسمنٹ
 DocType: Payment Entry Reference,Allocated,مختص
@@ -4448,10 +4463,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.",سٹینڈرڈ شرائط و فروخت اور خرید میں شامل کیا جا سکتا ہے کہ شرائط. مثالیں: پیشکش 1. درست. 1. ادائیگی کی شرائط (کریڈٹ پر پیشگی میں،، حصہ پیشگی وغیرہ). 1. اضافی (یا گاہکوں کی طرف سے قابل ادائیگی) کیا ہے. 1. سیفٹی / استعمال انتباہ. 1. وارنٹی اگر کوئی ہے تو. 1. واپسی کی پالیسی. شپنگ 1. شرائط، اگر قابل اطلاق ہو. تنازعات سے خطاب کرتے ہوئے، معاوضہ، ذمہ داری کی 1. طریقے، وغیرہ 1. ایڈریس اور آپ کی کمپنی سے رابطہ کریں.
 DocType: Homepage Section,Section Based On,پر مبنی سیکشن
+DocType: Shopping Cart Settings,Show Apply Coupon Code,لاگو کوپن کوڈ دکھائیں
 DocType: Issue,Issue Type,مسئلہ کی قسم
 DocType: Attendance,Leave Type,ٹائپ کریں چھوڑ دو
 DocType: Purchase Invoice,Supplier Invoice Details,سپلائر انوائس کی تفصیلات دیکھیں
 DocType: Agriculture Task,Ignore holidays,تعطیلات کو نظر انداز کریں
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,کوپن کی شرائط شامل / ترمیم کریں
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,اخراجات / فرق اکاؤنٹ ({0}) ایک &#39;نفع یا نقصان کے اکاؤنٹ ہونا ضروری ہے
 DocType: Stock Entry Detail,Stock Entry Child,اسٹاک اندراج چائلڈ
 DocType: Project,Copied From,سے کاپی
@@ -4623,6 +4640,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,تشخیص کی منصوبہ بندی کا کلیہ
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,ٹرانسمیشن
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,خریداری کے احکامات کو روکیں
+DocType: Coupon Code,Coupon Name,کوپن کا نام
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,ممنوعہ
 DocType: Email Campaign,Scheduled,تخسوچت
 DocType: Shift Type,Working Hours Calculation Based On,ورکنگ اوقات کا حساب کتاب
@@ -4639,7 +4657,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,مختلف حالتیں بنائیں۔
 DocType: Vehicle,Diesel,ڈیزل
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,قیمت کی فہرست کرنسی منتخب نہیں
+DocType: Quick Stock Balance,Available Quantity,دستیاب مقدار
 DocType: Purchase Invoice,Availed ITC Cess,آئی ٹی سی سیس کا دورہ
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,براہ کرم تعلیم&gt; تعلیم کی ترتیبات میں انسٹرکٹر نام دینے کا نظام مرتب کریں
 ,Student Monthly Attendance Sheet,Student کی ماہانہ حاضری شیٹ
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,فروخت کے لئے صرف شپنگ اصول لاگو ہوتا ہے
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,استحکام صف {0}: اگلے قیمت کی قیمت کی تاریخ خریداری کی تاریخ سے پہلے نہیں ہوسکتی ہے
@@ -4708,6 +4728,7 @@
 DocType: Quality Meeting,Quality Meeting,کوالٹی میٹنگ۔
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,گروپ غیر گروپ
 DocType: Employee,ERPNext User,ERPNext صارف
+DocType: Coupon Code,Coupon Description,کوپن کی تفصیل
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},بیچ {0} میں لازمی ہے
 DocType: Company,Default Buying Terms,پہلے سے طے شدہ خریداری کی شرائط۔
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,خریداری کی رسید آئٹم فراہم
@@ -4868,6 +4889,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,دستاویز تفصیل کے خلاف کوئی
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},ملک کے لئے حذف کرنے کی اجازت نہیں ہے {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,پارٹی قسم لازمی ہے
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,کوپن کوڈ کا اطلاق کریں
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",جاب کارڈ {0} کے ل you ، آپ صرف &#39;مادی تیاری برائے مینوفیکچر&#39; قسم اسٹاک اندراج کرسکتے ہیں۔
 DocType: Quality Inspection,Outgoing,سبکدوش ہونے والے
 DocType: Customer Feedback Table,Customer Feedback Table,کسٹمر کی رائے ٹیبل
@@ -5018,7 +5040,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,خریداری کا آرڈر جمع کروانے پر۔
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,تمام سپلائرز شامل کریں
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,صف # {0}: مختص رقم بقایا رقم سے زیادہ نہیں ہو سکتا.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,کسٹمر&gt; کسٹمر گروپ&gt; علاقہ۔
 DocType: Tally Migration,Parties,پارٹیاں۔
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,براؤز BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,محفوظ قرضوں
@@ -5048,7 +5069,6 @@
 DocType: Subscription,Past Due Date,ماضی کی تاریخ
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,تاریخ دہرایا گیا ہے
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,مجاز دستخط
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,براہ کرم تعلیم&gt; تعلیم کی ترتیبات میں انسٹرکٹر نام دینے کا نظام مرتب کریں۔
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),نیٹ آئی ٹی سی دستیاب ہے (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,فیس بنائیں
 DocType: Project,Total Purchase Cost (via Purchase Invoice),کل خریداری کی لاگت (انوائس خریداری کے ذریعے)
@@ -5073,6 +5093,7 @@
 DocType: Quiz Result,Wrong,غلط
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,شرح جس قیمت کی فہرست کرنسی میں گاہکوں کی بنیاد کرنسی تبدیل کیا جاتا ہے
 DocType: Purchase Invoice Item,Net Amount (Company Currency),نیول رقم (کمپنی کرنسی)
+DocType: Sales Partner,Referral Code,حوالہ کوڈ
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,کل پیشگی رقم مجموعی منظور شدہ رقم سے زیادہ نہیں ہوسکتی ہے
 DocType: Salary Slip,Hour Rate,گھنٹے کی شرح
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,آٹو ری آرڈر کو فعال کریں۔
@@ -5199,6 +5220,7 @@
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},براہ مہربانی آئٹم کے خلاف BOM منتخب کریں {0}
 DocType: Shopping Cart Settings,Show Stock Quantity,اسٹاک کی مقدار دکھائیں
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,آپریشنز سے نیٹ کیش
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM کے تبادلوں کا عنصر ({0} -&gt; {1}) آئٹم کے لئے نہیں ملا: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,آئٹم 4
 DocType: Student Admission,Admission End Date,داخلے کی آخری تاریخ
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,ذیلی سمجھوتہ
@@ -5221,6 +5243,7 @@
 DocType: Travel Request,Fully Sponsored,مکمل طور پر سپانسر
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,ریورس جرنل انٹری
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,جاب کارڈ بنائیں۔
+DocType: Quotation,Referral Sales Partner,ریفرل سیلز پارٹنر
 DocType: Quality Procedure Process,Process Description,عمل کی تفصیل
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,کسٹمر {0} پیدا ہوتا ہے.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,فی الحال کوئی اسٹاک کسی بھی گودام میں دستیاب نہیں ہے
@@ -5352,6 +5375,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM کی شرح
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,اپ لوڈ کردہ فائل پڑھنا۔
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel",روک دیا کام کا آرڈر منسوخ نہیں کیا جاسکتا، اسے منسوخ کرنے کے لئے سب سے پہلے غیرقانونی
+DocType: Coupon Code,Coupon Code,کوپن کوڈ
 DocType: Asset,Journal Entry for Scrap,سکریپ کے لئے جرنل اندراج
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,ترسیل کے نوٹ سے اشیاء پر ھیںچو کریں
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},قطار {0}: آپریشن کے خلاف ورکشاپ کا انتخاب کریں {1}
@@ -5432,6 +5456,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;تاریخ&#39; ضروری ہے۔
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},وجہ / حوالہ تاریخ کے بعد نہیں ہو سکتا {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,ڈیٹا کی درآمد اور برآمد
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired",معذرت ، کوپن کوڈ کی میعاد ختم ہوگئی ہے
 DocType: Bank Account,Account Details,اکاؤنٹ کی تفصیلات
 DocType: Crop,Materials Required,مواد کی ضرورت ہے
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,کوئی طالب علم نہیں ملا
@@ -5469,6 +5494,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,صارفین پر جائیں
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,ادائیگی کی رقم رقم گرینڈ کل سے زیادہ نہیں ہو سکتا لکھنے +
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} شے کے لئے ایک درست بیچ نمبر نہیں ہے {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,براہ کرم درست کوپن کوڈ درج کریں !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},نوٹ: حکم کی قسم کے لئے کافی چھٹی توازن نہیں ہے {0}
 DocType: Task,Task Description,ٹاسک کی تفصیل۔
 DocType: Training Event,Seminar,سیمینار
@@ -5735,6 +5761,7 @@
 ,TDS Payable Monthly,قابل ادائیگی TDS ماہانہ
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,بوم کو تبدیل کرنے کے لئے قطار یہ چند منٹ لگ سکتا ہے.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',زمرہ &#39;تشخیص&#39; یا &#39;تشخیص اور کل&#39; کے لئے ہے جب کٹوتی نہیں کر سکتے ہیں
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,برائے کرم انسانی وسائل&gt; HR کی ترتیبات میں ملازمین کے نام دینے کا نظام مرتب کریں
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,کل ادائیگی
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},serialized کی شے کے لئے سیریل نمبر مطلوب {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,انوائس کے ساتھ ملائیں ادائیگیاں
@@ -5822,6 +5849,7 @@
 DocType: Production Plan,Get Raw Materials For Production,پیداوار کے لئے خام مال حاصل کریں
 DocType: Job Opening,Job Title,ملازمت کا عنوان
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,مستقبل کی ادائیگی ریفری
+DocType: Quotation,Additional Discount and Coupon Code,اضافی ڈسکاؤنٹ اور کوپن کوڈ
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.",{0} یہ اشارہ کرتا ہے کہ {1} کوٹیشن فراہم نہیں کرے گا، لیکن تمام اشیاء \ کو حوالہ دیا گیا ہے. آر ایف پی کی اقتباس کی حیثیت کو اپ ڈیٹ کرنا.
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,زیادہ سے زیادہ نمونے - {1} بیچ {1} اور آئٹم {2} بیچ میں {3} پہلے ہی برقرار رکھے ہیں.
@@ -6046,6 +6074,7 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,ویب سائٹ کے ہوم پیج کے لئے ترتیبات
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} جب تک {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},{1} کے سکور کارڈ کے کھڑے ہونے کی وجہ سے RFQ کو {0} کی اجازت نہیں ہے.
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,خریداری کی رسید بنائیں
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,استعمال شدہ پتیوں
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,کیا آپ مادی درخواست جمع کروانا چاہتے ہیں؟
 DocType: Job Offer,Awaiting Response,جواب کا منتظر
@@ -6060,6 +6089,7 @@
 DocType: Training Event Employee,Optional,اختیاری
 DocType: Salary Slip,Earning & Deduction,کمائی اور کٹوتی
 DocType: Agriculture Analysis Criteria,Water Analysis,پانی تجزیہ
+DocType: Sales Order,Skip Delivery Note,ترسیل نوٹ چھوڑ دیں
 DocType: Price List,Price Not UOM Dependent,قیمت UOM پر منحصر نہیں ہے۔
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} مختلف قسم کی تخلیق
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,پہلے سے طے شدہ سروس لیول کا معاہدہ موجود ہے۔
@@ -6166,6 +6196,7 @@
 DocType: Vehicle,Last Carbon Check,آخری کاربن چیک کریں
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,قانونی اخراجات
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,صف پر مقدار براہ مہربانی منتخب کریں
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},ورک آرڈر {0}: جاب کارڈ کیلئے آپریشن نہیں ملا {1}
 DocType: Purchase Invoice,Posting Time,پوسٹنگ وقت
 DocType: Timesheet,% Amount Billed,٪ رقم بل
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,ٹیلی فون اخراجات
@@ -6267,7 +6298,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,ٹیکس اور الزامات شامل کر دیا گیا
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,استحکام صف {0}: اگلے قیمتوں کا تعین تاریخ دستیاب - استعمال کے لئے تاریخ سے پہلے نہیں ہوسکتا ہے
 ,Sales Funnel,سیلز قیف
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,آئٹم کوڈ&gt; آئٹم گروپ&gt; برانڈ۔
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,مخفف لازمی ہے
 DocType: Project,Task Progress,ٹاسک پیش رفت
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,ٹوکری
@@ -6361,6 +6391,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,پی او ایس پی او ایس پروفائل اندراج کرنے کے لئے کی ضرورت ہے
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",وفاداری پوائنٹس کا حساب کردہ عنصر کے حساب سے خرچ کردہ (سیلز انوائس کے ذریعہ) کے حساب سے شمار کیا جائے گا.
 DocType: Program Enrollment Tool,Enroll Students,طلباء اندراج کریں
+DocType: Pricing Rule,Coupon Code Based,کوپن کوڈ پر مبنی
 DocType: Company,HRA Settings,HRA ترتیبات
 DocType: Homepage,Hero Section,ہیرو سیکشن
 DocType: Employee Transfer,Transfer Date,منتقلی کی تاریخ
@@ -6474,6 +6505,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',اگر گروپ سے &#39;کمپنی&#39; ہے کمپنی فلٹر کو خالی مقرر مہربانی
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,پوسٹنگ کی تاریخ مستقبل کی تاریخ میں نہیں ہو سکتا
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},صف # {0}: سیریل نمبر {1} کے ساتھ مطابقت نہیں ہے {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,براہ کرم حاضری کے لئے نمبر بندی سیریز سیٹ اپ&gt; نمبرنگ سیریز کے ذریعے ترتیب دیں
 DocType: Stock Entry,Target Warehouse Address,ہدف گودام ایڈریس
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,آرام دہ اور پرسکون کی رخصت
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,شفٹ شروع ہونے سے قبل کا وقت جس کے دوران ملازمین کے داخلے کے لئے چیک ان سمجھا جاتا ہے۔
@@ -6508,7 +6540,6 @@
 DocType: Employee Grade,Employee Grade,ملازم گریڈ
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Piecework
 DocType: GSTR 3B Report,June,جون
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,سپلائر&gt; سپلائر کی قسم
 DocType: Share Balance,From No,نمبر سے نہیں
 DocType: Shift Type,Early Exit Grace Period,ابتدائی ایکزٹ گریس پیریڈ
 DocType: Task,Actual Time (in Hours),(گھنٹوں میں) اصل وقت
@@ -6791,7 +6822,6 @@
 DocType: Warehouse,Warehouse Name,گودام نام
 DocType: Naming Series,Select Transaction,منتخب ٹرانزیکشن
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,کردار کی منظوری یا صارف منظوری داخل کریں
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM کے تبادلوں کا عنصر ({0} -&gt; {1}) آئٹم کے لئے نہیں ملا: {2}
 DocType: Journal Entry,Write Off Entry,انٹری لکھنے
 DocType: BOM,Rate Of Materials Based On,شرح معدنیات کی بنیاد پر
 DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.",اگر فعال ہو تو، فیلڈ تعلیمی ٹرم پروگرام کے اندراج کے آلے میں لازمی ہوگا.
@@ -6928,6 +6958,7 @@
 DocType: Budget,Warn,انتباہ
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,تمام اشیاء پہلے سے ہی اس ورک آرڈر کے لئے منتقل کردیئے گئے ہیں.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.",کسی بھی دوسرے ریمارکس، ریکارڈ میں جانا چاہئے کہ قابل ذکر کوشش.
+DocType: Bank Account,Company Account,کمپنی کا اکاؤنٹ
 DocType: Asset Maintenance,Manufacturing User,مینوفیکچرنگ صارف
 DocType: Purchase Invoice,Raw Materials Supplied,خام مال فراہم
 DocType: Subscription Plan,Payment Plan,ادائیگی کی منصوبہ بندی
@@ -6968,6 +6999,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) کام کی آرڈر {3} میں منصوبہ بندی کی مقدار ({2}) سے زیادہ نہیں ہوسکتا ہے.
 DocType: Certification Application,Name of Applicant,درخواست گزار کا نام
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,مینوفیکچرنگ کے لئے وقت شیٹ.
+DocType: Quick Stock Balance,Quick Stock Balance,فوری اسٹاک بیلنس
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,ذیلی کل
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,سٹاک ٹرانزیکشن کے بعد مختلف خصوصیات کو تبدیل نہیں کر سکتے ہیں. ایسا کرنا آپ کو نیا آئٹم بنانا ہوگا.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA مینڈیٹ
@@ -7273,6 +7305,8 @@
 DocType: Purchase Invoice Item,Include Exploded Items,دھماکہ خیز اشیاء شامل کریں
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,"Buying must be checked, if Applicable For is selected as {0}",قابل اطلاق کے لئے کے طور پر منتخب کیا جاتا ہے تو خریدنے، جانچ پڑتال ہونا ضروری {0}
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Discount must be less than 100,ڈسکاؤنٹ کم 100 ہونا ضروری ہے
+apps/erpnext/erpnext/support/doctype/service_level/service_level.py,"Start Time can't be greater than or equal to End Time \
+					for {0}.",شروع کا وقت اختتامی وقت to کے لئے {0} سے زیادہ یا اس کے برابر نہیں ہوسکتا ہے۔
 DocType: Shipping Rule,Restrict to Countries,ممالک پر پابندی
 DocType: Shift Type,Alternating entries as IN and OUT during the same shift,ایک ہی شفٹ کے دوران بطور IN اور OUT بطور اندراجات۔
 DocType: Shopify Settings,Shared secret,مشترکہ راز
@@ -7292,6 +7326,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},مقرر کریں {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} غیر فعال طالب علم ہے
 DocType: Employee,Health Details,صحت کی تفصیلات
+DocType: Coupon Code,Coupon Type,کوپن کی قسم
 DocType: Leave Encashment,Encashable days,ناقابل یقین دن
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,ایک ادائیگی کی درخواست ریفرنس دستاویز کی ضرورت ہے پیدا کرنے کے لئے
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,ایک ادائیگی کی درخواست ریفرنس دستاویز کی ضرورت ہے پیدا کرنے کے لئے
@@ -7574,6 +7609,7 @@
 DocType: Hotel Room Package,Amenities,سہولیات
 DocType: Accounts Settings,Automatically Fetch Payment Terms,ادائیگی کی شرائط خود بخود بازیافت کریں۔
 DocType: QuickBooks Migrator,Undeposited Funds Account,Undeposited فنڈز اکاؤنٹ
+DocType: Coupon Code,Uses,استعمال کرتا ہے
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,ادائیگی کے ایک سے زیادہ ڈیفالٹ موڈ کی اجازت نہیں ہے
 DocType: Sales Invoice,Loyalty Points Redemption,وفاداری پوائنٹس کو چھٹکارا
 ,Appointment Analytics,تقرری تجزیات
@@ -7591,6 +7627,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,آپ ہر سال طلباء گروپوں بنا دیں تو خالی چھوڑ دیں
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,آپ ہر سال طلباء گروپوں بنا دیں تو خالی چھوڑ دیں
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day",جانچ پڑتال تو، کل کوئی. کام کے دنوں کے چھٹیوں کے شامل ہوں گے، اور اس تنخواہ فی دن کی قیمت کم ہو جائے گا
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,ڈومین شامل کرنے میں ناکام
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.",رسید / ترسیل کی اجازت دینے کے لئے ، اسٹاک کی ترتیبات یا آئٹم میں &quot;اوور رسید / ڈیلیوری الاؤنس&quot; کو اپ ڈیٹ کریں۔
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?",موجودہ کلید کا استعمال کرتے ہوئے اطلاقات تک رسائی حاصل نہیں ہو گی، کیا آپ کو یقین ہے؟
 DocType: Subscription Settings,Prorate,پراجیکٹ
@@ -7604,6 +7641,7 @@
 ,BOM Stock Report,BOM اسٹاک رپورٹ
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group",اگر کوئی تفویض کردہ ٹائم سلاٹ نہیں ہے تو پھر اس گروپ کے ذریعہ مواصلات کو سنبھالا جائے گا۔
 DocType: Stock Reconciliation Item,Quantity Difference,مقدار فرق
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,سپلائر&gt; سپلائر کی قسم
 DocType: Opportunity Item,Basic Rate,بنیادی شرح
 DocType: GL Entry,Credit Amount,کریڈٹ کی رقم
 ,Electronic Invoice Register,الیکٹرانک انوائس رجسٹر
@@ -7852,6 +7890,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),ٹیکسز اور الزامات کٹوتی (کمپنی کرنسی)
 DocType: Item Group,General Settings,عام ترتیبات
 DocType: Article,Article,آرٹیکل۔
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,براہ کرم کوپن کوڈ درج کریں !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,کرنسی سے اور کرنسی کے لئے ایک ہی نہیں ہو سکتا
 DocType: Taxable Salary Slab,Percent Deduction,فی صد کٹوتی
 DocType: GL Entry,To Rename,نام بدلنا۔
diff --git a/erpnext/translations/uz.csv b/erpnext/translations/uz.csv
index 7471f5d..bee2f95 100644
--- a/erpnext/translations/uz.csv
+++ b/erpnext/translations/uz.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Mijozlar bilan aloqa
 DocType: Shift Type,Enable Auto Attendance,Avtomatik qatnashishni yoqish
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,"Iltimos, ombor va sanani kiriting"
 DocType: Lost Reason Detail,Opportunity Lost Reason,Imkoniyatni yo&#39;qotish sababi
 DocType: Patient Appointment,Check availability,Mavjudligini tekshirib ko&#39;ring
 DocType: Retention Bonus,Bonus Payment Date,Bonus To&#39;lov sanasi
@@ -264,6 +265,7 @@
 ,Completed Work Orders,Tugallangan ish buyurtmalari
 DocType: Support Settings,Forum Posts,Foydalanuvchining profili Xabarlar
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Vazifa asosiy ish sifatida qabul qilindi. Agar fonda ishlov berish bo&#39;yicha biron bir muammo yuzaga kelsa, tizim ushbu aktsiyalashtirish xatosi haqida sharh qo&#39;shib, qoralama bosqichiga qaytadi."
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Kechirasiz, kupon kodi yaroqsiz"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Soliq summasi
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},{0} dan oldin kiritilgan yozuvlarni qo&#39;shish yoki yangilash uchun ruxsat yo&#39;q
 DocType: Leave Policy,Leave Policy Details,Siyosat tafsilotlarini qoldiring
@@ -329,6 +331,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Sarflanadigan
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,Baholash
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Element kodi&gt; Mahsulotlar guruhi&gt; Tovar
 DocType: Restaurant Table,No of Seats,O&#39;rindiqlar soni
 DocType: Sales Invoice,Overdue and Discounted,Kechiktirilgan va chegirma
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Qo&#39;ng&#39;iroq uzilib qoldi
@@ -505,6 +508,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,So&#39;zdagi so&#39;zlar uchun qator oralig&#39;i
 DocType: Vehicle,Additional Details,Qo&#39;shimcha tafsilotlar
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Tavsif berilmagan
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Ombordan olinadigan narsalar
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Sotib olish talabi.
 DocType: POS Closing Voucher Details,Collected Amount,To&#39;plangan summa
 DocType: Lab Test,Submitted Date,O&#39;tkazilgan sana
@@ -612,6 +616,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,O&#39;rganish
 ,Trial Balance (Simple),Sinov balansi (oddiy)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Kechiktirilgan xarajatlarni yoqish
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Amaliy Kupon kodi
 DocType: Asset,Next Depreciation Date,Keyingi Amortizatsiya sanasi
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Xodimga ko&#39;ra harajatlar
 DocType: Accounts Settings,Settings for Accounts,Hisob sozlamalari
@@ -846,8 +851,6 @@
 DocType: BOM,Work Order,Ish tartibi
 DocType: Sales Invoice,Total Qty,Jami Miqdor
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2 Email identifikatori
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Ushbu hujjatni bekor qilish uchun <a href=""#Form/Employee/{0}"">{0}</a> \ xodimini o&#39;chiring"
 DocType: Item,Show in Website (Variant),Saytda ko&#39;rsatish (variant)
 DocType: Employee,Health Concerns,Sog&#39;liq muammolari
 DocType: Payroll Entry,Select Payroll Period,Ajratish davrini tanlang
@@ -1011,6 +1014,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Soliq to&#39;lashni hisobga olish
 DocType: Pricing Rule,Sales Partner,Savdo hamkori
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Barcha etkazib beruvchi kartalari.
+DocType: Coupon Code,To be used to get discount,Chegirma olish uchun ishlatiladi
 DocType: Buying Settings,Purchase Receipt Required,Qabul qilish pulligizga.Albatta talab qilinadi
 DocType: Sales Invoice,Rail,Rail
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Haqiqiy xarajat
@@ -1061,6 +1065,7 @@
 DocType: Production Plan,Production Plan,Ishlab chiqarish rejasi
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Billingni ochish vositasini ochish
 DocType: Salary Component,Round to the Nearest Integer,Eng yaqin butun songa aylantiring
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Savatda bo&#39;lmagan narsalarning savatga qo&#39;shilishiga ruxsat bering
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Sotishdan qaytish
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Serial No Input ga asoslangan operatsiyalarda Miqdorni belgilash
 ,Total Stock Summary,Jami Qisqacha Xulosa
@@ -1188,6 +1193,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Asosiy soatingiz (Kompaniya valyutasi)
 ,Qty To Be Billed,Hisobni to&#39;lash kerak
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Miqdori topshirilgan
+DocType: Coupon Code,Gift Card,Sovg&#39;a kartasi
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Ishlab chiqarish uchun zahiralangan miqdor: ishlab chiqarish buyumlarini tayyorlash uchun xom ashyo miqdori.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Qaytarilish sanasi
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Ushbu bank operatsiyasi allaqachon to&#39;liq kelishilgan
@@ -1275,6 +1281,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Vaqt jadvalini yarating
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,{0} hisobi bir necha marta kiritilgan
 DocType: Account,Expenses Included In Valuation,Baholashda ishtirok etish xarajatlari
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Xarajatlarni sotib oling
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Sizning a&#39;zoning 30 kun ichida amal qilish muddati tugaguncha yangilanishi mumkin
 DocType: Shopping Cart Settings,Show Stock Availability,Qimmatli qog&#39;ozlar mavjudligini ko&#39;rsatish
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},{1} guruhidagi {0} yoki kompaniya {2}
@@ -1814,6 +1821,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Elementlar va UOM-larni import qilish
 DocType: Repayment Schedule,Balance Loan Amount,Kreditning qoldig&#39;i
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Tafsilotlarga qo&#39;shildi
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Kechirasiz, kupon kodi tugagan"
 DocType: Communication Medium,Catch All,Barchasini ushlash
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,Jadval kursi
 DocType: Budget,Applicable on Material Request,Materiallar talabiga muvofiq qo&#39;llaniladi
@@ -1981,6 +1989,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Noto&#39;g&#39;ri attribut
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} yuborilishi kerak
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Elektron pochta kampaniyalari
+DocType: Sales Partner,To Track inbound purchase,Kiruvchi xaridni kuzatish uchun
 DocType: Buying Settings,Default Supplier Group,Standart yetkazib beruvchi guruhi
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Miqdori {0} dan kam yoki unga teng bo&#39;lishi kerak
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},{0} komponentiga mos keladigan maksimal miqdor {1} dan oshib ketdi
@@ -2136,8 +2145,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Birjaga kirishni amalga oshiring
 DocType: Hotel Room Reservation,Hotel Reservation User,Mehmonxona Rezervasyoni
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Holatni o&#39;rnating
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Iltimos Setup&gt; Raqamlash seriyalari orqali qatnashish uchun raqamlash seriyasini sozlang
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,"Iltimos, avval prefiksni tanlang"
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,"Iltimos, sozlash&gt; Sozlamalar&gt; Nomlash seriyalari orqali {0} uchun nomlash seriyasini o&#39;rnating"
 DocType: Contract,Fulfilment Deadline,Tugatish muddati
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Yoningizda
 DocType: Student,O-,O-
@@ -2261,6 +2270,7 @@
 DocType: Quality Meeting Table,Under Review,Sharh ostida
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Kirish amalga oshmadi
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,{0} obyekti yaratildi
+DocType: Coupon Code,Promotional,Reklama
 DocType: Special Test Items,Special Test Items,Maxsus test buyumlari
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Bozorda ro&#39;yxatdan o&#39;tish uchun tizim menejeri va element menejeri vazifalarini bajaradigan foydalanuvchi bo&#39;lishingiz kerak.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Asosiy hisobotlar
@@ -2298,6 +2308,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Doc turi
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Savdo jamoasi uchun jami ajratilgan foiz 100 bo&#39;lishi kerak
 DocType: Subscription Plan,Billing Interval Count,Billing oralig&#39;i soni
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Ushbu hujjatni bekor qilish uchun <a href=""#Form/Employee/{0}"">{0}</a> \ xodimini o&#39;chiring"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Uchrashuvlar va bemor uchrashuvlari
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Qiymat kam
 DocType: Employee,Department and Grade,Bo&#39;lim va sinf
@@ -2400,6 +2412,7 @@
 DocType: Project,Start and End Dates,Boshlanish va tugash sanalari
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Shartnoma shartlarini bajarish shartlari
 ,Delivered Items To Be Billed,Taqdim etiladigan narsalar
+DocType: Coupon Code,Maximum Use,Maksimal foydalanish
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Serial raqami uchun omborni o&#39;zgartirib bo&#39;lmaydi.
 DocType: Authorization Rule,Average Discount,O&#39;rtacha chegirma
@@ -2559,6 +2572,7 @@
 DocType: Item,Inventory,Inventarizatsiya
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Json sifatida yuklab oling
 DocType: Item,Sales Details,Sotish tafsilotlari
+DocType: Coupon Code,Used,Ishlatilgan
 DocType: Opportunity,With Items,Mahsulotlar bilan
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',&quot;{0}&quot; kampaniyasi {1} &#39;{2}&#39; uchun allaqachon mavjud
 DocType: Asset Maintenance,Maintenance Team,Xizmat jamoasi
@@ -2688,7 +2702,7 @@
 						Serial No cannot be ensured",{0} elementi uchun faol BOM topilmadi. \ Serial No orqali etkazib bo&#39;lmaydi
 DocType: Sales Partner,Sales Partner Target,Savdo hamkorining maqsadi
 DocType: Loan Type,Maximum Loan Amount,Maksimal kredit summasi
-DocType: Pricing Rule,Pricing Rule,Raqobatchilar qoidasi
+DocType: Coupon Code,Pricing Rule,Raqobatchilar qoidasi
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Talabalar uchun {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Buyurtma buyurtmasiga buyurtma berish
 DocType: Company,Default Selling Terms,Sotishning odatiy shartlari
@@ -2765,6 +2779,7 @@
 DocType: Payment Schedule,Payment Amount,To&#39;lov miqdori
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Yarim kunlik sana Sana va Ish tugash sanasi o&#39;rtasida bo&#39;lishi kerak
 DocType: Healthcare Settings,Healthcare Service Items,Sog&#39;liqni saqlash xizmatlari
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Shtrix-kod noto‘g‘ri. Ushbu shtrix-kodga hech qanday element qo&#39;shilmagan.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Iste&#39;mol qilingan summalar
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Naqd pulning aniq o&#39;zgarishi
 DocType: Assessment Plan,Grading Scale,Baholash o&#39;lchovi
@@ -2884,7 +2899,6 @@
 DocType: Share Transfer,Asset Account,Shaxs hisoblari
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Yangi chiqarilgan sana kelajakda bo&#39;lishi kerak
 DocType: Purchase Invoice,End date of current invoice's period,Joriy hisob-kitob davri tugash sanasi
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Iltimos, xodimlarni nomlash tizimini inson resurslari&gt; Kadrlar sozlamalarida o&#39;rnating"
 DocType: Lab Test,Technician Name,Texnik nom
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -2995,6 +3009,7 @@
 DocType: Products Settings,Hide Variants,Variantlarni yashirish
 DocType: Lead,Next Contact By,Keyingi aloqa
 DocType: Compensatory Leave Request,Compensatory Leave Request,Compensatory Leave Request
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings",{1} qatoridan {2} dan ortiq {0} elementi uchun ortiqcha buyurtma berish mumkin emas. Ortiqcha hisob-kitob qilishga ruxsat berish uchun hisob qaydnomasi sozlamalarida ruxsatnomani belgilang
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},{1} qatoridagi {0} element uchun zarur miqdori
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},{1} elementi uchun {0} ombori miqdorini yo&#39;q qilib bo&#39;lmaydi
 DocType: Blanket Order,Order Type,Buyurtma turi
@@ -3164,7 +3179,6 @@
 DocType: Student,Student Mobile Number,Isoning shogirdi mobil raqami
 DocType: Item,Has Variants,Varyantlar mavjud
 DocType: Employee Benefit Claim,Claim Benefit For,Shikoyat uchun manfaat
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","{1} qatorda {2} dan ortiq {0} mahsulotiga ortiqcha to&#39;lov berilmaydi. Haddan ortiq hisob-kitoblarga ruxsat berish uchun, Stok Sozlamalarni-ni tanlang"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Javobni yangilash
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},{0} {1} dan tanlangan elementlarni tanladingiz
 DocType: Monthly Distribution,Name of the Monthly Distribution,Oylik tarqatish nomi
@@ -3454,6 +3468,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,"Iltimos, kompaniyadagi valyutani ko&#39;rsating"
 DocType: Workstation,Wages per hour,Bir soatlik ish haqi
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Sozlash {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Xaridor&gt; Mijozlar guruhi&gt; Hudud
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},{3} omboridagi {2} mahsulot uchun {0} partiyadagi balans salbiy {1} bo&#39;ladi.
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,"Materiallar so&#39;rovlaridan so&#39;ng, Materiallar buyurtma buyurtma darajasi bo&#39;yicha avtomatik ravishda to&#39;ldirildi"
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Hisob {0} yaroqsiz. Hisob valyutasi {1} bo&#39;lishi kerak
@@ -3783,6 +3798,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Ish haqi slipini topshirish
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Kutib turishda
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Qustion kamida bitta to&#39;g&#39;ri tanlovga ega bo&#39;lishi kerak
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Buyurtmalarni sotib oling
 DocType: Account,Inter Company Account,Inter kompaniyasi hisobi
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Katta hajmdagi import
 DocType: Sales Partner,Address & Contacts,Manzil va Kontaktlar
@@ -3793,6 +3809,7 @@
 DocType: POS Profile,[Select],[Tanlash]
 DocType: Staffing Plan Detail,Number Of Positions,Pozitsiyalar soni
 DocType: Vital Signs,Blood Pressure (diastolic),Qon bosimi (diastolik)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,"Iltimos, mijozni tanlang."
 DocType: SMS Log,Sent To,Yuborilgan
 DocType: Agriculture Task,Holiday Management,Dam olishni boshqarish
 DocType: Payment Request,Make Sales Invoice,Sotuvdagi hisob-fakturani tanlang
@@ -4002,7 +4019,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} yuborilmadi
 DocType: Subscription,Trialling,Tajovuz
 DocType: Sales Invoice Item,Deferred Revenue,Ertelenmiş keladi
-DocType: Bank Account,GL Account,GL hisobi
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Sotuvdagi hisobvaraqni yaratish uchun naqd pul hisobidan foydalaniladi
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Istisno Quyi toifalar
 DocType: Member,Membership Expiry Date,Registratsiya sanasi
@@ -4404,13 +4420,13 @@
 DocType: C-Form Invoice Detail,Territory,Hudud
 DocType: Pricing Rule,Apply Rule On Item Code,Kod kodi bo&#39;yicha qoida amal qiling
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,"Iltimos, kerakli tashriflardan hech qanday foydalanmang"
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Fond balansi to&#39;g&#39;risidagi hisobot
 DocType: Stock Settings,Default Valuation Method,Standart baholash usuli
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Narxlar
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Kümülatiya miqdori ko&#39;rsatilsin
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Yangilanish davom etmoqda. Biroz vaqt talab etiladi.
 DocType: Production Plan Item,Produced Qty,Ishlab chiqarilgan Miqdor
 DocType: Vehicle Log,Fuel Qty,Yoqilg&#39;i miqdori
-DocType: Stock Entry,Target Warehouse Name,Nishon ombor nomi
 DocType: Work Order Operation,Planned Start Time,Rejalashtirilgan boshlash vaqti
 DocType: Course,Assessment,Baholash
 DocType: Payment Entry Reference,Allocated,Ajratilgan
@@ -4476,10 +4492,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","Savdo va xaridlarga qo&#39;shilishi mumkin bo&#39;lgan standart shartlar. Misollar: 1. Taklifning amal qilish muddati. 1. To&#39;lov shartlari (Advance, Credit, part advance va boshqalar). 1. Qanday qo&#39;shimcha (yoki Xaridor tomonidan to&#39;lanishi kerak). 1. Xavfsizlik / foydalanish bo&#39;yicha ogohlantirish. 1. Agar mavjud bo&#39;lsa, kafolat. 1. Siyosatni qaytaradi. 1. Taqdim etish shartlari, agar mavjud bo&#39;lsa. 1. Nizolarni hal etish usullari, tovon, javobgarlik va boshqalar. 1. Sizning kompaniyangiz manzili va aloqasi."
 DocType: Homepage Section,Section Based On,Bo&#39;lim Asoslangan
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Kupon kodini qo&#39;llashni ko&#39;rsatish
 DocType: Issue,Issue Type,Muammo turi
 DocType: Attendance,Leave Type,Turini qoldiring
 DocType: Purchase Invoice,Supplier Invoice Details,Yetkazib beruvchi hisob-faktura ma&#39;lumotlari
 DocType: Agriculture Task,Ignore holidays,Bayramlarni e&#39;tiborsiz qoldiring
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Kupon shartlarini qo&#39;shish / tahrirlash
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Xarajatlar / farq statistikasi ({0}) &quot;Qor yoki ziyon&quot; hisobiga bo&#39;lishi kerak
 DocType: Stock Entry Detail,Stock Entry Child,Stokga kirish bolasi
 DocType: Project,Copied From,Ko&#39;chirildi
@@ -4654,6 +4672,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Baholashni baholash mezonlari
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Jurnallar
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Buyurtma buyurtmalaridan saqlanish
+DocType: Coupon Code,Coupon Name,Kupon nomi
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,E&#39;tiborli
 DocType: Email Campaign,Scheduled,Rejalashtirilgan
 DocType: Shift Type,Working Hours Calculation Based On,Ish vaqtini hisoblash asosida
@@ -4670,7 +4689,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Variantlarni yarating
 DocType: Vehicle,Diesel,Diesel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Narxlar ro&#39;yxati Valyutasi tanlanmagan
+DocType: Quick Stock Balance,Available Quantity,Mavjud miqdori
 DocType: Purchase Invoice,Availed ITC Cess,Qabul qilingan ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,"Iltimos, Ta&#39;lim beruvchiga nom berish tizimini Ta&#39;lim sozlamalarida o&#39;rnating"
 ,Student Monthly Attendance Sheet,Talabalar oylik davomiyligi varaqasi
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Yuk tashish qoidasi faqat Sotish uchun amal qiladi
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Amortizatsiya sathi {0}: Keyingi Amortizatsiya tarixi sotib olish sanasidan oldin bo&#39;lishi mumkin emas
@@ -4737,8 +4758,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Row {0}: mijozga qarshi avans kredit bo&#39;lishi kerak
 DocType: Quality Meeting,Quality Meeting,Sifat uchrashuvi
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Guruh bo&#39;lmagan guruhga
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,"Iltimos, sozlash&gt; Sozlamalar&gt; Nomlash seriyalari orqali {0} uchun nomlash seriyasini o&#39;rnating"
 DocType: Employee,ERPNext User,ERPNext Foydalanuvchi
+DocType: Coupon Code,Coupon Description,Kupon tavsifi
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},{0} qatorida paketli bo&#39;lish kerak
 DocType: Company,Default Buying Terms,Odatiy sotib olish shartlari
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Qabul qilish uchun ma&#39;lumot elementi yetkazib berildi
@@ -4901,6 +4922,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Hujjat bo&#39;yicha batafsil ma&#39;lumot yo&#39;q
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},{0} mamlakat uchun o&#39;chirishga ruxsat yo&#39;q
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Partiya turi majburiydir
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Kupon kodini qo&#39;llang
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",{0} ish kartasi uchun siz &quot;Ishlab chiqarish uchun pul o&#39;tkazmasi&quot; turidagi yozuvlarni amalga oshirishingiz mumkin
 DocType: Quality Inspection,Outgoing,Chiqish
 DocType: Customer Feedback Table,Customer Feedback Table,Mijozlarning fikr-mulohazalari jadvali
@@ -5050,7 +5072,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Xarid buyurtmasini berish to&#39;g&#39;risida
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Barcha etkazib beruvchilarni qo&#39;shish
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Row # {0}: Ajratilgan miqdori uncha katta bo&#39;lmagan miqdordan ortiq bo&#39;lishi mumkin emas.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Xaridor&gt; Mijozlar guruhi&gt; Hudud
 DocType: Tally Migration,Parties,Tomonlar
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,BOM-ga ko&#39;z tashlang
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Kafolatlangan kreditlar
@@ -5082,7 +5103,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},{0} elementi uchun muqobil elementni o&#39;rnatishga ruxsat berish
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Sana takrorlanadi
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Vakolatli vakil
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,"Iltimos, Ta&#39;limni sozlashda o&#39;qituvchiga nom berish tizimini sozlang"
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),Mavjud ITC (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Narxlarni yarating
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Jami xarid qiymati (Xarid qilish byudjeti orqali)
@@ -5107,6 +5127,7 @@
 DocType: Quiz Result,Wrong,Noto&#39;g&#39;ri
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Narxlar ro&#39;yxati valyutasi mijozning asosiy valyutasiga aylantirildi
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Sof miqdori (Kompaniya valyutasi)
+DocType: Sales Partner,Referral Code,Yo&#39;naltirish kodi
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Umumiy avans miqdori jami ruxsat etilgan miqdordan ortiq bo&#39;lishi mumkin emas
 DocType: Salary Slip,Hour Rate,Soat darajasi
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Avtomatik buyurtmani yoqish
@@ -5235,6 +5256,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Stok miqdorini ko&#39;rsatish
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Operatsiyalar bo&#39;yicha aniq pul
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},# {0} qator: Hisob-fakturani chegirma uchun {1} holati {1} bo&#39;lishi kerak.
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM konversiyalash koeffitsienti ({0} -&gt; {1}) quyidagi element uchun topilmadi: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,4-band
 DocType: Student Admission,Admission End Date,Qabul tugash sanasi
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Sub-shartnoma
@@ -5257,6 +5279,7 @@
 DocType: Travel Request,Fully Sponsored,To&#39;liq homiylik
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Jurnalga teskari qaytish
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Ish kartasini yarating
+DocType: Quotation,Referral Sales Partner,Yo&#39;naltiruvchi savdo bo&#39;yicha hamkori
 DocType: Quality Procedure Process,Process Description,Jarayon tavsifi
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Xaridor {0} yaratildi.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Hozirda biron-bir omborda stok yo&#39;q
@@ -5391,6 +5414,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM darajasi
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Yuklangan faylni o&#39;qish
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","To&#39;xtatilgan ish tartibi bekor qilinishi mumkin emas, bekor qilish uchun avval uni to&#39;xtatib turish"
+DocType: Coupon Code,Coupon Code,Kupon kodi
 DocType: Asset,Journal Entry for Scrap,Hurda uchun jurnalni kiritish
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,"Iltimos, mahsulotni etkazib berish Eslatma"
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Row {0}: ish stantsiyasini {1} operatsiyasidan qarshi tanlang
@@ -5473,6 +5497,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&quot;Sana&quot; shart
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Vaqt / ariza sanasi {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,Ma&#39;lumotlarni import qilish va eksport qilish
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Kechirasiz, kupon kodining amal qilish muddati tugadi"
 DocType: Bank Account,Account Details,Hisob ma&#39;lumotlari
 DocType: Crop,Materials Required,Materiallar kerak
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Hech kim topilmadi
@@ -5510,6 +5535,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Foydalanuvchilarga o&#39;ting
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,To&#39;langan pul miqdori + Write Off To&#39;lov miqdori Grand Totaldan katta bo&#39;lishi mumkin emas
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} {1} element uchun haqiqiy partiya raqami emas
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,"Iltimos, to&#39;g&#39;ri kupon kodini kiriting !!"
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Izoh: Tovar {0} uchun qoldirilgan muvozanat etarli emas.
 DocType: Task,Task Description,Vazifalar tavsifi
 DocType: Training Event,Seminar,Seminar
@@ -5773,6 +5799,7 @@
 ,TDS Payable Monthly,TDS to&#39;lanishi mumkin oylik
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,BOMni almashtirish uchun navbat. Bir necha daqiqa o&#39;tishi mumkin.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',&quot;Baholash&quot; yoki &quot;Baholash va jami&quot;
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Iltimos, xodimlarni nomlash tizimini inson resurslari&gt; Kadrlar sozlamalarida o&#39;rnating"
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Umumiy to&#39;lovlar
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Serileştirilmiş Mahsulot uchun Serial Nos kerak {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Xarajatlarni hisob-kitob qilish
@@ -5862,6 +5889,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Ishlab chiqarish uchun xomashyodan foydalaning
 DocType: Job Opening,Job Title,Lavozim
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Kelgusidagi to&#39;lov ref
+DocType: Quotation,Additional Discount and Coupon Code,Qo&#39;shimcha chegirma va kupon kodi
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} {1} tirnoq taqdim etmasligini bildiradi, lekin barcha elementlar \ kote qilingan. RFQ Buyurtma holatini yangilash."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Eng ko&#39;p namuna - {0} ommaviy {1} va {2} elementlari uchun ommaviy {3} da allaqachon saqlangan.
@@ -6088,7 +6116,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Veb-sayt bosh sahifasining sozlamalari
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} {1} gacha ushlab turiladi
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},{1} hisob qaydnomasi holati tufayli {0} uchun RFQ-larga ruxsat berilmaydi.
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Xarid fakturasini tuzing
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Ishlatilgan barglar
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} ishlatilgan kupon {1}. Ruxsat berilgan miqdor tugadi
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Talabnomani topshirishni xohlaysizmi
 DocType: Job Offer,Awaiting Response,Javobni kutish
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6102,6 +6132,7 @@
 DocType: Training Event Employee,Optional,Majburiy emas
 DocType: Salary Slip,Earning & Deduction,Mablag&#39;larni kamaytirish
 DocType: Agriculture Analysis Criteria,Water Analysis,Suvni tahlil qilish
+DocType: Sales Order,Skip Delivery Note,Yetkazib berish haqida eslatmani o&#39;tkazib yuboring
 DocType: Price List,Price Not UOM Dependent,Narx UOMga bog&#39;liq emas
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0} variantlar yaratildi.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Standart xizmat darajasi to&#39;g&#39;risidagi shartnoma allaqachon mavjud.
@@ -6206,6 +6237,7 @@
 DocType: Vehicle,Last Carbon Check,Oxirgi Karbon nazorati
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Huquqiy xarajatlar
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,"Iltimos, qatordagi miqdorni tanlang"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},{0} ish tartibi: ish uchun karta topilmadi {1}
 DocType: Purchase Invoice,Posting Time,Vaqtni yuborish vaqti
 DocType: Timesheet,% Amount Billed,% To&#39;lov miqdori
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Telefon xarajatlari
@@ -6308,7 +6340,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Soliqlar va to&#39;lovlar qo&#39;shildi
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Amortizatsiya sathi {0}: Keyingi Amortizatsiya tarixi foydalanish uchun tayyor bo&#39;lgan sanadan oldin bo&#39;lishi mumkin emas
 ,Sales Funnel,Savdo huni
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Element kodi&gt; Mahsulotlar guruhi&gt; Tovar
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Qisqartirish majburiydir
 DocType: Project,Task Progress,Vazifa muvaffaqiyati
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Savat
@@ -6403,6 +6434,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,Qalin kirishni amalga oshirish uchun qalin profil talab qilinadi
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",Sodiqlik ballari eslatilgan yig&#39;ish faktori asosida amalga oshirilgan sarf-xarajatlardan (Sotuvdagi schyot-faktura orqali) hisoblab chiqiladi.
 DocType: Program Enrollment Tool,Enroll Students,O&#39;quvchilarni ro&#39;yxatga olish
+DocType: Pricing Rule,Coupon Code Based,Kupon kodiga asoslangan
 DocType: Company,HRA Settings,HRA sozlamalari
 DocType: Homepage,Hero Section,Qahramonlar bo&#39;limi
 DocType: Employee Transfer,Transfer Date,O&#39;tkazish sanasi
@@ -6518,6 +6550,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',"Guruh tomonidan &quot;Kompaniya&quot; bo&#39;lsa, Kompaniya filtrini bo&#39;sh qoldiring."
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Kiritilgan sana kelajakdagi sana bo&#39;la olmaydi
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},# {0} qatori: ketma-ket No {1} {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Iltimos Setup&gt; Raqamlash seriyalari orqali qatnashish uchun raqamlash seriyasini sozlang
 DocType: Stock Entry,Target Warehouse Address,Nishon QXI manzili
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Oddiy chiqish
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,Ishchilarni ro&#39;yxatdan o&#39;tkazilishi qatnashish uchun hisobga olinadigan smena boshlanishidan oldingi vaqt.
@@ -6552,7 +6585,6 @@
 DocType: Employee Grade,Employee Grade,Ishchilar darajasi
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Perework
 DocType: GSTR 3B Report,June,Iyun
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Ta&#39;minotchi&gt; Ta&#39;minotchi turi
 DocType: Share Balance,From No,Yo&#39;q
 DocType: Shift Type,Early Exit Grace Period,Erta chiqish imtiyoz davri
 DocType: Task,Actual Time (in Hours),Haqiqiy vaqt (soati)
@@ -6837,7 +6869,6 @@
 DocType: Warehouse,Warehouse Name,Ombor nomi
 DocType: Naming Series,Select Transaction,Jurnalni tanlang
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,"Iltimos, rozni rozilikni kiriting yoki foydalanuvchini tasdiqlang"
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},UOM konversiyalash koeffitsienti ({0} -&gt; {1}) quyidagi element uchun topilmadi: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,{0} turi va {1} subyekt bilan xizmat ko&#39;rsatish darajasi to&#39;g&#39;risidagi kelishuv allaqachon mavjud.
 DocType: Journal Entry,Write Off Entry,Yozuvni yozing
 DocType: BOM,Rate Of Materials Based On,Materiallar asoslari
@@ -6975,6 +7006,7 @@
 DocType: Budget,Warn,Ogoh bo&#39;ling
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Barcha buyumlar ushbu Ish tartibi uchun allaqachon uzatilgan.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Boshqa yozuvlar, yozuvlardagi diqqat-e&#39;tiborli harakatlar."
+DocType: Bank Account,Company Account,Kompaniya hisobi
 DocType: Asset Maintenance,Manufacturing User,Ishlab chiqarish foydalanuvchisi
 DocType: Purchase Invoice,Raw Materials Supplied,Xom-ashyo etkazib berildi
 DocType: Subscription Plan,Payment Plan,To&#39;lov rejasi
@@ -7016,6 +7048,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) ish tartibi {3} da rejalashtirilgan miqdordan ({2}) ko&#39;p bo&#39;lmasligi kerak.
 DocType: Certification Application,Name of Applicant,Ariza beruvchining nomi
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,Ishlab chiqarish uchun vaqt jadvalini.
+DocType: Quick Stock Balance,Quick Stock Balance,Tez zaxiralar balansi
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Jami summ
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Birja bitimidan so&#39;ng Variant xususiyatlarini o&#39;zgartirib bo&#39;lmaydi. Buning uchun yangi mahsulotni yaratish kerak bo&#39;ladi.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA mandati
@@ -7342,6 +7375,7 @@
 apps/erpnext/erpnext/public/js/queries.js,Please set {0},"Iltimos, {0}"
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} faol emas
 DocType: Employee,Health Details,Sog&#39;liqni saqlash haqida ma&#39;lumot
+DocType: Coupon Code,Coupon Type,Kupon turi
 DocType: Leave Encashment,Encashable days,Ajablanadigan kunlar
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,To&#39;lov talabnomasini yaratish uchun ma&#39;lumotnoma talab qilinadi
 DocType: Soil Texture,Sandy Clay,Sandy Clay
@@ -7624,6 +7658,7 @@
 DocType: Hotel Room Package,Amenities,Xususiyatlar
 DocType: Accounts Settings,Automatically Fetch Payment Terms,To&#39;lov shartlarini avtomatik ravishda yuklab oling
 DocType: QuickBooks Migrator,Undeposited Funds Account,Qaytarilmagan mablag&#39;lar hisoblari
+DocType: Coupon Code,Uses,Foydalanadi
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Ko&#39;p ko&#39;rsatiladigan to&#39;lov shakli yo&#39;l qo&#39;yilmaydi
 DocType: Sales Invoice,Loyalty Points Redemption,Sadoqatli ballarni qaytarish
 ,Appointment Analytics,Uchrashuv tahlillari
@@ -7640,6 +7675,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,Jami byudjet
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Agar talabalar guruhlarini yil davomida qilsangiz, bo&#39;sh qoldiring"
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Belgilangan bo&#39;lsa, Jami no. Ish kunlari davomida bayramlar bo&#39;ladi va bu kunlik ish haqining qiymatini kamaytiradi"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Domenni qo&#39;shib bo&#39;lmadi
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.",Qabul qilish / etkazib berishga ruxsat berish uchun &quot;Sozlamalar&quot; yoki bandidagi &quot;Ortiqcha qabul qilish / etkazib berishga ruxsat&quot; bo&#39;limini yangilang.
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Joriy kalitdan foydalanadigan ilovalar kirish imkoniga ega emas, ishonchingiz komilmi?"
 DocType: Subscription Settings,Prorate,Prorate
@@ -7652,6 +7688,7 @@
 ,BOM Stock Report,BOM birjasi
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Agar belgilangan vaqt vaqti mavjud bo&#39;lmasa, aloqa ushbu guruh tomonidan amalga oshiriladi"
 DocType: Stock Reconciliation Item,Quantity Difference,Miqdor farq
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Ta&#39;minotchi&gt; Ta&#39;minotchi turi
 DocType: Opportunity Item,Basic Rate,Asosiy darajasi
 DocType: GL Entry,Credit Amount,Kredit miqdori
 ,Electronic Invoice Register,Elektron hisob-faktura registri
@@ -7905,6 +7942,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Soliq va majburiy to&#39;lovlar (Kompaniya valyutasi)
 DocType: Item Group,General Settings,Umumiy sozlamalar
 DocType: Article,Article,Maqola
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,"Iltimos, kupon kodini kiriting !!"
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Valyuta va valyutaga nisbatan bir xil bo&#39;lmaydi
 DocType: Taxable Salary Slab,Percent Deduction,Foizni kamaytirish
 DocType: GL Entry,To Rename,Nomini o&#39;zgartirish uchun
diff --git a/erpnext/translations/vi.csv b/erpnext/translations/vi.csv
index 597307e..ccaa0de 100644
--- a/erpnext/translations/vi.csv
+++ b/erpnext/translations/vi.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Liên hệ Khách hàng
 DocType: Shift Type,Enable Auto Attendance,Kích hoạt tự động tham dự
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,Vui lòng nhập kho và ngày
 DocType: Lost Reason Detail,Opportunity Lost Reason,Cơ hội mất lý do
 DocType: Patient Appointment,Check availability,Sẵn sàng kiểm tra
 DocType: Retention Bonus,Bonus Payment Date,Ngày thanh toán thưởng
@@ -265,6 +266,7 @@
 ,Completed Work Orders,Đơn đặt hàng Hoàn thành
 DocType: Support Settings,Forum Posts,Bài đăng trên diễn đàn
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage","Nhiệm vụ này đã được thực hiện như một công việc nền. Trong trường hợp có bất kỳ vấn đề nào về xử lý nền, hệ thống sẽ thêm nhận xét về lỗi trên Bản hòa giải chứng khoán này và hoàn nguyên về giai đoạn Dự thảo"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started","Xin lỗi, tính hợp lệ của mã phiếu giảm giá chưa bắt đầu"
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,Lượng nhập chịu thuế
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},Bạn không được phép thêm hoặc cập nhật bút toán trước ngày {0}
 DocType: Leave Policy,Leave Policy Details,Để lại chi tiết chính sách
@@ -330,6 +332,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,Tiêu hao
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,Cấp
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Mã hàng&gt; Nhóm vật phẩm&gt; Thương hiệu
 DocType: Restaurant Table,No of Seats,Số ghế
 DocType: Sales Invoice,Overdue and Discounted,Quá hạn và giảm giá
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,Cuộc gọi bị ngắt kết nối
@@ -507,6 +510,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,Khoảng cách dòng cho số tiền bằng chữ
 DocType: Vehicle,Additional Details,Chi tiết bổ sung
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,Không có mô tả có sẵn
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,Lấy các mục từ kho
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,Yêu cầu để mua hàng.
 DocType: POS Closing Voucher Details,Collected Amount,Số tiền đã thu
 DocType: Lab Test,Submitted Date,Ngày nộp đơn
@@ -614,6 +618,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,Học
 ,Trial Balance (Simple),Số dư dùng thử (Đơn giản)
 DocType: Purchase Invoice Item,Enable Deferred Expense,Bật chi phí hoãn lại
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,Mã giảm giá áp dụng
 DocType: Asset,Next Depreciation Date,Kỳ hạn khấu hao tiếp theo
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,Chi phí hoạt động cho một nhân viên
 DocType: Accounts Settings,Settings for Accounts,Cài đặt cho tài khoản
@@ -853,8 +858,6 @@
 DocType: Sales Invoice,Total Qty,Tổng số Số lượng
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,ID Email Guardian2
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,ID Email Guardian2
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Vui lòng xóa Nhân viên <a href=""#Form/Employee/{0}"">{0}</a> \ để hủy tài liệu này"
 DocType: Item,Show in Website (Variant),Hiện tại Website (Ngôn ngữ địa phương)
 DocType: Employee,Health Concerns,Mối quan tâm về sức khỏe
 DocType: Payroll Entry,Select Payroll Period,Chọn lương Thời gian
@@ -1020,6 +1023,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,Tài khoản khấu trừ thuế
 DocType: Pricing Rule,Sales Partner,Đại lý bán hàng
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,Tất cả phiếu ghi của Nhà cung cấp.
+DocType: Coupon Code,To be used to get discount,Được sử dụng để được giảm giá
 DocType: Buying Settings,Purchase Receipt Required,Yêu cầu biên lai nhận hàng
 DocType: Sales Invoice,Rail,Đường sắt
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,Gia thật
@@ -1070,6 +1074,7 @@
 DocType: Production Plan,Production Plan,Kế hoạch sản xuất
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Mở Công cụ Tạo Hóa Đơn
 DocType: Salary Component,Round to the Nearest Integer,Làm tròn đến số nguyên gần nhất
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,Cho phép các mặt hàng không có trong kho được thêm vào giỏ hàng
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,Bán hàng trở lại
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Đặt số lượng trong giao dịch dựa trên sê-ri không có đầu vào
 ,Total Stock Summary,Tóm tắt Tổng số
@@ -1201,6 +1206,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),Cơ sở tỷ giá giờ (Công ty ngoại tệ)
 ,Qty To Be Billed,Số lượng được thanh toán
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,Số tiền gửi
+DocType: Coupon Code,Gift Card,Thẻ quà tặng
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,Dành riêng cho sản xuất: Số lượng nguyên liệu để sản xuất các mặt hàng sản xuất.
 DocType: Loyalty Point Entry Redemption,Redemption Date,Ngày cứu chuộc
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,Giao dịch ngân hàng này đã được đối chiếu đầy đủ
@@ -1290,6 +1296,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,Tạo bảng chấm công
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,Tài khoản {0} đã được nhập nhiều lần
 DocType: Account,Expenses Included In Valuation,Chi phí bao gồm trong định giá
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,Hóa đơn mua hàng
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,Bạn chỉ có thể gia hạn nếu hội viên của bạn hết hạn trong vòng 30 ngày
 DocType: Shopping Cart Settings,Show Stock Availability,Hiển thị tình trạng sẵn có
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},Đặt {0} trong danh mục nội dung {1} hoặc công ty {2}
@@ -1833,6 +1840,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,Nhập vật phẩm và UOM
 DocType: Repayment Schedule,Balance Loan Amount,Số dư vay nợ
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,Đã thêm vào chi tiết
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted","Xin lỗi, mã phiếu giảm giá đã hết"
 DocType: Communication Medium,Catch All,Bắt hết
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,lịch học
 DocType: Budget,Applicable on Material Request,Áp dụng cho Yêu cầu Vật liệu
@@ -2003,6 +2011,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,Thuộc tính không hợp lệ
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1} phải được đệ trình
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,Chiến dịch email
+DocType: Sales Partner,To Track inbound purchase,Để theo dõi mua hàng trong nước
 DocType: Buying Settings,Default Supplier Group,Nhóm nhà cung cấp mặc định
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},Số lượng phải nhỏ hơn hoặc bằng {0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},Số tiền tối đa đủ điều kiện cho thành phần {0} vượt quá {1}
@@ -2160,8 +2169,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,Nhập kho
 DocType: Hotel Room Reservation,Hotel Reservation User,Khách đặt phòng khách sạn
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,Đặt trạng thái
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Vui lòng thiết lập chuỗi đánh số cho Tham dự thông qua Cài đặt&gt; Sê-ri đánh số
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,Vui lòng chọn tiền tố đầu tiên
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Vui lòng đặt Sê-ri đặt tên cho {0} qua Cài đặt&gt; Cài đặt&gt; Sê-ri đặt tên
 DocType: Contract,Fulfilment Deadline,Hạn chót thực hiện
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,Gần bạn
 DocType: Student,O-,O-
@@ -2285,6 +2294,7 @@
 DocType: Quality Meeting Table,Under Review,Đang xem xét
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,Đăng nhập thất bại
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,Đã tạo nội dung {0}
+DocType: Coupon Code,Promotional,Khuyến mại
 DocType: Special Test Items,Special Test Items,Các bài kiểm tra đặc biệt
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Bạn cần phải là người dùng có vai trò Quản lý hệ thống và Trình quản lý mặt hàng để đăng ký trên Marketplace.
 apps/erpnext/erpnext/config/buying.py,Key Reports,Báo cáo chính
@@ -2323,6 +2333,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,Loại doc
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,Tổng tỷ lệ phần trăm phân bổ cho đội ngũ bán hàng nên được 100
 DocType: Subscription Plan,Billing Interval Count,Số lượng khoảng thời gian thanh toán
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Vui lòng xóa Nhân viên <a href=""#Form/Employee/{0}"">{0}</a> \ để hủy tài liệu này"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,Các cuộc hẹn và cuộc gặp gỡ bệnh nhân
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,Thiếu giá trị
 DocType: Employee,Department and Grade,Sở và lớp
@@ -2426,6 +2438,7 @@
 DocType: Project,Start and End Dates,Ngày bắt đầu và kết thúc
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Điều khoản tuân thủ mẫu hợp đồng
 ,Delivered Items To Be Billed,Hàng hóa đã được giao sẽ được xuất hóa đơn
+DocType: Coupon Code,Maximum Use,Sử dụng tối đa
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},Mở BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,Không thể đổi kho cho Số seri
 DocType: Authorization Rule,Average Discount,Giảm giá trung bình
@@ -2587,6 +2600,7 @@
 DocType: Item,Inventory,Hàng tồn kho
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,Tải xuống dưới dạng Json
 DocType: Item,Sales Details,Thông tin chi tiết bán hàng
+DocType: Coupon Code,Used,Đã sử dụng
 DocType: Opportunity,With Items,Với mục
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',Chiến dịch &#39;{0}&#39; đã tồn tại cho {1} &#39;{2}&#39;
 DocType: Asset Maintenance,Maintenance Team,Đội bảo trì
@@ -2719,7 +2733,7 @@
 						Serial No cannot be ensured",Không tìm thấy BOM hiện hữu cho mặt hàng {0}. Giao hàng bằng \ Số Serial không thể đảm bảo
 DocType: Sales Partner,Sales Partner Target,Mục tiêu DT của Đại lý
 DocType: Loan Type,Maximum Loan Amount,Số tiền cho vay tối đa
-DocType: Pricing Rule,Pricing Rule,Quy tắc định giá
+DocType: Coupon Code,Pricing Rule,Quy tắc định giá
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Số cuộn trùng nhau cho sinh viên {0}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},Số cuộn trùng nhau cho sinh viên {0}
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,Yêu cầu vật liệu để đặt hóa đơn
@@ -2799,6 +2813,7 @@
 DocType: Payment Schedule,Payment Amount,Số tiền thanh toán
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,Ngày Nửa Ngày phải ở giữa Ngày Làm Việc Từ Ngày và Ngày Kết Thúc Công Việc
 DocType: Healthcare Settings,Healthcare Service Items,Dịch vụ chăm sóc sức khỏe
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,Mã vạch không hợp lệ. Không có mục nào được đính kèm với mã vạch này.
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,Số tiền được tiêu thụ
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,Chênh lệch giá tịnh trong tiền mặt
 DocType: Assessment Plan,Grading Scale,Phân loại
@@ -2920,7 +2935,6 @@
 DocType: Share Transfer,Asset Account,Tài khoản nội dung
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,Ngày phát hành mới sẽ có trong tương lai
 DocType: Purchase Invoice,End date of current invoice's period,Ngày kết thúc của thời kỳ hóa đơn hiện tại của
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Vui lòng thiết lập Hệ thống đặt tên nhân viên trong Nhân sự&gt; Cài đặt nhân sự
 DocType: Lab Test,Technician Name,Tên kỹ thuật viên
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3032,6 +3046,7 @@
 DocType: Products Settings,Hide Variants,Ẩn các biến thể
 DocType: Lead,Next Contact By,Liên hệ tiếp theo bằng
 DocType: Compensatory Leave Request,Compensatory Leave Request,Yêu cầu để lại đền bù
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings","Không thể ghi đè cho Mục {0} trong hàng {1} nhiều hơn {2}. Để cho phép thanh toán vượt mức, vui lòng đặt trợ cấp trong Cài đặt tài khoản"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},Số lượng cần thiết cho mục {0} trong hàng {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},Không xóa được Kho {0} vì vẫn còn {1} tồn kho
 DocType: Blanket Order,Order Type,Loại đặt hàng
@@ -3204,7 +3219,6 @@
 DocType: Student,Student Mobile Number,Số di động Sinh viên
 DocType: Item,Has Variants,Có biến thể
 DocType: Employee Benefit Claim,Claim Benefit For,Yêu cầu quyền lợi cho
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Không thể overbill cho Khoản {0} trong hàng {1} nhiều hơn {2}. Để cho phép thanh toán quá mức, vui lòng đặt trong Cài đặt kho"
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,Cập nhật phản hồi
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},Bạn đã chọn các mục từ {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Tên phân phối hàng tháng
@@ -3498,6 +3512,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,Hãy xác định tiền tệ của Công ty
 DocType: Workstation,Wages per hour,Tiền lương mỗi giờ
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},Định cấu hình {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Khách hàng&gt; Nhóm khách hàng&gt; Lãnh thổ
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Số tồn kho in Batch {0} sẽ bị âm {1} cho khoản mục {2} tại Kho {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,Các yêu cầu về chất liệu dưới đây đã được nâng lên tự động dựa trên mức độ sắp xếp lại danh mục của
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},Tài khoản của {0} là không hợp lệ. Tài khoản ngắn hạn phải là {1}
@@ -3831,6 +3846,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,Trình Lương trượt
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,Đang chờ
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Một đốt phải có ít nhất một lựa chọn đúng
+apps/erpnext/erpnext/hooks.py,Purchase Orders,Đơn đặt hàng
 DocType: Account,Inter Company Account,Tài khoản công ty liên công ty
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,Nhập khẩu với số lượng lớn
 DocType: Sales Partner,Address & Contacts,Địa chỉ & Liên hệ
@@ -3841,6 +3857,7 @@
 DocType: POS Profile,[Select],[Chọn]
 DocType: Staffing Plan Detail,Number Of Positions,Số vị trí
 DocType: Vital Signs,Blood Pressure (diastolic),Huyết áp (tâm trương)
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,Vui lòng chọn khách hàng.
 DocType: SMS Log,Sent To,Gửi Đến
 DocType: Agriculture Task,Holiday Management,Quản lý kỳ nghỉ
 DocType: Payment Request,Make Sales Invoice,Làm Mua hàng
@@ -4051,7 +4068,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1} chưa được đệ trình
 DocType: Subscription,Trialling,Trialling
 DocType: Sales Invoice Item,Deferred Revenue,Doanh thu hoãn lại
-DocType: Bank Account,GL Account,Tài khoản GL
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Tài khoản tiền mặt sẽ được sử dụng để tạo hóa đơn bán hàng
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Danh mục phụ miễn
 DocType: Member,Membership Expiry Date,Ngày hết hạn thành viên
@@ -4458,13 +4474,13 @@
 DocType: C-Form Invoice Detail,Territory,Địa bàn
 DocType: Pricing Rule,Apply Rule On Item Code,Áp dụng quy tắc về mã hàng
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,Xin đề cập không có các yêu cầu thăm
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,Báo cáo số dư cổ phiếu
 DocType: Stock Settings,Default Valuation Method,Phương pháp mặc định Định giá
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,Chi phí
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,Hiển thị số tiền tích luỹ
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,Đang cập nhật. Nó có thể mất một thời gian.
 DocType: Production Plan Item,Produced Qty,Số lượng sản xuất
 DocType: Vehicle Log,Fuel Qty,nhiên liệu Số lượng
-DocType: Stock Entry,Target Warehouse Name,Tên kho mục tiêu
 DocType: Work Order Operation,Planned Start Time,Planned Start Time
 DocType: Course,Assessment,"Thẩm định, lượng định, đánh giá"
 DocType: Payment Entry Reference,Allocated,Phân bổ
@@ -4542,10 +4558,12 @@
  1. Các phương pháp giải quyết tranh chấp, bồi thường, trách nhiệm pháp lý v.v..
  1. Địa chỉ và Liên hệ của Công ty bạn."
 DocType: Homepage Section,Section Based On,Mục Dựa trên
+DocType: Shopping Cart Settings,Show Apply Coupon Code,Hiển thị áp dụng mã phiếu giảm giá
 DocType: Issue,Issue Type,các loại vấn đề
 DocType: Attendance,Leave Type,Loại di dời
 DocType: Purchase Invoice,Supplier Invoice Details,Nhà cung cấp chi tiết hóa đơn
 DocType: Agriculture Task,Ignore holidays,Bỏ qua ngày lễ
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,Thêm / Chỉnh sửa điều kiện phiếu giảm giá
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Chi phí tài khoản / khác biệt ({0}) phải là một ""lợi nhuận hoặc lỗ 'tài khoản"
 DocType: Stock Entry Detail,Stock Entry Child,Nhập cảnh trẻ em
 DocType: Project,Copied From,Sao chép từ
@@ -4721,6 +4739,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Tiêu chuẩn Kế hoạch đánh giá
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,Giao dịch
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Ngăn chặn Đơn đặt hàng
+DocType: Coupon Code,Coupon Name,Tên phiếu giảm giá
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,Nhạy cảm
 DocType: Email Campaign,Scheduled,Dự kiến
 DocType: Shift Type,Working Hours Calculation Based On,Tính toán giờ làm việc dựa trên
@@ -4737,7 +4756,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,Tạo các biến thể
 DocType: Vehicle,Diesel,Dầu diesel
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,Danh sách giá ngoại tệ không được chọn
+DocType: Quick Stock Balance,Available Quantity,Số lượng có sẵn
 DocType: Purchase Invoice,Availed ITC Cess,Có sẵn ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Vui lòng thiết lập Hệ thống đặt tên giảng viên trong giáo dục&gt; Cài đặt giáo dục
 ,Student Monthly Attendance Sheet,Sinh viên tham dự hàng tháng Bảng
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,Quy tắc vận chuyển chỉ áp dụng cho Bán hàng
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Hàng khấu hao {0}: Ngày khấu hao tiếp theo không thể trước ngày mua hàng
@@ -4805,8 +4826,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,Dòng số {0}: Khách hàng tạm ứng phải bên Có
 DocType: Quality Meeting,Quality Meeting,Cuộc họp chất lượng
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,Không nhóm tới Nhóm
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Vui lòng đặt Sê-ri đặt tên cho {0} qua Cài đặt&gt; Cài đặt&gt; Sê-ri đặt tên
 DocType: Employee,ERPNext User,Người dùng ERPNext
+DocType: Coupon Code,Coupon Description,Mô tả phiếu giảm giá
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Hàng loạt là bắt buộc ở hàng {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},Hàng loạt là bắt buộc ở hàng {0}
 DocType: Company,Default Buying Terms,Điều khoản mua mặc định
@@ -4971,6 +4992,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,Đối với tài liệu chi tiết Không
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},Không cho phép xóa quốc gia {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,Kiểu đối tác  bắt buộc
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,Áp dụng mã phiếu thưởng
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry","Đối với thẻ công việc {0}, bạn chỉ có thể thực hiện mục nhập loại chứng khoán &#39;Chuyển giao nguyên liệu cho sản xuất&#39;"
 DocType: Quality Inspection,Outgoing,Đi
 DocType: Customer Feedback Table,Customer Feedback Table,Bảng phản hồi của khách hàng
@@ -5123,7 +5145,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,Khi nộp đơn đặt hàng
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,Thêm Tất cả Nhà cung cấp
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Hàng # {0}: Khoản tiền phân bổ không thể lớn hơn số tiền chưa thanh toán.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Khách hàng&gt; Nhóm khách hàng&gt; Lãnh thổ
 DocType: Tally Migration,Parties,Các bên
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,duyệt BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,Các khoản cho vay được bảo đảm
@@ -5155,7 +5176,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},Không cho phép đặt mục thay thế cho mục {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,Ngày lặp lại
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,Ký Ủy quyền
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Vui lòng thiết lập Hệ thống đặt tên giảng viên trong giáo dục&gt; Cài đặt giáo dục
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),ITC ròng có sẵn (A) - (B)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,Tạo phí
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Tổng Chi phí mua hàng (thông qua danh đơn thu mua)
@@ -5180,6 +5200,7 @@
 DocType: Quiz Result,Wrong,Sai rồi
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,tỷ giá mà báo giá được quy đổi về tỷ giá khách hàng chung
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Số lượng tịnh(tiền tệ công ty)
+DocType: Sales Partner,Referral Code,Mã giới thiệu
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,Tổng số tiền tạm ứng không được lớn hơn tổng số tiền bị xử phạt
 DocType: Salary Slip,Hour Rate,Tỷ lệ giờ
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,Bật tự động đặt hàng lại
@@ -5310,6 +5331,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,Hiển thị số lượng cổ phiếu
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,Tiền thuần từ hoạt động
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},Hàng # {0}: Trạng thái phải là {1} cho Chiết khấu hóa đơn {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Không tìm thấy yếu tố chuyển đổi UOM ({0} -&gt; {1}) cho mục: {2}
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,Khoản 4
 DocType: Student Admission,Admission End Date,Nhập học ngày End
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,Thầu phụ
@@ -5332,6 +5354,7 @@
 DocType: Travel Request,Fully Sponsored,Hoàn toàn được tài trợ
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,Reverse Journal Entry
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,Tạo thẻ công việc
+DocType: Quotation,Referral Sales Partner,Đối tác bán hàng giới thiệu
 DocType: Quality Procedure Process,Process Description,Miêu tả quá trình
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,Đã tạo {0} khách hàng.
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,Hiện tại không có hàng hóa dự trữ nào trong nhà kho
@@ -5466,6 +5489,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,Tỷ giá BOM
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,Đọc tập tin đã tải lên
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Đơn đặt hàng công việc đã ngừng làm việc không thể hủy, hãy dỡ bỏ nó trước để hủy bỏ"
+DocType: Coupon Code,Coupon Code,mã giảm giá
 DocType: Asset,Journal Entry for Scrap,BÚt toán nhật ký cho hàng phế liệu
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,Hãy kéo các mục từ phiếu giao hàng
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},Hàng {0}: chọn máy trạm chống lại hoạt động {1}
@@ -5550,6 +5574,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;Ngày&#39; là bắt buộc
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},Ngày đến hạn /ngày tham chiếu không được sau {0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,dữ liệu nhập và xuất
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired","Xin lỗi, hiệu lực mã phiếu giảm giá đã hết hạn"
 DocType: Bank Account,Account Details,Chi tiết tài khoản
 DocType: Crop,Materials Required,Vật liệu thiết yếu
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,Không có học sinh Tìm thấy
@@ -5587,6 +5612,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,Chuyển đến Người dùng
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,Số tiền thanh toán + Viết Tắt Số tiền không thể lớn hơn Tổng cộng
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0} không phải là một dãy số hợp lệ với vật liệu  {1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,Vui lòng nhập mã phiếu giảm giá hợp lệ !!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},Lưu ý: Không có đủ số dư để lại cho Loại di dời {0}
 DocType: Task,Task Description,Mô tả công việc
 DocType: Training Event,Seminar,Hội thảo
@@ -5854,6 +5880,7 @@
 ,TDS Payable Monthly,TDS phải trả hàng tháng
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,Xếp hàng để thay thế BOM. Có thể mất vài phút.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Không thể khấu trừ khi loại là 'định giá' hoặc 'Định giá và Total'
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Vui lòng thiết lập Hệ thống đặt tên nhân viên trong Nhân sự&gt; Cài đặt nhân sự
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,Tổng chi phí
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},Nối tiếp Nos Yêu cầu cho In nhiều mục {0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,Thanh toán phù hợp với hoá đơn
@@ -5944,6 +5971,7 @@
 DocType: Production Plan,Get Raw Materials For Production,Lấy nguyên liệu thô để sản xuất
 DocType: Job Opening,Job Title,Chức vụ
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,Tham chiếu thanh toán trong tương lai
+DocType: Quotation,Additional Discount and Coupon Code,Mã giảm giá và phiếu giảm giá bổ sung
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} cho biết rằng {1} sẽ không cung cấp báo giá, nhưng tất cả các mục \ đã được trích dẫn. Đang cập nhật trạng thái báo giá RFQ."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Các mẫu tối đa - {0} đã được giữ lại cho Batch {1} và Item {2} trong Batch {3}.
@@ -6173,7 +6201,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,Cài đặt cho trang chủ của trang web
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0} đang bị giữ đến {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},Các yêu cầu RFQ không được phép trong {0} do bảng điểm của điểm số {1}
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,Thực hiện mua hóa đơn
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,Lá đã qua sử dụng
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0} Phiếu giảm giá được sử dụng là {1}. Số lượng cho phép đã cạn kiệt
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,Bạn có muốn gửi yêu cầu tài liệu
 DocType: Job Offer,Awaiting Response,Đang chờ Response
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6187,6 +6217,7 @@
 DocType: Training Event Employee,Optional,Không bắt buộc
 DocType: Salary Slip,Earning & Deduction,Thu nhập và khoản giảm trừ
 DocType: Agriculture Analysis Criteria,Water Analysis,Phân tích nước
+DocType: Sales Order,Skip Delivery Note,Bỏ qua ghi chú giao hàng
 DocType: Price List,Price Not UOM Dependent,Giá không phụ thuộc UOM
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,Đã tạo {0} biến thể.
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,Thỏa thuận cấp độ dịch vụ mặc định đã tồn tại.
@@ -6294,6 +6325,7 @@
 DocType: Vehicle,Last Carbon Check,Kiểm tra Carbon lần cuối
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,Chi phí pháp lý
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,Vui lòng chọn số lượng trên hàng
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},Lệnh công việc {0}: không tìm thấy thẻ công việc cho hoạt động {1}
 DocType: Purchase Invoice,Posting Time,Thời gian gửi bài
 DocType: Timesheet,% Amount Billed,% Số tiền đã ghi hóa đơn
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,Chi phí điện thoại
@@ -6396,7 +6428,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,Thuế và phí bổ sung
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Hàng khấu hao {0}: Ngày khấu hao tiếp theo không được trước ngày có sẵn để sử dụng
 ,Sales Funnel,Kênh bán hàng
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Mã hàng&gt; Nhóm vật phẩm&gt; Thương hiệu
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,Tên viết tắt là bắt buộc
 DocType: Project,Task Progress,Tiến độ công việc
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,Giỏ hàng
@@ -6492,6 +6523,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,POS hồ sơ cần thiết để làm cho POS nhập
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Điểm trung thành sẽ được tính từ chi tiêu đã thực hiện (thông qua Hóa đơn bán hàng), dựa trên yếu tố thu thập được đề cập."
 DocType: Program Enrollment Tool,Enroll Students,Ghi danh học sinh
+DocType: Pricing Rule,Coupon Code Based,Mã Coupon Dựa
 DocType: Company,HRA Settings,Cài đặt HRA
 DocType: Homepage,Hero Section,Phần anh hùng
 DocType: Employee Transfer,Transfer Date,Ngày chuyển giao
@@ -6608,6 +6640,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',Vui lòng đặt Bộ lọc của Công ty trống nếu Nhóm theo là &#39;Công ty&#39;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,Viết bài ngày không thể ngày trong tương lai
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},Hàng # {0}: Số sê ri{1} không phù hợp với {2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Vui lòng thiết lập chuỗi đánh số cho Tham dự thông qua Cài đặt&gt; Sê-ri đánh số
 DocType: Stock Entry,Target Warehouse Address,Địa chỉ Kho Mục tiêu
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,Nghỉ phép năm
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,Thời gian trước khi bắt đầu ca làm việc trong đó Đăng ký nhân viên được xem xét để tham dự.
@@ -6642,7 +6675,6 @@
 DocType: Employee Grade,Employee Grade,Nhân viên hạng
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,Việc làm ăn khoán
 DocType: GSTR 3B Report,June,Tháng 6
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Nhà cung cấp&gt; Loại nhà cung cấp
 DocType: Share Balance,From No,Từ Không
 DocType: Shift Type,Early Exit Grace Period,Thời gian xuất cảnh sớm
 DocType: Task,Actual Time (in Hours),Thời gian thực tế (tính bằng giờ)
@@ -6929,7 +6961,6 @@
 DocType: Warehouse,Warehouse Name,Tên kho
 DocType: Naming Series,Select Transaction,Chọn giao dịch
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,Vui lòng nhập Phê duyệt hoặc phê duyệt Vai trò tài
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Không tìm thấy yếu tố chuyển đổi UOM ({0} -&gt; {1}) cho mục: {2}
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,Thỏa thuận cấp độ dịch vụ với Loại thực thể {0} và Thực thể {1} đã tồn tại.
 DocType: Journal Entry,Write Off Entry,Viết Tắt bút toán
 DocType: BOM,Rate Of Materials Based On,Tỷ giá vật liệu dựa trên
@@ -7068,6 +7099,7 @@
 DocType: Budget,Warn,Cảnh báo
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,Tất cả các mục đã được chuyển giao cho Lệnh hoạt động này.
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Bất kỳ nhận xét khác, nỗ lực đáng chú ý mà nên đi vào biên bản."
+DocType: Bank Account,Company Account,Tài khoản công ty
 DocType: Asset Maintenance,Manufacturing User,Người dùng sản xuất
 DocType: Purchase Invoice,Raw Materials Supplied,Nguyên liệu thô đã được cung cấp
 DocType: Subscription Plan,Payment Plan,Kế hoạch chi tiêu
@@ -7109,6 +7141,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) không được lớn hơn số lượng đã lên kế hoạch ({2}) trong Yêu cầu công tác {3}
 DocType: Certification Application,Name of Applicant,Tên của người nộp đơn
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,thời gian biểu cho sản xuất.
+DocType: Quick Stock Balance,Quick Stock Balance,Cân bằng chứng khoán nhanh
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,Subtotal
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Không thể thay đổi các thuộc tính Biến thể sau giao dịch chứng khoán. Bạn sẽ phải tạo một Item mới để làm điều này.
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,Giấy phép SEPA do GoCard
@@ -7437,6 +7470,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} là sinh viên không hoạt động
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0} - {1} là sinh viên không hoạt động
 DocType: Employee,Health Details,Thông tin chi tiết về sức khỏe
+DocType: Coupon Code,Coupon Type,Loại phiếu giảm giá
 DocType: Leave Encashment,Encashable days,Ngày có thể sửa chữa
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Để tạo tài liệu tham chiếu yêu cầu thanh toán là bắt buộc
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,Để tạo tài liệu tham chiếu yêu cầu thanh toán là bắt buộc
@@ -7726,6 +7760,7 @@
 DocType: Hotel Room Package,Amenities,Tiện nghi
 DocType: Accounts Settings,Automatically Fetch Payment Terms,Tự động tìm nạp Điều khoản thanh toán
 DocType: QuickBooks Migrator,Undeposited Funds Account,Tài khoản tiền chưa ký gửi
+DocType: Coupon Code,Uses,Công dụng
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,Không cho phép nhiều chế độ mặc định
 DocType: Sales Invoice,Loyalty Points Redemption,Đổi điểm điểm thưởng
 ,Appointment Analytics,Analytics bổ nhiệm
@@ -7743,6 +7778,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Để trống nếu bạn thực hiện nhóm sinh viên mỗi năm
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Để trống nếu bạn thực hiện nhóm sinh viên mỗi năm
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Nếu được kiểm tra, Tổng số. của ngày làm việc sẽ bao gồm các ngày lễ, và điều này sẽ làm giảm giá trị của Lương trung bình mỗi ngày"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,Không thể thêm tên miền
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.","Để cho phép nhận / giao hàng quá mức, hãy cập nhật &quot;Quá mức nhận / cho phép giao hàng&quot; trong Cài đặt chứng khoán hoặc Mục."
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?","Ứng dụng sử dụng khóa hiện tại sẽ không thể truy cập, bạn có chắc không?"
 DocType: Subscription Settings,Prorate,Prorate
@@ -7756,6 +7792,7 @@
 ,BOM Stock Report,Báo cáo hàng tồn kho BOM
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group","Nếu không có thời gian được chỉ định, thì liên lạc sẽ được xử lý bởi nhóm này"
 DocType: Stock Reconciliation Item,Quantity Difference,SỰ khác biệt về số lượng
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Nhà cung cấp&gt; Loại nhà cung cấp
 DocType: Opportunity Item,Basic Rate,Tỷ giá cơ bản
 DocType: GL Entry,Credit Amount,Số nợ
 ,Electronic Invoice Register,Đăng ký hóa đơn điện tử
@@ -8010,6 +8047,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Thuế và Phí được khấu trừ (Theo tiền tệ Cty)
 DocType: Item Group,General Settings,Thiết lập chung
 DocType: Article,Article,Bài báo
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,Vui lòng nhập mã phiếu giảm giá !!
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,Từ tiền tệ và ngoại tệ để không thể giống nhau
 DocType: Taxable Salary Slab,Percent Deduction,Phần trăm khấu trừ
 DocType: GL Entry,To Rename,Đổi tên
diff --git a/erpnext/translations/zh.csv b/erpnext/translations/zh.csv
index 50aae04..93c5e2d 100644
--- a/erpnext/translations/zh.csv
+++ b/erpnext/translations/zh.csv
@@ -46,6 +46,7 @@
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,客户联系
 DocType: Shift Type,Enable Auto Attendance,启用自动出勤
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,请输入仓库和日期
 DocType: Lost Reason Detail,Opportunity Lost Reason,机会失去理智
 DocType: Patient Appointment,Check availability,检查可用性
 DocType: Retention Bonus,Bonus Payment Date,奖金支付日期
@@ -264,6 +265,7 @@
 ,Completed Work Orders,完成的工单
 DocType: Support Settings,Forum Posts,论坛帖子
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage",该任务已被列入后台工作。如果在后台处理有任何问题，系统将在此库存对帐中添加有关错误的注释并恢复到草稿阶段
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started",抱歉，优惠券代码有效期尚未开始
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,应税金额
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},你没有权限在{0}前添加或更改分录。
 DocType: Leave Policy,Leave Policy Details,休假政策信息
@@ -329,6 +331,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,耗材
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,职级
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,物料代码&gt;物料组&gt;品牌
 DocType: Restaurant Table,No of Seats,座位数
 DocType: Sales Invoice,Overdue and Discounted,逾期和折扣
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,呼叫已断开连接
@@ -506,6 +509,7 @@
 DocType: Cheque Print Template,Line spacing for amount in words,行距文字量
 DocType: Vehicle,Additional Details,额外细节
 apps/erpnext/erpnext/templates/generators/bom.html,No description given,未提供描述
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,从仓库中获取物品
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,请求您的报价。
 DocType: POS Closing Voucher Details,Collected Amount,收集金额
 DocType: Lab Test,Submitted Date,提交日期
@@ -613,6 +617,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,学习
 ,Trial Balance (Simple),试算结余（简单）
 DocType: Purchase Invoice Item,Enable Deferred Expense,启用延期费用
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,应用的优惠券代码
 DocType: Asset,Next Depreciation Date,接下来折旧日期
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,每个员工活动费用
 DocType: Accounts Settings,Settings for Accounts,科目设置
@@ -853,8 +858,6 @@
 DocType: Sales Invoice,Total Qty,总数量
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2电子邮件ID
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2电子邮件ID
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","请删除员工<a href=""#Form/Employee/{0}"">{0}</a> \以取消此文档"
 DocType: Item,Show in Website (Variant),在网站上展示（变体）
 DocType: Employee,Health Concerns,健康问题
 DocType: Payroll Entry,Select Payroll Period,选择工资名单的时间段
@@ -1020,6 +1023,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,代扣税款科目
 DocType: Pricing Rule,Sales Partner,销售合作伙伴
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,所有供应商记分卡。
+DocType: Coupon Code,To be used to get discount,用于获得折扣
 DocType: Buying Settings,Purchase Receipt Required,需要采购收据
 DocType: Sales Invoice,Rail,轨
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,实际成本
@@ -1070,6 +1074,7 @@
 DocType: Production Plan,Production Plan,生产计划
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,费用清单创建工具
 DocType: Salary Component,Round to the Nearest Integer,舍入到最近的整数
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,允许将无库存的商品添加到购物车
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,销售退货
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,根据序列号输入设置交易数量
 ,Total Stock Summary,总库存总结
@@ -1200,6 +1205,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),基数小时率（公司货币）
 ,Qty To Be Billed,计费数量
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,已交付金额
+DocType: Coupon Code,Gift Card,礼物卡
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,生产保留数量：生产制造项目的原材料数量。
 DocType: Loyalty Point Entry Redemption,Redemption Date,赎回日期
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,此银行交易已完全已对帐
@@ -1289,6 +1295,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,创建时间表
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,科目{0}已多次输入
 DocType: Account,Expenses Included In Valuation,计入库存评估价的费用科目
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,购买发票
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,如果您的会员资格在30天内到期，您只能续订
 DocType: Shopping Cart Settings,Show Stock Availability,显示库存可用性
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},在资产类别{1}或公司{2}中设置{0}
@@ -1842,6 +1849,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,导入项目和UOM
 DocType: Repayment Schedule,Balance Loan Amount,贷款额余额
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,添加到细节
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted",对不起，优惠券代码已用尽
 DocType: Communication Medium,Catch All,抓住一切
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,课程工时单
 DocType: Budget,Applicable on Material Request,适用于物料申请
@@ -2012,6 +2020,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,无效属性
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1}必须提交
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,电邮广告系列
+DocType: Sales Partner,To Track inbound purchase,跟踪入站购买
 DocType: Buying Settings,Default Supplier Group,默认供应商组
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},量必须小于或等于{0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},符合组件{0}的最高金额超过{1}
@@ -2169,8 +2178,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,进入股票
 DocType: Hotel Room Reservation,Hotel Reservation User,酒店预订用户
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,设置状态
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,请通过“设置”&gt;“编号序列”为出勤设置编号序列
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,请先选择前缀
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,请通过设置&gt;设置&gt;命名系列为{0}设置命名系列
 DocType: Contract,Fulfilment Deadline,履行截止日期
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,在你旁边
 DocType: Student,O-,O-
@@ -2294,6 +2303,7 @@
 DocType: Quality Meeting Table,Under Review,正在审查中
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,登录失败
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,资产{0}已创建
+DocType: Coupon Code,Promotional,促销性
 DocType: Special Test Items,Special Test Items,特殊测试项目
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,您需要是具有System Manager和Item Manager角色的用户才能在Marketplace上注册。
 apps/erpnext/erpnext/config/buying.py,Key Reports,主要报告
@@ -2332,6 +2342,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,文档类型
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,对于销售团队总分配比例应为100
 DocType: Subscription Plan,Billing Interval Count,计费间隔计数
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","请删除员工<a href=""#Form/Employee/{0}"">{0}</a> \以取消此文档"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,预约和患者遭遇
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,栏位值缺失
 DocType: Employee,Department and Grade,部门和职级
@@ -2435,6 +2447,7 @@
 DocType: Project,Start and End Dates,开始和结束日期
 DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,合同模板履行条款
 ,Delivered Items To Be Billed,待开费用清单已出货物料
+DocType: Coupon Code,Maximum Use,最大使用量
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},开放物料清单 {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,仓库不能因为序列号变更
 DocType: Authorization Rule,Average Discount,平均折扣
@@ -2596,6 +2609,7 @@
 DocType: Item,Inventory,库存
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,下载为Json
 DocType: Item,Sales Details,销售信息
+DocType: Coupon Code,Used,用过的
 DocType: Opportunity,With Items,物料
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',{1}&#39;{2}&#39;广告系列“{0}”已存在
 DocType: Asset Maintenance,Maintenance Team,维修队
@@ -2725,7 +2739,7 @@
 						Serial No cannot be ensured",未找到项{0}的有效BOM。无法确保交货\串口号
 DocType: Sales Partner,Sales Partner Target,销售合作伙伴目标
 DocType: Loan Type,Maximum Loan Amount,最高贷款额度
-DocType: Pricing Rule,Pricing Rule,定价规则
+DocType: Coupon Code,Pricing Rule,定价规则
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},学生{0}的重复卷号
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},学生{0}的重复卷号
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,给采购订单的材料申请
@@ -2805,6 +2819,7 @@
 DocType: Payment Schedule,Payment Amount,付款金额
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,半天日期应在工作日期和工作结束日期之间
 DocType: Healthcare Settings,Healthcare Service Items,医疗服务项目
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,无效的条形码。该条形码没有附件。
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,消耗量
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,现金净变动
 DocType: Assessment Plan,Grading Scale,分级量表
@@ -2926,7 +2941,6 @@
 DocType: Share Transfer,Asset Account,资产科目
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,新的发布日期应该是将来的
 DocType: Purchase Invoice,End date of current invoice's period,当前费用清单周期的结束日期
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,请在人力资源&gt;人力资源设置中设置员工命名系统
 DocType: Lab Test,Technician Name,技术员姓名
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -3038,6 +3052,7 @@
 DocType: Products Settings,Hide Variants,隐藏变体
 DocType: Lead,Next Contact By,下次联络人
 DocType: Compensatory Leave Request,Compensatory Leave Request,补休（假）申请
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings",第{1}行中的项目{0}的出价不能超过{2}。要允许超额计费，请在“帐户设置”中设置配额
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},行{1}中的物料{0}必须指定数量
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},仓库{0}无法删除，因为产品{1}有库存量
 DocType: Blanket Order,Order Type,订单类型
@@ -3208,7 +3223,6 @@
 DocType: Student,Student Mobile Number,学生手机号码
 DocType: Item,Has Variants,有变体
 DocType: Employee Benefit Claim,Claim Benefit For,福利类型（薪资构成）
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings",{1}行中的项目{0}不能超过{2}。要允许超额结算，请在库存设置中进行设置
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,更新响应
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},您已经选择从项目{0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,月度分布名称
@@ -3502,6 +3516,7 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,请公司指定的货币
 DocType: Workstation,Wages per hour,时薪
 apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},配置{0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,客户&gt;客户组&gt;地区
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},批次{0}中，仓库{3}中物料{2}的库存余额将变为{1}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,以下物料需求数量已自动根据重订货水平相应增加了
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},科目{0}状态为非激活。科目货币必须是{1}
@@ -3835,6 +3850,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,提交工资单
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,暂缓处理
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Qustion必须至少有一个正确的选项
+apps/erpnext/erpnext/hooks.py,Purchase Orders,订单
 DocType: Account,Inter Company Account,关联公司间交易科目
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,进口散装
 DocType: Sales Partner,Address & Contacts,地址及联系方式
@@ -3845,6 +3861,7 @@
 DocType: POS Profile,[Select],[选择]
 DocType: Staffing Plan Detail,Number Of Positions,人数
 DocType: Vital Signs,Blood Pressure (diastolic),血压（舒张）
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,请选择客户。
 DocType: SMS Log,Sent To,发给
 DocType: Agriculture Task,Holiday Management,度假管理
 DocType: Payment Request,Make Sales Invoice,创建销售费用清单
@@ -4053,7 +4070,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1}未提交
 DocType: Subscription,Trialling,试用
 DocType: Sales Invoice Item,Deferred Revenue,递延收入
-DocType: Bank Account,GL Account,GL帐户
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,现金科目将用于创建销售费用清单
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,豁免子类别
 DocType: Member,Membership Expiry Date,会员到期日
@@ -4472,13 +4488,13 @@
 DocType: C-Form Invoice Detail,Territory,区域
 DocType: Pricing Rule,Apply Rule On Item Code,在物品代码上应用规则
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,请注明无需访问
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,库存余额报告
 DocType: Stock Settings,Default Valuation Method,默认估值方法
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,费用
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,显示累计金额
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,正在更新。请稍等。
 DocType: Production Plan Item,Produced Qty,生产数量
 DocType: Vehicle Log,Fuel Qty,燃油数量
-DocType: Stock Entry,Target Warehouse Name,目标仓库名称
 DocType: Work Order Operation,Planned Start Time,计划开始时间
 DocType: Course,Assessment,评估
 DocType: Payment Entry Reference,Allocated,已分配
@@ -4544,10 +4560,12 @@
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.",可以添加至销售或采购的标准条款和条件。例如：1. 报价有效期。 2.付款条件(预付款，赊购，部分预付款)。3.其他，例如安全/使用警告，退货政策，配送条款，争议/赔偿/责任仲裁方式，贵公司的地址和联系方式。
 DocType: Homepage Section,Section Based On,基于的部分
+DocType: Shopping Cart Settings,Show Apply Coupon Code,显示申请优惠券代码
 DocType: Issue,Issue Type,发行类型
 DocType: Attendance,Leave Type,休假类型
 DocType: Purchase Invoice,Supplier Invoice Details,供应商费用清单信息
 DocType: Agriculture Task,Ignore holidays,忽略假期
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,添加/编辑优惠券条件
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,费用/差异科目({0})必须是一个“益损”类科目
 DocType: Stock Entry Detail,Stock Entry Child,股票入境儿童
 DocType: Project,Copied From,复制自
@@ -4723,6 +4741,7 @@
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,评估计划标准
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,交易
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,防止采购订单
+DocType: Coupon Code,Coupon Name,优惠券名称
 apps/erpnext/erpnext/healthcare/setup.py,Susceptible,易感
 DocType: Email Campaign,Scheduled,已计划
 DocType: Shift Type,Working Hours Calculation Based On,基于的工时计算
@@ -4739,7 +4758,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,创建变体
 DocType: Vehicle,Diesel,柴油机
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,价格清单货币没有选择
+DocType: Quick Stock Balance,Available Quantity,可用数量
 DocType: Purchase Invoice,Availed ITC Cess,有效的ITC 地方税
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,请在“教育”&gt;“教育设置”中设置教师命名系统
 ,Student Monthly Attendance Sheet,学生每月考勤表
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,运费规则仅适用于销售
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,折旧行{0}：下一个折旧日期不能在采购日期之前
@@ -4807,8 +4828,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,行{0}：预收客户款项须记在贷方
 DocType: Quality Meeting,Quality Meeting,质量会议
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,非群组转为群组
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,请通过设置&gt;设置&gt;命名系列为{0}设置命名系列
 DocType: Employee,ERPNext User,ERPNext用户
+DocType: Coupon Code,Coupon Description,优惠券说明
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},在{0}行中必须使用批次号
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},在{0}行中必须使用批处理
 DocType: Company,Default Buying Terms,默认购买条款
@@ -4973,6 +4994,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,针对的对文档信息编号
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},国家{0}不允许删除
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,请输入往来单位类型
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,申请优惠券代码
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",对于作业卡{0}，您只能进行“制造材料转移”类型库存条目
 DocType: Quality Inspection,Outgoing,出货检验
 DocType: Customer Feedback Table,Customer Feedback Table,客户反馈表
@@ -5123,7 +5145,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,提交采购订单时
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,添加所有供应商
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,行＃{0}：已分配金额不能大于未付金额。
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,客户&gt;客户组&gt;地区
 DocType: Tally Migration,Parties,派对
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,浏览BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,抵押贷款
@@ -5155,7 +5176,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},不允许为项目{0}设置替代项目
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,日期重复
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,授权签字人
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,请在“教育”&gt;“教育设置”中设置教师命名系统
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),净ITC可用（A） - （B）
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,创造费用
 DocType: Project,Total Purchase Cost (via Purchase Invoice),总采购成本（通过采购费用清单）
@@ -5180,6 +5200,7 @@
 DocType: Quiz Result,Wrong,错误
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,价格清单货币转换成客户的本币后的单价
 DocType: Purchase Invoice Item,Net Amount (Company Currency),净金额（公司货币）
+DocType: Sales Partner,Referral Code,推荐码
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,总预付金额不得超过总核准金额
 DocType: Salary Slip,Hour Rate,时薪
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,启用自动重新排序
@@ -5310,6 +5331,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,显示库存数量
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,从运营产生的净现金
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},行＃{0}：发票贴现的状态必须为{1} {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},找不到项目{2}的UOM转换因子（{0}-&gt; {1}）
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,物料4
 DocType: Student Admission,Admission End Date,准入结束日期
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,分包
@@ -5332,6 +5354,7 @@
 DocType: Travel Request,Fully Sponsored,完全赞助
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,反向手工凭证
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,创建工作卡
+DocType: Quotation,Referral Sales Partner,推荐销售合作伙伴
 DocType: Quality Procedure Process,Process Description,进度解析
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,客户{0}已创建。
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,目前没有任何仓库可用的库存
@@ -5466,6 +5489,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,物料清单税率
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,阅读上传的文件
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel",停止的工单不能取消，先取消停止
+DocType: Coupon Code,Coupon Code,优惠券代码
 DocType: Asset,Journal Entry for Scrap,手工凭证报废
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,请从销售出货单获取物料
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},行{0}：根据操作{1}选择工作站
@@ -5550,6 +5574,7 @@
 apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;日期&#39;是必需的
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},到期/参照日期不能迟于{0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,数据导入和导出
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired",抱歉，优惠券代码有效期已过
 DocType: Bank Account,Account Details,科目信息
 DocType: Crop,Materials Required,所需材料
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,没有发现学生
@@ -5587,6 +5612,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,转到用户
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,已支付的金额+销帐金额不能大于总金额
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0}不是物料{1}的有效批次号
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,请输入有效的优惠券代码！
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},注意：休假期类型{0}的剩余天数不够
 DocType: Task,Task Description,任务描述
 DocType: Training Event,Seminar,研讨会
@@ -5854,6 +5880,7 @@
 ,TDS Payable Monthly,TDS应付月度
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,排队等待更换BOM。可能需要几分钟时间。
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',分类是“估值”或“估值和总计”的时候不能扣税。
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,请在人力资源&gt;人力资源设置中设置员工命名系统
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,总付款
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},序列化的物料{0}必须指定序列号
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,匹配付款与发票
@@ -5944,6 +5971,7 @@
 DocType: Production Plan,Get Raw Materials For Production,获取生产用原材料
 DocType: Job Opening,Job Title,职位
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,未来付款参考
+DocType: Quotation,Additional Discount and Coupon Code,附加折扣和优惠券代码
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.",{0}表示{1}不会提供报价，但所有项目都已被引用。更新询价状态。
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,批次{1}和批次{3}中的项目{2}已保留最大样本数量{0}。
@@ -6173,7 +6201,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,对网站的主页设置
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0}暂缓处理，直到{1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},由于{1}的记分卡，{0}不允许使用RFQ
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,创建购买发票
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,已休假(天数)
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0}使用的优惠券是{1}。允许数量已耗尽
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,您要提交材料申请吗？
 DocType: Job Offer,Awaiting Response,正在等待回应
 DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
@@ -6187,6 +6217,7 @@
 DocType: Training Event Employee,Optional,可选的
 DocType: Salary Slip,Earning & Deduction,收入及扣除
 DocType: Agriculture Analysis Criteria,Water Analysis,水分析
+DocType: Sales Order,Skip Delivery Note,跳过交货单
 DocType: Price List,Price Not UOM Dependent,价格不是UOM依赖
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,{0}变量已创建
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,已存在默认服务级别协议。
@@ -6294,6 +6325,7 @@
 DocType: Vehicle,Last Carbon Check,最后炭检查
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,法律费用
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,请选择行数量
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},工作单{0}：找不到工序{1}的工作卡
 DocType: Purchase Invoice,Posting Time,记帐时间
 DocType: Timesheet,% Amount Billed,（％）金额帐单
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,电话费
@@ -6396,7 +6428,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,已添加的税费
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,折旧行{0}：下一个折旧日期不能在可供使用的日期之前
 ,Sales Funnel,销售漏斗
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,物料代码&gt;物料组&gt;品牌
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,缩写字段必填
 DocType: Project,Task Progress,任务进度
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,购物车
@@ -6492,6 +6523,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,请创建POS配置记录
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",忠诚度积分将根据所花费的完成量（通过销售费用清单）计算得出。
 DocType: Program Enrollment Tool,Enroll Students,招生
+DocType: Pricing Rule,Coupon Code Based,基于优惠券代码
 DocType: Company,HRA Settings,HRA设置
 DocType: Homepage,Hero Section,英雄科
 DocType: Employee Transfer,Transfer Date,转移日期
@@ -6608,6 +6640,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',如果按什么分组是“Company”，请设置公司过滤器空白
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,记帐日期不能是未来的日期
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},行＃{0}：序列号{1}不相匹配{2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,请通过“设置”&gt;“编号序列”为出勤设置编号序列
 DocType: Stock Entry,Target Warehouse Address,目标仓库地址
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,事假
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,在考虑员工入住的班次开始时间之前的时间。
@@ -6642,7 +6675,6 @@
 DocType: Employee Grade,Employee Grade,员工职级
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,计件工作
 DocType: GSTR 3B Report,June,六月
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,供应商&gt;供应商类型
 DocType: Share Balance,From No,来自No
 DocType: Shift Type,Early Exit Grace Period,提前退出宽限期
 DocType: Task,Actual Time (in Hours),实际时间（小时）
@@ -6929,7 +6961,6 @@
 DocType: Warehouse,Warehouse Name,仓库名称
 DocType: Naming Series,Select Transaction,选择交易
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,请输入角色核准或审批用户
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},找不到项目{2}的UOM转换因子（{0}-&gt; {1}）
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,与实体类型{0}和实体{1}的服务水平协议已存在。
 DocType: Journal Entry,Write Off Entry,销帐分录
 DocType: BOM,Rate Of Materials Based On,基于以下的物料单价
@@ -7068,6 +7099,7 @@
 DocType: Budget,Warn,警告
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,所有物料已发料到该工单。
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.",任何其他注释，值得一提的努力，应该记录下来。
+DocType: Bank Account,Company Account,公司帐号
 DocType: Asset Maintenance,Manufacturing User,生产用户
 DocType: Purchase Invoice,Raw Materials Supplied,已提供的原材料
 DocType: Subscription Plan,Payment Plan,付款计划
@@ -7109,6 +7141,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0}（{1}）不能大于工单{3}中的计划数量（{2}）
 DocType: Certification Application,Name of Applicant,申请人名称
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,制造方面的时间表。
+DocType: Quick Stock Balance,Quick Stock Balance,快速库存平衡
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,小计
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,存货业务发生后不能更改变体物料的属性。需要新建新物料。
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA授权
@@ -7437,6 +7470,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0}  -  {1}是非活动学生
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0}  -  {1}是非活跃学生
 DocType: Employee,Health Details,健康信息
+DocType: Coupon Code,Coupon Type,优惠券类型
 DocType: Leave Encashment,Encashable days,可折现天数
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,必须生成一个付款申请参考文档
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,必须生成一个付款申请参考文档
@@ -7726,6 +7760,7 @@
 DocType: Hotel Room Package,Amenities,设施
 DocType: Accounts Settings,Automatically Fetch Payment Terms,自动获取付款条款
 DocType: QuickBooks Migrator,Undeposited Funds Account,未存入资金账户
+DocType: Coupon Code,Uses,用途
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,不允许多种默认付款方式
 DocType: Sales Invoice,Loyalty Points Redemption,忠诚积分兑换
 ,Appointment Analytics,约定分析
@@ -7743,6 +7778,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,如果您每年制作学生团体，请留空
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,如果您每年创建学生团体，请留空
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day",如果勾选，工作日总数将包含假期，“日工资”值会相应降低。
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,添加域失败
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.",要允许超过收货/交货，请在库存设置或项目中更新“超过收货/交货限额”。
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?",使用当前密钥的应用程序将无法访问，您确定吗？
 DocType: Subscription Settings,Prorate,按比例分配
@@ -7756,6 +7792,7 @@
 ,BOM Stock Report,物料清单库存报表
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group",如果没有分配的时间段，则该组将处理通信
 DocType: Stock Reconciliation Item,Quantity Difference,数量差异
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,供应商&gt;供应商类型
 DocType: Opportunity Item,Basic Rate,标准售价
 DocType: GL Entry,Credit Amount,信贷金额
 ,Electronic Invoice Register,电子发票登记
@@ -8010,6 +8047,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),已扣除税费（公司货币）
 DocType: Item Group,General Settings,常规设置
 DocType: Article,Article,文章
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,请输入优惠券代码！
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,源货币和目标货币不能相同
 DocType: Taxable Salary Slab,Percent Deduction,税率（%）
 DocType: GL Entry,To Rename,要重命名
diff --git a/erpnext/translations/zh_tw.csv b/erpnext/translations/zh_tw.csv
index 2551d55..7fb0b22 100644
--- a/erpnext/translations/zh_tw.csv
+++ b/erpnext/translations/zh_tw.csv
@@ -40,6 +40,7 @@
 DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,*將被計算在該交易。
 DocType: Purchase Order,Customer Contact,客戶聯絡
 DocType: Shift Type,Enable Auto Attendance,啟用自動出勤
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Please enter Warehouse and Date,請輸入倉庫和日期
 DocType: Lost Reason Detail,Opportunity Lost Reason,機會失去理智
 DocType: Patient Appointment,Check availability,檢查可用性
 DocType: Retention Bonus,Bonus Payment Date,獎金支付日期
@@ -233,6 +234,7 @@
 ,Completed Work Orders,完成的工作訂單
 DocType: Support Settings,Forum Posts,論壇帖子
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage",該任務已被列入後台工作。如果在後台處理有任何問題，系統將在此庫存對帳中添加有關錯誤的註釋，並恢復到草稿階段
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has not started",抱歉，優惠券代碼有效期尚未開始
 apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,應稅金額
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},你無權添加或更新{0}之前的條目
 DocType: Leave Policy,Leave Policy Details,退出政策詳情
@@ -291,6 +293,7 @@
 apps/erpnext/erpnext/selling/report/customer_wise_item_price/customer_wise_item_price.py,Available Stock,可用庫存
 DocType: Asset Settings,Asset Settings,資產設置
 DocType: Assessment Result,Grade,年級
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,物料代碼&gt;物料組&gt;品牌
 DocType: Restaurant Table,No of Seats,座位數
 apps/erpnext/erpnext/public/js/call_popup/call_popup.js,Call Disconnected,呼叫已斷開連接
 DocType: Sales Invoice Item,Delivered By Supplier,交付供應商
@@ -456,6 +459,7 @@
 DocType: POS Customer Group,POS Customer Group,POS客戶群
 DocType: Healthcare Practitioner,Practitioner Schedules,從業者時間表
 DocType: Vehicle,Additional Details,額外細節
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js,Fetch Items from Warehouse,從倉庫中獲取物品
 apps/erpnext/erpnext/config/buying.py,Request for purchase.,請求您的報價。
 DocType: POS Closing Voucher Details,Collected Amount,收集金額
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Company field is required,公司字段是必填項
@@ -552,6 +556,7 @@
 apps/erpnext/erpnext/config/desktop.py,Learn,學習
 ,Trial Balance (Simple),試算平衡（簡單）
 DocType: Purchase Invoice Item,Enable Deferred Expense,啟用延期費用
+apps/erpnext/erpnext/templates/includes/order/order_taxes.html,Applied Coupon Code,應用的優惠券代碼
 DocType: Asset,Next Depreciation Date,接下來折舊日期
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,每個員工活動費用
 DocType: Accounts Settings,Settings for Accounts,設置帳戶
@@ -774,8 +779,6 @@
 DocType: Sales Invoice,Total Qty,總數量
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2電子郵件ID
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2電子郵件ID
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","請刪除員工<a href=""#Form/Employee/{0}"">{0}</a> \以取消此文檔"
 DocType: Item,Show in Website (Variant),展網站（變體）
 DocType: Employee,Health Concerns,健康問題
 DocType: Payroll Entry,Select Payroll Period,選擇工資期
@@ -924,6 +927,7 @@
 DocType: Tax Withholding Account,Tax Withholding Account,扣繳稅款賬戶
 DocType: Pricing Rule,Sales Partner,銷售合作夥伴
 apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,所有供應商記分卡。
+DocType: Coupon Code,To be used to get discount,用於獲得折扣
 DocType: Buying Settings,Purchase Receipt Required,需要採購入庫單
 DocType: Sales Invoice,Rail,軌
 apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,實際成本
@@ -971,6 +975,7 @@
 DocType: Production Plan,Production Plan,生產計劃
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,打開發票創建工具
 DocType: Salary Component,Round to the Nearest Integer,舍入到最近的整數
+DocType: Shopping Cart Settings,Allow items not in stock to be added to cart,允許將無庫存的商品添加到購物車
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,銷貨退回
 DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,根據序列號輸入設置交易數量
 ,Total Stock Summary,總庫存總結
@@ -1085,6 +1090,7 @@
 DocType: BOM Operation,Base Hour Rate(Company Currency),基數小時率（公司貨幣）
 ,Qty To Be Billed,計費數量
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,交付金額
+DocType: Coupon Code,Gift Card,禮物卡
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,生產保留數量：生產製造項目的原材料數量。
 DocType: Loyalty Point Entry Redemption,Redemption Date,贖回日期
 apps/erpnext/erpnext/accounts/page/bank_reconciliation/bank_reconciliation.py,This bank transaction is already fully reconciled,此銀行交易已完全已對帳
@@ -1168,6 +1174,7 @@
 apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,創建時間表
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,帳戶{0}已多次輸入
 DocType: Account,Expenses Included In Valuation,支出計入估值
+apps/erpnext/erpnext/hooks.py,Purchase Invoices,購買發票
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,如果您的會員資格在30天內到期，您只能續訂
 DocType: Shopping Cart Settings,Show Stock Availability,顯示股票可用性
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},在資產類別{1}或公司{2}中設置{0}
@@ -1684,6 +1691,7 @@
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,導入項目和UOM
 DocType: Repayment Schedule,Balance Loan Amount,平衡貸款額
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,添加到細節
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code are exhausted",對不起，優惠券代碼已用盡
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,課程時間表
 DocType: Budget,Applicable on Material Request,適用於材料請求
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Stock Options,股票期權
@@ -1840,6 +1848,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,無效屬性
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,{0} {1}必須提交
 apps/erpnext/erpnext/selling/doctype/campaign/campaign_dashboard.py,Email Campaigns,電郵廣告系列
+DocType: Sales Partner,To Track inbound purchase,跟踪入站購買
 DocType: Buying Settings,Default Supplier Group,默認供應商組
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},量必須小於或等於{0}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},符合組件{0}的最高金額超過{1}
@@ -1987,8 +1996,8 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,進入股票
 DocType: Hotel Room Reservation,Hotel Reservation User,酒店預訂用戶
 apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,設置狀態
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,請通過“設置”&gt;“編號序列”為出勤設置編號序列
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,請先選擇前綴稱號
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,請通過設置&gt;設置&gt;命名系列為{0}設置命名系列
 apps/erpnext/erpnext/public/js/hub/pages/Home.vue,Near you,在你旁邊
 DocType: Subscription Settings,Subscription Settings,訂閱設置
 DocType: Purchase Invoice,Update Auto Repeat Reference,更新自動重複參考
@@ -2095,6 +2104,7 @@
 DocType: Quality Meeting Table,Under Review,正在審查中
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,登錄失敗
 apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,資產{0}已創建
+DocType: Coupon Code,Promotional,促銷性
 DocType: Special Test Items,Special Test Items,特殊測試項目
 apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,您需要是具有System Manager和Item Manager角色的用戶才能在Marketplace上註冊。
 apps/erpnext/erpnext/config/buying.py,Key Reports,主要報告
@@ -2130,6 +2140,8 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,文件類型
 apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,對於銷售團隊總分配比例應為100
 DocType: Subscription Plan,Billing Interval Count,計費間隔計數
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","請刪除員工<a href=""#Form/Employee/{0}"">{0}</a> \以取消此文檔"
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,預約和患者遭遇
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,價值缺失
 DocType: Employee,Department and Grade,部門和年級
@@ -2371,6 +2383,7 @@
 DocType: Item,Inventory,庫存
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,下載為Json
 DocType: Item,Sales Details,銷售詳細資訊
+DocType: Coupon Code,Used,用過的
 DocType: Opportunity,With Items,隨著項目
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,The Campaign '{0}' already exists for the {1} '{2}',{1}&#39;{2}&#39;廣告系列“{0}”已存在
 DocType: Asset Maintenance,Maintenance Team,維修隊
@@ -2488,7 +2501,7 @@
 						Serial No cannot be ensured",未找到項{0}的有效BOM。無法確保交貨\串口號
 DocType: Sales Partner,Sales Partner Target,銷售合作夥伴目標
 DocType: Loan Type,Maximum Loan Amount,最高貸款額度
-DocType: Pricing Rule,Pricing Rule,定價規則
+DocType: Coupon Code,Pricing Rule,定價規則
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},學生{0}的重複卷號
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},學生{0}的重複卷號
 apps/erpnext/erpnext/config/help.py,Material Request to Purchase Order,材料要求採購訂單
@@ -2559,6 +2572,7 @@
 DocType: Payment Schedule,Payment Amount,付款金額
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,半天日期應在工作日期和工作結束日期之間
 DocType: Healthcare Settings,Healthcare Service Items,醫療服務項目
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.py,Invalid Barcode. There is no Item attached to this barcode.,無效的條形碼。該條形碼沒有附件。
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,現金淨變動
 DocType: Assessment Plan,Grading Scale,分級量表
 apps/erpnext/erpnext/stock/doctype/item/item.py,Unit of Measure {0} has been entered more than once in Conversion Factor Table,計量單位{0}已經進入不止一次在轉換係數表
@@ -2666,7 +2680,6 @@
 DocType: Share Transfer,Asset Account,資產賬戶
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,New release date should be in the future,新的發布日期應該是將來的
 DocType: Purchase Invoice,End date of current invoice's period,當前發票的期限的最後一天
-apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,請在人力資源&gt;人力資源設置中設置員工命名系統
 DocType: Lab Test,Technician Name,技術員姓名
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
@@ -2771,6 +2784,7 @@
 DocType: Products Settings,Hide Variants,隱藏變體
 DocType: Lead,Next Contact By,下一個聯絡人由
 DocType: Compensatory Leave Request,Compensatory Leave Request,補償請假
+apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set allowance in Accounts Settings",第{1}行中的項目{0}的出價不能超過{2}。要允許超額計費，請在“帳戶設置”中設置配額
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},列{1}項目{0}必須有數量
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},倉庫{0} 不能被刪除因為項目{1}還有庫存
 DocType: Blanket Order,Order Type,訂單類型
@@ -2928,7 +2942,6 @@
 DocType: Student,Student Mobile Number,學生手機號碼
 DocType: Item,Has Variants,有變種
 DocType: Employee Benefit Claim,Claim Benefit For,索賠利益
-apps/erpnext/erpnext/controllers/accounts_controller.py,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings",{1}行中的項目{0}不能超過{2}。要允許超額結算，請在庫存設置中進行設置
 apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,更新響應
 apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},您已經選擇從項目{0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,每月分配的名稱
@@ -3198,6 +3211,7 @@
 DocType: Vehicle,Fuel Type,燃料類型
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,請公司指定的貨幣
 DocType: Workstation,Wages per hour,時薪
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,客戶&gt;客戶組&gt;地區
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},在批量庫存餘額{0}將成為負{1}的在倉庫項目{2} {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,下列資料的要求已自動根據項目的重新排序水平的提高
 apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},帳戶{0}是無效的。帳戶貨幣必須是{1}
@@ -3503,6 +3517,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,提交工資單
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,等候接聽
 apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Qustion必須至少有一個正確的選項
+apps/erpnext/erpnext/hooks.py,Purchase Orders,訂單
 DocType: Account,Inter Company Account,Inter公司帳戶
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,進口散裝
 DocType: Sales Partner,Address & Contacts,地址及聯絡方式
@@ -3513,6 +3528,7 @@
 DocType: POS Profile,[Select],[選擇]
 DocType: Staffing Plan Detail,Number Of Positions,職位數
 DocType: Vital Signs,Blood Pressure (diastolic),血壓（舒張）
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.py,Please select the customer.,請選擇客戶。
 DocType: SMS Log,Sent To,發給
 DocType: Payment Request,Make Sales Invoice,做銷售發票
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Softwares,軟件
@@ -3700,7 +3716,6 @@
 DocType: Item Price,Packing Unit,包裝單位
 DocType: Subscription,Trialling,試用
 DocType: Sales Invoice Item,Deferred Revenue,遞延收入
-DocType: Bank Account,GL Account,GL帳戶
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,現金帳戶將用於創建銷售發票
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,豁免子類別
 DocType: Member,Membership Expiry Date,會員到期日
@@ -4092,13 +4107,13 @@
 DocType: C-Form Invoice Detail,Territory,領土
 DocType: Pricing Rule,Apply Rule On Item Code,在物品代碼上應用規則
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,請註明無需訪問
+apps/erpnext/erpnext/stock/doctype/quick_stock_balance/quick_stock_balance.js,Stock Balance Report,庫存餘額報告
 DocType: Stock Settings,Default Valuation Method,預設的估值方法
 apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,費用
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,顯示累計金額
 apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,正在更新。它可能需要一段時間。
 DocType: Production Plan Item,Produced Qty,生產數量
 DocType: Vehicle Log,Fuel Qty,燃油數量
-DocType: Stock Entry,Target Warehouse Name,目標倉庫名稱
 DocType: Work Order Operation,Planned Start Time,計劃開始時間
 DocType: Course,Assessment,評定
 DocType: Payment Entry Reference,Allocated,分配
@@ -4172,9 +4187,11 @@
  1。的解決糾紛，賠償，法律責任等
  1的方式。地址和公司聯繫。"
 DocType: Homepage Section,Section Based On,基於的部分
+DocType: Shopping Cart Settings,Show Apply Coupon Code,顯示申請優惠券代碼
 DocType: Issue,Issue Type,發行類型
 DocType: Attendance,Leave Type,休假類型
 DocType: Purchase Invoice,Supplier Invoice Details,供應商發票明細
+apps/erpnext/erpnext/accounts/doctype/coupon_code/coupon_code.js,Add/Edit Coupon Conditions,添加/編輯優惠券條件
 apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,費用/差異帳戶（{0}）必須是一個'溢利或虧損的帳戶
 DocType: Stock Entry Detail,Stock Entry Child,股票入境兒童
 DocType: Project,Copied From,複製自
@@ -4337,6 +4354,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Colour,顏色
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,評估計劃標準
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,防止採購訂單
+DocType: Coupon Code,Coupon Name,優惠券名稱
 DocType: Email Campaign,Scheduled,預定
 DocType: Shift Type,Working Hours Calculation Based On,基於的工時計算
 apps/erpnext/erpnext/config/buying.py,Request for quotation.,詢價。
@@ -4352,7 +4370,9 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,創建變體
 DocType: Vehicle,Diesel,柴油機
 apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,尚未選擇價格表之貨幣
+DocType: Quick Stock Balance,Available Quantity,可用數量
 DocType: Purchase Invoice,Availed ITC Cess,採用ITC Cess
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,請在“教育”&gt;“教育設置”中設置教師命名系統
 ,Student Monthly Attendance Sheet,學生每月考勤表
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,運費規則僅適用於銷售
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,折舊行{0}：下一個折舊日期不能在購買日期之前
@@ -4417,8 +4437,8 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,行{0}：提前對客戶必須是信用
 DocType: Quality Meeting,Quality Meeting,質量會議
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,非集團集團
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,請通過設置&gt;設置&gt;命名系列為{0}設置命名系列
 DocType: Employee,ERPNext User,ERPNext用戶
+DocType: Coupon Code,Coupon Description,優惠券說明
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},在{0}行中必須使用批處理
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},在{0}行中必須使用批處理
 DocType: Company,Default Buying Terms,默認購買條款
@@ -4569,6 +4589,7 @@
 DocType: Maintenance Visit Purpose,Against Document Detail No,對文件詳細編號
 apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},國家{0}不允許刪除
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,黨的類型是強制性
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Apply Coupon Code,申請優惠券代碼
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",對於作業卡{0}，您只能進行“製造材料轉移”類型庫存條目
 DocType: Quality Inspection,Outgoing,發送
 DocType: Customer Feedback Table,Customer Feedback Table,客戶反饋表
@@ -4710,7 +4731,6 @@
 apps/erpnext/erpnext/setup/default_energy_point_rules.py,On Purchase Order Submission,提交採購訂單時
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,添加所有供應商
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,行＃{0}：分配金額不能大於未結算金額。
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,客戶&gt;客戶組&gt;地區
 DocType: Tally Migration,Parties,派對
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,瀏覽BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,抵押貸款
@@ -4741,7 +4761,6 @@
 apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},不允許為項目{0}設置替代項目
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,日期重複
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,授權簽字人
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,請在“教育”&gt;“教育設置”中設置教師命名系統
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),淨ITC可用（A） - （B）
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,創造費用
 DocType: Project,Total Purchase Cost (via Purchase Invoice),總購買成本（通過採購發票）
@@ -4765,6 +4784,7 @@
 DocType: Quiz Result,Wrong,錯誤
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,價目表貨幣被換算成客戶基礎貨幣的匯率
 DocType: Purchase Invoice Item,Net Amount (Company Currency),淨金額（公司貨幣）
+DocType: Sales Partner,Referral Code,推薦碼
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,總預付金額不得超過全部認可金額
 DocType: Salary Slip,Hour Rate,小時率
 apps/erpnext/erpnext/stock/doctype/item/item.py,Enable Auto Re-Order,啟用自動重新排序
@@ -4889,6 +4909,7 @@
 DocType: Shopping Cart Settings,Show Stock Quantity,顯示庫存數量
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,從運營的淨現金
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},行＃{0}：發票貼現的狀態必須為{1} {2}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},找不到項目{2}的UOM轉換因子（{0}-&gt; {1}）
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,項目4
 DocType: Student Admission,Admission End Date,錄取結束日期
 DocType: Journal Entry Account,Journal Entry Account,日記帳分錄帳號
@@ -4910,6 +4931,7 @@
 DocType: Travel Request,Fully Sponsored,完全贊助
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,反向日記帳分錄
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,創建工作卡
+DocType: Quotation,Referral Sales Partner,推薦銷售合作夥伴
 DocType: Quality Procedure Process,Process Description,進度解析
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,客戶{0}已創建。
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,目前任何倉庫沒有庫存
@@ -5028,6 +5050,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM率
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,閱讀上傳的文件
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel",停止的工作訂單不能取消，先取消它
+DocType: Coupon Code,Coupon Code,優惠券代碼
 DocType: Asset,Journal Entry for Scrap,日記帳分錄報廢
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,請送貨單拉項目
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},行{0}：根據操作{1}選擇工作站
@@ -5108,6 +5131,7 @@
 DocType: Woocommerce Settings,API consumer key,API消費者密鑰
 apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},由於/參考日期不能後{0}
 apps/erpnext/erpnext/config/settings.py,Data Import and Export,資料輸入和輸出
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Sorry,coupon code validity has expired",抱歉，優惠券代碼有效期已過
 DocType: Bank Account,Account Details,帳戶細節
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,沒有發現學生
 DocType: Clinical Procedure,Medical Department,醫學系
@@ -5142,6 +5166,7 @@
 apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,轉到用戶
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,支付的金額+寫的抵銷金額不能大於總計
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0}不是對項目的有效批號{1}
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter valid coupon code !!,請輸入有效的優惠券代碼！
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},注：沒有足夠的休假餘額請假類型{0}
 DocType: Task,Task Description,任務描述
 DocType: Training Event,Seminar,研討會
@@ -5391,6 +5416,7 @@
 ,TDS Payable Monthly,TDS應付月度
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,排隊等待更換BOM。可能需要幾分鐘時間。
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',不能抵扣當類別為“估值”或“估值及總'
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,請在人力資源&gt;人力資源設置中設置員工命名系統
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,總付款
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},序列號為必填項序列為{0}
 apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,付款與發票對照
@@ -5471,6 +5497,7 @@
 DocType: Production Plan,Get Raw Materials For Production,獲取生產原料
 DocType: Job Opening,Job Title,職位
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Future Payment Ref,未來付款參考
+DocType: Quotation,Additional Discount and Coupon Code,附加折扣和優惠券代碼
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.",{0}表示{1}不會提供報價，但所有項目都已被引用。更新詢價狀態。
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,批次{1}和批次{3}中的項目{2}已保留最大樣本數量{0}。
@@ -5683,7 +5710,9 @@
 apps/erpnext/erpnext/config/website.py,Settings for website homepage,對網站的主頁設置
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0}一直保持到{1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},由於{1}的記分卡，{0}不允許使用RFQ
+apps/erpnext/erpnext/templates/pages/order.html,Make Purchase Invoice,做出購買發票
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,使用的葉子
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,{0} Coupon used are {1}. Allowed quantity is exhausted,{0}使用的優惠券是{1}。允許量已耗盡
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,您要提交材料申請嗎？
 DocType: Job Offer,Awaiting Response,正在等待回應
 DocType: Support Search Source,Link Options,鏈接選項
@@ -5693,6 +5722,7 @@
 apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py,Please select the assessment group other than 'All Assessment Groups',請選擇“所有評估組”以外的評估組
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Row {0}: Cost center is required for an item {1},行{0}：項目{1}需要費用中心
 DocType: Training Event Employee,Optional,可選的
+DocType: Sales Order,Skip Delivery Note,跳過交貨單
 DocType: Price List,Price Not UOM Dependent,價格不是UOM依賴
 apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,創建了{0}個變體。
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,已存在默認服務級別協議。
@@ -5791,6 +5821,7 @@
 DocType: Vehicle,Last Carbon Check,最後檢查炭
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,法律費用
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,請選擇行數量
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0}: job card not found for the operation {1},工作單{0}：找不到工序{1}的工作卡
 DocType: Purchase Invoice,Posting Time,登錄時間
 DocType: Timesheet,% Amount Billed,（％）金額已開立帳單
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,電話費
@@ -5883,7 +5914,6 @@
 DocType: Purchase Invoice,Taxes and Charges Added,稅費上架
 apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,折舊行{0}：下一個折舊日期不能在可供使用的日期之前
 ,Sales Funnel,銷售漏斗
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,物料代碼&gt;物料組&gt;品牌
 apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,縮寫是強制性的
 DocType: Project,Task Progress,任務進度
 apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,車
@@ -5971,6 +6001,7 @@
 apps/erpnext/erpnext/public/js/account_tree_grid.js,Select Fiscal Year...,選擇會計年度...
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,所需的POS資料，使POS進入
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",忠誠度積分將根據所花費的完成量（通過銷售發票）計算得出。
+DocType: Pricing Rule,Coupon Code Based,基於優惠券代碼
 DocType: Company,HRA Settings,HRA設置
 DocType: Employee Transfer,Transfer Date,轉移日期
 apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py,Standard Selling,標準銷售
@@ -6079,6 +6110,7 @@
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',如果Group By是“Company”，請設置公司過濾器空白
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,發布日期不能是未來的日期
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},行＃{0}：序列號{1}不相匹配{2} {3}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,請通過“設置”&gt;“編號序列”為出勤設置編號序列
 DocType: Stock Entry,Target Warehouse Address,目標倉庫地址
 DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,在考慮員工入住的班次開始時間之前的時間。
 DocType: Agriculture Task,End Day,結束的一天
@@ -6107,7 +6139,6 @@
 DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",對於基於課程的學生小組，課程將從入學課程中的每個學生確認。
 DocType: Employee Grade,Employee Grade,員工等級
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,計件工作
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,供應商&gt;供應商類型
 DocType: Share Balance,From No,來自No
 DocType: Shift Type,Early Exit Grace Period,提前退出寬限期
 DocType: Task,Actual Time (in Hours),實際時間（小時）
@@ -6371,7 +6402,6 @@
 DocType: Warehouse,Warehouse Name,倉庫名稱
 DocType: Naming Series,Select Transaction,選擇交易
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,請輸入核准角色或審批用戶
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},找不到項目{2}的UOM轉換因子（{0}-&gt; {1}）
 apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,與實體類型{0}和實體{1}的服務水平協議已存在。
 DocType: Journal Entry,Write Off Entry,核銷進入
 DocType: BOM,Rate Of Materials Based On,材料成本基於
@@ -6499,6 +6529,7 @@
 apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge with Existing Account,與現有帳戶合併
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,所有項目已經為此工作單轉移。
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.",任何其他言論，值得一提的努力，應該在記錄中。
+DocType: Bank Account,Company Account,公司帳號
 DocType: Asset Maintenance,Manufacturing User,製造業用戶
 DocType: Purchase Invoice,Raw Materials Supplied,提供供應商原物料
 DocType: Subscription Plan,Payment Plan,付款計劃
@@ -6534,6 +6565,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0}（{1}）不能大於計畫數量 {3} 在工作訂單中（{2}）
 DocType: Certification Application,Name of Applicant,申請人名稱
 apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,時間表製造。
+DocType: Quick Stock Balance,Quick Stock Balance,快速庫存平衡
 apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,小計
 apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,股票交易後不能更改Variant屬性。你將不得不做一個新的項目來做到這一點。
 apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA授權
@@ -6840,6 +6872,7 @@
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0}  -  {1}是非活動學生
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0}  -  {1}是非活動學生
 DocType: Employee,Health Details,健康細節
+DocType: Coupon Code,Coupon Type,優惠券類型
 DocType: Leave Encashment,Encashable days,可以忍受的日子
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,要創建付款請求參考文檔是必需的
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,要創建付款請求參考文檔是必需的
@@ -7118,6 +7151,7 @@
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,如果您每年製作學生團體，請留空
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,如果您每年製作學生團體，請留空
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day",如果選中，則總數。工作日將包括節假日，這將縮短每天的工資的價值
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to add Domain,添加域失敗
 apps/erpnext/erpnext/controllers/status_updater.py,"To allow over receipt / delivery, update ""Over Receipt/Delivery Allowance"" in Stock Settings or the Item.",要允許超過收貨/交貨，請在庫存設置或項目中更新“超過收貨/交貨限額”。
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?",使用當前密鑰的應用程序將無法訪問，您確定嗎？
 DocType: Purchase Invoice,Total Advance,預付款總計
@@ -7130,6 +7164,7 @@
 ,BOM Stock Report,BOM庫存報告
 DocType: Communication Medium,"If there is no assigned timeslot, then communication will be handled by this group",如果沒有分配的時間段，則該組將處理通信
 DocType: Stock Reconciliation Item,Quantity Difference,數量差異
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,供應商&gt;供應商類型
 DocType: Opportunity Item,Basic Rate,基礎匯率
 DocType: GL Entry,Credit Amount,信貸金額
 ,Electronic Invoice Register,電子發票登記
@@ -7359,6 +7394,7 @@
 DocType: Academic Term,Term End Date,期限結束日期
 DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),稅收和扣除（公司貨幣）
 DocType: Item Group,General Settings,一般設定
+apps/erpnext/erpnext/shopping_cart/cart.py,Please enter coupon code !!,請輸入優惠券代碼！
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,原始貨幣和目標貨幣不能相同
 DocType: Taxable Salary Slab,Percent Deduction,扣除百分比
 DocType: Stock Entry,Repack,重新包裝
