diff --git a/docs/dev/custom_script_examples/docs.dev.custom_script.calculate.md b/docs/dev/custom_script_examples/docs.dev.custom_script.calculate.md
deleted file mode 100644
index 6744e2b..0000000
--- a/docs/dev/custom_script_examples/docs.dev.custom_script.calculate.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-{
-	"_label": "Calculate Incentive for Sales Team"
-}
----
-Can be used in any Sales Transaction with **Sales Team** Table:
-
-
-	cur_frm.cscript.custom_validate = function(doc) {
-	    // calculate incentives for each person on the deal
-	    total_incentive = 0
-	    $.each(wn.model.get("Sales Team", {parent:doc.name}), function(i, d) {
-
-	        // calculate incentive
-	        var incentive_percent = 2;
-	        if(doc.grand_total > 400) incentive_percent = 4;
-
-	        // actual incentive
-	        d.incentives = flt(doc.grand_total) * incentive_percent / 100;
-	        total_incentive += flt(d.incentives)
-	    });
-
-	    doc.total_incentive = total_incentive;
-	}
\ No newline at end of file
diff --git a/docs/dev/custom_script_examples/docs.dev.custom_script.fetch.md b/docs/dev/custom_script_examples/docs.dev.custom_script.fetch.md
deleted file mode 100644
index d0414fb..0000000
--- a/docs/dev/custom_script_examples/docs.dev.custom_script.fetch.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-{
-	"_label": "Custom Script: Fetch Values from Master"
-}
----
-To pull a value of a link on selection, use the `add_fetch` method.
-
-	add_fetch(link_fieldname, source_fieldname, target_fieldname)
-
-### Example
-
-You create Custom Field **VAT ID** (`vat_id`) in **Customer** and **Sales Invoice** and want to make sure this value gets updated every time you select a Customer in a Sales Invoice.
-
-Then in the Sales Invoice Custom Script, add this line:
-
-	cur_frm.add_fetch('customer','vat_id','vat_id')
-	
-
----
-See: [How to create a custom script](!docs.dev.custom_script.html)	
\ No newline at end of file
diff --git a/docs/dev/custom_script_examples/docs.dev.custom_script.item_code.md b/docs/dev/custom_script_examples/docs.dev.custom_script.item_code.md
deleted file mode 100644
index 22e75c9..0000000
--- a/docs/dev/custom_script_examples/docs.dev.custom_script.item_code.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-{
-	"_label": "Generate Item Code based on Custom Logic"
-}
----
-Add this in the Custom Script of **Item**, so that the new Item Code is generated just before the a new Item is saved.
-
-	cur_frm.cscript.custom_validate = function(doc) {
-	    // clear item_code (name is from item_code)
-	    doc.item_code = "";
-
-	    // first 2 characters based on item_group
-	    switch(doc.item_group) {
-	        case "Test A":
-	            doc.item_code = "TA";
-	            break;
-	        case "Test B":
-	            doc.item_code = "TB";
-	            break;
-	        default:
-	            doc.item_code = "XX";
-	    }
-
-	    // add next 2 characters based on brand
-	    switch(doc.brand) {
-	        case "Brand A":
-	            doc.item_code += "BA";
-	            break;
-	        case "Brand B":
-	            doc.item_code += "BB";
-	            break;
-	        default:
-	            doc.item_code += "BX";
-	    }
-	}
\ No newline at end of file
diff --git a/docs/dev/custom_script_examples/docs.dev.custom_script.read_only.md b/docs/dev/custom_script_examples/docs.dev.custom_script.read_only.md
deleted file mode 100644
index 9da3e85..0000000
--- a/docs/dev/custom_script_examples/docs.dev.custom_script.read_only.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-{
-	"_label": "Make an Item read-only after Saving"
-}
----
-Use the method `cur_frm.set_df_property` to update the field's display.
-
-In this script we also use the `__islocal` property of the doc to check if the document has been saved atleast once or is never saved. If `__islocal` is `1`, then the document has never been saved.
-
-	cur_frm.cscript.custom_refresh = function(doc) {
-	    // use the __islocal value of doc, to check if the doc is saved or not
-	    cur_frm.set_df_property("myfield", "read_only", doc.__islocal ? 0 : 1);
-	}
\ No newline at end of file
diff --git a/docs/dev/custom_script_examples/docs.dev.custom_script.validate.md b/docs/dev/custom_script_examples/docs.dev.custom_script.validate.md
deleted file mode 100644
index a22851c..0000000
--- a/docs/dev/custom_script_examples/docs.dev.custom_script.validate.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-{
-	"_label": "Date Validation: Do not allow past dates in a date field"
-}
----
-
-	cur_frm.cscript.custom_validate = function(doc) {
-	    if (doc.from_date < get_today()) {
-	        msgprint("You can not select past date in From Date");
-	        validated = false;
-	    }
-	}
\ No newline at end of file
diff --git a/docs/dev/custom_script_examples/docs.dev.custom_script.validate1.md b/docs/dev/custom_script_examples/docs.dev.custom_script.validate1.md
deleted file mode 100644
index b12c61f..0000000
--- a/docs/dev/custom_script_examples/docs.dev.custom_script.validate1.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-{
-	"_label": "Restrict Purpose of Stock Entry"
-}
----
-
-	cur_frm.cscript.custom_validate = function(doc) {
-	    if(user=="user1@example.com" && doc.purpose!="Material Receipt") {
-	        msgprint("You are only allowed Material Receipt");
-	        validated = false;
-	    }
-	}
\ No newline at end of file
diff --git a/docs/dev/custom_script_examples/docs.dev.custom_script.validate2.md b/docs/dev/custom_script_examples/docs.dev.custom_script.validate2.md
deleted file mode 100644
index 05d662e..0000000
--- a/docs/dev/custom_script_examples/docs.dev.custom_script.validate2.md
+++ /dev/null
@@ -1,22 +0,0 @@
----
-{
-	"_label": "Restrict User Based on Child Record (Warehouse)"
-}
----
-
-	// restrict certain warehouse to Material Manager 
-	cur_frm.cscript.custom_validate = function(doc) {
-	    if(user_roles.indexOf("Material Manager")==-1) {
-
-	        var restricted_in_source = wn.model.get("Stock Entry Detail", 
-	            {parent:cur_frm.doc.name, s_warehouse:"Restricted"});
-
-	        var restricted_in_target = wn.model.get("Stock Entry Detail", 
-	            {parent:cur_frm.doc.name, t_warehouse:"Restricted"})
-
-	        if(restricted_in_source.length || restricted_in_target.length) {
-	            msgprint("Only Material Manager can make entry in Restricted Warehouse");
-	            validated = false;
-	        }
-	    }
-	}
\ No newline at end of file
diff --git a/docs/dev/custom_script_examples/docs.dev.custom_script.validate3.md b/docs/dev/custom_script_examples/docs.dev.custom_script.validate3.md
deleted file mode 100644
index 629f1c1..0000000
--- a/docs/dev/custom_script_examples/docs.dev.custom_script.validate3.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-{
-	"_label": "Restrict Cancel Rights based on Certain Order Value"
-}
----
-Add a handler to `custom_before_cancel` event:
-
-	cur_frm.cscript.custom_before_cancel = function(doc) {
-	    if (user_roles.indexOf("Accounts User")!=-1 && user_roles.indexOf("Accounts Manager")==-1
-	            && user_roles.indexOf("System Manager")==-1) {
-	        if (flt(doc.grand_total) > 10000) {
-	            msgprint("You can not cancel this transaction, because grand total \
-	                is greater than 10000");
-	            validated = false;
-	        }
-	    }
-	}
diff --git a/docs/dev/docs.dev.api.md b/docs/dev/docs.dev.api.md
deleted file mode 100644
index 0f694b5..0000000
--- a/docs/dev/docs.dev.api.md
+++ /dev/null
@@ -1,177 +0,0 @@
----
-{
-	"_label": "Web Service API"
-}
----
-All communication with the ERPNext server happens via web services using HTTP requests and passing data via JSON (Javascript Object Notation). Using web requests you can insert, update, query, run public triggers etc. The basic scheme is as follows:
-
-1. All API calls are to me made to `server.py` on your public folder of your erpnext account. For hosted users, it is (yourdomain.erpnext.com).
-1. The `cmd` parameter points to the python function to be executed.
-1. Authentication is managed using cookies.
-
-### Authentication
-
-Authentication is done via the login method:
-
-	GET server.py?cmd=login&usr=[username]&password=[password]
-
-The login method returns a session id `sid` cookie in the header and a status in the
-body of the request. The `sid` cookie must be sent for each subsequent request.
-	
-Example:
-
-	$ curl -I http://localhost/webnotes/erpnext/public/server.py?cmd=login\&usr=Administrator\&pwd=admin
-	HTTP/1.1 200 OK
-	Date: Tue, 23 Jul 2013 05:29:24 GMT
-	Server: Apache/2.2.22 (Unix) DAV/2 mod_ssl/2.2.22 OpenSSL/0.9.8r
-	Set-Cookie: country=None
-	Set-Cookie: sid=d0ce00d49c24869984960607a2467b50ff59b0024741922db4b23818; expires=Fri, 26 Jul 2013 10:59:25
-	Content-Length: 32
-	Content-Type: text/html; charset: utf-8
-		
-	{"message":"Logged In","exc":""}
-	
-	$ curl http://localhost/webnotes/erpnext/public/server.py?cmd=webnotes.client.get\&doctype=Profile\&name=Administrator -b sid=d0ce00d49c24869984960607a2467b50ff59b0024741922db4b23818
-	
-	{
-		"message":[
-			{
-				"user_image":null,
-				"last_name":"User",
-				"last_ip":"::1",
-				..
-				..
-### Python Remote Client
-
-You can use the `webclient.py` module as an example of how to access data using the webservice API
-
-- [Code](https://github.com/webnotes/wnframework/blob/master/webnotes/utils/webclient.py)
-- [Docs](http://erpnext.org/docs.dev.framework.server.webnotes.utils.webclient.html)
-
-### Passing and Receiving Documents (`doclist`)
-
-To insert or update documents in ERPNext you have to pass them as a JSON Object. The structure of a Document is a list of plain objects (called `doclist`). The `doclist`
-contains the the parent document and any child documents (if they are present).
-
-Example:
-
-	[{
-		"doctype": "Parent"
-		"key1": "value1"
-		..
-	},{
-		"doctype": "Child",
-		"parenttype": "Parent",
-		"parentfield": "children",
-		"key1", "value1",
-		..
-	}]
-
-### webnotes.client
-
-`webnotes.client` is the easiest way to interact with the ERPNext Server. It contains
-a bunch of server-side public methods that can be used by any client.
-
-- [Code](https://github.com/webnotes/wnframework/blob/master/webnotes/client.py)
-- [Docs](http://erpnext.org/docs.dev.framework.server.webnotes.client.html)
-
-### Example
-
-Here is an example how you can use the webclient module to insert a new Sales Invoice
-in ERPNext.
-
-	from webclient import *
- 
-	server = "http://myaccount.erpnext.com/server.py"
-	user = "your user name"
-	password = "your password"
- 
-	login()
- 
-	customer = get_doc("Customer", customer_name)
- 
-	# make customer if required
-	if not customer:
-	  	response = insert([{
-			"doctype":"Customer",
-			"customer_name": customer_name,
-			"customer_type": "Company",
-			"customer_group": "Standard Group",
-			"territory": "Default",
-			"customer_details": "some unique info",
-			"company": "Alpha"
-		}])
-    
-	# make invoice
-	resonse = insert([
-	  	# main
-	 	{
-	  		"naming_series": "_T-Sales Invoice-",
-			"company": "_Test Company", 
-			"conversion_rate": 1.0, 
-			"currency": "INR", 
-			"debit_to": "_Test Customer - _TC",
-			"customer": "_Test Customer",
-			"customer_name": "_Test Customer",
-			"doctype": "Sales Invoice", 
-			"due_date": "2013-01-23", 
-			"fiscal_year": "_Test Fiscal Year 2013", 
-			"grand_total": 561.8, 
-			"grand_total_export": 561.8, 
-			"net_total": 500.0, 
-			"plc_conversion_rate": 1.0, 
-			"posting_date": "2013-01-23", 
-			"price_list_currency": "INR", 
-			"selling_price_list": "_Test Price List", 
-			"territory": "_Test Territory"
-		},
- 
-		# items 
-		{
-			"amount": 500.0, 
-			"basic_rate": 500.0, 
-			"description": "138-CMS Shoe", 
-			"doctype": "Sales Invoice Item", 
-			"export_amount": 500.0, 
-			"export_rate": 500.0, 
-			"income_account": "Sales - _TC",
-			"cost_center": "_Test Cost Center - _TC",
-			"item_name": "138-CMS Shoe", 
-			"parentfield": "entries",
-			"qty": 1.0
-		}, 
- 
-		# taxes
-		{
-			"account_head": "_Test Account VAT - _TC", 
-			"charge_type": "On Net Total", 
-			"description": "VAT", 
-			"doctype": "Sales Taxes and Charges", 
-			"parentfield": "other_charges",
-			"tax_amount": 30.0,
-		}, 
-		{
-			"account_head": "_Test Account Service Tax - _TC", 
-			"charge_type": "On Net Total", 
-			"description": "Service Tax", 
-			"doctype": "Sales Taxes and Charges", 
-			"parentfield": "other_charges",
-			"tax_amount": 31.8,
-		},
-  
-		# sales team
-		{
-			"parentfield": "sales_team",
-			"doctype": "Sales Team",
-			"sales_person": "_Test Sales Person 1",
-			"allocated_percentage": 65.5,
-		},
-		{
-			"parentfield": "sales_team",
-			"doctype": "Sales Team",
-			"sales_person": "_Test Sales Person 2",
-			"allocated_percentage": 34.5,
-		},
-	)]
-
-
diff --git a/docs/dev/docs.dev.custom_script.md b/docs/dev/docs.dev.custom_script.md
deleted file mode 100644
index ad50637..0000000
--- a/docs/dev/docs.dev.custom_script.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-{
-	"_label": "Custom Script Examples",
-	"_toc": [
-		"docs.dev.custom_script.fetch",
-		"docs.dev.custom_script.validate",
-		"docs.dev.custom_script.validate1",
-		"docs.dev.custom_script.validate2",
-		"docs.dev.custom_script.validate3",
-		"docs.dev.custom_script.read_only",
-		"docs.dev.custom_script.calculate",
-		"docs.dev.custom_script.item_code"
-	]
-}
----
-### How to Create a Custom Script
-
-Create a Custom Script (you must have System Manager role for this):
-
-1. Got to: Setup > Custom Script > New Custom Script
-1. Select the DocType in which you want to add the Custom Script
-
----
-### Notes
-
-1. Server Custom Scripts are only available for the Administrator.
-1. Client Custom Scripts are in Javascript and Server Custom Scripts are in Python.
-1. For testing, make sure to go to Tools > Clear Cache and refresh after updating a Custom Script.
-
-	
-	
diff --git a/docs/dev/docs.dev.docs.md b/docs/dev/docs.dev.docs.md
deleted file mode 100644
index f54b0b8..0000000
--- a/docs/dev/docs.dev.docs.md
+++ /dev/null
@@ -1,46 +0,0 @@
----
-{
-	"_label": "How to Build ERPNext Documentation"
-}
----
-This page explains how to build the ERPNext documentation.
-
-The documentation sources are in the [`docs` folder of the erpnext repository](https://github.com/webnotes/erpnext/tree/master/docs). The source files are in markdown format and they have a custom header that is separated by `---`
-
-## Documentation Header
-
-The header contains the title of the page and sub pages (table of contents) in any. Example of a simple header with title is:
-
-	---
-	{
-		"_label": "How to Build ERPNext Documentation"
-	}
-	---
-	
-#### Adding Table of Contents
-
-Table of contents is added by setting the `_toc` property as below:
-
-	---
-	{
-		"_label": "Developer",
-		"_toc": [
-			"docs.dev.install",
-			"docs.dev.quickstart",
-			"docs.dev.framework",
-			"docs.dev.api",
-			"docs.dev.modules",
-			"docs.dev.translate"
-		]
-	}
-	---
-	
-## Building the Output pages
-
-Once the sources have been edited / updated, to build the documentation, login into your local ERPNext account.
-
-1. Open __Documenation Tool__ by adding `#Form/Documentation Tool` to the address bar.
-1. Check on all the pages to be generated
-1. Click on "Make Docs"
-
-All the output pages are generated in the `public/docs` folder
\ No newline at end of file
diff --git a/docs/dev/docs.dev.install.md b/docs/dev/docs.dev.install.md
deleted file mode 100644
index f9df566..0000000
--- a/docs/dev/docs.dev.install.md
+++ /dev/null
@@ -1,65 +0,0 @@
----
-{
-	"_label": "How to Install ERPNext",
-	"_toc": [
-		"docs.dev.install.restore_from_backup"
-	]
-}
----
-
-> These are instructions that will help you to install ERPNext on your Unix like system (Linux / Ubuntu / MacOS) using the Terminal. If you are looking at easier ways to evaluate ERPNext, [see this page](docs.user.intro.try.html).
-
-### ERPNext Installer (Beta)
-
-1. Make sure that you have Python 2.7+
-```
-$ python -c "import platform; print platform.python_version()"
-2.7.3
-```
-or
-```
-$ which python2.7
-/usr/bin/python2.7
-```
-If your python version is less than 2.7, then follow,
-	* For CentOS, you can refer to http://toomuchdata.com/2012/06/25/how-to-install-python-2-7-3-on-centos-6-2/
-	* For Ubuntu, refer to http://askubuntu.com/questions/101591/how-do-i-install-python-2-7-2-on-ubuntu/101595#101595
-1. Make sure the 'passwd' command exists. Install passwd if necessary (e.g. on CentOS, run `yum install passwd`)
-1. Switch to root user using `sudo su`
-1. `wget https://raw.github.com/webnotes/erpnext/master/install_erpnext.py`
-1. `python2.7 install_erpnext.py --create_user`
-
- This will create a user 'erpnext' and install erpnext in its home directory.
-To start a development server, login as erpnext with password erpnext (or `su erpnext` from your root shell)
-```
-cd /home/erpnext/erpnext
-./lib/wnf.py --serve
-```
-
-> If you are installing on your server for deployment, remember to change Administrator's password!
-> You can set the erpnext username and password by passing it to the install script,
-`python2.7 install_erpnext.py --create_user --username erpnext_username --password secretpassword`
-
-> If you get stuck, post your questions at [ERPNext Developer Forum](https://groups.google.com/forum/#!forum/erpnext-developer-forum)
-
-> [Troubleshooting SELinux](http://www.crypt.gen.nz/selinux/disable_selinux.html)
-
---
-
-> [Server Setup Tips](http://plusbryan.com/my-first-5-minutes-on-a-server-or-essential-security-for-linux-servers)
-
-> [MySQL configuration file - my.cnf](https://github.com/webnotes/erpnext/wiki/MySQL-configuration-file)
-
-> [Some Useful Aliases](https://github.com/webnotes/erpnext/wiki/Some-Useful-Aliases)
-
----
-### Upgrade / run latest patches
-
-1. Backup your database!
-```
-./lib/wnf.py --backup
-```
-1. Pull changes
-```
-./lib/wnf.py --update origin master
-```
diff --git a/docs/dev/docs.dev.install.restore_from_backup.md b/docs/dev/docs.dev.install.restore_from_backup.md
deleted file mode 100644
index e795bfa..0000000
--- a/docs/dev/docs.dev.install.restore_from_backup.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-{
-	"_label": "Restoring From ERPNext Backup"
-}
----
-
-* Download backup files
-
-		cd /tmp
-		wget [DATABASE BACKUP FILE URL]
-		wget [FILES BACKUP FILE URL]
-
-* Suppose your backup files are downloaded at /tmp
-
-		gunzip [DATABASE BACKUP FILE.sql.gz]
-		tar xvf [FILES BACKUP.tar]
-
-* Go to your ERPNext installation folder
-* When restoring from database, the 'Administrator' user password gets reset to 'admin'. To set a better password when restoring, set admin_password variable in conf.py to the desired 'Administrator' user password.
-* Restore database using:
-
-		lib/wnf.py --install [DATABASE NAME] /tmp/[DATABASE BACKUP FILE.sql]
-
-* Copy extracted files
-
-		cp /tmp/[FILES BACKUP EXTRACTED FOLDER/---/public/files/*] [YOUR ERPNEXT INSTALLATION]/public/files/
\ No newline at end of file
diff --git a/docs/dev/docs.dev.md b/docs/dev/docs.dev.md
deleted file mode 100644
index f14208a..0000000
--- a/docs/dev/docs.dev.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-{
-	"_label": "Developer",
-	"_toc": [
-		"docs.dev.install",
-		"docs.dev.quickstart",
-		"docs.dev.framework",
-		"docs.dev.modules",
-		"docs.dev.custom_script",
-		"docs.dev.api",
-		"docs.dev.translate",
-		"docs.dev.docs"
-	]
-}
----
-### Is this for me?
-
-To start hacking into ERPNext, you must have some understanding of how a dynamic web application works. There are hundreds of architectures and frameworks to make web development easier, but at the core there are a few elements that are important to understand.
-
-ERPNext is built on `wnframework` which is primarily developed for ERPNext but can be extended to make similar database driven applications. wnframework uses Python on the server-side and has a javascript based client for entering data, managing workflow and making reports.
\ No newline at end of file
diff --git a/docs/dev/docs.dev.modules.md b/docs/dev/docs.dev.modules.md
deleted file mode 100644
index 34fea9a..0000000
--- a/docs/dev/docs.dev.modules.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-{
-	"_label": "Modules"
-}
----
-The models used in both `wnframework` (**Core** module) and ERPNext are listed here. The basic element of the model is a `DocType`, which is most often also a database table. The model properties are called `DocFields`, which describe the view and the database columns.
\ No newline at end of file
diff --git a/docs/dev/docs.dev.translate.md b/docs/dev/docs.dev.translate.md
deleted file mode 100644
index a65f7b7..0000000
--- a/docs/dev/docs.dev.translate.md
+++ /dev/null
@@ -1,64 +0,0 @@
----
-{
-	"_label": "Managing Translations"
-}
----
-This document shows how to translations are managed in ERPNext and how to add a new language or update translations of an existing language.
-
-### Source
-
-Translatable text exists in 3 main sources:
-
-1. Javascript Code Files (both framework and application)
-1. Python Code Files
-1. DocTypes (names, labels and select options)
-
-#### Strings in Code Files
-
-Strings in code files are annotated using the `_` (underscore) method
-
-1. In Python it is the `webnotes._` method. Example:
-
-	webnotes._("This string must be translated")
-	
-1. In Javascript it is the `wn._` method. Example:
-
-	`wn._("This string must be translated")`
-
-### How Translations Are Picked up During Execution
-
-When the __build__ (`lib/wnf.py -b`) process is run, along with generating the `public` folders, it will also add a `locale` folder in each folder where translations need to be applied. This `locale` folder is rebuilt every time new translations are made.
-
-Based on the user preferences or request preferences, the appropriate translations are loaded at the time of request on the server side. Or if metadata (DocType) is queried, then the appropriate translations are appended when the DocType data is requested.
-
-The underscore `_` method will replace the strings based on the available translations loaded at the time.
-
-### Master Translations
-
-Master translations are stored in the application (erpnext repository) in the `translations` folder. [Translations master folder](https://github.com/webnotes/erpnext/tree/master/translations)
-
-These are built using the `webnotes.translate module` ([Docs](http://erpnext.org/docs.dev.framework.server.webnotes.translate.html) | [Code](https://github.com/webnotes/wnframework/blob/master/webnotes/translate.py)).
-
-### Building Translations
-
-Translations can be built using the `lib/wnf.py` utility. Do `lib/wnf.py --help` for more info.
-
-> New translations are built using Google Translate API. As of the time of writing of this document, Google Translate API is not free. To build a translation of your own from Google, you will have to register with Google API and add your API key in `conf.py`
-
-To add a new language just add:
-
-1. Build new translation from Google: `lib/wnf.py --translate ru`
-1. Get user the ability to select this language: Go to #Form/DocType/Profile and update the options in `langauge` field.
-1. Map the language name to the abbreviation: Update `startup/__init__.py` ([Link](https://github.com/webnotes/erpnext/blob/master/startup/__init__.py))
-
-### Updating Translations
-
-#### Updating Sources:
-
-If you find translatable strings are not properly annotated using the `_` method, you can add them in the code and rebuild the translations.
-
-#### Improving Translations:
-
-To improve an existing translation, just edit the master translation files in `app/translations` and rebuild using `lib/wnf.py -b`
-
-> Please contribute your translations back to ERPNext by sending us a Pull Request.
\ No newline at end of file
diff --git a/docs/docs.about.md b/docs/docs.about.md
deleted file mode 100644
index 0ff1433..0000000
--- a/docs/docs.about.md
+++ /dev/null
@@ -1,95 +0,0 @@
----
-{
-	"_label": "About ERPNext"
-}
----
-ERPNext is a web based, open source ERP for small, medium sized businesses. Includes Accounting, Inventory, CRM, Sales, Purchase, Projects, HRMS. Built on Python / MySQL. ERPNext also contains a CMS (Content Management System) to generate a website and webshop.
-
-Published by [Web Notes Technlogies Pvt Ltd, Mumbai](https://erpnext.com/about).
-
-- [User Guide](https://erpnext.org/docs.user.html)
-- [Getting Help](https://erpnext.org/docs.user.help.html)
-- [Developer Forum](http://groups.google.com/group/erpnext-developer-forum)
-- [User Forum](http://groups.google.com/group/erpnext-user-forum)
-- [Donate](https://erpnext.com)
-
----
-
-### Download and Install
-
-##### Virtual Image:
-
-- [ERPNext Download](http://erpnext.com/erpnext-download)
-
-##### On Linux:
-
-1. Switch to root user using `sudo su`
-1. create a folder where you want to install erpnext
-1. go to the new folder
-1. `wget https://raw.github.com/webnotes/erpnext/master/install_erpnext.py`
-1. `python install_erpnext.py`
-    
-[See installation notes](https://github.com/webnotes/erpnext/wiki/How-to-Install-ERPNext)
-
-##### Patch and update
-
-To patch and update from the latest git repository the erpnext folder and run.
-You will have to set your origin in git remote
-
-    $ lib/wnf.py --update origin master
-
----
-
-## License
-
-GNU/General Public License (see LICENSE.txt)
-
-The ERPNext code is licensed as GNU General Public License (v3) and the Documentation is licensed as Creative Commons (CC-BY-SA-3.0) and the copyright is owned by Web Notes Technologies Pvt Ltd (Web Notes). 
-
-### Copyright for Contributors
-
-Unless otherwise asserted in the code files, Web Notes will own the copyright of all contributions too. That means Web Notes holds the rights to change the license in the future or offer Commercial Licenses.
-
-Web Notes will only accept copyright assertions in case of a significant contribution like a whole new functionality or a major rewrite. We believe if your contribution is significant then you should have a say in what license Web Notes selects in the future and/or have a right to any revenue Web Notes gets from a Commercial License. Either ways Web Notes will have the right to decide what is a "significant" contribution.
-
-Note: At the moment, Web Notes does not give Commercial License for ERPNext nor has specific plans do so in the future.
-
----
-
-## Logo and Trademark
-
-The brand name ERPNext and the logo are trademarks of Web Notes Technologies Pvt. Ltd.
-
-### Introduction
-
-Web Notes Technologies Pvt. Ltd. (Web Notes) owns and oversees the trademarks for the ERPNext name and logos. We have developed this trademark usage policy with the following goals in mind:
-
-- We’d like to make it easy for anyone to use the ERPNext name or logo for community-oriented efforts that help spread and improve ERPNext.
-- We’d like to make it clear how ERPNext-related businesses and projects can (and cannot) use the ERPNext name and logo.
-- We’d like to make it hard for anyone to use the ERPNext name and logo to unfairly profit from, trick or confuse people who are looking for official ERPNext resources.
-
-### Web Notes Trademark Usage Policy
-
-Permission from Web Notes is required to use the ERPNext name or logo as part of any project, product, service, domain or company name.
-
-We will grant permission to use the ERPNext name and logo for projects that meet the following criteria:
-
-- The primary purpose of your project is to promote the spread and improvement of the ERPNext software.
-- Your project is non-commercial in nature (it can make money to cover its costs or contribute to non-profit entities, but it cannot be run as a for-profit project or business).
-Your project neither promotes nor is associated with entities that currently fail to comply with the GPL license under which ERPNext is distributed.
-- If your project meets these criteria, you will be permitted to use the ERPNext name and logo to promote your project in any way you see fit with one exception: Please do not use ERPNext as part of a domain name. 
-
-Use of the ERPNext name and logo is additionally allowed in the following situations:
-
-All other ERPNext-related businesses or projects can use the ERPNext name and logo to refer to and explain their services, but they cannot use them as part of a product, project, service, domain, or company name and they cannot use them in any way that suggests an affiliation with or endorsement by the ERPNext or WebNotes or the ERPNext open source project. For example, a consulting company can describe its business as “123 Web Services, offering ERPNext consulting for small businesses,” but cannot call its business “The ERPNext Consulting Company.”
-
-Similarly, it’s OK to use the ERPNext logo as part of a page that describes your products or services, but it is not OK to use it as part of your company or product logo or branding itself. Under no circumstances is it permitted to use ERPNext as part of a top-level domain name.
-
-We do not allow the use of the trademark in advertising, including AdSense/AdWords.
-
-Please note that it is not the goal of this policy to limit commercial activity around ERPNext. We encourage ERPNext-based businesses, and we would love to see hundreds of them.
-
-When in doubt about your use of the ERPNext name or logo, please contact the Web Notes Technologies for clarification.
-
-(inspired from Wordpress)
-
diff --git a/docs/docs.blog.md b/docs/docs.blog.md
deleted file mode 100644
index eae263e..0000000
--- a/docs/docs.blog.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-{
-	"_label": "Blog"
-}
----
-Here is the list of latest blogs from erpnext.com
-
-[https://erpnext.com/blog](https://erpnext.com/blog)
\ No newline at end of file
diff --git a/docs/docs.download.md b/docs/docs.download.md
deleted file mode 100644
index 27a95ec..0000000
--- a/docs/docs.download.md
+++ /dev/null
@@ -1,58 +0,0 @@
----
-{
-	"_label": "Download ERPNext",
-	"_icon": "download"
-}
----
-### Download a pre-installed Virtual Box Image
-
-#### How To Install
-
-> You will need Oracle's Virtual Box to use the image:
-
-[https://www.virtualbox.org/](https://www.virtualbox.org/)
-
-Import the .ova file into VirtualBox. Though the default settings of the appliance should be good enough for most users, you may need to change them if you face performace issues.
-
-Also, you will need to change its timezone to match yours, once the Virtual Machine boots up.
-
-The virtual appliance uses Elementary OS.
-
-The credentials of the virtual image are:
-
-- username: erpnext
-- password: erpnext
-- mysql root password: erpnext
-- erpnext database name: erpnext
-- erpnext database password: erpnext
-
-Once the Virtual Machine boots, you need to start firefox, go to:
-
-http://localhost:8080
-
-and login using:
-
-- user: Administrator
-- password: admin
-
-#### Download Image
-
-[https://erpnext.com/downloads/erpnext-1305.ova](https://erpnext.com/downloads/erpnext-1305.ova) (~1.6 GB, MD5 Checksum - 60fe727f3a7a689edb6b2d4bd0ff55ad)
-
-Created on 15th May 2013.
-
----
-
-### Get the Source
-
-#### wnframework
-
-The web application framework that powers ERPNext:
-
-- [https://github.com/webnotes/wnframework](https://github.com/webnotes/wnframework)
-
-#### erpnext
-
-ERPNext modules:
-
-- [https://github.com/webnotes/erpnext](https://github.com/webnotes/erpnext)
\ No newline at end of file
diff --git a/docs/docs.md b/docs/docs.md
deleted file mode 100644
index 3ed24b7..0000000
--- a/docs/docs.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-{
-	"_label": "ERPNext",
-	"_no_title": 1,
-	"_toc": [
-		"docs.user",
-		"docs.dev",
-		"docs.download",
-		"docs.community",
-		"docs.blog"
-	],
-	"_no_toc": 1
-}
----
-<div class="text-center" style="margin: 10px 0px">
-	<h1>ERPNext Docs (beta)</h1>
-	<h3 class="text-muted">Open Source ERP Built for The Web.</h3>
-	<p>For the main site, go to <a href="https://erpnext.com/">https://erpnext.com</a></p>
-</div>
-
-![Home Screen](img/home.png)
-
-Welcome to the ERPNext Documentation + Community Site
-
-### What is ERPNext?
-
-ERPNext is an Open Source integrated app (that manages Financial Accounting, Inventory, CRM) that is built grounds up for the web, using some of the latest web technologies and frameworks. ERPNext helps your organization manage Financial Accounting, Inventory, Sales, Purchase, Payroll, Customer Support, E-Commerce all in one platform. Learn more at [https://erpnext.com](https://erpnext.com)
-
-### Site Contents
-
-This site contains the full User and Developer Documentation for ERPNext. This is still a work-in-progress. Please feel free to contribute issues and documentation.
diff --git a/docs/templates/docs.html b/docs/templates/docs.html
deleted file mode 100644
index ef3cf8e..0000000
--- a/docs/templates/docs.html
+++ /dev/null
@@ -1,51 +0,0 @@
-{% extends "lib/core/doctype/documentation_tool/docs.html" %}
-
-{% block navbar %}
-<div class="navbar navbar-default" style="border-bottom: 2px solid #c0392b">
-	<div class="container">
-		<button type="button" class="navbar-toggle" 
-			data-toggle="collapse" data-target=".navbar-responsive-collapse">
-			<span class="icon-bar"></span>
-			<span class="icon-bar"></span>
-			<span class="icon-bar"></span>
-		</button>
-		<a class="navbar-brand" href="index.html">
-			<object data="img/splash.svg" class="erpnext-logo" 
-				type="image/svg+xml"></object> erpnext.org</a>
-		<div class="collapse navbar-collapse navbar-responsive-collapse">
-			<ul class="nav navbar-nav">
-				<li><a href="docs.user.html">User</a></li>
-				<li><a href="docs.dev.html">Developer</a></li>
-				<li><a href="docs.user.help.html">Help</a></li>
-				<li><a href="docs.download.html">Download</a></li>
-				<li><a href="https://erpnext.com" target="_blank">Cloud</a></li>
-			</ul>
-			<ul class="nav navbar-nav pull-right">
-				<li><a href="docs.about.html">About</a></li>
-			</ul>
-		</div>
-	</div>
-</div>
-{% endblock %}
-
-{% block footer %}
-<hr />
-<div class="footer text-muted" style="font-size: 80%;">
-	<div class="content row">
-		<div class="col-md-12">
-		&copy; <a href="https://erpnext.com">Web Notes</a> | 
-		<a href="docs.user.help.html">Help</a> | 
-		<a href="https://github.com/webnotes/erpnext" target="_blank">Code</a> |  
-		<a href="docs.attributions.html">Attributions</a> | 
-		<a href="https://erpnext.com">ERPNext Cloud</a> | 
-		<a href="https://erpnext.com/partners">Find a Partner</a> | 
-		<a href="https://erpnext.com/donate">Donate</a>
-		<br>
-		<p>
-		Code License: <a href="https://www.gnu.org/licenses/gpl.html">GNU/GPL 3</a>.
-		Documentation License: <a href="https://creativecommons.org/licenses/by-sa/3.0/">CC-BY-SA-3.0</a>.
-		</p>
-		</div>
-	</div>
-</div>
-{% endblock %}
\ No newline at end of file
diff --git a/docs/user/accounts/docs.user.accounts.closing.md b/docs/user/accounts/docs.user.accounts.closing.md
deleted file mode 100644
index 7daee92..0000000
--- a/docs/user/accounts/docs.user.accounts.closing.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-{
-	"_label": "Closing a Financial Period"
-}
----
-At the end of every year or (quarterly or maybe even monthly), after completing auditing, you close your books of accounts. This means that you make all your special entries like:
-
-- Depreciation
-- Change in value of Assets
-- Defer taxes and liabilities
-- Update bad debts
-
-etc. and book your Profit or Loss.
-
-By doing this, your Income and Expense Accounts become zero .You start a new Fiscal Year (or period) with a balanced Balance Sheet and fresh Profit and Loss account.
-
-In ERPNext after making all the special entries via Journal Voucher, you can make all your Income and Expense accounts to zero via:
-
-> Accounts > Tools > Period Closing Voucher
-
-
-
-![Period Closing](img/period-closing.png)
-
-
-
-
-
-
-The Period Closing Voucher will make accounting entries (GL Entry) making all your Income and Expense Accounts zero and transferring the balance to the Account you define.
\ No newline at end of file
diff --git a/docs/user/accounts/docs.user.accounts.journal_voucher.md b/docs/user/accounts/docs.user.accounts.journal_voucher.md
deleted file mode 100644
index 5ab60e0..0000000
--- a/docs/user/accounts/docs.user.accounts.journal_voucher.md
+++ /dev/null
@@ -1,63 +0,0 @@
----
-{
-	"_label": "Journal Vouchers"
-}
----
-All types of accounting entries other than **Sales Invoice** and **Purchase Invoice** are made using the **Journal Voucher**. A **Journal Voucher** (also called Journal Entry) is a standard accounting transaction that affects multiple Accounts and the sum of debits is equal to the sum of credits.
-
-To create a Journal Voucher go to:
-
-> Accounts > Journal Voucher > New Journal Voucher
-
-
-
-![Journal Voucher](img/journal-voucher.png)
-
-
-
-
-In a Journal Voucher, you must select.
-
-- Type of Voucher from the drop down. 
-- Add rows for the individual accounting entries. In each row, you must specify:
-	- The Account that will be affected
-	- The amount to Debit or Credit
-	- The Cost Center (if it is an Income or Expense)
-	- Against Voucher: Link it to a voucher or invoice if it affects the “outstanding” amount of that invoice.
-	- Is Advance: Select “Yes” if you want to make it selectable in an Invoice. 
-Other information in case it is a Bank Payment or a bill.
-
-#### Difference
-
-The “Difference” field is the difference between the Debit and Credit amounts. This should be zero if the Journal Voucher is to be “Submitted”. If this number is not zero, you can click on “Make Difference Entry” to add a new row with the amount required to make the total as zero.
-
----
-
-## Common Entries
-
-A look at some of the common accounting entries that can be done via Journal Voucher.
-
-#### Expenses (non accruing)
-
-Many times it may not be necessary to accrue an expense, but it can be directly booked against an expense Account on payment. For example a travel allowance or a telephone bill. You can directly debit Telephone Expense (instead of your telephone company) and credit your Bank on payment.
-
-- Debit: Expense Account (like Telephone expense)
-- Credit: Bank or Cash Account
-
-#### Bad Debts or Write Offs
-
-If you are writing off an Invoice as a bad debt, you can create a Journal Voucher similar to a Payment, except instead of debiting your Bank, you can debit an Expense Account called Bad Debts.
-
-- Debit: Bad Debts Written Off
-- Credit: Customer
-
-> Note: There may be regulations in your country before you can write off bad debts.
-
-#### Depreciation
-
-Depreciation is when you write off certain value of your assets as an expense. For example if you have a computer that you will use for say 5 years, you can distribute its expense over the period and pass a Journal Voucher at the end of each year reducing its value by a certain percentage.
-
-- Debit: Depreciation (Expense)
-- Credit: Asset (the Account under which you had booked the asset to be depreciated)
-
-> Note: There may be regulations in your country that define by how much amount you can depreciate a class of Assets.
diff --git a/docs/user/accounts/docs.user.accounts.md b/docs/user/accounts/docs.user.accounts.md
deleted file mode 100644
index 01ce425..0000000
--- a/docs/user/accounts/docs.user.accounts.md
+++ /dev/null
@@ -1,58 +0,0 @@
----
-{
-	"_label": "Accounts",
-	"_toc": [
-		"docs.user.accounts.sales_invoice",
-		"docs.user.accounts.purchase_invoice",
-		"docs.user.accounts.payments",
-		"docs.user.accounts.journal_voucher",
-		"docs.user.accounts.opening_entry",
-		"docs.user.accounts.closing",
-		"docs.user.accounts.reports",
-		"docs.user.accounts.voucher_import",
-		"docs.user.accounts.pos"
-	]
-}
----
-
-![Accounts](img/accounts-image.png)
-
-
-
-At end of the sales and purchase cycle is billing and payments. You may have an accountant in your team, or you may be doing accounting yourself or you may have outsourced your accounting. Financial accounting forms the core of any business management system like an ERP.
-
-In ERPNext, your accounting operations consists of 3 main transactions:
-
-- Sales Invoice: The bills that you raise to your Customers for the products or services you provide. 
-- Purchase Invoice: Bills that your Suppliers give you for their products or services. 
-- Journal Vouchers: For accounting entries, like payments, credit and other types.
-
----
-
-### Accounting Basics
-
-#### Debit and Credit
-
-People new to accounting are often confused with the terms Debit and Credit. Contrary to their meaning, these terms have nothing to do with who owes what. 
-
-Debit and Credit are conventions. All accounting follows these so that it is easy to understand the state of finances in a universal manner. These conventions are:
-
-- All Accounts are of type Debit or Credit.
-- Assets and Expenses (and their sub-groups) are always Debit.
-- Liabilities and Income (and their sub-groups) are always Credit.
-- In all accounting entries, you “debit” an Account or “credit” one.
-- When you “debit” an Debit Account (an asset or expense), its value increases (“add” operation). When you “credit” a Debit Account, its value decreases (“subtract” operation). The same rule applies for Credit Accounts. “Crediting” a Credit Account, increases its value, “debiting” it decreases its value.
-- All accounting transactions (like a sales or a payment) must affect at least two different Accounts and sum of debits must be equal to sum of credits for the transaction. This is called the “double-entry bookkeeping system”.
-
-Still confused? These conventions will become clearer as you make transactions.
-
-#### Accrual System
-
-Another important concept to understand in Accounting is accrual. This is important when your payment happens separately from delivery. 
-
-For example you buy X from a Supplier and your Supplier sends you a bill and expects you to pay in, for example, seven days. Even if you have not yet paid your Supplier, your expense must be booked immediately. This expense is booked against a group of Accounts called “Accounts Payable” that is the sum of all your outstanding dues to your Suppliers. This is called accrual. When you pay your Supplier, you will cancel his dues and update your bank account.
-
-ERPNext works on an accrual system. The transactions that accrue income and expense are Sales Invoice and Purchase Invoice.
-
-In retail, typically, delivery and payment happens at the same time. To cover this scenario, we have in ERPNext a POS Invoice (POS = Point of Sales). More on that later.
-
diff --git a/docs/user/accounts/docs.user.accounts.opening_entry.md b/docs/user/accounts/docs.user.accounts.opening_entry.md
deleted file mode 100644
index f8d0841..0000000
--- a/docs/user/accounts/docs.user.accounts.opening_entry.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-{
-	"_label": "Opening Entry"
-}
----
-
-If you are a new company you can start using ERPNext accounting module by going to chart of accounts.
-
-However, if you are migrating from a legacy accounting system like Tally or a Fox Pro based software, please visit [Opening Entry](docs.user.setup.opening.html)
-
diff --git a/docs/user/accounts/docs.user.accounts.opening_stock.md b/docs/user/accounts/docs.user.accounts.opening_stock.md
deleted file mode 100644
index b0927bd..0000000
--- a/docs/user/accounts/docs.user.accounts.opening_stock.md
+++ /dev/null
@@ -1,44 +0,0 @@
----
-{
-	"_label": "Opening Stock"
-}
----
-
-
-You can upload your opening stock in the system using Stock Reconciliation. Stock Reconciliation will update your stock for a given Item on a given date for a given Warehouse to the given quantity.
-
-Stock Reconciliation will make a “difference entry” (the difference between the system stock and the actual stock in your file) for the Item.
-
-Tip: Stock Reconciliation can also be used to update the “value” of an Item.
-
-To make a Stock Reconciliation, go to:
-
-> Stock > Stock Reconciliation > New Stock Reconciliation
-
-and follow the steps mentioned on the page.
-
-#### Step 1: Download Template
-
-
-![Stock Reconciliation](img/stock-reconciliation-1.png)
-
-#### Step 2: Enter Data in csv file.
-
-
-![Stock Reconciliation](img/stock-reconciliation-csv-1.png)
-
-The csv format is case-sensitive. Thus special care should be taken to avoid spelling errors or wrong names. Even if you do not list some quantities or valuation rates, the file will still process the data.
-
-#### Step 3: Upload the csv file with data
-
-![Stock Reconciliation](img/stock-reconciliation-2.png)
-
-<br>
-
-#### Step 4: Attach the uploaded file.
-
-![Stock Reconciliation](img/stock-reconciliation-3.png)
-
-
-
-After reviewing saved Reconciliation Data, submit the Stock Reconciliation. On successful submission, the data will be updated in the system. To check the uploaded data go to Stock and view  Stock Level Report.
\ No newline at end of file
diff --git a/docs/user/accounts/docs.user.accounts.payments.md b/docs/user/accounts/docs.user.accounts.payments.md
deleted file mode 100644
index 5f6e7ff..0000000
--- a/docs/user/accounts/docs.user.accounts.payments.md
+++ /dev/null
@@ -1,85 +0,0 @@
----
-{
-	"_label": "Making Payments"
-}
----
-Payments made against Sales Invoices or Purchase Invoices can be made by clicking on “Make Payment Entry” button on “Submitted” invoices.
-
-1. Update the “Bank Account” (you can also set the default account in the Company master).
-1. Update posting date.
-1. Enter the cheque number, cheque date.
-1. Save and Submit.
-
-
-
-
-
-![Payment Entry](img/payment-entry.png)
-
-
-
-
-
-
-Payments can also be made independent of invoices by creating a new Journal Voucher and selecting the type of payment.
-
-#### Incoming Payment
-
-For payments from Customers,
-
-- Debit: Bank or Cash Account
-- Credit: Customer
-
-> Note: Remember to the “Against Sales Invoice” or “Is Advance” as applicable.
-
-#### Outgoing Payment
-
-For payments to Suppliers,
-
-- Debit: Supplier
-- Credit: Bank or Cash Account
-
-> Note: Remember to the “Against Purchase Invoice” or “Is Advance” as applicable.
-
----
-
-### Reconciling Cheque Payments
-
-If you are receiving payments or making payments via cheques, the bank statements will not accurately match the dates of your entry, this is because the bank usually takes time to “clear” these payments. Also you may have mailed a cheque to your Supplier and it may be a few days before it is received and deposited by the Supplier. In ERPNext you can synchronize your bank statements and your Journal Vouchers using the “Bank Reconciliation” tool.
-
-To use this, go to:
-
-> Accounts > Bank Reconciliation
-
-Select your “Bank” Account and enter the dates of your statement. Here you will get all the “Bank Voucher” type entries. In each of the entry on the right most column, update the “Clearance Date” and click on “Update”.
-
-By doing this you will be able to sync your bank statements and entries into the system.
-
-
----
-
-## Managing Outstanding Payments
-
-In most cases, apart from retail sales, billing and payments are separate activities. There are several combinations in which these payments are done. These cases apply to both sales and purchases.
-
-- They can be upfront (100% in advance).
-- Post shipment. Either on delivery or within a few days of delivery.
-- Part in advance and part on or post delivery.
-- Payments can be made together for a bunch of invoices.
-- Advances can be given together for a bunch of invoices (and can be split across invoices).
-
-ERPNext allows you to manage all these scenarios. All accounting entries (GL Entry) can be made against a Sales Invoice, Purchase Invoice or Journal Vouchers (in special cases, an invoice can be made via a Sales Invoice too).
-
-The total outstanding amount against an invoice is the sum of all the accounting entries that are made “against” (or are linked to) that invoice. This way you can combine or split payments in Journal Vouchers to manage the scenarios.
-
-### Matching Payments to Invoices
-￼
-In complex scenarios, especially in the capital goods industry, sometimes there is no direct link between payments and invoices. You send invoices to your Customers and your Customer sends you block payments or payments based on some schedule that is not linked to your invoices. 
-
-In such cases, you can use the Payment to Invoice Matching Tool.
-
-> Accounts > Payment Reconciliation
-
-In this tool, you can select an account (your Customer’s account) and click on “Pull Payment Entries” and it will select all un-linked Journal Vouchers and Sales Invoices from that Customer.
-
-To cancel off some payments and invoices, select the Invoices and Journal Vouchers and click on “Reconcile”.
\ No newline at end of file
diff --git a/docs/user/accounts/docs.user.accounts.pos.md b/docs/user/accounts/docs.user.accounts.pos.md
deleted file mode 100644
index 7bd668e..0000000
--- a/docs/user/accounts/docs.user.accounts.pos.md
+++ /dev/null
@@ -1,87 +0,0 @@
----
-{
-	"_label": "Point of Sale (POS) Invoice"
-}
----
-Point of sale (POS) is the place where a retail transaction is completed. It is the point at which a customer makes a payment to the merchant in exchange for goods or services. For retail operations, the delivery of goods, accrual of sale and payment all happens in one event, that is usually called the “Point of Sale”.
-
-You can make a Sales Invoice of type POS by checking on “Is POS”. When you check this, you will notice that some fields get hidden and some new ones emerge.
-
-> Tip: In retail, you may not create a separate Customer record for each customer. You can create a general Customer called “Walk-in Customer” and make all your transactions against this Customer record.
-
-#### Different sections of the POS
-
-- Update Stock: If this is checked, Stock Ledger Entries will be made when you “Submit” this Sales Invoice thereby eliminating the need for a separate Delivery Note. 
-- In your Items table, update inventory information like Warehouse  (saved as default), Serial Number, or Batch Number if applicable. 
-- Update Payment Details like your Bank / Cash Account, Paid amount etc. 
-- If you are writing off certain amount. For example when you receive extra cash as a result of not having exact denomination of change, check on ‘Write off Outstanding Amount’ and set the Account.
-
-
-#### Enable POS View
-
-- Every Sales & Purchase documents has 2 different interfaces, Invoice View and POS View. The current view used by most users is the Invoice View. This view is preferred by non-retailing companies.The POS view is used by retailing companies. For retailers it is very important to provide bill or sales invoice at the point of sale. Their customers cannot wait to receive the bill by post. The customers want an immediate bill for the payment which they make. In such cases, the POS View is preferred.
-
- > Setup  > Show/Hide Features
-
-![POS View](img/pos-features-setup.png)
-
-- Setup [POS Setting](docs.user.setup.pos_setting.html)
-
-### Adding an Item
-
-At the billing counter, the retailer needs to select Items which the consumer buys. In the POS interface you can select an Item by two methods. One, is by clicking on the Item image and the other, is through the Barcode / Serial No. 
-
-**Select Item** - To select a  product click on the Item image and add it into the cart. A cart is an area that prepares a customer for checkout by allowing to edit product information, adjust taxes and add discounts.
-
-**Barcode / Serial No** - A Barcode / Serial No is an optical machine-readable representation of data relating to the object to which it is attached. Enter Barcode / Serial No in the box as shown in the image below and pause for a second, the item will be automatically added to the cart.
-
-![POS](img/pos-add-item.png)
-
-> Tip: To change the quantity of an Item, enter your desired quantity in the quantity box. These are mostly used if the same Item is purchased in bulk.
-
-
-If your product list is very long use the Search field, type the product name in Search box. 
-
-### Removing an Item
-
-There are two ways to remove an Item.
-
-- Select an Item by clicking on the row of that Item from Item cart. Then click on “Del” button. OR
-
-
-- Enter 0(zero) quantity of any item to delete that item.
-
-To remove multiple Items together, select multiple rows & click on “Del” button. 
-
-> Delete button appears only when Items are selected.
-
-![POS](img/pos-remove-item.png)
-
-### Make Payment
-
-After all the Items and their quantities are added into the cart, you are ready to make the Payment. Payment process is divided into 3 steps - 
-
-1. Click on “Make Payment” to get the Payment window.
-1. Select your “Mode of Payment”.
-1. Click on “Pay” button to Save the document.
-
-![POS Payment](img/pos-make-payment.png)
-
-Submit the document to finalise the record. After the document is submitted, you can either print or email it directly to the customer.
-
-#### Accounting entries (GL Entry) for a Point of Sale:
-
-Debits:
-
-- Customer (grand total)	
-- Bank / Cash (payment)
-
-Credits:
-
-- Income (net total, minus taxes for each Item) 
-- Taxes (liabilities to be paid to the government)
-- Customer (payment)
-- Write Off (optional)
-
-To see entries after “Submit”, click on “View Ledger”.￼
-
diff --git a/docs/user/accounts/docs.user.accounts.purchase_invoice.md b/docs/user/accounts/docs.user.accounts.purchase_invoice.md
deleted file mode 100644
index 9f43d4b..0000000
--- a/docs/user/accounts/docs.user.accounts.purchase_invoice.md
+++ /dev/null
@@ -1,61 +0,0 @@
----
-{
-	"_label": "Purchase Invoice"
-}
----
-Purchase Invoice is the exact opposite of your Sales Invoice. It is the bill that your Supplier sends you for products or services delivered. Here you accrue expenses to your Supplier. Making a Purchase Invoice is very similar to making a Purchase Order.
-
-To make a new Purchase Invoice, go to:
-
-> Accounts > Purchase Invoice > New Purchase Invoice
-
-or click on “Make Purchase Invoice” in Purchase Order or Purchase Receipt.
-
-
-
-
-![Purchase Invoice](img/purchase-invoice.png)
-
-
-
-
-
-
-The concept of “Posting Date” is again same as Sales Invoice. “Bill No” and “Bill Date” helps to track the bill number as set by your Supplier for reference.
-
-#### Accounting Impact
-
-Like in Sales Invoice, you have to enter an Expense or an Asset account for each row in your Items table. This helps to indicate if the Item is an Asset or an Expense. You must also enter a Cost Center. These can also be set in the Item master.
-
-The Purchase Invoice will affect your accounts as follows:
-
-Accounting entries (GL Entry) for a typical double entry “purchase”:
-
-Debits:
-
-- Expense or Asset (net totals, excluding taxes)
-- Taxes (assets if VAT-type or expense again).
-
-Credits:
-
-- Supplier
-
-To see entries in your Purchase Invoice after you “Submit”, click on “View Ledger”.
-
----
-
-#### Is purchase an “Expense” or an “Asset”?
-
-If the Item is consumed immediately on purchase, or if it is a service, then the purchase becomes an “Expense”. For example, a telephone bill or travel bill is an “Expense” - it is already consumed.
-
-For inventory Items, that have a value, these purchases are not yet “Expense”, because they still have a value while they remain in your stock. They are “Assets”. If they are raw-materials (used in a process), they will become “Expense” the moment they are consumed in the process. If they are to be sold to a Customer, they become “Expense” when you ship them to the Customer.
-
----
-
-#### Deducting Taxes at Source
-
-In many countries, the law may require you to deduct taxes, while paying your suppliers. These taxes could be based on a standard rate. Under these type of schemes, typically if a Supplier crosses a certain threshold of payment, and if the type of product is taxable, you may have to deduct some tax (which you pay back to your government, on your Supplier’s behalf).
-
-To do this, you will have to make a new Tax Account under “Tax Liabilities” or similar and credit this Account by the percent you are bound to deduct for every transaction.
-
-For more help, please contact your Accountant!
\ No newline at end of file
diff --git a/docs/user/accounts/docs.user.accounts.reports.md b/docs/user/accounts/docs.user.accounts.reports.md
deleted file mode 100644
index 5806875..0000000
--- a/docs/user/accounts/docs.user.accounts.reports.md
+++ /dev/null
@@ -1,61 +0,0 @@
----
-{
-	"_label": "Accounting Reports"
-}
----
-Some of the major accounting reports are:
-
-### General Ledger
-
-General Ledger is based on the table GL Entry and can be filtered by Account and between a period. This will help you get a full update for all entries done in that period for that Account.
-
-
-
-
-![General Ledger](img/general-ledger.png)
-
-
-
-
-
-
-### Trial Balance
-￼
-Trial Balance is the list of Account balances for all your Accounts (“Ledger” and “Group”) on a particular date. For each Account it will give you the:
-
-- Opening
-- Debits
-- Credits
-- Closing
-
-
-![Trial Balance](img/trial-balance.png)
-
-
-
-
-The sum of all closing balances in a Trial Balance must be zero. 
-
-### Accounts Payable and Accounts Receivable (AP / AR)
-
-These reports help you to track the outstanding invoices sent to Customer and Suppliers. In this report, you will get your outstanding amounts period wise. i.e. between 0-30 days, 30-60 days and so on.
-
-
-
-![Query Report](img/query-report-accounts-payable.png)
-
-
-
-
-You can also get your payables and receivables from direct reports on Sales Invoice and Purchase Invoice.
-
-### Sales and Purchase Register
-
-In this report, each tax Account is transposed in columns.For each Invoice and invoice Item, you will get the amount of individual tax that has been paid, based on the Taxes and Charges table.
-
-
-
-![Query Report Sales Register](img/query-report-sales-register.png)
-
-
-
diff --git a/docs/user/accounts/docs.user.accounts.returns.md b/docs/user/accounts/docs.user.accounts.returns.md
deleted file mode 100644
index 697c235..0000000
--- a/docs/user/accounts/docs.user.accounts.returns.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-{
-	"_label": "Handling Returns"
-}
----
-Returns are a part of doing business. Your Customers may return Items in exchange of other Items or money back or you may return Items to your Supplier. In each case there could be a variety of scenarios.
-
-### Credit and Debit Notes
-
-Credit Notes are given to your Customers against a return that can be redeemed as cash or adjusted in another purchase. You can create a Journal Voucher of type Credit Note as follows:
-
-- Debit: Income
-- Credit: Customer
-
-Similarly if you are deducting an amount from your Supplier’s bill due to rejection or similar, you can issue a Debit Note to your Supplier. You can adjust the Debit Note against another pending Purchase Invoice (in which case, remember to set the “Against Purchase Invoice” column or return the money. In the second case you will have to create a new payment entry (Journal Voucher) when you receive the money. Entry for a Debit Note would be:
-
-- Debit: Supplier
-- Credit: Expense
-
-> If Items are also returned, remember to make a Delivery Note or Stock Entry for the Items.
-
-### Exchange
-
-If there is an exchange with your Customer, you can create a new POS type Sales Invoice in which the returning item has a negative quantity and the selling item has a positive quantity. In this way your taxes will also be adjusted against the return.
-
-### Sales and Purchase Return Wizard
-
-This is a tool that can help you automate the entry for this process. Go to:
-
-> Accounts > Tools > Sales and Purchase Return
\ No newline at end of file
diff --git a/docs/user/accounts/docs.user.accounts.sales_invoice.md b/docs/user/accounts/docs.user.accounts.sales_invoice.md
deleted file mode 100644
index e887936..0000000
--- a/docs/user/accounts/docs.user.accounts.sales_invoice.md
+++ /dev/null
@@ -1,68 +0,0 @@
----
-{
-	"_label": "Sales Invoice"
-}
----
-A Sales Invoice is a bill that you send to your Customers, against which they will process your payment. 
-
-If you have managed to create Sales Orders or Delivery Notes, creating a Sales Invoice follows the same process. 
-
-You can create a Sales Invoice directly from
-
-> Accounting > Sales Invoice > New Sales Invoice
-
-or from the “Make Sales Invoice” button in the Sales Order or Delivery Note.
-
-
-
-<br>
-
-
-![Sales Invoice](img/sales-invoice.png)
-
-<br>
-
-
-
-
-#### Accounting Impact
-
-All Sales must be booked against an “Income Account”. This refers to an Account in the “Income” section of your Chart of Accounts. It is a good practice to classify your income by type (like product income, service income etc). The Income Account must be set for each row of the Items table.
-
-> Tip: To set default Income Accounts for Items, you can set it in the Item or Item Group.
-
-The other account that is affected is the Account of the Customer. That is automatically set from “Debit To” in the heading section.
-
-You must also mention the Cost Centers in which your Income must be booked. Remember that your Cost Centers tell you the profitability of the different lines of business or product. You can also set a default Cost Center in the Item master.
-
-#### Accounting entries (GL Entry) for a typical double entry “Sale”:
-
-When booking a sale (accrual):
-
-**Debit:** Customer (grand total)
-**Credit:** Income (net total, minus taxes for each Item) 
-**Credit:** Taxes (liabilities to be paid to the government)
-
-> To see entries in your Sales Invoice after you “Submit”, click on “View Ledger”.
-
-#### Dates
-
-Posting Date: The date on which the Sales Invoice will affect your books of accounts i.e. your General Ledger. This will affect all your balances in that accounting period. 
-
-Due Date: The date on which the payment is due (if you have sold on credit). This can be automatically set from the Customer master.
-
-#### Recurring Invoices
-
-If you have a contract with a Customer where you bill the Customer on a monthly, quarterly, half-yearly or annual basis, you can check the “Recurring Invoice” box. Here you can fill in the details of how frequently you want to bill this Invoice and the period for which the contract is valid.
-
-ERPNext will automatically create new Invoices and mail it to the email ids you set.
-
----
-
-#### "Pro Forma" Invoice
-
-If you want to give an Invoice to a Customer to make a payment before you deliver, i.e. you operate on a payment first basis, you should create a Quotation and title it as a “Pro-forma Invoice” (or something similar) using the Print Heading feature. 
-
-“Pro Forma” means for formality. Why do this? Because if you book a Sales Invoice it will show up in your “Accounts Receivable” and “Income”. This is not ideal as your Customer may or may not decide to pay up. But since your Customer wants an “Invoice”, you could give the Customer a Quotation (in ERPNext) titled as “Pro Forma Invoice”. This way everyone is happy.
-
-This is a fairly common practice. We follow this at Web Notes too.
diff --git a/docs/user/buying/docs.user.buying.material_request.md b/docs/user/buying/docs.user.buying.material_request.md
deleted file mode 100644
index c6a7785..0000000
--- a/docs/user/buying/docs.user.buying.material_request.md
+++ /dev/null
@@ -1,53 +0,0 @@
----
-{
-	"_label": "Material Request"
-}
----
-A Material Request is a simple document identifying a requirement of a set of Items (products or services) for a particular reason.
-
-
-![Workflow](img/material-request-workflow.jpg)
-
-
-
-
-To generate a Material Request manually go to:
-
-> Buying > Material Request > New Material Request
-
-**Step 1**
-
-![Material Request](img/material-request-1.png)
-
-
-
-
-A Material Request can be generated:
-
-- By a User.
-- Automatically from a Sales Order.
-- Automatically when the Projected Quantity of an Item in stores reaches a particular level.
-- Automatically from your Bill of Materials if you use Production Plan to plan your manufacturing activities.
-
-**Step 2**
-
-![Material Request 2](img/material-request-2.png)
-
-
-
-
-In the Material Request form, 
-
-- Fill in the Items you want and their quantities.
-
-- If your Items are inventory items, you must also mention the Warehouse where you expect these Items to be delivered. This helps to keep track of the [Projected Quantity](docs.user.stock.projected_quantity.html)for this Item.
-
-
-- You can optionally add the Terms, using the Terms and Conditions master and also the reason.
-
-
-> Info: Material Request is not mandatory. It is ideal if you have centralized buying so that you can collect this information from various departments.
-
-#### Authorization
-
-If you want your Material Request to be authorized by a senior person like a Purchase Manager then you can give “Submit” rights only to that person. Everyone can create requests, but only the authorized person can “Submit”.
\ No newline at end of file
diff --git a/docs/user/buying/docs.user.buying.md b/docs/user/buying/docs.user.buying.md
deleted file mode 100644
index 8247475..0000000
--- a/docs/user/buying/docs.user.buying.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-{
-	"_label": "Buying",
-	"_toc": [
-		"docs.user.buying.supplier_type",
-		"docs.user.buying.supplier",
-		"docs.user.buying.material_request",
-		"docs.user.buying.supplier_quotation",
-		"docs.user.buying.purchase_order",
-		"docs.user.buying.purchase_taxes",
-		"docs.user.buying.price_lists",
-		"docs.user.buying.sub_contracting"
-	]
-}
----
-
-
-
-![Buying](img/buying-home.png)
-
-
-
-
-If your business involves physical goods, buying is one of your core business activity. Your suppliers are as important as your customers and they must be provided with as much accurate information as possible.
-
-Buying in right amounts, in right quantities, can affect your cash flow and profitability.
-
-ERPNext contains a set of transactions that will make your buying process as efficient and seamless as possible.
\ No newline at end of file
diff --git a/docs/user/buying/docs.user.buying.purchase_order.md b/docs/user/buying/docs.user.buying.purchase_order.md
deleted file mode 100644
index 434588a..0000000
--- a/docs/user/buying/docs.user.buying.purchase_order.md
+++ /dev/null
@@ -1,42 +0,0 @@
----
-{
-	"_label": "Purchase Order"
-}
----
-A Purchase Order is analogous to a Sales Order. It is usually a binding contract with your Supplier that you promise to buy a set of Items under the given conditions.
-
-
-A Purchase Order can  be automatically created from a Material Request or Supplier Quotation.
-
-
-![Purchase Order](img/purchase-order-f.jpg)
-
-
-In ERPNext, you can also make a Purchase Order directly by going to:
-
-> Buying > Purchase Order > New Purchase Order
-￼
-
-
-![Purchase Order](img/purchase-order.png)
-
-
-
-
-Entering a Purchase Order is very similar to a Purchase Request, additionally you will have to set:
-
-- Supplier. 
-- A “Required By” date on each Item: If you are expecting part delivery, your Supplier will know how much quantity to deliver at which date. This will help you from preventing over-supply. It will also help you to track how well your Supplier is doing on timeliness.
-
-### Taxes
-
-If your Supplier is going to charge you additional taxes or charge like a shipping or insurance charge, you can add it here. It will help you to accurately track your costs. Also, if some of these charges add to the value of the product you will have to mention them in the Taxes table. You can also use templates for your taxes. For more information on setting up your taxes see the Purchase Taxes and Charges Master.
-
-
-### Value Added Taxes (VAT)
-
-Many a times, the tax paid by you to a Supplier, for an Item, is the same tax which you collect from your Customer. In many regions, what you pay to your government is only the difference between what you collect from your Customer and what you pay to your Supplier. This is called Value Added Tax (VAT). 
-
-For example you buy Items worth X and sell them for 1.3X. So your Customer pays 1.3 times the tax you pay your Supplier. Since you have already paid tax to your Supplier for X, what you owe your government is only the tax on 0.3X.
-
-This is very easy to track in ERPNext since each tax head is also an Account. Ideally you must create two Accounts for each type of VAT you pay and collect, “Purchase VAT-X” (asset) and “Sales VAT-X” (liability), or something to that effect. Please contact your accountant if you need more help or post a query on our forums!
\ No newline at end of file
diff --git a/docs/user/buying/docs.user.buying.purchase_taxes.md b/docs/user/buying/docs.user.buying.purchase_taxes.md
deleted file mode 100644
index 31e58bf..0000000
--- a/docs/user/buying/docs.user.buying.purchase_taxes.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-{
-
-	"_label": "Purchase Taxes"
-}
----
-For Tax Accounts that you want to use in the tax templates, you must mention them as type “Tax” in your Chart of Accounts.
-
-Similar to your Sales Taxes and Charges Master is the Purchase Taxes and Charges Master. This is the tax template that you can use in your Purchase Orders and Purchase Invoices. 
-
-> Buying > Purchase Taxes and Charges Master > New Purchase Taxes and Charges Master
-
-
-![Purchase-Taxes](img/purchase-taxes.png)
-
-
-<br>
-
-
-You can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.
-
-If  you select a particular tax as your Default tax, the system will apply this tax to all the purchase transactions by default.
-Calculation Type:
-
-This can be on Net Total (that is the sum of basic amount).
-On Previous Row Total / Amount (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
-Actual (as mentioned).
-
-- **Account Head:** The Account ledger under which this tax will be booked.
-- **Cost Center:** If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
-- **Description:** Description of the tax (that will be printed in invoices / quotes).
-- **Rate:** Tax rate.
-- **Amount:** Tax amount.
-- **Total:** Cumulative total to this point.
-- **Enter Row:** If based on "Previous Row Total" you can select the row number which will be taken as a base for this calculation (default is the previous row).
-- **Consider Tax or Charge for:** In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.
-- **Add or Deduct:** Whether you want to add or deduct the tax.
diff --git a/docs/user/buying/docs.user.buying.supplier.md b/docs/user/buying/docs.user.buying.supplier.md
deleted file mode 100644
index 3707fbe..0000000
--- a/docs/user/buying/docs.user.buying.supplier.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-{
-	"_label": "Supplier Master"
-}
----
-Suppliers are companies or individuals who provide you with products or services. They are treated in exactly the same manner as Customers in ERPNext.
-
-
-You can create a new Supplier via:
-
-> Buying > Supplier > New Supplier
-
-![Supplier](img/supplier.png)
-
-
-### Contacts and Addresses
-
- Contacts and Addresses in ERPNext are stored separately so that you can attach multiple Contacts or Addresses to Customers and Suppliers. To add a Contact or Address go to Buying and click on “New Contact” or “New Address”.
-
-
-> Tip: When you select a Supplier in any transaction, one Contact and Address gets pre-selected. This is the “Default Contact or Address”. So make sure you set your defaults correctly!
-
-### Integration with Accounts
-
-In ERPNext, there is a separate Account record for each Supplier, of Each company.
-
-When you create a new Supplier, ERPNext will automatically create an Account Ledger for the Supplier under “Accounts Receivable” in the Company set in the Supplier record. 
-
-> Advanced Tip: If you want to change the Account Group under which the Supplier Account is created, you can set it in the Company master.
-
-If you want to create an Account in another Company, just change the Company value and “Save” the Supplier again.
-
-
-> Buying > Contact > New Contact
-
-![Contact](img/contact.png)
-
-
-
-
-You can also import from the Data Import Tool
\ No newline at end of file
diff --git a/docs/user/buying/docs.user.buying.supplier_quotation.md b/docs/user/buying/docs.user.buying.supplier_quotation.md
deleted file mode 100644
index 4cb9a75..0000000
--- a/docs/user/buying/docs.user.buying.supplier_quotation.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-{
-	"_label": "Supplier Quotation"
-}
----
-A Supplier Quotation is a formal statement of promise by potential supplier to supply the goods or services required by a buyer, at specified prices, and within a specified period. A quotation may also contain terms of sale and payment, and warranties. Acceptance of quotation by the buyer constitutes an agreement binding on both parties.
-
-
-You can make a supplier quotation from a Material Request
-
-
-
-![Supplier Quotation](img/supplier-quotation-f.jpg)
-
-
-
-You can also make a Supplier Quotation directly from:
-
-> Buying > Supplier Quotation > New Supplier Quotation
-
-
-
-![Supplier Quotation](img/supplier-quotation.png)
-
-
-
-
-If you have multiple **Suppliers** who supply you with the same **Item**, you usually send out a message (Request for Quote) to various **Suppliers**. In many cases, especially if you have centralized buying, you may want to record all the quotes so that 
-
-- You can easily compare prices in the future 
-- Audit whether all Suppliers were given the opportunity to quote.
-
-Supplier Quotations are not necessary for most small businesses. Always evaluate the cost of collecting information to the value it really provides! You could only do this for high value items.
-
diff --git a/docs/user/buying/docs.user.buying.supplier_type.md b/docs/user/buying/docs.user.buying.supplier_type.md
deleted file mode 100644
index 3871991..0000000
--- a/docs/user/buying/docs.user.buying.supplier_type.md
+++ /dev/null
@@ -1,21 +0,0 @@
----
-{
-	"_label": "Supplier Type"
-}
----
-A supplier may be distinguished from a contractor or subcontractor, who commonly adds specialized input to deliverables. A supplier is also known as a vendor. There are different types of suppliers based on their goods and products. 
-
-ERPNext allows you to create your own categories of suppliers. These categories are known as Supplier Type. For Example, if your suppliers are mainly pharmaceutical companies and FMCG distributors, You can create a new Type for them and name them accordingly.
-
-Based on what the suppliers supply, they are classified into different categories called Supplier Type. There can be different types of suppliers. You can create your own category of Supplier Type.
-
-> Buying > Supplier Type > New Supplier Type
-
-![Buying](img/supplier-type.png)
-
-You can classify your suppliers from a range of choice available in ERPNext. Choose from a set of given options like Distributor, Electrical,Hardware, Local, Pharmaceutical, Raw material, Services etc.
-
-Classifying your supplier into different types facilitates accounting and payments. 
-
-
-Type your new supplier category and Save.
diff --git a/docs/user/customer_portal/docs.user.customer_portal.login.md b/docs/user/customer_portal/docs.user.customer_portal.login.md
deleted file mode 100644
index a41d0b2..0000000
--- a/docs/user/customer_portal/docs.user.customer_portal.login.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-{
-	"_label": "Portal Login"
-}
----
-To login into the customer account, the customer has to use his email id and the password sent by ERPNext; generated through the sign-up process.
-
-![Login](img/customer-portal-login.png)
\ No newline at end of file
diff --git a/docs/user/customer_portal/docs.user.customer_portal.md b/docs/user/customer_portal/docs.user.customer_portal.md
deleted file mode 100644
index 54d6e30..0000000
--- a/docs/user/customer_portal/docs.user.customer_portal.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-{
-	"_label": "Customer Portal",
-	"_toc": [
-		"docs.user.customer_portal.sign_up",
-		"docs.user.customer_portal.login",
-		"docs.user.customer_portal.order",
-		"docs.user.customer_portal.tickets"
-	]
-}
----
-
-Customer Portal is designed to give easy accesibility to customers of a company.
-
-
-
diff --git a/docs/user/customer_portal/docs.user.customer_portal.orders.md b/docs/user/customer_portal/docs.user.customer_portal.orders.md
deleted file mode 100644
index d24d038..0000000
--- a/docs/user/customer_portal/docs.user.customer_portal.orders.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-{
-	"_label": "Customer Orders, Invoices, and Shipping Status"
-}
----
-ERPNext Web Portal gives your customers quick access to their Orders, Invoices and Shipments
-Customers can check the status of their orders, invoices, and shipping status by logging on to the web.
-
-
-![Portal Menu](img/portal-menu.png)
-
-
-
-Once an order is raised, either using the Shopping Cart or from within ERPNext, your customer can view the order and keep an eye on the billing and shipment status. When the invoice and payment against these orders are submitted, the customer can see the updated status on the portal, at a glance. 
-
-
-![Customer Portal](img/customer-portal-orders-1.png)
-
-
-#### Invoice with paid status.
-
-
-![Invoice Paid](img/portal-invoice-paid.png)
-
-
-#### Invoice with billed status.
-
-
-![Billed Invoice](img/portal-order-billed.png)
-
diff --git a/docs/user/customer_portal/docs.user.customer_portal.sign_up.md b/docs/user/customer_portal/docs.user.customer_portal.sign_up.md
deleted file mode 100644
index 9574f65..0000000
--- a/docs/user/customer_portal/docs.user.customer_portal.sign_up.md
+++ /dev/null
@@ -1,25 +0,0 @@
----
-{
-	"_label": "Sign-Up"
-}
----
-Customers have to log-in to the Company Website, and sign-up as a customer. 
-
-#### Step 1: Click on Login Icon 
-
-![Sign Up](img/customer-portal-sign-up-1.png)
-
-<br>
-
-#### Step 2: Click on Sign Up Icon
-
-![Sign Up](img/customer-portal-sign-up-2.png)
-
-<br>
-
-#### Step 3: Enter Customer Name and ID
-
-![Sign Up](img/customer-portal-sign-up-3.png)
-
-After the sign up process, a mail will be sent to the customers email id with the password details.
-
diff --git a/docs/user/customer_portal/docs.user.customer_portal.tickets.md b/docs/user/customer_portal/docs.user.customer_portal.tickets.md
deleted file mode 100644
index 6ac8a37..0000000
--- a/docs/user/customer_portal/docs.user.customer_portal.tickets.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-{
-	"_label": "Support Tickets"
-}
----
-
-The customer portal makes it very easy for a customer to raise concerns. A simple and intuitive interface facilitates your customer to report their concerns as Support Tickets. They can view the complete thread of their conversation.
-
-#### Empty Ticket List
-
-![Ticket List](img/portal-ticket-list-empty.png)
-
-
-
-#### New Support Ticket
-
-![New Ticket](img/portal-new-ticket.png)
-
-
-#### Open Support Ticket
-
-![Open Support Ticket](img/portal-ticket-1.png)
-
-
-#### Reply on Support Ticket
-
-![Reply Support Ticket](img/portal-ticket-reply.png)
-
diff --git a/docs/user/customize/docs.user.customize.custom_field.md b/docs/user/customize/docs.user.customize.custom_field.md
deleted file mode 100644
index c5aac31..0000000
--- a/docs/user/customize/docs.user.customize.custom_field.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-{
-	"_label": "Custom Field"
-}
----
-A very common customization is adding of custom fields. You can add Custom Fields in any Master or Transaction in ERPNext. To add a Custom Field, go to:
-
-> Setup > Custom Field > New Custom Field
-
-![Custom Field](img/custom-field.png)
-
-
-
-In the form:
-
-- Select the Document on which you want to add the Custom Field.
-- Select the Type of field and the Options .
-- Select where you want the field to appear in the Form (“after field” section).
-
-and save the Custom Field. When you open a new / existing form of the type you selected in step 1, you will see it with the Custom Fields.
-
-To understand Custom Fields in detail, visit [DocType-Fields](docs.user.knowledge.doctype_fields.html)
-
-#### Naming
-
-Many times you want your fields to be carried over from one form to another. For example, you may have added a Custom Field in Quotation that you want to include in Sales Order when a Sales Order is created from the Quotation. This is simple in ERPNext, just make sure the fields have the same “fieldname”
diff --git a/docs/user/customize/docs.user.customize.custom_form.md b/docs/user/customize/docs.user.customize.custom_form.md
deleted file mode 100644
index f418430..0000000
--- a/docs/user/customize/docs.user.customize.custom_form.md
+++ /dev/null
@@ -1,38 +0,0 @@
----
-{
-	"_label": "Customize Form"
-}
----
-
-You can Customize Forms by changing its layout, making certain fields mandatory, hiding others and changing permission levels on fields by going to:
-
-> Setup > Customize ERPNext > Customize Forms
-
-#### Step 1: Select the required Form Type for Customization.
-
-
-![Customize Forms](img/customize-form-1.png)
-
-
-Select the Form you want to customize and the fields table will be updated with the fields from that form. Here you can:
-
-- Change field types (for e.g. you want to increase the number of decimal places, you can convert some fields from Float to Currency).
-- Change labels to suit your industry / language.
-- Make certain fields mandatory.
-- Hide certain fields.
-- Change layout (sequence of fields). To do this, select a field in the grid and click on “Up” or “Down” in the grid toolbar.
-- Add / edit “Select” Options. (for example, you can add more sources in Leads etc).
-
-You can also allow attachments, set max number of attachments and set the default Print Format.
-
-#### Step 2: Replace Fields with required changes.
-
-![Customize Forms](img/customize-form-2.png)
-
-
-<br>
-
-To understand field definitions, visit [Doctype-Fields](docs.user.knowledge.doctype_fields.html)
-
-
-> Though we want you to do everything you can to customize your ERP based on your business needs, we recommend that you do not make “wild” changes to the forms. This is because, these changes may affect certain operations and may mess up your forms. Make small changes and see its effect before doing some more.
\ No newline at end of file
diff --git a/docs/user/customize/docs.user.customize.custom_scripts b/docs/user/customize/docs.user.customize.custom_scripts
deleted file mode 100644
index 9b6c91f..0000000
--- a/docs/user/customize/docs.user.customize.custom_scripts
+++ /dev/null
@@ -1,6 +0,0 @@
----
-{
-	"_label": "Custom Scripts"
-}
----
-
diff --git a/docs/user/customize/docs.user.customize.custom_scripts.md b/docs/user/customize/docs.user.customize.custom_scripts.md
deleted file mode 100644
index d885ba5..0000000
--- a/docs/user/customize/docs.user.customize.custom_scripts.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-{
-	"_label": "Custom Scripts"
-}
----
-If you wish to change any ERPNext form formats, you can do so by using Custom Scripts. For example, if you wish to add a submit button after saving, to a Lead form, you can do so by creating your own script.
-
-> Setup > Customization > Custom Script
-
-
-![Custom Script](img/custom-script.png)
-
diff --git a/docs/user/customize/docs.user.customize.hide_unhide.md b/docs/user/customize/docs.user.customize.hide_unhide.md
deleted file mode 100644
index 8edf8f6..0000000
--- a/docs/user/customize/docs.user.customize.hide_unhide.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-{
-	"_label": "Hiding Modules and Features"
-}
----
-### Hiding Unused Features
-
-As you have seen from this manual that ERPNext contains tons of features which you may not use. We have observed that most users start with using 20% of the features, though a different 20%. To hide fields belonging to features you dont require, go to:
-
-> Setup > Tools > Hide/Unhide Features
-
-![Hide Features](img/hide-features.png)
-
-
-Check / uncheck the features you want to use and refresh your page for the changes to take effect.
-
----
-
-### Hiding Module Icons
-
-To hide modules (icons) from the home page, go to:
-
-Setup > Tools> Modules Setup
-
-![Hide/Unhide Modules](img/hide-module.png)
-
-
-> Note: Modules are automatically hidden for users that have no permissions on the documents within that module. For example, if a user has no permissions on Purchase Order, Purchase Request, Supplier, the “Buying” module will automatically be hidden.
diff --git a/docs/user/customize/docs.user.customize.md b/docs/user/customize/docs.user.customize.md
deleted file mode 100644
index 9bcdac3..0000000
--- a/docs/user/customize/docs.user.customize.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-{
-	"_label": "Customize ERPNext",
-	"_toc": [
-		"docs.user.customize.custom_field",
-		"docs.user.customize.custom_form",
-		"docs.user.customize.hide_unhide",
-		"docs.user.customize.print_format",
-		"docs.user.customize.custom_scripts"
-	]
-}
----
-ERPNext offers many tools to customize the system.
-
-You simplify the forms by hiding features you don’t need using Disable Features and Module Setup, add Custom Fields, change form properties, like adding more options to drop-downs or hiding fields using Customize Form View and make your own Print Formats by using HTML Templates. You can also create multiple Letter Heads for your Prints.
diff --git a/docs/user/customize/docs.user.customize.print_format.md b/docs/user/customize/docs.user.customize.print_format.md
deleted file mode 100644
index eed52bd..0000000
--- a/docs/user/customize/docs.user.customize.print_format.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-{
-	"_label": "Print Format"
-}
----
-Print Formats are the layouts that are generated when you want to Print or Email a transaction like a Sales Invoice. There are two types of Print Formats,
-
-- The auto-generated “Standard” Print Format: This type of format follows the same layout as the form and is generated automatically by ERPNext.
-- Based on the Print Format document. There are templates in HTML that will be rendered with data.
-
-ERPNext comes with a number of pre-defined templates in three styles: Modern, Classic and Spartan. You modify these templates or create your own. Editing ERPNext templates is not allowed because they may be over-written in an upcoming release.
-
-To create your own versions, open an existing template from:
-
-> Setup > Printing > Print Formats
-
-
-![Print Format](img/print-format.png)
-
-<br>
-
-
-
-Select the type of Print Format you want to edit and click on the “Copy” button on the right column. A new Print Format will open up with “Is Standard” set as “No” and you can edit the Print Format.
-
-Editing a Print Format is a long discussion and you will have to know a bit of HTML, Javascript and Python to learn this. For help, please post on our forum.
-
-> Note: Pre-printed stationary is usually not a good idea because your Prints will look incomplete (inconsistent) when you send them by mail.
-
-#### Footers
-
-Many times you may want to have a standard footer for your prints with your address and contact information. Unfortunately due to the limited print support in HTML pages, it is not possible unless you get it scripted. Either you can use pre-printed stationary or add this information in your header.
-
diff --git a/docs/user/docs.user.help.md b/docs/user/docs.user.help.md
deleted file mode 100644
index 9563ce1..0000000
--- a/docs/user/docs.user.help.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-{
-	"_label": "Getting Help",
-	"_icon": "question"
-}
----
-If you are stuck, have searched all the posible help that is available online, and need to talk to someone, here is how you do it:
-
-### 1. Head to the Forums
-
-- If you are a user or you are evaluating and want to talk to other ERPNext users, go to the [ERPNext User Forum](groups.google.com/group/erpnext-user-forum/)
-
-- If you are a developer and want help in customizing or extending ERPNext, head to the developer forums [ERPNext Developer Forum](groups.google.com/group/erpnext-developer-forum/)
-
-### 2. Report an Issue / Suggestion at GitHub
-
-We use GitHub to manage the development of ERPNext. So if you encounter a bug or have a suggestion, feel free to add a GitHub issue. Everyone on the core team keeps a watch on that list.
-
-- [ERPNext Issues on GitHub](https://github.com/webnotes/erpnext/issues)
-
-### 3. Get in touch with a local partner.
-
-ERPNext has an expanding partner community. So check this page out if there is a local partner in your region.
-
-- [ERPNext Parter List](https://erpnext.com/partners)
-
-### 4. Buy Commercial Support / Hosting
-
-You can buy affordable hosting from Web Notes or buy commercial support which offers:
-
-1. One-on-one sessions via screen sharing.
-1. Priority bug fixing
-1. Remote setup and installation on your linux server.
-1. Help in setting up backups and restoring.
-
-- [ERPNext Commercial Support](http://erpnext.com/open-source-commercial-support)
diff --git a/docs/user/docs.user.md b/docs/user/docs.user.md
deleted file mode 100644
index 8c58ad4..0000000
--- a/docs/user/docs.user.md
+++ /dev/null
@@ -1,178 +0,0 @@
----
-{
-	"_label": "User Guide",
-	"_toc": [
-		"docs.user.intro",
-		"docs.user.five_day_setup",
-		"docs.user.implement",
-		"docs.user.setup",
-		"docs.user.selling",
-		"docs.user.buying",
-		"docs.user.stock",
-		"docs.user.accounts",
-		"docs.user.hr",
-		"docs.user.mfg",
-		"docs.user.support",
-		"docs.user.projects",
-		"docs.user.website",
-		"docs.user.tools",
-		"docs.user.customize",
-		"docs.user.knowledge",
-		"docs.user.customer_portal"
-	],
-	"_no_toc": 1
-}
----
-This manual covers all the major processes in setting up and using ERPNext. The manual is written in a way that the user can manage a self-implementation of the ERP. We recommend that the manual be read first before starting implementation.
-
-Contents
-
-1. [Introduction](docs.user.intro.html)
-	1. [Open Source](docs.user.intro.open_source.html)
-	1. [Ways to get started](docs.user.intro.try.html)
-	1. [Getting Help](docs.user.help.html)
-1. [Five-Day-Setup](docs.user.five_day_setup.html)
-	1. [Day-1: Setup Customer,Item, and Supplier](docs.user.five_day_setup.day_1.html)
-	1. [Day-2: Setup Chart of Accounts, Opening Accounts, and HR](docs.user.five_day_setup.day_2.html)
-	1. [Day-3: Sales Cycle and Purchase Cycle](docs.user.five_day_setup.day_3.html)
-	1. [Day-4: Manufacturing Cycle and Accounting Reports](docs.user.five_day_setup.day_4.html)
-	1. [Day-5: Projects, Calendar, and Website](docs.user.five_day_setup.day_5.html)
-1. [Implementation](docs.user.implement.html)
-	1. [Implementation Strategy](docs.user.implement.strategy.html)
-	1. [Concepts](docs.user.implement.concepts.html)
-1. [Setup](docs.user.setup.html)
-	1. [First Login](docs.user.setup.first.html)
-	1. [Setting Up Masters (Item, Customer, Supplier)](docs.user.setup.masters.html)
-	1. [Chart of Accounts](docs.user.setup.accounting.html)
-	1. [Chart of Cost Centers](docs.user.setup.cost_centers.html)
-	1. [Company Setup](docs.user.setup.company.html)
-	1. [Adding Users](docs.user.setup.users.html)
-	1. [Permissions](docs.user.setup.permissions.html)
-	1. [Workflows](docs.user.setup.workflows.html)
-	1. [Letter Heads](docs.user.setup.letter_head.html)
-	1. [Print Headings](docs.user.setup.print_headings.html)
-	1. [Numbering Series](docs.user.setup.series.html)
-	1. [Global Defaults](docs.user.setup.global_defaults.html)
-	1. [Importing Data](docs.user.setup.data_import.html)
-	1. [Email Settings](docs.user.setup.email.html)
-	1. [SMS Settings](docs.user.setup.sms.html)
-	1. [Setting up Taxes](docs.user.setup.taxes.html)
-	1. [Price Lists](docs.user.setup.price_list.html)
-	1. [Adding Opening Entries](docs.user.setup.opening.html)
-	1. [POS Setting](docs.user.setup.pos_setting.html)
-	1. [Third Party Backups](docs.user.setup.third_party_backups.html)	
-1. [Selling](docs.user.selling.html)
-	1. [Selling Setup](docs.user.selling.selling_setup.html)
-		1. [Customer Group](docs.user.selling.customer_groups.html)
-		1. [Territory](docs.user.selling.territory.html)
-		1. [Sales Partner](docs.user.selling.sales_partner.html)
-		1. [Sales Person](docs.user.selling.sales_person.html)
-		1. [Campaign](docs.user.selling.campaign.html)
-		1. [Terms and Conditions](docs.user.selling.terms.html)
-		1. [Price Lists](docs.user.setup.price_list.html)
-		1. [Discount](docs.user.selling.discount.html)
-		1. [Shopping Cart](docs.user.selling.shopping_cart.html)
-	1. [Customers](docs.user.selling.customer.html)
-	1. [Lead](docs.user.selling.lead.html)
-	1. [Opportunity](docs.user.selling.opportunity.html)
-	1. [Quotation](docs.user.selling.quotation.html)
-	1. [Sales Order](docs.user.selling.sales_order.html)
-1. [Buying](docs.user.buying.html)
-	1. [Supplier Type](docs.user.buying.supplier_type.html)
-	1. [Supplier](docs.user.buying.supplier.html)
-	1. [Material Request](docs.user.buying.material_request.html)
-	1. [Supplier Quotation](docs.user.buying.supplier_quotation.html)
-	1. [Purchase Order](docs.user.buying.purchase_order.html)
-	1. [Purchase Taxes](docs.user.buying.purchase_taxes.html)
-	1. [Price Lists](docs.user.setup.price_list.html)
-	1. [Sub Contracting](docs.user.stock.sub_contracting.html)
-1. [Stock (Inventory)](docs.user.stock.html)
-	1. [Warehouse](docs.user.stock.warehouse.html)
-	1. [Item Group](docs.user.stock.item_group.html)
-	1. [Item](docs.user.stock.item.html)
-	1. [Product Listing on Website](docs.user.stock.product_listing_on_website.html)
-	1. [Serialized Inventory](docs.user.stock.serialized.html)
-	1. [Purchase Receipt](docs.user.stock.purchase_receipt.html)
-	1. [Delivery Note](docs.user.stock.delivery_note.html)
-	1. [Stock Entry / Material Transfer](docs.user.stock.stock_entry.html)
-	1. [Opening Stock](docs.user.accounts.opening_stock.html)
-	1. [Material Issue](docs.user.stock.material_issue.html)
-	1. [Purchase Return](docs.user.stock.purchase_return.html)
-	1. [Projected Quantity](docs.user.stock.projected_quantity.html)
-	1. [Accounting for Stock](docs.user.stock.accounting_for_stock.html)
-	1. [Perpetual Inventory](docs.user.stock.perpetual_inventory.html)
-	1. [How To](docs.user.stocks.how_to.html)
-         1. [Repack Products](docs.user.stock.how_to_repack_products.html)
-         1. [Sales Return](docs.user.stock.sales_return.html)
-	     1. [Migrate to Perpetual Inventory](docs.user.stock.migrate_to_perpetual.html)
-1. [Accounts](docs.user.accounts.html)
-	1. [Chart of Accounts](docs.user.setup.accounting.html)
-	1. [Chart of Cost Centers](docs.user.setup.cost_centers.html)
-	1. [Sales Invoice](docs.user.accounts.sales_invoice.html)
-	1. [Purchase Invoice](docs.user.accounts.purchase_invoice.html)
-	1. [Payment Entry](docs.user.accounts.payments.html)
-	1. [Journal Voucher](docs.user.accounts.journal_voucher.html)
-	1. [Opening Entry](docs.user.accounts.opening_entry.html)
-	1. [Period Closing](docs.user.accounts.closing.html)
-	1. [Accounting Reports](docs.user.accounts.reports.html)
-	1. [Point of Sale (POS) Invoice](docs.user.accounts.pos.html)	
-1. [Human Resources (HR)](docs.user.hr.html)
-	1. [HR Setup](docs.user.hr.setup.html)
-	1. [Employee](docs.user.hr.employee.html)
-	1. [Leave Management](docs.user.hr.leave.html)
-	1. [Attendance](docs.user.hr.attendance.html)
-	1. [Salary and Payroll](docs.user.hr.payroll.html)
-	1. [Expense Claim](docs.user.hr.expense_claim.html)
-	1. [Appraisal](docs.user.hr.appraisal.html)
-1. [Manufacturing](docs.user.mfg.html)
-	1. [Bill of Materials](docs.user.mfg.bom.html)
-	1. [Production Planning](docs.user.mfg.planning.html)
-	1. [Production Order](docs.user.mfg.production_order.html)
-1. [Customer Support and Maintenance](docs.user.support.html)
-	1. [Support Ticket](docs.user.support.support_ticket.html)
-	1. [Customer Issue](docs.user.support.customer_issue.html)
-	1. [Maintenance Schedule](docs.user.support.maintenance_schedule.html)
-	1. [Maintenance Visit](docs.user.support.maintenance_visit.html)
-	1. [Maintenance Schedule](docs.user.support.maintenance_schedule.html)
-	1. [Newsletter](docs.user.support.newsletter.html)
-1. [Projects](docs.user.projects.html)
-	1. [Projects](docs.user.projects.projects.html)
-	1. [Task](docs.user.projects.task.html)
-	1. [Time Log](docs.user.projects.timelog.html)
-1. [Website](docs.user.website.html)
-	1. [Setup](docs.user.website.setup.html)
-	1. [Web Pages](docs.user.website.web_page.html)
-	1. [Style](docs.user.website.style.html)
-	1. [Blog](docs.user.website.blog.html)
-	1. [Shopping Cart](docs.user.website.shopping_cart.html)
-	1. [Add Products](docs.user.website.add_products_to_website.html)
-1. [Tools](docs.user.tools.html)
-	1. [To Do](docs.user.tools.todo.html)
-	1. [Calendar](docs.user.tools.calendar.html)
-	1. [Assignments](docs.user.tools.assignment.html)
-	1. [Tags](docs.user.tools.tags.html)
-	1. [Forms](docs.user.tools.form_tools.html)
-	1. [Messages](docs.user.tools.messages.html)
-	1. [Notes](docs.user.tools.notes.html)
-1. [Customize](docs.user.customize.html)
-	1. [Custom Fields](docs.user.customize.custom_field.html)
-	1. [Customize Form](docs.user.customize.custom_form.html)
-	1. [Hide / Unhide modules](docs.user.customize.hide_unhide.html)
-	1. [Print Formats](docs.user.customize.print_formats.html)
-	1. [Custom Scripts](docs.user.customize.custom_scripts.html)
-1. [Knowledge Library](docs.user.knowledge.html)
-	1. [Fiscal Year](docs.user.knowledge.fiscal_year.html)
-	1. [Accounting Knowledge](docs.user.knowledge.accounting.html)
-	1. [Accounting Entries](docs.user.knowledge.accounting_entries.html)
-	1. [DocType Definitions](docs.user.knowledge.doctype.html)
-	1. [DocType Fields](docs.user.knowledge.doctype_fields.html)
-	1. [Attachment and CSV Files](docs.user.knowledge.attachment_csv.html)
-	1. [Format using Markdown](docs.user.knowledge.markdown.html)
-	1. [Make-to-Stock Manufacturing](docs.user.knowledge.make_to_stock.html)
-	1. [Make-to-Order Manufacturing](docs.user.knowledge.make_to_order.html)
-	1. [Engineer-to-Order Manufacturing](docs.user.knowledge.engineer_to_order.html)
-1. [Customer Portal](docs.user.customer_portal.html)
-	1. [Sign Up](docs.user.customer_portal.sign_up.html)
-	2. [Login](docs.user.customer_portal.login.html)
-	3. [Customer Orders](docs.user.customer_portal.orders.html)
-	4. [Support Tickets](docs.user.customer_portal.tickets.html)
diff --git a/docs/user/docs.user.reports.builder.md b/docs/user/docs.user.reports.builder.md
deleted file mode 100644
index 31a1939..0000000
--- a/docs/user/docs.user.reports.builder.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-{
-	"_label": "Report Builder"
-}
----
-All the data that you enter in ERPNext is stored in database tables. An easy way to visualize this is to imagine each type of data like Customer, Sales Invoice, Task is stored in a separate spreadsheets, each containing all the data included in one table.
-
-ERPNext gives you a simple tool called the Report Builder to extract data from these tables and show them in rows and columns where you can pick and choose which column to display and filter and sort the data by different parameters.
-
-To start a new report click on the “Report” menu in the top toolbar or on the list page of any transaction click on the “Build Report” button. For example, to make a report of Sales Invoices, go to
-
-> Accounts > Sales Invoice > Build Report
-
-### Exporting
-
-If you have “Report Manager” or “System Manager” permission, you can export the data from the Report Building via CSV to your favorite Spreadsheet application where you can do further analysis, apply formulas, make graphs etc.Selecting Columns
-￼
-You can select columns by clicking on “Pick Columns”. Select the column you want from the drop-down.
-
-You can also select columns from the “child tables”. For example if you have selected Sales Invoice, you can select columns from the Sales Invoice Item table also.
-
-### Adding Filters
-￼
-You can also add multiple filters by clicking on the “Show Filters” button.
-
-### Saving
-
-You can also save your selection of columns and filters by clicking on the “Save” button. You might need “System Manager” or “Report Manager” privileges for this. When you save a report, it will appear in the “Reports” section of the module page.
diff --git a/docs/user/docs.user.reports.md b/docs/user/docs.user.reports.md
deleted file mode 100644
index 4f08fff..0000000
--- a/docs/user/docs.user.reports.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-{
-	"_label": "Reports and Analytics",
-	"_toc": [
-		"docs.user.reports.builder"
-	]
-}
----
diff --git a/docs/user/five_day_setup/docs.user.five_day_setup.day_1.md b/docs/user/five_day_setup/docs.user.five_day_setup.day_1.md
deleted file mode 100644
index bbb8b86..0000000
--- a/docs/user/five_day_setup/docs.user.five_day_setup.day_1.md
+++ /dev/null
@@ -1,81 +0,0 @@
----
-{
-	"_label": "Day-1: Setup Customer, Item, and Supplier"
-}
----
-Login to your ERPNext account with the User ID and Password sent through the mail.
-
-After logging into your account you will receive a pop-up form to fill. Please fill this form. Select the abbreviation you would wish to have for your company. The abbreviation selected here will be used in naming most of the business documents.
-
-#### Form Part I
-
-![1st Form](img/firstdaysetup-1.png)
-<br><br>
-#### Form Part II
-To understand about Company Financial Year or Fiscal Year visit [Fiscal Year](docs.user.knowledge.fiscal_year.html)
-
-
-![1st Form](img/firstdaysetup-2.png)
-
-After filling this form, you will get a pop-up message for completing the  set-up process. Click on the Setup button. The Setup page will appear.
-
-<br>
-#### Setup Page - Customer
-
-The Organisation details are updated in ERPNext, after filling the first form. Go directly to the Customer Icon.
-
-![Customer](img/firstdaysetup-customer.png)
-<br>
-
-
-After clicking on Customer, a new form will appear. 
-<br>
-
-![Customer](img/firstdaysetup-customer-1.png)
-
-To see how customer details are added, visit [Customer](docs.user.selling.customer.html). Create 5 new customer records in the system. 
-
-Now proceed to make an Item. To go to the main menu, click on erpnext icon which is on the left hand corner of the page. On the main menu page, click on Setup
-
-![Main Menu](img/firstdaysetup-main-menu.png)
-
-<br>
-
-#### Setup Page - Item
-
-On the setup page go to Item.
-
-
-![Item](img/firstdaysetup-item.png)
-
-
-Create a new Item. An Item is your company's product or a service.The term Item is applicable to your core products as well as your raw materials. It can be a product or service that you buy/sell from your customers/ suppliers.
-
-Filling Item details is an important step in ERPNext. Do not postpone this step. After clicking on Item, make a new Item.
-
-![Item](img/firstdaysetup-item-1.png)
-
-To understand how to fill an Item in detail, visit [Item](docs.user.stock.item.html). Add 5 item records to ERPnext. After adding these records, go back to the Setup Page and add Suppliers.
-
-<br>
-#### Setup Page - Suppliers
-On the Setup page go to Supplier.
-
-![Supplier](img/firstdaysetup-supplier.png)
-<br>
-
-Suppliers are companies or individuals who provide you with products or services. They are treated in exactly the same manner as Customers in ERPNext. Create a new Supplier record.
-
-![Supplier](img/firstdaysetup-supplier-1.png)
-
-
-To understand how to fill Supplier details, visit [Supplier](docs.user.buying.supplier.html). 
-
-If you wish to import your list of customers and suppliers directly to ERPNext, you can do that via the Data Import Tool.
-
-To upload Customers or suppliers in bulk, go to the Data Import Tool.
-
-> Note: The data import format is case-sensitive. The file will not be processed if there are any spelling mistakes or deviations from the default values.
-
-To understand how to import data, visit [Importing Data](docs.user.setup.data_import.html).
-
diff --git a/docs/user/five_day_setup/docs.user.five_day_setup.day_2.md b/docs/user/five_day_setup/docs.user.five_day_setup.day_2.md
deleted file mode 100644
index f016623..0000000
--- a/docs/user/five_day_setup/docs.user.five_day_setup.day_2.md
+++ /dev/null
@@ -1,54 +0,0 @@
----
-{
-	"_label": "Day-2: Setup Chart of Accounts, Opening Accounts, and HR"
-}
----
-
-#### Setup Page - Accounts
-<br>
-Go to the Accounts icon and make ledgers under Chart of Accounts.
-
-![Accounts](img/seconddaysetup-accounts.png)
-
-<br>
-
-
-Create acccounting ledgers.
-
-![Tree](img/seconddaysetup-tree.png)
-
-<br>
-
-To begin Opening Entries, go to 'Opening Accounts and Stock' on the Setup Page. 
-
-![Ledger](img/seconddaysetup-accounts-jv.png)
-
-<br>
-
-
-To understand how to create opening entries in detail visit [Opening Entry](docs.user.setup.opening.html).
-
-<br>
-
-#### Opening Stock
-
-You can upload your opening stock in the system using Stock Reconciliation. Stock Reconciliation will update your stock for any given Item. 
-
-![Stock Opening](img/seconddaysetup-stock-opening.png)
-<br>
-
-
-To understand Stock Opening in detail visit [Opening Stock](docs.user.accounts.opening_stock.html).
-
-<br>
-
-#### Setup Page - HR Setup
-
-To setup HR, begin by creating individual employee records.
-
-
-![Employee](img/seconddaysetup-hr.png)
-
-To fill the Employee Form, refer to [Employee](docs.user.hr.employee.html)
-
-To complete the remaining HR-Setup, see [Human Resources](docs.user.hr.html)
\ No newline at end of file
diff --git a/docs/user/five_day_setup/docs.user.five_day_setup.day_3.md b/docs/user/five_day_setup/docs.user.five_day_setup.day_3.md
deleted file mode 100644
index e0c4114..0000000
--- a/docs/user/five_day_setup/docs.user.five_day_setup.day_3.md
+++ /dev/null
@@ -1,139 +0,0 @@
----
-{
-	"_label": "Day-3: Sales Cycle and Purchase Cycle"
-}
----
-After completing the set-up and account opening process, it is advisable  to complete a few cycles of sales, purchase, and manufacturing process.
-
-
-### Sales Cycle
-
-Complete a standard Sales Cycle.
-> Lead > Opportunity > Quotation > Sales Order > Delivery Note > Sales Invoice > Payment (Journal Voucher)
-
-<br>
-#### Lead
-
-To begin the sales cycle, go to the Selling Icon. On the selling page, click on Lead. 
-
-![Lead](img/thirddaysetup-lead.png)
-
-Fill the Lead form.
-
-> To understand Lead in detail, visit [Lead](docs.user.selling.lead.html)
-
-<br>
-#### Opportunity
-
-After completing the Lead form, assume that, this same lead is getting converted into an Opportunity. Thus, to create an Opportunity from the existing lead, click on Create Opportunity, on the Lead page.
-
-##### Step 1: Go to 'Lead List' Page and open the Lead that shows interested status.
-
-![Opportunity](img/thirddaysetup-opportunity-1.png)
-
-<br>
-
-##### Step 2: Generate Opportunity from the selected Lead
-
-![Opportunity](img/thirddaysetup-opportunity.png)
-
-You can also generate an Opportunity directly from the Selling Page.
-
-> To understand Opportunity in detail visit [Opportunity](docs.user.selling.opportunity.html).
-
-<br>
-#### Quotation
-
-Imagine that your Opportunity has shown interest and asked for a Quotation. To generate a Quotation from the same Opportunity, open the submitted Opportunity and click on Create Quotation.
-
-![Quotation](img/thirddaysetup-quotation.png)
-
-You can also generate a Quotation directly from the Selling Page.
-
-> To understand Quotation in detail visit [Quotation](docs.user.selling.quotation.html)
-
-<br>
-#### Sales Order
-
-Imagine that the Quotation which you sent was accepted by the prospect. You are now  reequired to send him a Sales Order. To make a sales order from this same Quotation, go to that Quotation page and click on Make Sales Order.
-
-![Sales Order](img/thirddaysetup-sales-order.png)
-
-You can also generate a Sales Order directly from the Selling Page.
-
-> To understand Sales Order in detail visit [Sales Order](docs.user.selling.sales_order.html).
-
-<br>
-#### Delivery Note
-
-If your organisation has the practice of sending Delivery Note, this section will be helpful. To create a Delivery Note from the a Sales Order, go to that Sales Order and click on Make Delivery.
-
-
-![Delivery Note](img/thirddaysetup-delivery-note.png)
-
-> To understand Delivery Note in detail, visit [Delivery Note](docs.user.stock.delivery_note.html)
-
-<br>
-#### Sales Invoice
-
-Save and Submit your Delivery Note to generate a Sales Invoice. You can also generate an Invoice from Sales Order.
-
-![Sales Invoice](img/thirddaysetup-sales-invoice.png)
-
-<br>
-
-#### Payment (Journal Voucher)
-
-
-A Journal Voucher or a payment entry can be generated directly from the Sales Invoice.
-
-![Payment Entry](img/thirddaysetup-payment-entry.png)
-
-> To understand a Journal Voucher in detail, visit [Journal Voucher](docs.user.accounts.journal_voucher.html)
-
-<br>
-
-### Purchase Cycle
-
-Complete a standard Purchase Cycle.
-> Material Request > Purchase Order > Purchase Receipt > Payment (Journal Voucher).
-
-<br>
-#### Material Request
-
-To create a Material Request, go to Stock/Buying and Click on Material Request.
-
-![Material Request](img/thirddaysetup-material-request.png)
-
-> To understand Material Request in detail, visit [Material Request](docs.user.buying.material_request.html)
-
-<br>
-#### Purchase Order
-
-To create a Purchase Order go to Buying and click on Purchase Order
-
-![Purchase Order](img/thirddaysetup-purchase-order.png)
-
-> To understand Purchase Order in detail, visit [Purchase Order](docs.user.buying.purchase_order.html)
-
-<br>
-#### Purchase Receipt
-
-To create a Purchase Receipt from an existing Purchase Order, open that purchase order and click on Make Purchase Receipt.
-
-![Purchase Receipt](img/thirddaysetup-purchase-receipt.png)
-<br>
-
->To understand Purchase Receipt in detail, visit [Purchase Receipt](docs.user.stock.purchase_receipt.html)
-
-<br>
-
-#### Payment (Journal Voucher)
-
-Payments made against Sales Invoices or Purchase Invoices can be made by clicking on “Make Payment Entry” button on “Submitted” invoices.
-
-
-![Payment Entry](img/thirddaysetup-payment-entry.png)
-<br>
-
-> To understand Payment Entry in detail, visit [Payment Entry](docs.user.accounts.payments.html).
diff --git a/docs/user/five_day_setup/docs.user.five_day_setup.day_4.md b/docs/user/five_day_setup/docs.user.five_day_setup.day_4.md
deleted file mode 100644
index af6e636..0000000
--- a/docs/user/five_day_setup/docs.user.five_day_setup.day_4.md
+++ /dev/null
@@ -1,86 +0,0 @@
----
-{
-	"_label": "Day-4: Manufacturing Cycle and Accounting Reports"
-}
----
-
-### Manufacturing Cycle
-
-Complete a manufacturing cycle (if applicable).
-> BOM > Production Planning Tool > Production Order > Stock Entry (Material Issue) > Stock Entry (Sales Return)
-
-<br>
-#### Bill of Materials
-
-To go to Bill of Materials, Click on Manufacturing. On the Manufacturing page, click on Bill of Materials.
-
-![Bill of Materials](img/fourthdaysetup-bom.png)
-
-> To understand BOM in detail, visit [Bill of Materials](docs.user.mfg.bom.html)
-
-<br>
-#### Production Planning Tool
-
-To go to Production Planning Tool, click on the Manufacturing Icon. On the Manufacturing Page, click on Production Planning Tool to go to that page.
-
-![Production Planning Page](img/fourthdaysetup-ppt.png)
-
-> To understand Production Planning Tool in detail, visit [Production Planning](docs.user.mfg.planning.html)
-
-<br>
-#### Production Order
-
-To go to Production Order click on the Manufacturing Icon. On the Manufacturing Page, click on Production Order.
-
-![Production Order](img/fourthdaysetup-po.png)
-
-> To understand Production Order in detail, visit [Production Order](docs.user.mfg.production_order.html)
-
-<br>
-#### Stock Entry
-
-To go to Stock Entry, click on the Stock Icon and go to Stock Entry.
-
-![Stock Entry](img/fourthdaysetup-stock.png)
-
-> To understand Material Issue, visit [Material Issue](docs.user.stock.material_issue.html).
-
-> To understand Sales Return, visit [Sales Return](docs.user.stock.sales_return.html).
-
-<br>
-#### Delivery Note
-
-To go to Delivery Note, click on Stock. On the Stock Page, click on Delivery Note.
-
-![Delivery Note](img/fourthdaysetup-delivery-note.png)
-
-> To understand Delivery Note in detail, visit [Delivery Note](docs.user.stock.delivery_note.html)
-
-<br>
-#### Warehouse
-
-To go to Warehouse, Click on Stock. On the Stock Page, go to Warehouse.
-
-![Warehouse](img/fourthdaysetup-warehouse.png)
-
-> To understand Warehouse in detail, visit [Warehouse](docs.user.stock.warehouse.html)
-
-<br>
-#### Accounts
-
-Make a few Journal Vouchers. Generate some Accounting Reports.
-
-#### Journal Voucher
-
-To go to a Journal Voucher, click on Accounts. On the Accounts page, click on Journal Voucher.
-
-![Journal Voucher](img/fourthdaysetup-jv.png)
-
-> To understand Journal Voucher in detail, visit [Journal Voucher](docs.user.accounts.journal_voucher.html)
-
-<br>
-### Accounting Reports
-
-Some of the major Accounting Reports are General Ledger, Trial Balance, Accounts  Payable and Accounts Receivables, and Sales and Purchase Register.
-
-> To be able to generate these accounts, visti [Accounting Reports](docs.user.accounts.report.html)
diff --git a/docs/user/five_day_setup/docs.user.five_day_setup.day_5.md b/docs/user/five_day_setup/docs.user.five_day_setup.day_5.md
deleted file mode 100644
index db386a0..0000000
--- a/docs/user/five_day_setup/docs.user.five_day_setup.day_5.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-{
-	"_label": "Day-5: Projects, Calendar, and Website"
-}
----
-
-#### Projects
-
-ERPNext helps you to manage your Projects by breaking them into Tasks and allocating them to different people.
-
-<br>
-#### Tasks
-
-Project is divided into Tasks and each Task is allocated to a resource. In ERPNext, you can also create and allocate a Task independently of a Project.
-
-To create a Task, go to Project and click on Task.
-
-![Tasks](img/fifthdaysetup-tasks.png)
-
-> To understand Projects in detail, visit [Projects](docs.user.projects.html).
-
-> To understand Task in detail, visit [Tasks](docs.user.projects.tasks.html)
-
-<br>
-#### Calendar
-
-> To understand Calendar in detail, visit [Calendar](docs.user.tools.calendar.html)
-
-<br>
-#### Website
-
-> To understand Website in detail, visit [Website](docs.user.website.html)
diff --git a/docs/user/five_day_setup/docs.user.five_day_setup.md b/docs/user/five_day_setup/docs.user.five_day_setup.md
deleted file mode 100644
index 90aeb56..0000000
--- a/docs/user/five_day_setup/docs.user.five_day_setup.md
+++ /dev/null
@@ -1,48 +0,0 @@
----
-{
-	"_label": "Five-Day Setup",
-	"_toc": [
-		"docs.user.five_day_setup.day_1",
-		"docs.user.five_day_setup.day_2",
-		"docs.user.five_day_setup.day_3",
-		"docs.user.five_day_setup.day_4",
-		"docs.user.five_day_setup.day_5"
-			
-	]
-}
----
-Welcome to ERPNext. To be able to setup ERPNext account successfully, a five-day-setup process is recommended. Perform the 5-days-setup instructions and sail through the ERPNext implementation.
-
-The setup help is divided into day-wise instructions for 5 consecutive days. 
-
-#### Day 1
-
-- Company Setup
-- Customer Setup
-- Item Setup
-- Supplier Setup
-- Data Import Tool
-
-#### Day 2
-
-- Opening Accounts 
-- Opening Stock
-- HR Setup
-
-#### Day 3
-
-- Sales Cycle
-- Purchase Cycle
-
-	
-#### Day 4
-
-- Manufacturing Cycle
-- Delivery Note and Warehouse 
-- Accounts
-
-#### Day 5
-
-- Projects
-- Calendar
-- Website
\ No newline at end of file
diff --git a/docs/user/hr/docs.user.hr.appraisal.md b/docs/user/hr/docs.user.hr.appraisal.md
deleted file mode 100644
index 5737256..0000000
--- a/docs/user/hr/docs.user.hr.appraisal.md
+++ /dev/null
@@ -1,29 +0,0 @@
----
-{
-	"_label": "Appraisal"
-}
----
-In ERPNext, you can manage Employee Appraisals by creating an Appraisal Template for each role with the parameters that define the performance by giving appropriate weightage to each parameter.
-
-> HR > Appraisal > New Appraisal
-
-
-
-#### Step 1: Select an Appraisal Template
-
-
-![Appraisal](img/appraisal-1.png)
-
-
-After you select the template, the remaining form appears.
-
-
-#### Step 2: Enter Employee Details
-
-![Appraisal](img/appraisal-2.png)
-
-
-
-Once the Appraisal Template is completed, you can create Appraisal records for each period where you track performance. You can give points out of 5 for each parameter and the system will calculate the overall performance of the Employee.
-
-To make the Appraisal final, make sure to “Submit” it.
\ No newline at end of file
diff --git a/docs/user/hr/docs.user.hr.attendance.md b/docs/user/hr/docs.user.hr.attendance.md
deleted file mode 100644
index 03001b7..0000000
--- a/docs/user/hr/docs.user.hr.attendance.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-{
-	"_label": "Attendance"
-}
----
-
-An Attendance record stating that an Employee has been present on a particular day can be created manually by:
-
-> HR > Attendance > New Attendance
-￼
-
-![Attendance](img/attendance.png)
-
-
-
-
-It can also be done by collecting attendance information via an automated system like a swipe card. You can even upload a CSV file with the attendance information. 
-
-You can get a monthly report of your Attendance data by going to the “Monthly Attendance Details” report.
-
-To upload the attendance go to:
-
-> HR > Upload Attendance 
-
-![Upload Attendance](img/upload-attendance.png)
-
diff --git a/docs/user/hr/docs.user.hr.employee.md b/docs/user/hr/docs.user.hr.employee.md
deleted file mode 100644
index 16ee8cd..0000000
--- a/docs/user/hr/docs.user.hr.employee.md
+++ /dev/null
@@ -1,50 +0,0 @@
----
-{
-	"_label": "Employee Master"
-}
----
-There are many fields you can add in your Employee records. As the organisation grows, it becomes difficult to manage more records. It is advisable to keep updating and entering records to facilitate data management of employees.
-
-Employee records also help in keeping a list of your team’s skills, previous employment history and  emergency information.
-
-To create new Employee go to:
-
-> HR > Employee > New Employee 
-
-#### Step 1: Capture basic information and Employement Details.
-
-
-![Employee Master](img/employee-master-1.png)
-
-<br>
-
-
-#### Step 2: Complete Job Profile and Organisation Profile.
-
-
-![Employee Master](img/employee-master-2.png)
-
-
-
-<br>
-
-
-#### Step 3: Update contact details, personal details, and previous employement details.
-
-
-
-![Employee Master](img/employee-master-3.png)
-
-
-
-### Numbering Employees (Employee ID)
-
-By default, in ERPNext Employee Records are Numbered. You can have multiple series if you are a really large company and want to have separate numbering series for separate locations etc. You can set the numbering series just like any other transaction by going to:
-
-> Setup > Customize  > Document Numbering Series.
-
-Alternatively, you can create employees by the “Employee Number” field if you already have an existing Employee Numbering system you want to follow. To set this, go to
-
-> Setup > Global Defaults > HR
-
-and update the “Employee Records created by” field.
\ No newline at end of file
diff --git a/docs/user/hr/docs.user.hr.expense_claim.md b/docs/user/hr/docs.user.hr.expense_claim.md
deleted file mode 100644
index 06bb8eb..0000000
--- a/docs/user/hr/docs.user.hr.expense_claim.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-{
-	"_label": "Expense Claim"
-}
----
-Expense Claim is made when Employee’s make expenses out of their pocket on behalf of the company. For example, if they take a customer out for lunch, they can make a request for reimbursement via the Expense Claim form. 
-
-To make a new Expense Claim, go to:
-
-> HR > Expense Claim > New Expense Claim
-
-
-![Expense Claim](img/expense-claim.png)
-
-
-
-
-Set the Employee ID, date and the list of expenses that are to be claimed and “Submit” the record.
-
-### Approving Expenses
-
-The person making the claim must also set the id of the user who will “Approve” these expenses and set the “Assign To” to notify the user of the request Approve.
-
-If the Approver sees the “form”, she or he can update the “Approved Amounts” and click on “Approve”. To cancel the claim, they can click on the “Reject” button.
-
-Comments can be added in the Comments section explaining why the claim was approved or rejected.
-
-### Booking the Expense and Reimbursement
-
-The approved Expense Claim must then be converted into a Journal Voucher and a payment must be made. Note: This amount should not be clubbed with Salary because the amount will then be taxable to the Employee.
\ No newline at end of file
diff --git a/docs/user/hr/docs.user.hr.leave.md b/docs/user/hr/docs.user.hr.leave.md
deleted file mode 100644
index b5dbba6..0000000
--- a/docs/user/hr/docs.user.hr.leave.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-{
-	"_label": "Leave"
-}
----
-
-### Leave Allotment
-
-Fixed number of leaves per Employee can be allocated using the Leave Allocation Tool. If you have special leaves to be allocated, you can also allocate them manually by creating new Leave Allocation records.
-
-> HR > Leave Allocation > New Leave Allocation
-
-![Leave ALlocation](img/leave-allocation.png)
-
----
-
-### Leave Application
-
-If your company has a formal system where Employees have to apply for leaves to be able to qualify as paid leaveas, you can create Leave Application to track approval and usage of leaves. You have to mention the Employee, Leave Type and the period for which the leave is taken. If you want specific users to approve leaves, you can give “Submission” rights to those users only.
-
-> HR > Leave Application > Make New Leave Application
-
-
-![New Leave Application](img/new-leave-application.png)
-
-
-
-If you want all users to create their own Leave Applications, you can set their “Employee ID” as a match rule in the Leave Application Permission settings. See the earlier discussion on permission settings for more info. [Permissions](docs.user.setup.permissions.html)
-
-
diff --git a/docs/user/hr/docs.user.hr.md b/docs/user/hr/docs.user.hr.md
deleted file mode 100644
index e86f9e0..0000000
--- a/docs/user/hr/docs.user.hr.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-{
-	"_label": "Human Resource Management",
-	"_toc": [
-		"docs.user.hr.set-up",
-		"docs.user.hr.employee",
-		"docs.user.hr.leave",
-		"docs.user.hr.attendance",
-		"docs.user.hr.payroll",
-		"docs.user.hr.expense_claim",
-		"docs.user.hr.appraisal"		
-	]
-}
----
-The Human Resources (HR) Module covers the processes linked to managing a team of co-workers. Most important feature here is processing the payroll by using the Salary Manager to generate Salary Slips. Most countries have complex tax rules stating which expenses the company can make on behalf of the Employees. There are a set of rules for the company to deduct taxes and social security from employee payroll. ERPNext allows to accomodate all types of taxes and their calculation.
-
-It  also maintains a complete employee database including contact information, salary details, attendance, performance evaluation, and appraisal records.
\ No newline at end of file
diff --git a/docs/user/hr/docs.user.hr.payroll.md b/docs/user/hr/docs.user.hr.payroll.md
deleted file mode 100644
index 9da590d..0000000
--- a/docs/user/hr/docs.user.hr.payroll.md
+++ /dev/null
@@ -1,73 +0,0 @@
----
-{
-	"_label": "Salary and Payroll"
-}
----
-To process Payroll in ERPNext,
-
-1. Create Salary Structures for all Employees.
-1. Generate Salary Slips via the Salary Manager Tool.
-1. Book the Salary in your Accounts.
-
-### Salary Structure
-
-The Salary Structure represents how Salaries are calculated based on Earnings and Deductions. To create a new Salary Structure go to:
-
-> HR > Salary Structure > New Salary Structure
-
-
-![Salary Structure](img/salary-structure.png)
-
-
-### In the Salary Structure,
-
-- Select the Employee
-- Set the starting date from which this is valid (Note: There can only be one Salary Structure that can be “Active” for an Employee during any period)
-- In the “Earnings” and “Deductions” table all your defined Earning Type and Deductions Type will be auto-populated. Set the values of the Earnings and Deductions and save the Salary Structure.
-
-### Leave Without Pay (LWP)
-
-Leave Without Pay (LWP) happens when an Employee runs out of allocated leaves or takes a leave without an approval (via Leave Application). If you want ERPNext to automatically deduct salary in case of LWP, then you must check on the “Apply LWP” column in the Earning Type and Deduction Type masters. The amount of pay cut is the proportion of LWP days divided by the total working days for the month (based on the Holiday List).
-
-If you don’t want ERPNext to manage LWP, just don’t click on LWP in any of the Earning Types and Deduction Types.
-
----
-
-### Creating Salary Slips
-
-Once the Salary Structure is created, you can make a salary slip from the same form or you can process your payroll for the month using the Salary Manager.
-
-To create a salary slip from Salary Structure, click on the button Make Salary Slip.
-
-
-![Salary Slip](img/salary-slip-1.png)
-
-<br>
-
-
-Through Salary Manager:
-
-> HR > Process Payroll
-
-
-![Salary Manager](img/salary-manager.png)
-
-
-
-In the Salary Manager tool,
-
-1. Select the Company for which you want to create the Salary Slips.
-1. Select the Month and the Year for which you want to create the Salary Slips.
-1. Click on “Create Salary Slips”. This will create Salary Slip records for each active Employee for the month selected. If the Salary Slips are created, the system will not create any more Salary Slips. All updates will be shown in the “Activity Log” section.
-1. Once all Salary Slips are created, you can check if they are created correctly or edit it if you want to deduct Leave Without Pay (LWP).
-1. After checking, you can “Submit” them all together by clicking on “Submit Salary Slips”. 1. If you want them to be automatically emailed to the Employee, make sure to check the “Send Email” box.
-
-### Booking Salaries in Accounts
-
-The final step is to book the Salaries in your Accounts. 
-
-Salaries in businesses are usually dealt with extreme privacy. In most cases, the companies issues a single payment to the bank combining all salaries and the bank distributes the salaries to each employee’s salary account. This way there is only one payment entry in the company’s books of accounts and anyone with access to the company’s accounts will not have access to the individual salaries.
-
-The salary payment entry is a Journal Voucher entry that debits the total salary of all Employees to the Salary Account and credits the company’s bank Account.
-
-To generate your salary payment voucher from the Salary Manager, click on “Make Bank Voucher” and a new Journal Voucher with the total salaries will be created.
\ No newline at end of file
diff --git a/docs/user/hr/docs.user.hr.setup.md b/docs/user/hr/docs.user.hr.setup.md
deleted file mode 100644
index a796c36..0000000
--- a/docs/user/hr/docs.user.hr.setup.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-{
-	"_label": "Human Resource Setup"
-}
----
-The HR module has a setup process where you create the masters for all the major activities.
-
-### Organization Setup
-￼
-To setup your Employee master you must first create:
-
-- Employment Type (like Permanent, Temp, Contractor, Intern etc).
-- Branch (if there are multiple offices).
-- Department (if any, like Accounting, Sales etc).
-- Designation (CEO, Sales Manager etc).
-- Grade (A, B, C etc, usually based on seniority).
-
-### Leave Setup
-
-To setup Leaves, create:
-
-- Leave Type (like Sick Leave, Travel Leave etc)
-- Holiday List (list of annual holidays for the year - these days will not be considered in Leave Applications).
-
-### Payroll (Salary) Setup
-
-In ERPNext, salaries have two types of components, earnings (basic salary, expenses paid by the company, like telephone bill, travel allowance etc) and deductions (amounts deducted for taxes, social security etc). To setup payroll, you must first setup all the different types of earnings and deductions. These are
-
-- Earning Type
-- Deduction Type
-
-These are just labels, we will see how to use them when we discuss the payroll section.
diff --git a/docs/user/intro/docs.user.implement.concepts.md b/docs/user/intro/docs.user.implement.concepts.md
deleted file mode 100644
index 9fc4012..0000000
--- a/docs/user/intro/docs.user.implement.concepts.md
+++ /dev/null
@@ -1,367 +0,0 @@
----
-{
-	"_label": "Concepts and Terms"
-}
----
-Before you start implementation, lets get familiar with the terminology that is used and some basic concepts in ERPNext.
-
----
-
-### Basic Concepts
-
-#### Company
-
-This represents the Company records for which ERPNext is setup. With this same setup, you can create multiple Company records, each representing a different legal entity. The accounting for each Company will be different, but they will share the Customer, Supplier and Item records.
-
-> Setup > Company 
-
-#### Customer
-
-Represents a customer. A Customer can be an individual or an organizations. You can create multiple Contacts and Addresses for each Customer.
-
-> Selling > Customer
-
-#### Supplier
-
-Represents a supplier of goods or services. Your telephone company is a Supplier, so is your raw materials Supplier. Again, a Supplier can be an individual or an organization and has multiple Contacts and Addresses.
-
-> Buying > Supplier
-
-#### Item
-
-A Product, sub-product or Service that is either bought, sold or manufactured and is uniquely identified.
-
-> Stock > Item
-
-#### Account
-
-An Account is a heading under which financial and business transactions are carried on. For example, “Travel Expense” is an account, “Customer Zoe”, “Supplier Mae” are accounts. ERPNext creates accounts for Customers and Suppliers automatically.
-
-> Accounts > Chart of Accounts
-
-#### Address
-
-An address represents location details of a Customer or Supplier. These can be of different locations such as Head Office, Factory, Warehouse, Shop etc. 
-
-> Selling > Address
-
-#### Contact
-
-An individual Contact belongs to a Customer or Supplier or is just an independent. A Contact has a name and contact details like email and phone number.
-
-> Selling > Contact
-
-#### Communication
-
-A list of all Communication with a Contact or Lead. All emails sent from the system are added to the Communication table.
-
-> Support > Communication
-
-#### Price List
-
-A Price List is a place where different rate plans can be stored. It’s a name you give to a set of Item Prices stored under a particular List.
-
-> Selling > Price List
-
-> Buying > Price List
-
----
-
-### Accounting
-
-#### Fiscal Year
-
-Represents a Financial Year or Accounting Year. You can operate multiple Fiscal Years at the same time. Each Fiscal Year has a start date and an end date and transactions can only be recorded in this period. When you “close” a fiscal year, it's balances are transferred as “opening” balances for the next fiscal year.
-
-> Setup > Company > Fiscal Year
-
-#### Cost Center
-
-A Cost Center is like an Account, but the only difference is that its structure represents your business more closely than Accounts. For example in your Chart of Accounts, you separate your expenses by type (say travel, marketing etc). In your Chart of Cost Centers, you can separate them by product line or business group (for example online sales, retail sales)
-
-> Accounts > Chart of Cost Centers
-
-#### Journal Voucher
-
-A document that contains General Ledger (GL) entries and the sum of Debits and Credits of those entries is the same. In ERPNext you can update Payments, Returns etc using Journal Vouchers.
-
-> Accounts > Journal Voucher
-
-#### Sales Invoice
-
-A bill sent to Customers for delivery of Items (goods or services).
-
-> Accounts > Sales Invoice
-
-#### Purchase Invoice
-
-A bill sent by a Supplier for delivery of Items (goods or services).
-
-> Accounts > Purchase Invoice
-
-#### Currency
-
-ERPNext allows you to book transactions in multiple currencies. There is only one currency for your book of accounts though. While posting your Invoices, payments in different currencies, the amount is converted to the default currency by the specified conversion rate.
-
-> Setup > Currency
-
----
-
-### Selling
-
-#### Customer Group
-
-A classification of Customers, usually based on market segment.
-
-> Selling > Setup > Customer Group
-
-#### Lead
-
-A person who could be a future source of business. A Lead may generate Opportunities. (from: “may lead to a sale”).
-
-> Selling > Lead
-
-#### Opportunity
-
-A potential sale. (from: “opportunity for a business”).
-
-> Selling > Opportunity
-
-#### Sales Order
-
-A note confirming the terms of delivery and price of an Item (product or service) by the Customer. Deliveries, Production Orders and Invoices are made on basis of Sales Orders.
-
-> Selling > Sales Order
-
-#### Territory
-
-A geographical area classification for sales management. You can set targets for Territories and each sale is linked to a Territory.
-
-> Selling > Setup > Territory
-
-#### Sales Partner
-
-A third party distributer / dealer / affiliate / commission agent who sells the company’s products usually for a commission.
-
-> Selling > Setup > Sales Partner
-
-#### Sales Person
-
-Someone who pitches to the Customer and closes deals. You can set targets for Sales Persons and tag them in transactions.
-
-> Selling > Setup > Sales Person
-
----
-
-### Buying
-
-#### Purchase Order
-
-A contract given to a Supplier to deliver the specified Items at the specified cost, quantity, dates and other terms.
-
-> Buying > Purchase Order
-
-#### Material Request
-
-A request made by a system User, or automatically generated by ERPNext based on reorder level or projected quantity in Production Plan for purchasing a set of Items.
-
-> Buying > Material Request
-
----
-
-### Stock (Inventory)
-
-#### Warehouse
-
-A logical Warehouse against which stock entries are made.
-
-> Stock > Warehouse
-
-#### Stock Entry
-
-Material transfer from a Warehouse, to a Warehouse or from one Warehouse to another.
-
-> Stock > Stock Entry
-
-#### Delivery Note
-
-A list of Items with quantities for shipment. A Delivery Note will reduce the stock of Items for the Warehouse from where you ship. A Delivery Note is usually made against a Sales Order.
-
-> Stock > Delivery Note
-
-#### Purchase Receipt
-
-A note stating that a particular set of Items were received from the Supplier, most likely against a Purchase Order.
-
-> Stock > Purchase Receipt
-
-#### Serial Number
-
-A unique number given to a particular unit of an Item.
-
-> Stock > Serial Number
-
-#### Batch
-
-A number given to a group of units of a particular Item that may be purchased or manufactured in a group.
-
-> Stock > Batch
-
-#### Stock Ledger Entry
-
-A unified table for all material movement from one warehouse to another. This is the table that is updated when a Stock Entry, Delivery Note, Purchase Receipt, and Sales Invoice (POS) is made.
-
-#### Stock Reconciliation
-
-Update Stock of multiple Items from a spreadsheet (CSV) file.
-
-> Stock > Stock Reconciliation
-
-#### Quality Inspection
-
-A note prepared to record certain parameters of an Item at the time of Receipt from Supplier, or Delivery to Customer.
-
-> Stock > Quality Inspection
-
-#### Item Group
-
-A classification of Item.
-
-> Stock > Setup > Item Group
-
----
-
-### Human Resource Management
-
-#### Employee
-
-Record of a person who has been in present or past, in the employment of the company.
-
-Human Resources > Employee
-
-#### Leave Application
-
-A record of an approved or rejected request for leave.
-
-> Human Resource > Leave Application
-
-#### Leave Type
-
-A type of leave (for example, Sick Leave, Maternity Leave etc.)
-
-> Human Resource > Leave and Attendance > Leave Type
-
-#### Salary Manager
-
-A tool that will help creation of multiple Salary Slips for Employees.
-
-> Human Resource > Salary and Payroll > Process Payroll
-
-#### Salary Slip
-
-A record of the monthly salary given to an Employee.
-
-> Human Resource > Salary Slip
-
-#### Salary Structure
-
-A template identifying all the components of an Employees' salary (earnings) and tax and other social security deductions.
-
-> Human Resource > Salary and Payroll > Salary Structure
-
-#### Appraisal
-
-A record of the performance of an Employee over a specified period based on certain parameters.
-
-> Human Resources > Appraisal
-
-#### Appraisal Template
-
-A template recording the different parameters of Employee performance and their weightage for a particular role.
-
-> Human Resources > Employee Setup > Appraisal Template
-
-#### Attendance
-
-A record indicating presence or absence of an Employee on a particular day.
-
-> Human Resources > Attendance
-
----
-
-### Manufacturing
-
-#### Bill of Materials (BOM)
-
-A list of Operations and Items with their quantities, that are required to produce another Item. A Bill of Materials (BOM) is used to plan purchases and do product costing.
-
-> Manufacturing > BOM
-
-#### Workstation
-
-A place where a BOM operation takes place. It is useful to calculate the direct cost of the product.
-
-> Manufacturing > Workstation
-
-#### Production Order
-
-A document signaling production (manufacture) of a particular Item with specified quantities.
-
-> Manufacturing > Production Order
-
-#### Production Planning Tool
-
-A tool for automatic creation of Production Orders and Purchase Requests based on Open Sales Orders in a given period.
-
-> Manufacturing > Production Planning Tool
-
----
-
-### Website
-
-#### Blog Post
-
-A short article that appears in the “Blog” section of the website generated from the ERPNext website module. Blog is a short from of “Web Log”.
-
-> Website > Blog Post
-
-#### Web Page
-
-A web page with a unique URL (web address) on the website generated from ERPNext.
-
-> Website > Web Page
-
----
-
-### Setup / Customization
-
-#### Custom Field
-
-A user defined field on a form / table.
-
-Setup > Customize ERPNext > Custom Field
-
-#### Global Defaults
-
-This is the section where you set default values for various parameters of the system.
-
-Setup > Data > Global Defaults
-
-#### Print Heading
-
-A title that can be set on a transaction just for printing. For example, you want to print a Quotation with a title “Proposal” or “Pro forma Invoice”.
-
-> Setup > Branding and Printing > Print Headings
-
-#### Terms and Conditions
-
-Text of your terms of contract.
-
-> Selling > Setup > Terms and Conditions 
-
-#### Unit of Measure (UOM)
-
-How quantity is measured for an Item. For example (Kg, No, Pair, Packet) etc.
-
-> Stock > Setup > UOM
-
diff --git a/docs/user/intro/docs.user.implement.md b/docs/user/intro/docs.user.implement.md
deleted file mode 100644
index 79c8576..0000000
--- a/docs/user/intro/docs.user.implement.md
+++ /dev/null
@@ -1,39 +0,0 @@
----
-{
-	"_label": "Implementation",
-	"_toc": [
-		"docs.user.implement.strategy",
-		"docs.user.implement.concepts"
-	]
-}
----
-
-![Implementation](img/implementation-image.png)
-
-
-
-We have seen dozens of ERP implementations over the past few years and we realize that successful implementation is a lot about intangibles and attitude.
-
-**ERPs are not required.**
-
-Like exercise. 
-
-Human body may seem like it does not require exercise today or even tomorrow, but in the long run, if you wish to maintain your body and its health, you should get on the treadmill.
-
-In the same way, ERPs improve the health of your organization over a long run by keeping it fit and efficient. The more you delay putting things in order, the more time you lose, and the closer you get to a major disaster.
-
-So when you start implementing an ERP, keep your sight on the long term benefits. Like exercise, its painful in the short run, but will do wonders if you stay on course.
-
----
-
-## The Champion
-
-ERP means organization wide change and it does not happen without effort. Every change requires a champion and it is the duty of the champion to organize and energize the entire team towards implementation. The champion needs to be resilient incase something goes wrong .
-
-In many organizations we have seen, the champion is most often the owner or a senior manager. Occasionally, the champion is an outsider who is hired for a particular purpose.
-
-In either case, you must identify your champion first.
-
-Most likely it's **you!** 
-
-Lets Begin!
\ No newline at end of file
diff --git a/docs/user/intro/docs.user.implement.strategy.md b/docs/user/intro/docs.user.implement.strategy.md
deleted file mode 100644
index e077a90..0000000
--- a/docs/user/intro/docs.user.implement.strategy.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-{
-	"_label": "Implementation Strategy"
-}
----
-Before you start managing your Operations in EPRNext, you must first become familiar with the system and the terms used. For this we recommend implementation should happen in two phases.
-
-- A Test Phase, where you enter dummy records representing your day to day transactions and a - Live Phase, where we start entering live data.
-
-### Test Phase
-
-- Read the Manual
-- Follow the Five-Day-Setup Module or the instructions given below.
-- Create your first Customer, Supplier and Item. Add a few more so you get familiar with them.
-- Create Customer Groups, Item Groups, Warehouses, Supplier Groups, so that you can classify your Items.
-- Complete a standard sales cycle - Lead > Opportunity > Quotation > Sales Order > Delivery Note > Sales Invoice > Payment (Journal Voucher)
-- Complete a standard purchase cycle - Material Request > Purchase Order > Purchase Receipt > Payment (Journal Voucher).
-- Complete a manufacturing cycle (if applicable) - BOM > Production Planning Tool > Production Order > Material Issue >  Sales Return
-
-> Tip: Use the 30-day free trial at [erpnext.com](https://erpnext.com) to take your test drive.
-
-### Live Phase
-
-Once you are familiar with ERPNext, start entering your live data!
-
-- Clean up the account of test data or better, start a fresh install.
-- Setup all the modules with Customer Groups, Item Groups, Warehouses, BOMs etc.
-- Import Customers, Suppliers, Items, Contacts and Addresses using Data Import Tool.
-- Import opening stock using Stock Reconciliation Tool.
-- Create opening accounting entries via Journal Voucher and create outstanding Sales Invoices and Purchase Invoices.
\ No newline at end of file
diff --git a/docs/user/intro/docs.user.intro.md b/docs/user/intro/docs.user.intro.md
deleted file mode 100644
index 5c1cb56..0000000
--- a/docs/user/intro/docs.user.intro.md
+++ /dev/null
@@ -1,70 +0,0 @@
----
-{
-	"_label": "Introduction",
-	"_toc": [
-		"docs.user.intro.open_source",
-		"docs.user.intro.try",
-		"docs.dev.install",
-		"docs.user.help"
-	]
-}
----
-## What is an ERP and why should I care?
-
-(If you are already convinced you need an all-in-one system for your organization, you can skip this page.)
-
-If you are running a small business that has a few employees, you understand that it's hard to manage the dynamic nature of doing businesses. You are already using a software like Accounting, and may be some more to manage your inventory and sales (or CRM). 
-
-An ERP brings all of this together in one place.
-
-Small businesses are not so different from large ones. They contain most of the complexities of a large business along with many other constraints. Small businesses have to communicate with customers, do accounts, pay taxes, do payroll, manage timelines, deliver quality, answer questions, and keep everyone happy just like in large businesses.
-
-Large businesses have the advantage of using advanced data systems to manage their process efficiently. Small businesses, on the other hand, typically struggle to keep things organized. They often use a mix of apps like spreadsheets, accounting software, web CRM etc to manage.The problem is, not everyone is on the same page. An ERP changes that.
-
----
-
-## What is ERPNext?
-
-ERPNext helps you to manage all your business information in one application and use it to manage operations and take decisions based on data.
-
-
-
-![ERPNext-Introduction](img/erpnext-introduction.png)
-
-
-
-
-Among other things, ERPNext will help you to:
-
-- Track all Invoices and Payments.
-- Know what quantity of which product is available in stock.
-- Identify open customer queries.
-- Manage payroll.
-- Assign tasks and follow up on them.
-- Maintain a database of all your customers, suppliers and their contacts.
-- Prepare quotes.
-- Get reminders on maintenance schedules.
-- Publish your website.
-
-And a lot lot lot more.
-
----
-
-## Why Should I Use ERPNext?
-
-ERPNext is a modern tool that covers not only accounting but also all other business functions, on an integrated platform. It has many benefits over both traditional accounting as well as ERP applications.
-
-### Benefits over traditional accounting software:
-
-- Do a lot more than just accounting! Manage inventory, billing, quotes, leads, payroll and a lot more.
-- Keep all your data safe and in one place. Don’t keep hunting for data when you need it across spreadsheets and different computers.
--Manage everyone on the same page. All users get the same updated data.
-- Stop repetitive work. Don’t enter the same information from your word processor to your accounting tool. It's all integrated.
-- Keep track. Get the entire history of a customer or a deal in one place.
-
-### Benefits over big ERPs
-
-- $$$ - Saves money.
-- **Easier to configure:** Big ERPs are notoriously hard to setup and will ask you a zillion questions before you can do something meaningful.
-- **Easier to use:** Modern web like user interface will keep your users happy and in familiar territory.
-- **Open Source :** This software is always free and you can host it anywhere you like.
\ No newline at end of file
diff --git a/docs/user/intro/docs.user.intro.open_source.md b/docs/user/intro/docs.user.intro.open_source.md
deleted file mode 100644
index bc36ce4..0000000
--- a/docs/user/intro/docs.user.intro.open_source.md
+++ /dev/null
@@ -1,25 +0,0 @@
----
-{
-	"_label": "Open Source"
-}
----
-The source code is an Open Source software. It is open for anyone to understand, extend or improve. And it is free!
-
-Advantages of an Open Source software are:
-
-1. You can choose to change your service provider anytime.
-1. You can host the application anywhere, including your own server to gain complete ownership and privacy of the data.
-1. You can access a community to support you, incase you need help. You are not dependant on your service provider.
-1. You can benefit from using a product that is critiqued and used by a wide range of people, who have reported hundreds of issues and suggestions to make this product better, and this will always continue.
-
----
-
-### Alternatives
-
-There are many Open Source ERPs you can consider. Popular ones are:
-
-1. OpenERP
-1. OpenBravo
-1. Apache OfBiz
-1. xTuple
-1. Compiere (and forks)
\ No newline at end of file
diff --git a/docs/user/intro/docs.user.intro.try.md b/docs/user/intro/docs.user.intro.try.md
deleted file mode 100644
index 2a53ca5..0000000
--- a/docs/user/intro/docs.user.intro.try.md
+++ /dev/null
@@ -1,39 +0,0 @@
----
-{
-	"_label":"Getting Started with ERPNext"
-}
----
-There are many ways to get started with ERPNext.
-
-### 1. See the Demo
-
-If you want to check out the user interface and **feel** the application, just see the demo at:
-
-- [https://demo.erpnext.com](https://demo.erpnext.com)
-
-### 2. Get a Free 30 day Trial at ERPNext.com
-
-If you like the feel and want to set it up for your own company, you can take a 30 day free trial (no credit card details required) at ERPNext.com
-
-ERPNext.com is managed by the organization (Web Notes) that publishes ERPNext. You can do a trial run with your own account by [signing up on the website](https://erpnext.com/pricing-and-signup).
-
-You can also decide to host your application at ERPNext.com by buying the hosting plans. This way you support the organization that develops and improves ERPNext. You also get one-to-one functional (usage) support with the hosting plans.
-
-### 3. Download a Virtual Machine
-
-To avoid the trouble of installing an instance, ERPNext is available as a Virtual Image (a full loaded operating system with ERPNext installed). You can use this on **any** platform including Microsoft Windows.
-
-[Click here to see instructions on how to use the Virtual Image](docs.download.html)
-
-### 4. Install ERPNext on your Unix/Linux/Mac machine
-
-ERPNext is reasonably easy to install on a Unix like operating system and requires:
-
-1. MySQL database
-1. Apache Web Server
-1. Python
-1. Memcached
-
-to be installed.
-
-[More instructions on this page](docs.dev.install.html).
\ No newline at end of file
diff --git a/docs/user/knowledge/docs.user.knowledge.accounting.md b/docs/user/knowledge/docs.user.knowledge.accounting.md
deleted file mode 100644
index 995d38c..0000000
--- a/docs/user/knowledge/docs.user.knowledge.accounting.md
+++ /dev/null
@@ -1,110 +0,0 @@
----
-{
-	"_label": "Accounting Knowledge"
-}
----
-
-Chart of Accounts represents a tree like representation of all accounting heads, used to represent company's financial information. There are two types of accounts: Balance Sheet and Profit and Loss Statement accounts. Balance Sheet consists of Assets and Liabilities accounts and Profit and Loss Statement accounts consists of Incomes and Expenses.
-
-**Assets:** Bank and Cash balances, outstanding amounts of customers and all other assets are recorded here.
-
-**Liabilities:** All the company's liabilities like shareholder's capital, outstanding amount to be paid to suppliers, taxes to be paid to concerned to authorities are recorded under this group.
-
-**Income:** Income from direct/indirect sales.
-
-**Expenses:** All the expenses to run the business, like salaries, purchases, rent etc. are recorded here.
-
-### Debit and Credit
-
-Each of these accounts are either "Debit" or "Credit" type. Assets, Expenses are "Debit" accounts and Liabilities, Incomes are "Credit" accounts.
-
-Accounting Entries
-
-The balance of account can be increased / decreased, depending on account type and transaction type.
-
-<table class="table table-bordered text-center">
-    <thead>
-        <tr class="active">
-            <td>Account Type</td>
-            <td>Transaction Type</td>
-            <td>Effect on account balance</td>
-        </tr>
-    </thead>
-    <tbody>
-        <tr>
-            <td>Debit</td>
-            <td>Debit</td>
-            <td>Increases</td>
-        </tr>
-        <tr>
-            <td>Debit</td>
-            <td>Credit</td>
-            <td>Decreases</td>
-        </tr>
-        <tr>
-            <td>Credit</td>
-            <td>Credit</td>
-            <td>Increases</td>
-        </tr>
-        <tr>
-            <td>Credit</td>
-            <td>Debit</td>
-            <td>Decreases</td>
-        </tr>
-    </tbody>
-</table>
-
-### Double Entry
-
-This means that every accounting entry has two parts, one debit and one credit and must affect two separate accounts. If you add or deduct to one account, some other account somewhere else must also be affected. See the example below:
-
-1. Company sells a laptop worth 50000 to Customer A and delivers that with an invoice.
-
-As the company will receive a payment from customer, the customer is considered as an asset account. For booking income, company maintains an account called "Sales of Laptop". So, entries will be done in the following manner: 
-
-<table class="table table-bordered text-center">
-    <thead>
-        <tr class="active">
-            <td>Account</td>
-            <td>Debit</td>
-            <td>Credit</td>
-        </tr>
-    </thead>
-    <tbody>
-        <tr>
-            <td>Customer A</td>
-            <td>50000</td>
-            <td></td>
-        </tr>
-        <tr>
-            <td>Sales of Laptop</td>
-            <td></td>
-            <td>50000</td>
-        </tr>
-    </tbody>
-</table>
-
-Customer A has made the payment, so customer balance should decreased based on the paid amount, which will increase "Cash" balance.
-
-<table class="table table-bordered text-center">
-    <thead>
-        <tr class="active">
-            <td>Account</td>
-            <td>Debit</td>
-            <td>Credit</td>
-        </tr>
-    </thead>
-    <tbody>
-        <tr>
-            <td>Customer A</td>
-            <td></td>
-            <td>50000</td>
-        </tr>
-        <tr>
-            <td>Cash</td>
-            <td>50000</td>
-            <td></td>
-        </tr>
-    </tbody>
-</table>
-
diff --git a/docs/user/knowledge/docs.user.knowledge.accounting_entries.md b/docs/user/knowledge/docs.user.knowledge.accounting_entries.md
deleted file mode 100644
index 05b197d..0000000
--- a/docs/user/knowledge/docs.user.knowledge.accounting_entries.md
+++ /dev/null
@@ -1,38 +0,0 @@
----
-{
-	"_label": "Accounting Entries"
-}
----
-The concept of accounting is explained with an example given below: 
-We will take a "Tea Stall" as a company and see how to book accounting entries for the business.
-
-- Mama (The Tea-stall owner) invests Rs 25000 to start the business.
-
-![A&L](img/assets-1.png)
-
-
-Analysis: Mama invested 25000 in company, hoping to get some profit. In other words, company is liable to pay 25000 to Mama in the future. So, account "Mama" is a liability account and it is credited. Company's cash balance will be increased due to the investment, "Cash" is an asset to the company and it will debited.
-
-- The company needs equipments (Stove, teapot, cups etc) and raw materials (tea, sugar, milk etc) immediately. He decides to buy from the nearest general store "Super Bazaar" who is a friend so that he gets some credit. Equipments cost him 2800 and raw materials worth of 2200. He pays 2000 out of total cost 5000.
-
-![A&L](img/assets-2.png)
-
-Analysis: Equipments are "Fixed Assets" (because they have a long life) of the company and raw materials "Current Assets" (since they are used for day-to-day business), of the company. So, "Equipments" and "Stock in Hand" accounts have been debited to increase the value. He pays 2000, so "Cash" account will be reduced by that amount, hence credited and he is liable to pay 3000 to "Super Bazaar" later, so Super Bazaar will be credited by 3000.
-
-- Mama (who takes care of all entries) decides to book sales at the end of the every day, so that he can analyze daily sales. At the end of the very first day, the tea stall sells 325 cups of tea, which gives net sales of Rs. 1575. The owner happily books his first day sales.
-
-![A&L](img/assets-3.png)
-
-Analysis: Income has been booked in "Sales of Tea" account which has been credited to increase the value and the same amount will be debited to "Cash" account. Lets say, to make 325 cups of tea, it costs Rs. 800, so "Stock in Hand" will be reduced (Cr) by 800 and expense will be booked in "Cost of goods sold" account by same amount.
-
-At the end of the month, the company paid the rent amount of stall (5000) and salary of one employee (8000), who joined from the very first day.
-
-![A&L](img/assets-4.png)
-
-### Booking Profit
-
-As month progress, company purchased more raw materials for the business. After a month he books profit to balance the "Balance Sheet" and "Profit and Loss Statements" statements. Profit belongs to Mama and not the company hence its a liability for the company (it has to pay it to Mama). When the Balance Sheet is not balanced i.e. Debit is not equal to Credit, the profit has not yet been booked. To book profit, the following entry has to be made:
-
-![A&L](img/assets-5.png)
-
-Explanation: Company's net sales and expenses are 40000 and 20000 respectively. So, company made a profit of 20000. To make the profit booking entry, "Profit or Loss" account has been debited and "Capital Account" has been credited. Company's net cash balance is 44000 and there is some raw materials available worth 1000 rupees.
diff --git a/docs/user/knowledge/docs.user.knowledge.attachment_csv.md b/docs/user/knowledge/docs.user.knowledge.attachment_csv.md
deleted file mode 100644
index eecc42d..0000000
--- a/docs/user/knowledge/docs.user.knowledge.attachment_csv.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-{
-	"_label": "Attachment and CSV files"
-}
----
-
-#### How to Attach files?
-
-When you open a form, on the right sidebar, you will see a section to attach files. Click on “Add” and select the file you want to attach. Click on “Upload” and you are set.
-
-#### What is a CSV file?
-
-A CSV (Comma Separated Value) file is a data file that you can upload into ERPNext to update various data. Any spreadsheet file from popular spreadsheet applications like MS Excel or Open Office Spreadsheet can be saved as a CSV file.
-
-If you are using Microsoft Excel and using non-English characters, make sure to save your file encoded as UTF-8. For older versions of Excel, there is no clear way of saving as UTF-8. So save your file as a CSV, then open it in Notepad, and save as “UTF-8”. (Sorry blame Microsoft for this!)
-
diff --git a/docs/user/knowledge/docs.user.knowledge.doctype.md b/docs/user/knowledge/docs.user.knowledge.doctype.md
deleted file mode 100644
index 8614fdf..0000000
--- a/docs/user/knowledge/docs.user.knowledge.doctype.md
+++ /dev/null
@@ -1,73 +0,0 @@
----
-{
-	"_label": "DocType"
-}
----
-
-
-
-ERPNext is a based on a “metadata” (data about data) framework that helps define all the different types of documents in the system. The basic building block of ERPNext is a DocType. 
-
-A DocType represents both a table in the database and a form from which a user can enter data. 
-
-Many DocTypes are single tables, but some work in groups. For example, Quotation has a “Quotation” DocType and a “Quotation Item” doctype for the Items table, among others.  DocTypes contain a collection of fields called DocFields that form the basis of the columns in the database and the layout of the form.
-
-<table class="table table-bordered text-left">
-    <thead>
-        <tr class="active">
-            <td width="30%">Column</td>
-            <td>Description</td>
-        </tr>
-    </thead>
-    <tbody>
-        <tr>
-            <td>Name</td>
-            <td>Name of the record</td>
-           
-        </tr>
-        <tr>
-            <td>Owner</td>
-            <td>Creator and Owner of the record</td>
-          
-        </tr>
-        <tr>
-            <td>Created on</td>
-            <td>Date and Time of Creation</td>
-          
-        </tr>
-        <tr>
-            <td>Modified On </td>
-            <td>Date and Time of Modification</td>
-        </tr>
-        <tr>
-            <td>Docstatus</td>
-            <td>Status of the record<br>
-                0 = Saved/Draft<br>
-                1 = Submitted<br>
-                2 = Cancelled/Deleted
-            </td> 
-        </tr>
-        <tr>
-            <td>Parent</td>
-            <td>Name of the Parent</td>
-        </tr>
-        <tr>
-            <td>Parent Type</td>
-            <td>Type of Parent</td>
-        </tr>
-        <tr>
-            <td>Parent Field</td>
-            <td>Specifying the relationship with the parent (there can be multiple child relationships with the same DocType).</td>
-        </tr>
-        <tr>
-            <td>Index(idx)</td>
-            <td>Index (sequence) of the record in the child table.</td>
-
-        </tr>
-    </tbody>
-</table>
-
-#### Single DocType
-
-There are a certain type of DocTypes that are “Single”, i.e. they have no table associated and have only one record of its fields. DocTypes such as Global Defaults, Production Planning Tool are “Single” DocTypes.
-
diff --git a/docs/user/knowledge/docs.user.knowledge.doctype_fields.md b/docs/user/knowledge/docs.user.knowledge.doctype_fields.md
deleted file mode 100644
index dcc6d4e..0000000
--- a/docs/user/knowledge/docs.user.knowledge.doctype_fields.md
+++ /dev/null
@@ -1,201 +0,0 @@
----
-{
-	"_label": "DocType-Fields"
-}
----
-
-#### Field Columns
-
-In the fields table, there are many columns. The columns of the field table are explained below:
-
-<table class="table table-bordered text-left">
-	<thead>
-		<tr class="active">
-			<td width="30%">Column</td>
-			<td>Description</td>
-		</tr>
-		</thead>
-		<tbody>
-			<tr>
-				<td>Label</td>
-				<td>Field Label (that appears in the form).</td>
-			</tr>
-			<tr>
-				<td>Type</td>
-				<td>Field Type</td>
-			</tr>
-			<tr>
-				<td>Name</td>
-				<td>Column name in the database, must be code friendly with no white spaces, special characters and capital letters.</td>
-		</tr>
-			<tr>
-			<td>options</td>
-			<td>Field settings:<br>
-				For Select: List of options (each on a new line).<br>
-				For Link: DocType that is “linked”.<br>
-				For HTML: HTML Content
-		</tr>
-		<tr>
-			<td>Perm Level</td>
-			<td>Permission level (number) of the field. You can group fields by numbers, called levels, and apply rules on the levels.</td>
-		</tr>
-		<tr>
-			<td>Width</td>
-			<td>Width of the field (in pixels) - useful for “Table” types.</td>
-		</tr>
-		<tr>
-			<td>Reqd</td>
-			<td>Checked if field is mandatory (required).</td>
-		</tr>
-		<tr>
-			<td>In Filter</td>
-			<td>Checked if field appears as a standard filter in old style reports.</td>
-		</tr>
-		<tr>
-			<td>Hidden</td>
-			<td>Checked if field is hidden.</td>
-		</tr>
-		<tr>
-			<td>Print Hide</td>
-			<td>Checked if field is hidden in Print Formats.</td>
-		</tr>
-		<tr>
-			<td>Report Hide</td>
-			<td>Checked if field is hidden in old style reports.</td>
-		</tr>
-		<tr>
-			<td>Allow on Submit</td>
-			<td>Checked if this field can be edited after the document is “Submitted”.</td>
-		</tr>
-		<tr>
-			<td>Depends On</td>
-			<td>The fieldname of the field that will decide whether this field will be shown or hidden. It is useful to hide un-necessary fields.</td>
-		</tr>
-		<tr>
-			<td>Description</td>
-			<td>Description of the field</td>
-		</tr>
-		<tr>
-			<td>Default</td>
-			<td>Default value when a new record is created.<br>
-			Note: “user” will set the current user as default and “today” will set today’s date (if the field is a Date field).</td>
-		</tr>
-	<tbody>
-<table>
-
-
-#### Field Types and Options
-
-Here is a list of the different types of fields used to make / customize forms in ERPNext.
-
-<table class="table table-bordered text-left">
-	<thead>
-		<tr class="active">
-			<td width="30%">Type</td>
-			<td>Description</td>
-			<td>Options/Setting</td>
-		</tr>
-	</thead>
-	<tbody>
-		<tr>
-			<td>Data</td>
-			<td>Single line text field with 180 characters</td>
-			<td>  </td>
-		</tr>
-		<tr>
-			<td>Select</td>
-			<td>Select from a pre-determined items in a drop-down.</td>
-			<td>The “Options” contains the drop-down items, each on a new row</td>
-		</tr>
-		<tr>
-			<td>Link</td>
-			<td>Link an existing document / record</td>
-			<td>Options contains the name of the type of document (DocType)</td>
-		</tr>
-		<tr>
-			<td>Currency</td>
-			<td>Number with 2 decimal places, that will be shown separated by commas for thousands etc. in Print.</td>
-			<td>e.g. 1,000,000.00</td>
-		</tr>
-		<tr>
-			<td>Float</td>
-			<td>Number with 6 decimal places.</td>
-			<td>e.g. 3.141593</td>
-		</tr>
-		<tr>
-			<td>Int</td>
-			<td>Integer (no decimals)</td>
-			<td>e.g. 100</td>
-		</tr>
-		<tr>
-			<td>Date</td>
-			<td>Date</td>
-			<td>Format can be selected in Global Defaults</td>
-		</tr>
-		<tr>
-			<td>Time</td>
-			<td>Time</td>
-			<td></td>
-		</tr>
-		<tr>
-			<td colspan="3" class="active">Text</td>
-		</tr>
-		<tr>
-			<td>Text</td>
-			<td>Multi-line text box without formatting features</td>
-			<td></td>
-		</tr>
-		<tr>
-			<td>Text editor</td>
-			<td>Multi-line text box with formatting toolbar etc</td>
-			<td></td>
-		</tr>
-		<tr>
-			<td>Code</td>
-			<td>Code Editor</td>
-			<td>Options can include the type of language for syntax formatting.
-				Eg JS / Python / HTML</td>
-		</tr>
-		<tr>
-			<td colspan="3" class="active">Table (Grid)</td>
-		</tr>
-		<tr> 
-			<td>Table</td>
-			<td>Table of child items linked to the record.</td>
-			<td>Options contains the name of the DocType of the child table. For example “Sales Invoice Item” for “Sales Invoice”</td>
-		</tr>
-		<tr>
-			<td colspan="3" class="active">Layout</td>
-		</tr>
-		<tr>
-			<td>Section Break</td>
-			<td>Break into a new horizontal section.</td>
-			<td>The layout in ERPNext is evaluated from top to bottom.</td>
-		</tr>
-		<tr>
-			<td>Column Break</td>
-			<td>Break into a new vertical column.</td>
-			<td></td>
-		</tr>
-		<tr>
-			<td>HTML</td>
-			<td>Add a static text / help / link etc in HTML</td>
-			<td>Options contains the HTML.</td>
-		</tr>
-		<tr>
-			<td colspan="3" class="active">Action</td>
-		</tr>
-		<tr>
-			<td>Button</td>
-			<td>Button</td>
-			<td>[for developers only]</td>
-		</tr>
-		<tbody>
-	<table>
-
-
-
-
-
-
-		
\ No newline at end of file
diff --git a/docs/user/knowledge/docs.user.knowledge.engineer_to_order.md b/docs/user/knowledge/docs.user.knowledge.engineer_to_order.md
deleted file mode 100644
index a48ad70..0000000
--- a/docs/user/knowledge/docs.user.knowledge.engineer_to_order.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-{
-	"_label": "Engineer-to-Order Manufacturing"
-}
----
-
-Engineer-to-order manufacturing is a strategy where the product is designed and manufactured based on very specific customer requirements. Since the end product tends to be complex, customers may engage with the ETO company throughout the entire design and manufacturing phases, to ensure that their specifications are met. This strategy is used by construction, fabrication industry, etc. 
-
-Since most specifications like design, requirements, engineering changes etc are often tossed back and forth several times between the ETO company and the customer, either party can become confused if the exchange of product information is poorly managed. Managing and identifying parts for production is an important step.
-
-Engineered-to-order products are often built from difficult to source parts, expensive parts and highly engineered components. Thus, acquiring the necessary product components can be a time consuming and costly endeavor, causing issues before and during production runs.
-
-To manage ETO products  maintain a consistent serial number records and create a Bill of Material for each product. Focus on the bill of materials rather then on the estimation and budgeting of the product.
-
diff --git a/docs/user/knowledge/docs.user.knowledge.fiscal_year.md b/docs/user/knowledge/docs.user.knowledge.fiscal_year.md
deleted file mode 100644
index 980872c..0000000
--- a/docs/user/knowledge/docs.user.knowledge.fiscal_year.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-{
-	"_label": "Fiscal-Year"
-}
----
-
-A fiscal year is also known as a financial year or a budget year. It is used for calculating financial statements in businesses and other organisations. The fiscal year may or may not be the same as a calendar year. For tax purposes, companies can choose to be calendar-year taxpayers or fiscal-year taxpayers.  In many jurisdictions, regulatory laws regarding accounting and taxation require such reports once per twelve months. However, it is not mandatory that the period should be  a calendar year (that is, 1 January to 31 December).
-
-A fiscal year usually starts at the beginning of a quarter, such as April 1, July 1 or October 1. However, most companies' fiscal year also coincides with the calendar year, which starts January 1. For the most part, it is simpler and easier that way. For some organizations, there are advantages in starting the fiscal year at a different time. For example, businesses that are seasonal might start their fiscal year on July 1 or October 1. A business that has most of its income in the fall and most of its expenses in the spring might also choose to start its fiscal year on October 1. That way, they know what their income will be for that year, and can adjust their expenses to maintain their desired profit margins.
-
diff --git a/docs/user/knowledge/docs.user.knowledge.make_to_order.md b/docs/user/knowledge/docs.user.knowledge.make_to_order.md
deleted file mode 100644
index 8b83120..0000000
--- a/docs/user/knowledge/docs.user.knowledge.make_to_order.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-{
-	"_label": "Make-to-Order Manufacturing"
-}
----
-
-Make-to-order is a manufacturing process in which manufacturing starts only after a customer's order is received.
-
-The company has some standard items but the product is only made when the customer places an order. This is true for furniture, for designer gift items etc.
-
-Manufacturing after receiving customer's orders means to start a pull-type supply chain operation because manufacturing is performed when demand is confirmed, i.e. being pulled by demand. 
-
-In this type of manufacturing, production orders are linked to one or more sales orders.
-
diff --git a/docs/user/knowledge/docs.user.knowledge.make_to_stock.md b/docs/user/knowledge/docs.user.knowledge.make_to_stock.md
deleted file mode 100644
index ea07c58..0000000
--- a/docs/user/knowledge/docs.user.knowledge.make_to_stock.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-{
-	"_label": "Make-to-Stock Manufacturing"
-}
----
-
-Make-to-stock manufacturing is a system based on keeping stocks ready for customers in order to provide instant availability to customers. Products like FMCG goods and electronics are made and stocked. Here, the production cycle is completed before the sales orders are made. 
-
-This strategy is used by businesses to match production with consumer demand forecasts. The make-to-stock (MTS) method forecasts demand, to determine how much stock should be produced. If demand for the product can be accurately forecasted, the MTS strategy can be an efficient choice.
-
-The main drawback to the make-to-stock (MTS) method is that it relies heavily on the accuracy of demand forecasts. Inaccurate forecasts will lead to losses stemming from excessive inventory or stockouts.
-
-
-
-
-
diff --git a/docs/user/knowledge/docs.user.knowledge.markdown.md b/docs/user/knowledge/docs.user.knowledge.markdown.md
deleted file mode 100644
index b2f76be..0000000
--- a/docs/user/knowledge/docs.user.knowledge.markdown.md
+++ /dev/null
@@ -1,84 +0,0 @@
----
-{
-	"_label": "Format Using Markdown"
-}
----
-
-Markdown is a simple way of writing text to format your content. Markdown allows you easy ways to format.
-
-1. Headings (h1 (largest), h2, h3, h4 and so on) 
-1. Paragraphs
-1. Lists (numbered or bulleted)
-1. Hyper links (links to other pages)
-1. Images 
-1. Code
-1. Embed HTML (HTML tags within your text)
-
-#### Headings
-
-Headings are specified by adding a `#` (hash) at the beginning of the line. The more the number of hashes, the smaller the heading:
-
-    # This is a large heading.
-
-    ### This is a smaller heading.
-
-#### Paragraphs
-
-To start a new paragraph, just make sure that there is an empty line at the beginning and end of the paragraph.
-
-To format text as **bold** or with _italics_ format as follows:
-
-    **This text** is **bold** and _this one_ is with _italics_
-
-#### Lists
-
-To define numbered lists, start your link with a number and a dot (.) and ensure there is a blank line before and after the list. The numbers are automatically generated so it does not matter what number you put:
-
-    1. list 1st item
-    1. second item
-    1. and so on
-    1. and so forth
-
-To define bulleted lists, start your items with a hyphen (-)
-
-    - item 1
-    - item 2
-    - item 3
-
-To nest lists within one another, put four spaces to indent your inner list as follows:
-
-    1. item 1
-    1. item 2
-        - sub item 1
-        - sub item 2
-    1. item 3
-
-#### Links (to other pages)
-
-Links to other pages can be defined by adding your text in box brackets [] followed by the link in round brackets ()
-
-    [This is an external link](http://example.com)
-    [A link within the site](my-page.html)
-
-#### Images
-
-Images can be added by adding an exclamation ! before the link.
-
-    ![A flower](files/flower.gif)
-
-
-#### Code
-
-To add a code block, just leave a blank line before and after the block and make sure all code line are indented by four spaces:
-
-    This is normal text
-        
-        This is a code block
-
-#### HTML
-
-You can embed any kind of HTML tags within your code. Any content written within HTML tags will not be formatted.
-
-[Detailed description of the markdown format](http://daringfireball.net/projects/markdown/syntax)
-   
-
diff --git a/docs/user/knowledge/docs.user.knowledge.md b/docs/user/knowledge/docs.user.knowledge.md
deleted file mode 100644
index 229083a..0000000
--- a/docs/user/knowledge/docs.user.knowledge.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-{
-	"_label": "Knowledge Library",
-	"_toc": [
-		"docs.user.knowledge.fiscal_year",
-		"docs.user.knowledge.accounting",
-		"docs.user.knowledge.accounting_entries",
-		"docs.user.knowledge.doctype",
-		"docs.user.knowledge.doctype_fields",
-		"docs.user.knowledge.attachment_csv",
-		"docs.user.knowledge.markdown",
-		"docs.user.knowledge.make-to-stock",
-		"docs.user.knowledge.make-to-order",
-		"docs.user.knowledge.engineer-to-order"		
-	]
-}
----
-Knowledge Library contains definitions and explanations of various management concepts. This page is created for users who wish to elaborate their conceptual knowledge.
-
diff --git a/docs/user/mfg/docs.user.mfg.bom.md b/docs/user/mfg/docs.user.mfg.bom.md
deleted file mode 100644
index 9436f86..0000000
--- a/docs/user/mfg/docs.user.mfg.bom.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-{
-	"_label": "Bill of Materials"
-}
----
-At the heart of the Manufacturing system is the **Bill of Materials** (BOM). The **BOM** is a list of all materials (either bought or made) and operations that go into a finished product or sub-Item. In ERPNext, the component could have its own BOM hence forming a tree of Items with multiple levels.
-
-To make accurate Purchase Requests, you must always maintain correct BOMs. To make a new BOM:
-
-> Manufacturing > Bill of Materials > New BOM
-
-
-![Bill of Materials](img/bom.png)
-
-
-
-In the BOM form:
-
-- Select the Item for which you want to make the BOM.
-- Add the operations that you have to go through to make that particular Item in the “Operations” table. For each operation, you will be asked to enter a Workstation. You must create new Workstations as and when necessary. 
-
-![Bill of Materials with Operations](img/mfg-bom-3.png)
-
-
-
-- Add the list of Items you require for each operation, with its quantity. This Item could be a purchased Item or a sub-assembly with its own BOM. If the row Item is a manufactured Item and has multiple BOMs, select the appropriate BOM.  You can also define if a part of the Item goes into scrap.
-
-Workstations are defined only for product costing purposes not inventory. Inventory is tracked in Warehouses not Workstations.
-
-> The “Full BOM” section will list all the Items of that BOM right up to the lower most child node. This table is automatically updated if any of the BOMs of the sub-Items are updated.
\ No newline at end of file
diff --git a/docs/user/mfg/docs.user.mfg.md b/docs/user/mfg/docs.user.mfg.md
deleted file mode 100644
index 5522ec8..0000000
--- a/docs/user/mfg/docs.user.mfg.md
+++ /dev/null
@@ -1,56 +0,0 @@
----
-{
-	"_label": "Manufacturing",
-	"_toc": [
-		"docs.user.mfg.bom",
-		"docs.user.mfg.planning",
-		"docs.user.mfg.production_order"
-	]
-}
----
-The Manufacturing module in ERPNext helps you to maintain multi-level Bill of Materials (BOMs) for your Items. It helps you in Product Costing, planing your production via Production Plan, creating Production Orders for your manufacturing shop floors and planing your inventory by getting your material requirement via BOMs (also called Material Requirements Planning MRP).
-
-### Types of Production Planning
-
-Broadly there are three types of Production Planning Systems
-
-- Make-to-Stock: In these systems, production is planned based on a forecast and the Items are then sold to distributors or customers. All fast moving consumer goods that are sold in retail shops like soaps, packaged water etc and electronics like phones etc are Made to Stock.
-- Make-to-Order: In these systems, manufacturing takes place after a firm order is placed by a Customer.
-- Engineer-to-Order:  In this case each sale is a separate Project and has to be designed and engineered to the requirements of the Customer. Common examples of this are any custom business like furniture, machine tools, speciality devices, metal fabrication etc.
-
-Most small and medium sized manufacturing businesses are based on a make-to-order or engineer-to-order system and so is ERPNext.
-
-For engineer-to-order systems, the Manufacturing module should be used along with the Projects module.
-
-#### Manufacturing and Inventory
-￼
-You can track work-in-progress by creating work-in-progress Warehouses. 
-
-ERPNext will help you track material movement by automatically creating Stock Entries from your Production Orders by building from Bill of Materials.
-
-
----
-
-### Material Requirements Planning (MRP):
-
-The earliest ERP systems were made for manufacturing. The earliest adopters were automobile companies who had thousands of raw materials and sub-assemblies and found it very hard to keep track of requirements and plan purchases. They started using computers to build the material requirements from forecasts and Bill of Materials. 
-
-Later these systems were expanded to include Finances, Payroll, Order Processing, and Purchasing and thus became the more generic Enterprise Resource Systems (ERP). More recently Customer Relationship Management (CRM) was added as a function and is now an integral part of ERP systems.
-
-These days the term ERP is used to describe systems that help manage any kind of organization like education institutes (Education ERP) or Hospitals (Hospital ERP) and so on. 
-
----
-
-### Best Practice: Lean Manufacturing
-
-The state of art manufacturing philosophy (the rationale behind the planning processes) comes from Japanese auto major Toyota. At the time when American manufacturers depended on MRP systems to plan their manufacturing based on their sales forecasts, they turned around the problem by discovering a leaner way of planning their production. They realized that:
-
-The biggest cause of wastage in manufacturing is variation (in product and quantity).
-
-So they standardized their products and sub-assemblies and sold fixed quantities based on what they produced or did not produce based on what they sold. This way, they had an extremely predictable and stable product mix. If they sold less than planned, they would simply stop production. 
-
-Their card signaling system kanban, would notify all their suppliers to stop production too. Hence they never used any of the complex material planning tools like MRP to play day-to-day material requirements, but a simple signaling system that said either STOP or GO.
-
-They combined this system with neatly managed factories with well labeled racks.
-
-Small manufacturing companies are usually make-to-order or engineer-to-order and can hardly afford to have a high level of standardization. Thus small manufacturing businesses should aim for repeatability by innovating processes and creating a common platform for products.
\ No newline at end of file
diff --git a/docs/user/mfg/docs.user.mfg.planning.md b/docs/user/mfg/docs.user.mfg.planning.md
deleted file mode 100644
index a8075e1..0000000
--- a/docs/user/mfg/docs.user.mfg.planning.md
+++ /dev/null
@@ -1,71 +0,0 @@
----
-{
-	"_label": "Production Planning Tool"
-}
----
-Production Planning Tool helps you plan production and purchase of Items for a period (usually a week or a month).
-
-This list of Items can be generated from the open Sales Orders in the system and will generate:
-
-- Production Orders for each Item.
-- Purchase Requests for Items whose Projected Quantity is likely to fall below zero.
-
-To use the Production Planning Tool, go to: 
-
-> Manufacturing > Production Planning Tool
-
-
-![Material Requisition Planning](img/mrp.png)
-
-<br>
-
-
-#### Step 1: Select and get Sales Order
-
-Select sales orders for MRP using filters (Time, Item, and Customer)
-
-
-![Production Planning Tool](img/mrp-1.png)
-
-Click on Get Sales Order to generate a list.
-
-![Production Planning Tool](img/mrp-1.1.png)
-
-<br>
-
-
-#### Step 2: Get Item from Sales Orders.
-
- You can add/remove or change quantity of these Items.
-
- ![Production Planning Tool](img/mrp-2.png)
-
-
-<br>
-
-#### Step 3: Create Production Orders
-
-![Production Planning Tool](img/mrp-3.png)
-
-<br>
-
-#### Step 4: Create Material Request
-
-Create Material Request for Items with projected shortfall.
-
-
-![Production Planning Tool](img/mrp-4.png)
-
-<br>
-
-The Production Planning Tool is used in two stages:
-
-- Selection of Open Sales Orders for the period based on “Expected Delivery Date”.
-- Selection of Items from those Sales Orders.
-
-
-The tool will update if you have already created Production Orders for a particular Item against its Sales Order (“Planned Quantity”).
-
-You can always edit the Item list and increase / reduce quantities to plan your production.
-
-> Note: How do you change a Production Plan? The output of the Production Planning Tool is the Production Order. Once your orders are created, you can change them by amending the Production Orders.
diff --git a/docs/user/mfg/docs.user.mfg.production_order.md b/docs/user/mfg/docs.user.mfg.production_order.md
deleted file mode 100644
index 5cbcf84..0000000
--- a/docs/user/mfg/docs.user.mfg.production_order.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-{
-	"_label": "Production Order"
-}
----
-Production Order (also called as Work Order) is a document that is given to the manufacturing shop floor by the Production Planner as a signal to produce a certain quantity of a certain Item. Production Order also helps to generate the material requirements (Stock Entry) for the Item to be produced from its **Bill of Materials**. 
-
-The **Production Order** is generated directly from the **Production Planning Tool** based on Sales Orders. You can also create a direct Production Order by:
-
-> Manufacturing > Production Order > New Production Order
-
-
-![Production Order](img/production-order.png)
-
-
-
-- Select the Item to be produced (must have a Bill of Materials).
-- Select the BOM
-- Select Quantities
-- Select Warehouses. WIP (Work-in-Progress) is where your Items will be transferred when you begin production and FG (Finished Goods) where you store finished Items before they are shipped.
-- Select if you want to consider sub-assemblies (sub-Items that have their own BOM) as stock items or you want to explode the entire BOM when you make Stock Entries for this Item. What it means is that if you also maintain stock of your sub assemblies then you should set this as “No” and in your Stock Entires, it will also list the sub-assembly Item (not is sub-components).
-
-and “Submit” the Production Order.
-
-Once you “Submit”, you will see two more buttons:
-
-![Production Order](img/production-order-2.png)
-
-
-1. Transfer Raw Material: This will create a Stock Entry with all the Items required to complete this Production Order to be added to the WIP Warehouse. (this will add sub-Items with BOM as one Item or explode their children based on your setting above). 
-1. Update Finished Goods: This will create a Stock Entry that will deduct all the sub-Items from the WIP Warehouse and add them to the Finished Goods Warehouse.
-
-> Tip: You can also partially complete a Production Order by updating the Finished Goods stock creating a Stock Entry.
-
-When you Update Finished Goods to the Finished Goods Warehouse, the “Produced Quantity” will be updated in the Production Order.
-
diff --git a/docs/user/projects/docs.user.projects.md b/docs/user/projects/docs.user.projects.md
deleted file mode 100644
index 5c5bdf7..0000000
--- a/docs/user/projects/docs.user.projects.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-{
-	"_label": "Projects",
-	"_toc": [
-		"docs.user.projects.project",
-		"docs.user.projects.task",
-		"docs.user.projects.timelog"
-	]
-}
----
-Managing Projects
-
-ERPNext helps you manage your Projects by breaking them into Tasks and allocating them to different people. 
-
-Purchasing and selling can also be tracked against Projects and this can help the company keep tabs on its budget, delivery and profitability for a Project. 
-
-Projects can be used to manage internal projects, manufacturing jobs or service jobs. For service jobs, Time Sheets can also be created that can be used to bill Customers if billing is done on a Time & Money basis.
-
diff --git a/docs/user/projects/docs.user.projects.projects.md b/docs/user/projects/docs.user.projects.projects.md
deleted file mode 100644
index 5376b0a..0000000
--- a/docs/user/projects/docs.user.projects.projects.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-{
-	"_label": "Project"
-}
----
-
-## Project
-
-The Project record maintains the details of your project and milestones that you have set. The Project record can be linked in Quotations, Sales Orders, Delivery Notes, Sales Invoices, Purchase Requests, Purchase Orders and Purchase Invoices. This way you can keep a track of all the activities that happen around this project.
-
-
-![projects](img/projects.png)
\ No newline at end of file
diff --git a/docs/user/projects/docs.user.projects.task.md b/docs/user/projects/docs.user.projects.task.md
deleted file mode 100644
index 7972d58..0000000
--- a/docs/user/projects/docs.user.projects.task.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-{
-	"_label": "Tasks"
-}
----
-
-## Tasks
-
-Project is divided into Tasks and each Task is allocated to a resource. In ERPNext, you can also create and allocate a Task independently of a Project. If you define the start and end dates, it will add calendar events for the same and also show the task on the Gantt Chart that you can use for monitoring the Project.
-
-
-
-![Tasks](img/tasks.png)
-
-
diff --git a/docs/user/projects/docs.user.projects.tasks.md b/docs/user/projects/docs.user.projects.tasks.md
deleted file mode 100644
index 7a8cd48..0000000
--- a/docs/user/projects/docs.user.projects.tasks.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-{
-	"_label": "Task"
-}
----
-
-## Tasks
-
-Project is broken into Tasks and each Task is allocated to a resource. In ERPNext, you can also create an allocate a Task independently of a Project. If you define the start and end dates, it will add calendar events for the same and also show the task on the Gantt Chart that you can use for monitoring the Project.
-
-
-
-![Tasks](img/tasks.png)
-
diff --git a/docs/user/projects/docs.user.projects.timelog.md b/docs/user/projects/docs.user.projects.timelog.md
deleted file mode 100644
index ffecb70..0000000
--- a/docs/user/projects/docs.user.projects.timelog.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-{
-	"_label": "Time Log"	
-}
----
-
-## Time Sheets
-
-You can create Time Sheets to track billable work to Customers. These Time Sheets can be tracked against Project and Tasks so that you can get reports on how much time was spent on each Task or Project.
-
-
-![Time Log](img/time-log.png)
\ No newline at end of file
diff --git a/docs/user/selling/docs.user.selling.campaign.md b/docs/user/selling/docs.user.selling.campaign.md
deleted file mode 100644
index 5790c7f..0000000
--- a/docs/user/selling/docs.user.selling.campaign.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-{
-	"_label": "Campaign"
-}
----
-
-A Campaign is a full-scale implementation of a sales strategy to promote a product or a service. This is done in a market segment of a particular geographical area, to achieve specified objectives.
-
-![Campaign](img/campaign.png)
-
-
diff --git a/docs/user/selling/docs.user.selling.customer.md b/docs/user/selling/docs.user.selling.customer.md
deleted file mode 100644
index 5336ac6..0000000
--- a/docs/user/selling/docs.user.selling.customer.md
+++ /dev/null
@@ -1,80 +0,0 @@
----
-{
-	"_label": "Customer Master",
-	"_title_image": "img/customers.png"
-}
----
-A customer, who is sometimes known as a client, buyer, or purchaser is the one who receives goods, services, products, or ideas, from a seller for a monetary consideration. A customer can also receive goods or services from a vendor or a supplier for other valuable considerations.
-
- You can either directly create your Customers via 
-
-> Selling > Customer
-
-or upload it via the Data Import Tool.
-
-
-
-![Customer Master](img/customer.png)
-
-
-
-
-> Note: Customers are separate from Contacts and Addresses. A Customer can have multiple Contacts and Addresses.
-
-### Contacts and Addresses
-￼
-Contacts and Addresses in ERPNext are stored separately so that you can attach multiple Contacts or Addresses to Customers and Suppliers.
-
-To add a Contact or Address directly from the Customer record, click on “New Contact” or “New Address”.
-
-> Tip: When you select a Customer in any transaction, one Contact and Address gets pre-selected. This is the “Default Contact or Address”. 
-
-To Import multiple Contacts and Addresses from a spreadsheet, use the Data Import Tool.
-
-### Integration with Accounts
-
-In ERPNext, there is a separate Account record for each Customer, for each Company.
-
-When you create a new Customer, ERPNext will automatically create an Account Ledger for the Customer under “Accounts Receivable” in the Company set in the Customer record. 
-
-> Advanced Tip: If you want to change the Account Group under which the Customer Account is created, you can set it in the Company master.
-
-If you want to create an Account in another Company, just change the Company value and “Save” the Customer again.
-
-### Customer Settings
-
-You can link a Price List to a Customer (select “Default Price List”), so that when you select that Customer, the Price List will be automatically selected.
-
-You can set “Credit Days” so that it is automatically set in the Sales Invoices made against this Customer.
-
-You can set how much credit you want to allow for a Customer by adding the “Credit Limit”. You can also set a global “Credit Limit” in the Company master.Classifying Customers
-
-ERPNext allows you to group your Customers and also divide them into Territories. Grouping will help you get better analysis of your data and identify which Customers are profitable and which are not. Territories will help you set sales targets for the respective territories.
-
-### Customer Group
-
-You can group your Customers so that you can get trend analysis for each group. Typically Customers are grouped by market segment (that is usually based on your domain).
-
-> Tip: If you think all this is too much effort, you can leave it at “Default Customer Group”. But all this effort, will pay off when you start getting reports.
-￼
-An example of a sample report is given below:
-
-
-![Sales Analytics](img/sales-analytics-customer.png)
-
-
-
-
-### Territory
-
-If your business operates in multiple Territories (could be countries, states or cities) it is usually a great idea to build your structure in the system. Once you group your Customers by Territories, you can set annual targets for each Item Group and get reports that will show your actual performance in the territory v/s what you had planned.
-
-### Sales Person
-
-Sales Persons behave exactly like Territories. You can create an organization chart of Sales Persons where each Sales Person’s target can be set individually. Again as in Territory, the target has to be set against Item Group.
-
-### Sales Partner
-
-A Sales Partner is a third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products, for a commission. This is useful if you make the end sale to the Customer, involving your Sales Partner.
-
-If you sell to your Sales Partner who in-turn sells it to the Customer, then you must make a Customer instead.
\ No newline at end of file
diff --git a/docs/user/selling/docs.user.selling.customer_groups.md b/docs/user/selling/docs.user.selling.customer_groups.md
deleted file mode 100644
index 7c92ad7..0000000
--- a/docs/user/selling/docs.user.selling.customer_groups.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-{
-	"_label": "Customer Group"
-}
----
-
-Customer Group is a category where you specify your customer group type. Your customers can be Individuals or they can be corporate(Company) customers. Your customers could also be government officials or non-profit organisations. ERPNext allows you to create your own Customer Group.
-
-To create a new Customer Group, go to
-
-> Selling > Customer Group
-
-
-#### Step 1: Click on Add Child
-
-
-![Customer Group Tree](img/customer-group-tree-1.png)
-
-<br>
-
-#### Step 2: Name the Customer Group
-
-![Customer Group Tree](img/customer-group-tree-2.png)
-
-
-The new Customer Group will be added to the Customer Group Tree.
-
-
-![Customer Group Tree](img/customer-group-tree-3.png)
-
-
-
diff --git a/docs/user/selling/docs.user.selling.discount.md b/docs/user/selling/docs.user.selling.discount.md
deleted file mode 100644
index 0f0bf2a..0000000
--- a/docs/user/selling/docs.user.selling.discount.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-{
-	"_label": "Discount"
-}
----
-
-
-While making your sales transactions like a Quotation (or Sales Order) you would already have noticed that there is a “Discount” column. On the left is the “Price List Rate” on the right is the “Basic Rate”.  You can add a “Discount” value to update the basic rate.
-
-Since your taxes are calculated on Items, you must apply your discounts here so that you apply the tax on the discounted rate, which is the case for most taxes.
-
-The second way to apply discount is to add it in your Taxes and Charges table. This way you can explicitly show the Customer the discount you have applied on the order. If you choose this method, remember that you will tax your Customer at the full rate, not the discounted rate. So this is not a good way to track discounts.
-
-There is a third way to do it. Create an Item called “Discount” and make sure that all the taxes apply in the same way as the main Items. (This method is useful if only one type of tax is applicable on the sale). This way your “Discount” will appear as an expense. You will see a slightly higher income and expense but your profits will still remain the same. This method might be interesting where you want detailed accounting of your discounts.
-
-> Note: The maximum Discount that can be applied on an Item can be fixed in the Item master.
\ No newline at end of file
diff --git a/docs/user/selling/docs.user.selling.lead.md b/docs/user/selling/docs.user.selling.lead.md
deleted file mode 100644
index c50106a..0000000
--- a/docs/user/selling/docs.user.selling.lead.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-{
-	"_label": "Lead"
-}
----
-To get the customer through the door, you may be doing all or any of the following:
-
-- Listing your product on directories.
-- Maintaining an updated and searchable website.
-- Meeting people at trade events.
-- Advertising your product or services.
-
-When you send out the word that you are around and have something valuable to offer, people will come in to check out your product. These are your Leads.
-
-They are called Leads because they may lead you to a sale. Sales people usually work on leads by calling them, building a relationship and sending information about their products or services. It is important to track all this conversation to enable another person who may have to follow-up on that contact. The new person is then able to know the history of that particular Lead.
-
-To create a Lead, go to:
-
-> Selling > Lead > New Lead
-
-
-
-![Lead](img/lead.png)
-
-
-
-ERPNext gives you a lot of options you may want to store about your Leads. For example what is the source, how likely are they to give you business etc. If you have a healthy number of leads, this information will help you prioritize who you want to work with.
-
-> **Tip:** ERPNext makes it easy to follow-up on leads by updating the “Next Contact” details. This will add a new event in the Calendar for the User who has to contact the lead next.
-
-### Difference between Lead, Contact and Customer
-
-The difference is that a Lead is a potential Customer, someone who can give you business. A Customer is an organization or individual who has given you business before (and has an Account in your system). A Contact is a person who belongs to the Customer.
-
-A Lead can be converted to a Customer by clicking on the “Create Customer” button. Once the Customer is created, the Lead becomes “Converted” and any further Opportunities from the same source can be created against the Customer.
diff --git a/docs/user/selling/docs.user.selling.md b/docs/user/selling/docs.user.selling.md
deleted file mode 100644
index 86a07a8..0000000
--- a/docs/user/selling/docs.user.selling.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-{
-	"_label": "Selling",
-	"_toc": [
-		"docs.user.selling.selling_setup",
-		"docs.user.selling.customer_group",
-		"docs.user.selling.territory",
-		"docs.user.selling.sales_partner",
-		"docs.user.selling.sales_person",
-		"docs.user.selling.campaign",
-		"docs.user.selling.terms",
-		"docs.user.setup.price_list",
-		"docs.user.selling.discount",
-		"docs.user.selling.shopping_cart",
-		"docs.user.selling. customer",
-		"docs.user.selling.lead",
-		"docs.user.selling.opportunity",
-		"docs.user.selling.quotation",
-		"docs.user.selling.sales_order"
-	]
-}
----
-
-![Selling](img/selling-image.png)
-
-
-
-Selling is the communication that happens with the customer prior to and during the sale. You might be managing all the communication yourself or you may have a small team of sales people to handle this. ERPNext helps you track the communication leading up to the sale, by keeping all your documents in an organized and searchable manner.
-
-ERPNext helps you track business **Opportunities** from **Leads** and **Customers**, send them **Quotations** and make confirmed **Sales Orders**.
diff --git a/docs/user/selling/docs.user.selling.opportunity.md b/docs/user/selling/docs.user.selling.opportunity.md
deleted file mode 100644
index 7d03242..0000000
--- a/docs/user/selling/docs.user.selling.opportunity.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-{
-	"_label": "Opportunity"
-}
----
-When you know a Lead is looking for some products or services to buy, you can track that as an Opportunity.
-
-You can create an Opportunity from:
-
-> Selling > Opportunity > New Opportunity
-
-or open a “Open” Lead and click on “Create Opportunity” button.
-
-
-![Opportunity](img/opportunity.png)
-
-
-
-
- You can also open a “Open” Lead and click on “Create Opportunity” button.
-
-
-
-![Opportunity 1](img/opportunity-1.png)
-
-
-
-
-An Opportunity can also come from an existing Customer. You can create multiple Opportunities against the same Lead. In Opportunity, apart from the Communication, you can also add the Items for which the Lead or Contact is looking for. 
-
-> Best Practice: Leads and Opportunities are often referred as your “Sales Pipeline” this is what you need to track if you want to be able to predict how much business you are going to get in the future. Its always a good idea to be able to track what is coming in order to adjust your resources.
\ No newline at end of file
diff --git a/docs/user/selling/docs.user.selling.quotation.md b/docs/user/selling/docs.user.selling.quotation.md
deleted file mode 100644
index ae20af6..0000000
--- a/docs/user/selling/docs.user.selling.quotation.md
+++ /dev/null
@@ -1,94 +0,0 @@
----
-{
-	"_label": "Quotation"
-}
----
-During a sale, the customer may request for a written note about the products or services you are planning to offer, along with the prices and other terms of engagement. This is called a “Proposal” or an “Estimate” or a “Pro Forma Invoice”or a Quotation.
-
-To create a new Quotation go to:
-
-> Selling > Quotation > New Quotation
-
-#### Step 1: Enter Customer Details and Order Type.
-
-<br>
-
-
-![Quotation](img/quotation.png)
-
-<br>
-
-#### Step 2: Add Currency and Price List
-
-<br>
-
-![Quotation](img/quotation-1.png)
-
-
-
-#### Step #: Enter Item and Tax Details.
-<br>
-
-
-![Quotation](img/quotation-2.png)
-
-
-
-A Quotation contains details about:
-
-- The recipient of the Quotation
-- The Items and quantities you are offering.
-- The rates at which they are offered. For details refer 
-- The taxes applicable.
-- Other charges (like shipping, insurance) if applicable.
-- The validity of contract.
-- The time of delivery.
-- Other conditions.
-
-> Tip: Images look great on Quotations. To add images to your Quotations, attach the corresponding image in the Item master.
-
-
-### Rates
-
-The rates you quote may depend on two things.
-
-- The Price List: If you have multiple Price Lists, you can select a Price List or tag it to the Customer (so that it is auto-selected). Your Item prices will automatically be updated from the Price List.For details refer [Price List](docs.user.setup.price_list.html)
-
-- The Currency: If you are quoting to a Customer in a different currency, you will have to update the conversion rates to enable ERPNext to save the information in your standard Currency. This will help you to analyze the value of your Quotations in standard Currency.
-
-### Taxes
-
-To add taxes to your Quotation, you can either select a tax template, Sales Taxes and Charges Master or add the taxes on your own. To understand taxes in detail visit [Taxes](docs.user.setup.taxes.html)
-
-
-You can add taxes in the same manner as the Sales Taxes and Charges Master.
-
-### Terms and Conditions
-
-Each Quotation must ideally contain a set of terms, of your contract. It is usually a good idea to make templates of your Terms and Conditions, so that you have a standard set of terms. 
-You can do this by going to:
-
-> Selling > Terms and Conditions  
-
-#### What should Terms and Conditions Contain?
-
-- Validity of the offer.
-- Payment Terms (In Advance, On Credit, part advance etc).
-- What is extra (or payable by the Customer).
-- Safety / usage warning.
-- Warranty if any.
-- Returns Policy.
-- Terms of shipping, if applicable.
-- Ways of addressing disputes, indemnity, liability, etc.
-- Address and Contact of your Company.
-
-### Submission
-
-Quotation is a “Submittable” transaction. Since you send this Quotation to your Customer or Lead, you must freeze it so that changes are not made after you send the Quotation.  See Document Stages.
-
-> Tip: Quotations can also be titled as “Proforma Invoice” or “Proposal”. Select the right heading in the “Print Heading” field in the “More Info” section. To create new Print Headings go to Setup > Branding and Printing > Print Headings.
-
-### Discount
-
-While making your sales transactions like a Quotation (or Sales Order) you would already have noticed that there is a “Discount” column. On the left is the “Price List Rate” on the right is the “Basic Rate”.  You can add a “Discount” value to update the basic rate. To understand more about discount read [Discount](docs.user.selling.discount.html)
-
diff --git a/docs/user/selling/docs.user.selling.sales_order.md b/docs/user/selling/docs.user.selling.sales_order.md
deleted file mode 100644
index fc53780..0000000
--- a/docs/user/selling/docs.user.selling.sales_order.md
+++ /dev/null
@@ -1,66 +0,0 @@
----
-{
-	"_label": "Sales Order"
-}
----
-The Sales Order confirms your sales and triggers purchase (**Material  Request**) shipment (**Delivery Note**), billing (**Sales Invoice**) and manufacturing (**Production Plan**)
-
-A Sales Order is usually a binding Contract with your Customer.
-
-Once your customer confirms the Quotation you can convert your Quotation into a Sales Order.
-
-
-
-![Sales Order](img/sales-order-f.jpg)
-
-
-
-
-
-Alternatively, you can create a Sales Order directly from:
-
-
-> Selling > Sales Order > New Sales Order
-
-
-
-![Sales Order](img/sales-order.png)
-
-
-
-
-
-Most of the information in your Sales Order is the same as the Quotation. There are a few amongst other things that a Sales Order will ask you to update.
-
-- Expected date of delivery.
-- Customer Purchase Order number: If your customer has sent you a Purchase Order, you can update its number for future reference (in billing).
-
-#### Packing List
-
-The “Packing List” table will be automatically updated when you “Save” the Sales Order. If any Items in your table are Sales BOM (packets), then the “Packing List” will contain the exploded (detailed) list of your Items.
-
-#### Reservation and Warehouses
-
-If your Sales Order contains Items for which inventory is tracked (Is Stock Item is “Yes”) then, ERPNext will ask you for “Reservation Warehouse”. If you have set a default Warehouse for the Item, it will automatically set this Warehouse here.
-
-This “reserved” quantity will help you project what is the quantity you need to purchase based on all your commitments.
-
-#### Sales Team
-
-**Sales Partner:** If this Sale was booked via a Sales Partner, you can update the Sales Partner’s details with commission and other info that you can aggregate.
-
-**Sales Persons:** ERPNext allows you to tag multiple Sales Persons who may have worked on this deal. You can also split the amount in targets of different Sales Persons and track how much incentives they earned on this deal.
-
-#### Next Steps
-
-Once your “Submit” your Sales Order, you can now trigger different aspects of your organization:
-
-- To begin purchase click on “Make Purchase Request”
-- To make a shipment entry click on “Make Delivery Note”
-- To bill, make “Make Sales Invoice”
-- To stop further process on this Sales Order, click on “Stop”
-
-#### Submission
-
-Sales Order is a “Submittable” transaction. See Document Stages. You will be able to execute dependent steps (like making a Delivery Note) only after “Submitting” this Sales Order.
-
diff --git a/docs/user/selling/docs.user.selling.sales_partner.md b/docs/user/selling/docs.user.selling.sales_partner.md
deleted file mode 100644
index 0125a09..0000000
--- a/docs/user/selling/docs.user.selling.sales_partner.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-{
-	"_label": "Sales Partner"
-}
----
-
-People who assist you in getting business are termed as Sales Partners. Sales Partners can be represented by different names in ERPNext. You can call them Channel Partner, Distributor, Dealer, Agent, Retailer, Implementation Partner, Reseller etc. Based on the partner's functions and their areas of expertise, you can create your own Sales Partner Names.
-
-To create a sales partner go to 
-
-> Setup > Sales Partner > New Sales Partner
-
-
-![Sales Partner](img/sales-partner.png)
-
-To include the name of your Partner on your website, check the "Show in Website" box.
-
-![Sales Partner](img/sales-partner-1.png)
-
diff --git a/docs/user/selling/docs.user.selling.sales_person.md b/docs/user/selling/docs.user.selling.sales_person.md
deleted file mode 100644
index efc8836..0000000
--- a/docs/user/selling/docs.user.selling.sales_person.md
+++ /dev/null
@@ -1,21 +0,0 @@
----
-{
-	"_label": "Sales Person"
-}
----
-
-The person who helps in selling your products or services is called a Sales Person. A Sales Person could be your Sales Manager, Sales Executive, General Manager-Sales, Vice President-Sales etc.
-
-To create a sales person go to:
-
-> Setup > Sales Person
-
-
-![Sales Person](img/sales-person-1.png)
-
-<br>
-
-Click on "Add Child" to create new sales persons.
-
-
-![Sales Person](img/sales-person-2.png)
\ No newline at end of file
diff --git a/docs/user/selling/docs.user.selling.selling_setup.md b/docs/user/selling/docs.user.selling.selling_setup.md
deleted file mode 100644
index 33756d1..0000000
--- a/docs/user/selling/docs.user.selling.selling_setup.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-{
-	"_label": "Selling Setup"
-}
----
-
-Completing the selling setup is an important step in ERPNext. You need to identify whether you would like to name your customers with their Customer Name or with Serial No. Also, specify whether all the sales transactions have to be accompanied with Sales Order and Delivery Note. Specify your Default Customer Group and the Default Territory you operate in.
-
-
-<br>
-
-
-![Selling Setup](img/selling-setup.png)
\ No newline at end of file
diff --git a/docs/user/selling/docs.user.selling.shopping_cart.md b/docs/user/selling/docs.user.selling.shopping_cart.md
deleted file mode 100644
index cf55f76..0000000
--- a/docs/user/selling/docs.user.selling.shopping_cart.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-{
-	"_label": "Shopping Cart"
-}
----
-On the Webpage, a shopping cart is an icon that allows you to store all the things that you have earmarked for purchasing. It is a graphical representation of a shopping basket or a shopping cart that allows you to save the items you intend to buy. 
-
-This software displays the price of the product . It also displays shipping and handling charges, along with taxes, if applicable.
-
-To set up a shopping cart, go to the selling module.
-
-> Selling > Shopping Cart Settings
-
-
-#### Step 1: Enter Company Details and Default Territory.
-
-
-![Shopping Cart](img/shopping-cart-1.png)
-
-<br>
-
-#### Step 2: Enter Price List, Tax Master and Shipping Rule.
-
-
-![Shopping Cart](img/shopping-cart-2.png)
-
-<br>
-
-#### Shopping Cart Display
-
-On the Website, the shopping cart image will be seen below the Item price. Customers can click on the cart and enter the amount of quantity they wish to buy. The Item number will be stored on the right hand corner of the page, next to the flower sign.
-
-![Shopping Cart](img/shopping-cart-display-1.png)
-
-<br>
-
-Click on the flower sign on the right hand side to see the cart details. Click on the cart to get the final amount details.
-
-
-![Shopping Cart](img/shopping-cart-display-amount.png)
-
diff --git a/docs/user/selling/docs.user.selling.terms.md b/docs/user/selling/docs.user.selling.terms.md
deleted file mode 100644
index b69874b..0000000
--- a/docs/user/selling/docs.user.selling.terms.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-{
-	"_label": "Terms and Conditions"
-}
----
-
-Terms and conditions are the general and special arrangements, provisions, requirements, rules, specifications, and standards that a company follows. These specifications are an integral part of an agreement or contract that the company gets into with its customers, suppliers or partners.
-
-
-
-![Terms and Conditions](img/terms.png)
-
-
diff --git a/docs/user/selling/docs.user.selling.territory.md b/docs/user/selling/docs.user.selling.territory.md
deleted file mode 100644
index 0584c08..0000000
--- a/docs/user/selling/docs.user.selling.territory.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-{
-	"_label": "Territory"
-}
----
-
-Territory is a place to signify where your customers come from. If you operate in one country, you can give that country name as your Territory. For Example, India, US, or Rest of the World, could be your Territories. If you operate in many locations, ERPNext allows you to create more Territories. You can also have child Territories under parent Territories. This helps in assigning different regions to different sales staff.
-
-
-
-
-![Territory Tree](img/territory-tree.png)
-
-
-To add more territories to an existing tree, click on "Add Child"
-
-![Territory Tree](img/territory-tree-1.png)
diff --git a/docs/user/setup/docs.user.setup.accounting.md b/docs/user/setup/docs.user.setup.accounting.md
deleted file mode 100644
index b42b6af..0000000
--- a/docs/user/setup/docs.user.setup.accounting.md
+++ /dev/null
@@ -1,107 +0,0 @@
----
-{
-	"_label": "Chart of Accounts",
-	"_icon": "sitemap",
-	"_links": [
-		"docs.user.accounts"
-	]
-}
----
-The Chart of Accounts forms the blueprint of your organization. The overall structure of your Chart of Accounts is based on a system of double entry accounting that has become a standard all over the world to quantify how a company is doing financially. 
-
-The Chart of Accounts helps you to answer:
-
-- What is your organisation worth?
-- How much debt have you taken?
-- How much profit are you making (and hence paying tax)?
-- How much are you selling?
-- What is your expense break-up
-
- You may note that as a business manager,it is very valuable to see how well your business is doing. 
-
-> Tip: If you can’t read a Balance Sheet (I confess it took me a long time to figure this out) it's a good opportunity to start learning about this. It will be worth the effort. You can also take the help of your accountant to setup your Chart of Accounts.
-
-Financial statement of your company is easily viewable in ERPNext. An Example of a financial statement is given below:
-
-
-
-![Financial Analytics Balance Sheet](img/financial-analytic-bs.png)
-
-
-
-To edit your Chart of Accounts in ERPNext go to:
-
-> [Accounts](docs.user.accounts.html)  > Chart of Accounts 
-
-Chart of Accounts is a tree view of the names of the Accounts  (Ledgers and Groups) that a Company requires to manage its books of accounts. ERPNext sets up a simple chart of accounts for each Company you create, but you have to modify it according to your needs and legal requirements.
-￼
-For each company, Chart of Accounts signifies the way to classify the accounting entries, mostly based on statutory (tax, compliance to government regulations) requirements.
-
-Let us understand the main groups of the Chart of Accounts.
-
-![Chart of Accounts: Root Accounts](img/chart-of-accounts.png)
-
-### Balance Sheet Accounts
-
-The Balance Sheet has Application of Funds (Assets) and Sources of Funds (Liabilities) that signify the net-worth of your company at any given time. When you begin or end a financial period, all the Assets are equal to the Liabilities.
-
-> Accounting: If you are new to accounting, you might be wondering, how can Assets be equal to Liabilities? That would mean the company has nothing of its own. Thats right. All the “investment” made in the company to buy assets (like land, furniture, machines) is made by the owners and is a liability to the company. If the company would want to shut down, it would need to sell all the assets and pay back all the liabilities (including profits) to the owners, leaving itself with nothing.
-
-All the accounts under this represent an asset owned by the company like "Bank Account", "Land and Property", "Furniture" or a liability (funds that the company owes to others) like "Owners funds", "Debt" etc.
-
-Two special accounts to note here are Accounts Receivable (money you have to collect from your customers) and Accounts Payable (money you have to pay to your suppliers) under Assets and Liabilities respectively.
-
-### Profit and Loss Accounts
-
-Profit and Loss is the group of Income and Expense accounts that represent your accounting transactions over a period.
-
-Unlike Balance sheet accounts, Profit and Loss accounts (or PL accounts) do not represent net worth (assets), but rather represent the amount of money spent and collected in servicing customers during the period. Hence at the beginning and end of your Fiscal Year, they become zero.
-
-In ERPNext it is easy to create a Profit and Loss analysis chart. An example of a Profit and Loss analysis chart is given below:
-
-
-
-
-![Financial Analytics Profit and Loss](img/financial-analytic-pl.png)
-
-
-
-
-
-
-(On the first day of the year you have not made any profit or loss, but you still have assets, hence balance sheet accounts never become zero at the beginning or end of a period)
-
-### Groups and Ledgers
-
-There are two main kinds of Accounts in ERPNext - Group and Ledger. Groups can have sub-groups and ledgers within them, whereas ledgers are the leaf nodes of your chart and cannot be further classified.
-
-Accounting Transactions can only be made against Ledger Accounts (not Groups)
-
-> Info: The term "Ledger" means a page in an accounting book where entries are made. There is usually one ledger for each account (like a Customer or a Supplier).
-
-> Note: An Account “Ledger” is also sometimes called as Account “Head”.
-
-![Chart of Accounts: Groups and Ledger](img/chart-of-accounts-1.png)
-
-### Other Account Types
-
-In ERPNext, you can also specify more information when you create a new Account, this is there to help you select that particular account in a scenario like Bank Account or a Tax Account and has no effect on the Chart itself.
-
-You can also tag if an account represents a Customer, Supplier or Employee in "Master Type".
-
-### Creating / Editing Accounts
-
-To create new Accounts, explore your Chart of Accounts and click on an Account group under which you want to create the new Account. On the right side, you will see an option to “Edit” or “Add” a new Account.
-
-![Chart of Accounts: New Account](img/chart-of-accounts-2.png)
-
-Option to create will only appear if you click on a Group (folder) type Account.
-
-ERPNext creates a standard structure for you when the Company is created but it is up to you to modify or add or remove accounts.
-
-Typically, you might want to create Accounts for
-
-- Types of Expenses (travel, salaries, telephone etc) under Expenses.
-- Taxes (VAT, Sales Tax etc based on your country) under Current Liabilities.
-- Types of Sales (for example, Product Sales, Service Sales etc.) under Income.
-- Types of Assets (building, machinery, furniture etc.) under Fixed Assets.
\ No newline at end of file
diff --git a/docs/user/setup/docs.user.setup.codification.md b/docs/user/setup/docs.user.setup.codification.md
deleted file mode 100644
index 243e6ff..0000000
--- a/docs/user/setup/docs.user.setup.codification.md
+++ /dev/null
@@ -1,61 +0,0 @@
----
-{
-	"_label": "Item Codification"
-}
----
-If you already have a full-fledged business with a number of physical items, you would have probably coded your items. If you have not, you have a choice. We recommend that you should codify if you have lot of products with long or complicated names. In case you have few products with short names, it is preferable to keep the Item Code same as Item Name.
-
-Item codification has been a sensitive topic and wars have been fought on this (not joking). In our experience, when you have items that cross a certain size, life without codification is a nightmare. 
-
-### Benefits
-
-- Standard way of naming things.
-- Less likely to have duplicates.
-- Explicit definition.
-- Helps to quickly find if a similar item exists.
-- Item names get longer and longer as more types get introduced. Codes are shorter.
-
-### Pain
-
-- You have to remember the codes!
-- Harder for new team members to pick up.
-- You have to create new codes all the time.
-
-### Example
-
-You should have a simple manual / cheat-sheet to codify your Items instead of just numbering them sequentially. Each letter should mean something. Here is an example:
-
-If your business involves wooden furniture, then you may codify as follows:
-
-Item Codification Summary Sheet
-(SAMPLE)
-
-	First letter: "Material"			Third letter: "Size"
-
-	- W - Wood 							- 0 - less than 1mm
-	- H - Hardware 						- 1 - 1mm - 5mm
-	- G - Glass 						- 2 - 5mm - 10mm
-	- U - Upholstery 					- 3 - 10mm - 10cm
-	- P - Plastic
-
-	Second Letter: "Type"
-
-	For Wood:							For Hardware:
-
-	- S - Sheet							- S - Screw
-	- B - Bar							- N - Nut
-	- L - L-section 					- W - Washer
-	- M - Molded 						- B - Bracket
-	- R - Round
-
-The last few letters could be sequential. So by looking at code **WM304** - you know its a wooden molding less than 10cm in size 
-
-### Standardization
-
-If you have more than one person naming items, the style of naming items will change for everyone. Sometimes, even for one person, he or she may forget how they had named the item and may create a duplicate name _"Wooden Sheet 3mm" or "3mm Sheet of Wood"?_
-
-### Rationalizing
-
-It is a good practice to have minimum varieties of items so that you keep minimum stock, housekeeping is simpler etc. When you are planning a new product and you want to know if you are already purchasing a part in some other product, the item codes will help you quickly determine if you are using a similar raw material in another product.
-
-We believe if you do this small investment, it will help you rationalize things as your business grows, though its okay not to codify if you have less items.
\ No newline at end of file
diff --git a/docs/user/setup/docs.user.setup.company.md b/docs/user/setup/docs.user.setup.company.md
deleted file mode 100644
index 322f464..0000000
--- a/docs/user/setup/docs.user.setup.company.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-{
-	"_label": "Company Setup"
-}
----
-
-
-Enter your company details to complete Company Setup. Mention the type of business, under Domain. You can enter manufacturing, retail, or services depending on the nature of your business activity. If you have more than one companies, create the setup under the Company Setup page.
-
-> Setup > Company > New Company
-
-
-
-![Company Setup](img/company.png)
diff --git a/docs/user/setup/docs.user.setup.cost_centers.md b/docs/user/setup/docs.user.setup.cost_centers.md
deleted file mode 100644
index d666e41..0000000
--- a/docs/user/setup/docs.user.setup.cost_centers.md
+++ /dev/null
@@ -1,71 +0,0 @@
----
-{
-	"_label": "Cost Centers and Budgeting",
-	"_icon": "sitemap",
-	"_links": [
-		"docs.user.accounts"
-	]
-}
----
-
-Your Chart of Accounts is mainly designed to provide reports to the government and tax authorities.
-￼
-Most businesses have multiple activities like different product lines, market segments, areas of business, etc that share some common overheads.They should ideally have their own structure to report, whether they are profitable or not. For this purpose, there is an alternate structure, called the Chart of Cost Centers.
-
-You can create a tree of Cost Centers to represent your business better. Each Income / Expense entry is also tagged against a Cost Center. 
-
-For example, if you have two types of sales:
-
-- Walk-in Sales
-- Online Sales
-
-You may not have shipping expenses for your walk-in customers, and no shop-rent for your online customers. If you want to get the profitability of each of these separately, you should create the two as Cost Centers and mark all sales as either "Walk-in" or "Online". Mark your all your purchases in the same way.
-
-Thus when you do your analysis you get a better understanding as to which side of your business is doing better. Since ERPNext has an option to add multiple Companies, you can create Cost Centers for each Company and manage it separately.
-
-To understand chart of cost centers in detail visit [Accounting Knowledge](docs.user.knowledge.accounting.html)
-
-
-### Chart of Cost Centers
-
-To setup your Chart of Cost Centers go to:
-
-> Accounts > Chart of Cost Centers
-
-
-![Chart of Cost Center](img/chart-of-cost-centers.png)
-
-
-Cost centers help you in one more activity, budgeting.
-
-### Budgeting
-
-ERPNext will help you set and manage budgets on your Cost Centers. This is useful when, for example, you are doing online sales. You have a budget for search ads, and you want ERPNext to stop or warn you from over spending, based on that budget. 
-
-Budgets are also great for planning purposes. When you are making plans for the next financial year, you would typically target a revenue based on which you would set your expenses. Setting a budget will ensure that your expenses do not get out of hand, at any point, as per your plans.
-
-You can define it in the Cost Center. If you have seasonal sales you can also define a budget distribution that the budget will follow.
-
-> Accounts > Budget Distribution > New Budget Distribution
-
-
-![Budget Distribution](img/budgeting.png)
-
-
-
-￼
-#### Budget Actions
-
-ERPNext allows you to either:
-
-- Stop.
-- Warn or, 
-- Ignore 
-
-if you exceed budgets. 
-
-These can be defined from the Company record.
-
-Even if you choose to “ignore” budget overruns, you will get a wealth of information from the “Budget vs Actual” variance report.
-
-> Note: When you set a budget, it has to be set as per Account under the Cost Center. For example if you have a Cost Center “Online Sales”, you can restrict “Advertising Budget” by creating a row with that Account and defining the amount.
\ No newline at end of file
diff --git a/docs/user/setup/docs.user.setup.data_import.md b/docs/user/setup/docs.user.setup.data_import.md
deleted file mode 100644
index b40573e..0000000
--- a/docs/user/setup/docs.user.setup.data_import.md
+++ /dev/null
@@ -1,74 +0,0 @@
----
-{
-	"_label": "Data Import Tool"
-}
----
-The ￼Data Import Tool is a great way to upload (or edit) bulk data, specially master data, into the system. 
-
-To Open the data import tool, you either go to Setup or go to the Transaction you want to Import. If Data Import is allowed, you will see an Import Button:
-
-![Start Import](img/import-1.png)
-
-The tool has two sections, one to download a template and the second to upload the data.
-
-(Note: Only those DocTypes are allowed for Import whose Document Type is "Master" or Allow Import property is set.)
-
-### 1. Downloading The Template
-
-Data in ERPNext is stored in tables, much like a spreadsheet with columns and rows of data. Each entity in ERPNext can have multiple child tables associated with it too. The child tables are linked to the parent tables and are implemented where there are multiple values for any property. For example an Item can have multiple prices, An Invoice has multiple Items and so on.
-
-You can import each table separately, or all at a time. In the child table, you must mention the parent of the row in the “parent” column so that ERPNext knows which Item’s price or tax you are trying to set if you are importing separately.
-
-![Download The Template](img/import-2.png)
-
-- Click on the table you want to download or "All Tables"
-- For bulk editing, you can click on "Download With Data"
-
-### 2. Fill in the Template
-
-After downloading the template, open it in a spreadsheet application and fill in the data below the column headings.
-
-![Spreadsheet](img/import-3.png)
-
-Then export your template or save it as a **Comma Separated Values** (CSV) file.
-
-![Spreadsheet](img/import-4.png)
-
-### 3. Upload the .csv File
-
-Finally attach the .csv file in the section. Click on the "Upload and Import" button.
-
-![Attach and Upload](img/import-5.png)
-
-Notes:
-
-- Make sure that if your application allows, use encoding as UTF-8. 
-- Keep the ID column blank for new records.
-- Make sure you keep the modified column as it is for "All Tables".
-- "Parent" column is mandatory for child type tables.
-
-### 4. Uploading All Tables (Main + Child)
-
-If you select all tables, you will get columns belonging to all the tables in one row separated by `-` columns.
-
-If you have multiple child rows then you must start a new main item on a new row. See the example:
-
-	Main Table							- 	Child Table
-	Column 1	Column 2	Column 3	- 	Column 1	Column 2	Column 3
-	v11			v12			v13				c11			c12			c13
-											c14			c15			c17
-	v21			v22			v23				c21			c22			c23
-	
-> To see how its done, enter a few records manually using forms and export "All Tables" with "Download with Data"
-
-### 5. Overwriting
-
-ERPNext also allows you to overwrite all / certain columns. If you want to update certain columns, you can download the template with data.Remember to check on the “Overwrite” box before uploading.
-
-> Note: For child records, if you select Overwrite, it will delete all the child records of that parent.
-
-### 6. Upload Limitations
-
-ERPNext restricts the amount of data you can upload in one file. Though the number may vary based on the type of data. It is usually safe to upload around 1000 rows of a table at one go. If the system will not accept, then you will see an error.
-
-Why is this? Uploading a lot of data can cause your system to crash, specially if there are other users doing things in parallel. Hence ERPNext restricts the number of “writes” you can process in one request.
diff --git a/docs/user/setup/docs.user.setup.email.md b/docs/user/setup/docs.user.setup.email.md
deleted file mode 100644
index 63bc146..0000000
--- a/docs/user/setup/docs.user.setup.email.md
+++ /dev/null
@@ -1,77 +0,0 @@
----
-{
-	"_label": "Setting up Email"
-}
----
-Emails are the nervous system of business communication and ERPNext has been designed to make good use of this. 
-
-## Sending Emails
-
-You can email any document from the system, by clicking on the “Email” button on the right sidebar. Before that you will need to set your outgoing email settings (SMTP server).
-
-All emails sent from the system are added to the Communication table.
-
-> **Info:** What is SMTP? There are two types of email services, sending and receiving emails. Sending is done via a protocol called SMTP (Simple Mail Transfer Protocol) and the server (computer) that sends your email to its destination is called SMTP Server.
-
-> **Info:** Bulk Emails: Bulk Emails, especially those that are sent without consent (spam), are considered as bad behavior. While it may be okay to send emails to those who have “opted-in” to receive mails, it is very difficult for the internet community to know what is spam and what is allowed. To overcome this problem, most email servers share a black and white list of email senders. If your emails have been marked as spam, you will be blacklisted. So be careful. Many times, it may be a good idea to send email via whitelisted services also known as SMTP relay services which are paid services. These services will block you from sending spam while ensuring that most of your email does not go in the spam folder. There are many such services available like SendGrid and SMTP.com
-
-To setup your outgoing mails, go to
-
-> Setup > Outgoing Email Settings > Email Settings
-
-
-![Email Settings](img/email-settings1.png)
-
-
-
-Set your outgoing mail server settings here. These are the same settings you would use in your Outlook, Thunderbird, Apple Mail or other such email applications. If you are not sure, get in touch with your email service provider.
-
-> **Tip:** If you are using EPRNext hosted service, keep the first section blank. Emails will still be sent from your email id, but via our SMTP relay service.
-
-### Creating Support Tickets from Incoming Emails
-
-A very useful email integration is to sync the incoming emails from support inbox into Support Ticket, so that you can track, assign and monitor support issues.
-
-> **Case Study:** Here at ERPNext, we have regularly tracked incoming support issues via email at “support@erpnext.com”. At the time of writing we had answered more than 3000 tickets via this system.
-
-To setup your Support integration, go to:
-
-> Setup > Support Email Settings > EMail Settings
-
-
-![Email Settings](img/email-settings2.png)
-
-
-
-
-To make ERPNext pull emails from your mail box, enter the POP3 settings. (POP3 is a way of extracting emails from your mailbox. It should be fairly easy to find out what your POP3 settings are. If you have problems, contact your email service provider).
-If you want to setup an auto reply, check on the “Send Autoreply” box and whenever someone sends an email, an autoreply will be sent.
-Add a custom signature which you want to send with your replies. 
-
-### Setting Auto-notification on Documents
-
-ERPNext allows you to automatically email documents on “Submission” to the contact mentioned in the document. To set this up, go to:
-
-> Setup > Tools > Enable / Disable Notifications.
-
-
-![Auto Notification](img/auto-notification.png)
-
-
-
-Check on the transactions you want to send via email directly on Submission and add a custom message if you want on these documents.
-￼
-### Email Digests
-
-Email Digests allow you to get regular updates about your sales, expenses and other critical numbers directly in your Inbox. 
-
-Set your frequency, check all the items you want to receive in your weekly update and select the user ids whom you want to send the Digest to.
-
-Email Digests are a great way for top managers to keep track of the big numbers like “Sales Booked” or “Amount Collected” or “Invoices Raised” etc.
-
-To setup Email Digests, go to: 
-
-> Setup > Email Digest > New Email Digest 
-
-
-![Email Digest](img/email-digest.png)
diff --git a/docs/user/setup/docs.user.setup.first.md b/docs/user/setup/docs.user.setup.first.md
deleted file mode 100644
index 4784a69..0000000
--- a/docs/user/setup/docs.user.setup.first.md
+++ /dev/null
@@ -1,21 +0,0 @@
----
-{
-	"_label": "Initial Setup"
-}
----`
-After a successful sign-up / installation of ERPNext, on your first sign-in, you will get a form to fill.
-
-![First Screen](img/setup-first-screen.png)
-￼
-This form will create your first **Company** and **Fiscal Year** (accounting or financial year) record. You can create other Companies later.
-
-Some definitions:
-
-- [Fiscal Year](docs.user.knowledge.fiscal_year.html): This is your financial year, the fiscal year usually starts on 1st Jan or 1st March for most regions. If you are not sure, consult an accountant.
-- Abbreviation: In a multi-company setup, the abbreviation is appended to each account, so keep it small (2-4) characters and all caps.
-
-This will also set the default **Currency** and time zone for your account. Once you complete this, your first **Company** and **Chart of Accounts** will be created.
-
-Congrats! You are already on your way.
-
-The next step is to follow implementation instructions.
\ No newline at end of file
diff --git a/docs/user/setup/docs.user.setup.global_defaults.md b/docs/user/setup/docs.user.setup.global_defaults.md
deleted file mode 100644
index 8066a7f..0000000
--- a/docs/user/setup/docs.user.setup.global_defaults.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-{
-	"_label": "Global Default"
-}
----
-Default means automatic. Something that is predefined in the system settings, occurs without change or effort, if you do not choose another option.
-
-For example, If you deal in the currency-Rupee, you can set your default global setting as Rupee. Whenever a transaction takes place in ERPNext, the system will automatically consider Rupee as the default medium of currency, unless you specify otherwise.
-
-
-> Setup > Tools > Global Settings/Defaults
-
-
-
-![Global Defaults](img/global-defaults.png)
-
-
-
-
diff --git a/docs/user/setup/docs.user.setup.letter_head.md b/docs/user/setup/docs.user.setup.letter_head.md
deleted file mode 100644
index 84c861a..0000000
--- a/docs/user/setup/docs.user.setup.letter_head.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-{
-	"_label": "Letter Head"
-}
----
-You can create / manage Letter Heads from:
-
-> Setup > Printing > Letter Head > New Letter Head
-
-#### Step 1: Letter Head Name
-
-![Letter Head](img/letter-head1.png)
-
-
-#### Step 2 : Attach Image
-
-![Letter Head](img/letter-head2.png)
-
-
-
-
-- Create an image with your logo, brand and other information that you want to put on your letter head.
-- Attach the image in your Letter Head record by clicking on image icon to automatically generate the HTML required for this Letter Head.
-- If you want to make this the default letter head, click on “Is Default”.
-
-Thats it! Your letter head will now appear in all Prints and Emails of documents.
diff --git a/docs/user/setup/docs.user.setup.masters.md b/docs/user/setup/docs.user.setup.masters.md
deleted file mode 100644
index ccbc32d..0000000
--- a/docs/user/setup/docs.user.setup.masters.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-{
-	"_label": "Setting Up Masters",
-	"_toc": [
-		"docs.user.stock.item",
-		"docs.user.selling.customer",
-		"docs.user.buying.supplier"
-	]
-}
----
-First step is setting up your master data.
\ No newline at end of file
diff --git a/docs/user/setup/docs.user.setup.md b/docs/user/setup/docs.user.setup.md
deleted file mode 100644
index 585811f..0000000
--- a/docs/user/setup/docs.user.setup.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-{
-	"_label": "Setting Up",
-	"_toc": [
-		"docs.user.setup.first",
-		"docs.user.setup.masters",
-		"docs.user.setup.accounting",
-		"docs.user.setup.cost_centers",
-		"docs.user.setup.company",
-		"docs.user.setup.users",
-		"docs.user.setup.permissions",
-		"docs.user.setup.workflows",
-		"docs.user.setup.letter_head",
-		"docs.user.setup.print_headings",
-		"docs.user.setup.series",
-		"docs.user.setup.global_defaults",
-		"docs.user.setup.data_import",
-		"docs.user.setup.email",
-		"docs.user.setup.sms",
-		"docs.user.setup.taxes",
-		"docs.user.setup.price_list",
-		"docs.user.setup.opening",
-		"docs.user.setup.pos_setting",
-		"docs.user.setup.third_party_backups"
-	]
-}
----
-
-Setting up an ERP system is like starting your business all over again, although in the virtual world. Thankfully it is not as hard as the real business and you get to do a trial too!
-
-Implementation requires the implementer to take a step back and set aside some time to do this right. This is usually not a couple-of-hours, after-work kind of a project.
-
-Let us start with the screen that you see, the first time you login.
\ No newline at end of file
diff --git a/docs/user/setup/docs.user.setup.opening.md b/docs/user/setup/docs.user.setup.opening.md
deleted file mode 100644
index 4c30306..0000000
--- a/docs/user/setup/docs.user.setup.opening.md
+++ /dev/null
@@ -1,84 +0,0 @@
----
-{
-	"_label": "Opening Accounts and Inventory"
-}
----
-Now ￼that you have completed most of the setup, its time to start moving in!
-
-There are two important sets of data you need to enter before you start your operations.
-
-- Opening Account balances.
-- Opening Stock balances.
-
-To setup your accounts and stock correctly you will need accurate data to work with. Make sure you have the data setup for this.
-
-### Opening Accounts
-
-We usually recommend that you start using accounting in a new financial year, but you could start midway too. To setup your accounts, you will need the following for the “day” you start using accounting in ERPNext:
-
-Opening capital accounts - like your shareholder’s (or owner’) capital, loans, bank balances on that day.
-List of outstanding sales and purchase invoices (Payables and Receivables).
-
-#### Temporary Accounts
-
-A nice way to simplify opening is to create temporary accounts for assets and liability just for opening. These accounts will become zero once all your old invoices are entered. The two accounts which you can create are (example):
-
-- Temp Opening Liabilities
-- Temp Opening Assets
-
-#### The Opening Entry
-
-In ERPNext Opening Accounts are setup by submitting a special Journal Entries (Journal Voucher).
-
-Note: Make sure to set “Is Opening” as “Yes” in the More Info section.
-
-
-> Setup > Opening Accounts and Stock > Opening Accounting Entries.
-
-
-
-#### Step 1: Select Opening Entry in the Voucher Type section.
-
-![Opening Entry](img/opening-entry.png)
-
-<br>
-
-#### Step 2: Complete Journal Entries on the Debit and Credit side. 
-
-
-![Opening Entry](img/opening-entry-1.png)
-
-<br>
-
-
-#### Step 2: Select Yes in the "Is Opening " record under More Info.
-
-
-![Opening Entry](img/opening-entry-2.png)
-
-
-
-You can make two Opening Journal Vouchers:
-
-- For all assets (excluding Accounts Receivables): This entry will contain all your assets except the amounts you are expecting from your Customers against outstanding Sales Invoices. You will have to update your receivables by making an individual entry for each Invoice (this is because, the system will help you track the invoices which are yet to be paid). Since all the entries in this voucher will be of type “Debit”, you can credit the sum of all these debits against the “Temp Opening Liabilities” account.
-- For all liabilities: Similarly you need to pass a Journal Voucher for your Opening Liabilities (except for the bills you have to pay). This can be made against the “Temp Opening Assets” account.
-
-After completing the accounting entries, the trial balance report will look like the one given below:
-
-
-![Trial Balance](img/trial-balance-1.png)
-
-
-
-#### Outstanding Invoices
-
-After your Opening Journal Vouchers are made, you will need to enter each Sales Invoice and Purchase Invoice that is yet to be paid. 
-
-Since you have already booked the income or expense on these invoices in the previous period, select the temp opening accounts in the “Income” and “Expense” accounts.
-
-Note: Again make sure to set each invoice as “Is Opening”!
-
-If you don’t care what items are in that invoice, just make a dummy item entry in the Invoice. Item code in the Invoice is not necessary, so it should not be such a problem.
-
-Once all your invoices are entered, your “Temp Opening Assets” will be same as “Temp Opening Liabilities” and you can pass another “Is Opening” type of Journal Voucher and cancel them to zero!
-
diff --git a/docs/user/setup/docs.user.setup.permissions.md b/docs/user/setup/docs.user.setup.permissions.md
deleted file mode 100644
index 34de107..0000000
--- a/docs/user/setup/docs.user.setup.permissions.md
+++ /dev/null
@@ -1,91 +0,0 @@
----
-{
-	"_label": "Setting up Permissions"
-}
----
-ERPNext has a role-based permission system, which means that you can assign Roles to Users, and Permissions on Roles.
-
-ERPNext has a very powerful permission structure that will allow you to set permissions right up to the field level.
-
-Permissions are applied on:
-
-- **Roles:** As we saw earlier, Users are assigned to Roles and it is on these Roles that permission rules are applied.￼
-- **Document Types:** Each type of document, master or transaction, has a separate list of Role based permission.
-- **Document Stages:** Permissions are applied on each stage of the document like on Creation, Saving, Submission, Cancellation and Amendment. 
-- **Permission “Levels”:** In each document, you can group fields by “levels”. Each group of field is denoted by a unique number (1,2,3 etc.). A separate set of permission rules can be applied to each field group. By default all fields are of level 0.
-- **“Match Rules”** Based on certain properties of the document and the user: This can be used in cases where, for example, you have multiple Companies or sales persons in different Territories and you want to restrict each User to only view documents relating to the User’s Company or Territory etc. It is also called “match” rules.
-
-When you define a “match” rule, the User will only be allowed to access (or write) the document if the User has one or more such values (e.g. Company, Territories) and the document has the same values.   For example, if you have set a match rule on Sales Order for a particular Role based on “territory”, then all users of that Role will only be allowed to view Sales Orders of that Territory. Let us walk through an example.
-
-ERPNext comes with pre-set permission rules that you can change anytime by going to
-
-> Setup > Users and Permissions > Permission Manager
-
-![Permission Manager](img/permission-manager.png)
-
-
-
-
-## Using the Permission Manager
-
-The Permission Manager is an easy way to set / unset permission rules. The Permission Manager allows you to monitor rules per Document Type.
-
-When you select a document type from the drop-down. You will see the rules that have already been applied.
-
-To add a new rule, click on “Add a New Rule” button and a pop-up box will ask you to select a Role and a Permission Level. Once you select this and click on “Add”, this will add a new row to your rules table.
-
-To edit rules, just check or uncheck the boxes stating the permission level and Role and click on “Update”.
-
-To delete a rule, just uncheck all the boxes of the row and click on “Update” 
-
-To set “match” rules, select the drop-down in the last column.  For example, you want to restrict Users of Role “Sales User” by Territories in Sales Order. 
-
-
-1. Select Sales Order in “Set Permissions For”
-1. In the row for Role “Sales User”, in the last column “Restrict By”, select “territory”.
-1. To assign Territories to Users, click on “Set Users / Roles”
-1. In the popup box, 
-	- In the “Who” column, select “Profile” and the User you want to assign the Territory to
-	- In the “Is allowed if territory equals” column, select the Territory you want to assign 	to this user.
-1. Click on “Add”
-
-In the same way, add a row for each user.
-
-#### Step 1: Select Sales Order in "Set Permissions For"
-
-
-![Permissions Manager](img/permission-manager-1.png)
-
-#### Step 2: Select restriction option as Territory
-
-<br>
-![Permissions Manager](img/permission-manager-2.png)
-
-<br>
-
-#### Step 3: To assign Territories to users, click on "Set Users/Roles"
-
-<br>
-
-![Permissions Manager](img/permission-manager-3.png)
-
-
-#### Step 3: Restrict User by selecting Territory
-
-
-![Permission Manager](img/permission-manager-4.png)
-
-
-#### Step 4: Select the User to assign to a Territory
-
-
-![Permission Manager](img/permission-manager-5.png)
-
-
-> **Note 1:** The “match” rules apply to all documents that you have matched by Territory.
-
-> **Note 2:** You can set multiple rules for the same User. In this example, you can set a User to access more than one Territories.
- 
-
-If you have more than two companies, we recommend that you should maintain seperate databases for these companies (2/3 ERPnext accounts). This avoids data leak from one company to another.
-
diff --git a/docs/user/setup/docs.user.setup.pos_setting.md b/docs/user/setup/docs.user.setup.pos_setting.md
deleted file mode 100644
index bd2a1a8..0000000
--- a/docs/user/setup/docs.user.setup.pos_setting.md
+++ /dev/null
@@ -1,22 +0,0 @@
----
-{
-	"_label": "POS Setting"
-}
----
-
-#### POS Settings
-
-POS includes advanced features to cater to different functionality, such as inventory management, CRM, financials, warehousing, etc., all built into the POS software. Prior to the modern POS, all of these functions were done independently and required the manual re-keying of information, which could lead to entry errors.
-
-If you are in retail operations, you want your Point of Sale to be as quick and efficient as possible. To do this, you can create a POS Setting for a user from:
-
-> Accounts > Point-of-Sale Setting
-
-Set default values as defined.
-
-
-![POS Setting](img/pos-setting.png)
-
-
-> Important : If you specify a particular User, the POS setting will be applied only to that User. If the User option is left blank, the setting will be set for all users. To understand POS in detail visit [Point of Sale](docs.user.accounts.pos.html)
-
diff --git a/docs/user/setup/docs.user.setup.price_list.md b/docs/user/setup/docs.user.setup.price_list.md
deleted file mode 100644
index a1fbf89..0000000
--- a/docs/user/setup/docs.user.setup.price_list.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-{
-	"_label": "Price Lists"
-}
----
-A Price List is a place where different rate plans can be stored. It’s a name you give to a set of Item Prices stored under a particular Price List.
-
-An Item can have multiple prices based on customer, currency, region, shipping cost etc, which can be stored as different rate plans. In ERPNext, you are required to store all the lists seperately. Buying Price List is different from Selling Price List and thus is stored separately. 
-
-> Setup > Price List
-
-
-![Price-List](img/price-lists.png)
-
-
-> For multiple currencies, maintain multiple Price Lists.
-
-<br>
-### Add Item in Price List
-
-> Setup > Item Price
-
-- Enter Price List and Item Code, Valid for Buying or Selling, Item Name and Item Description will be automatically fetched.
-- Enter Rate and save the document.
-
-![Item-Price](img/item-price.png)
-
-For bulk upload of Item Prices, use [Data Import Tool](docs.user.setup.data_import.html)
\ No newline at end of file
diff --git a/docs/user/setup/docs.user.setup.print_headings b/docs/user/setup/docs.user.setup.print_headings
deleted file mode 100644
index 612bdf8..0000000
--- a/docs/user/setup/docs.user.setup.print_headings
+++ /dev/null
@@ -1,36 +0,0 @@
----
-{
-	"_label": "Print Headings"
-}
----
-Print Headings are the names which you can give to your sales invoices, supplier quotations etc. You can create a list of names for different business communications.
-
-You can create print headings from :
-
-> Setup > Printing > Print Heading > New Print Heading
-
- 
-
-![Print Heading](img/print-heading1.png)
-
-
-
-
-Example of a change in print heading is shown below:
-
-![Print Heading](img/print-heading2.png)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/docs/user/setup/docs.user.setup.print_headings.md b/docs/user/setup/docs.user.setup.print_headings.md
deleted file mode 100644
index 612bdf8..0000000
--- a/docs/user/setup/docs.user.setup.print_headings.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-{
-	"_label": "Print Headings"
-}
----
-Print Headings are the names which you can give to your sales invoices, supplier quotations etc. You can create a list of names for different business communications.
-
-You can create print headings from :
-
-> Setup > Printing > Print Heading > New Print Heading
-
- 
-
-![Print Heading](img/print-heading1.png)
-
-
-
-
-Example of a change in print heading is shown below:
-
-![Print Heading](img/print-heading2.png)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/docs/user/setup/docs.user.setup.series.md b/docs/user/setup/docs.user.setup.series.md
deleted file mode 100644
index 955bded..0000000
--- a/docs/user/setup/docs.user.setup.series.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-{
-	"_label": "Document Naming Series"
-}
----
-Data records are broadly classified as “Master” or “Transaction”. A master record is a record that has a “name”, for example a Customer, Item, Supplier, Employee etc. A Transaction is a record that has a “number”. Examples of transactions include Sales Invoices, Quotations etc. You make transactions against a number of master records.
-
-ERPNext allows you to make prefixes to your transactions, with each prefix forming its own series. For example a series with prefix INV12 will have numbers INV120001, INV120002 and so on.
-
-You can have multiple series for all your transactions. It is common to have a separate series for each financial year. For example in Sales Invoice you could have:
-
-- INV120001
-- INV120002
-- INV-A-120002
-
-etc. You could also have a separate series for each type of Customer or for each of your retail outlets.
-
-To setup a series, go to:
-
-> Setup > Tools > Update Numbering Series
-
-
-
-![Document Naming Series](img/naming-series.png)
-
-
-
-In this form,
-
-1. Select the transaction for which you want to make the series
-The system will update the current series in the text box.
-1. Edit the series as required with unique prefixes for each series. Each prefix must be on a new line.
-1. The first prefix will be the default prefix. If you want the user to explicitly select a series instead of the default one, check the “User must always select” check box.
-
-You can also update the starting point for a series by entering the series name and the starting point in the “Update Series” section.
\ No newline at end of file
diff --git a/docs/user/setup/docs.user.setup.sms.md b/docs/user/setup/docs.user.setup.sms.md
deleted file mode 100644
index 64892b9..0000000
--- a/docs/user/setup/docs.user.setup.sms.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-{
-	"_label": "SMS Setting"
-}
----
-To integrate SMS in ERPNext, approach a SMS Gateway Provider who provides HTTP API. They will create an account for you and will provide an unique username and password.
-
-To configure SMS Settings in ERPNext, find out their HTTP API (a document which describes the method of accessing their SMS interface from 3rd party applications). In this document, you will get an URL which is used to send the SMS using HTTP request. Using this URL, you can configure SMS Settings in ERPNext.
-
-Example URL: <br>
-<pre>http://instant.smses.com/web2sms.php?username=&lt;USERNAME>&password=&lt;PASSWORD>&to=&lt;MOBILENUMBER>&sender=&lt;SENDERID>&message=&lt;MESSAGE>
-</pre>
-
-![SMS Settings](img/sms-setting2.jpg)
-
-
-
-
-> Note: the string up to the "?" is the SMS Gateway URL
-
-Example:
-<pre>http://instant.smses.com/web2sms.php?username=abcd&password=abcd&to=9900XXXXXX&sender
-=DEMO&message=THIS+IS+A+TEST+SMS</pre>
-
-The above URL will send SMS from account abcd to mobile number 9900XXXXXX with sender ID as DEMO with text message as "THIS IS A TEST SMS"
-
-Note that some parameters in the URL are static.You will get static values from your SMS Provider like username, password etc. These static values should be entered in the Static Parameters table.
-
-![SMS Setting](img/sms-settings1.png)
-
diff --git a/docs/user/setup/docs.user.setup.taxes.md b/docs/user/setup/docs.user.setup.taxes.md
deleted file mode 100644
index ef3bbd5..0000000
--- a/docs/user/setup/docs.user.setup.taxes.md
+++ /dev/null
@@ -1,77 +0,0 @@
----
-{
-	"_label": "Setting up Taxes"
-}
----
-One of the primary motivator for compulsory use of accounting tools is calculation of Taxes. You may or may not make money but your government will (to help your country be safe and prosperous). And if you don’t calculate your taxes correctly, they get very unhappy. Ok, philosophy aside, ERPNext allows you to make configurable tax templates that you can apply to your sales or purchase.
-
-### Tax Accounts
-
-For Tax Accounts that you want to use in the tax templates, you must go to Chart of Accounts and mention them as type “Tax” in your Chart of Item. 
-
-## Item Tax 
-
-If some of your Items require different tax rates as compared to others, mention them in the Item tax table. Even if you have selected your sales and purchase taxes as default tax rates, the system will pull the Item tax rate for calculations. Item tax will get preference over other sales or purchase taxes. However, if you wish to apply default sales and purchase taxes, do not mention item tax rates in the Item master. The system will then select the sales or purchase tax rate specified by you as default rates.
-
-![Item Tax](img/item-tax-1.png)
-
-
-- **Inclusive and Exclusive Tax**: ERPNext allows you to enter Item rates which are tax inclusive.
-
-![Inclusive Tax](img/inclusive-tax.png)
-
-
-
-- **Exception to the rule**: Item tax settings are required only if a particular Item has a different tax rate than the rate defined in the standard tax Account
-- **Item tax is overwrite-able**: You can overwrite or change the item tax rate by going to the Item master in the Item tax table.
-
-## Sales Taxes and Charges Master
-
-You must usually collect taxes from your Customer and pay them to the government. At times, you may have to pay multiple taxes to multiple government bodies like local government, state or provincial and federal or central government.
-
-The way ERPNext sets up taxes is via templates. Other types of charges that may apply to your invoices (like shipping, insurance etc.) can also be configured as taxes.
-
-Select template and modify as per your need.
-
-To create a new sales tax template called Sales Taxes and Charges Master, you have to go to:
-
-> Setup > Accounts > Sales Taxes and Charge Master
-
-
-![Sales Tax Master](img/sales-tax-master.png)
-
-
-
-When you create a new master, you will have to add a row for each tax type.
-
-The tax rate you define here will be the standard tax rate for all Items. If there are Items that have different rates, they must be added in the Item Tax table in the Item master.
-
-In each row, you have to mention:
-
-- Calculation Type: 
-	- On Net Total : This can be on net total (total amount without taxes).
-	- On Previous Row Total/Amount: You can apply taxes on previous row total / amount. If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total. Previous row amount means a particular tax amount.And, previous row total means net total plus taxes applied up to that row. In the Enter Row Field, mention row number on which you want to apply the current tax. If you want to apply the tax on the 3rd row, mention "3" in the Enter Row field.
-
-	- Actual : Enter as per actual amount in rate column.
-
-- Account Head: The Account ledger under which this tax will be booked
-- Cost Center: If the tax / charge is an income (like shipping) it needs to be booked against - a Cost Center.
-- Description: Description of the tax (that will be printed in invoices / quotes).
-- Rate: Tax rate.
-- Amount: Tax amount.
-- Total: Cumulative total to this point.
-- Enter Row: If based on "Previous Row Total" you can select the row number which will be taken as a base for this calculation (default is the previous row).
-- Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the rate in your main item table. This is useful when you want to give a flat price (inclusive of all taxes) to your customers.
-
-Once you setup your template, you can select this in your sales transactions.
-
-## Purchase Taxes and Charges Master
-
-Similar to your Sales Taxes and Charges Master is the Purchase Taxes and Charges Master.
-
-This is the tax template that you can use in your Purchase Orders and Purchase Invoices. If you have value added taxes (VAT), where you pay to the government the difference between your incoming and outgoing taxes, you can select the same Account that you use for sales taxes.
-For more details see [Purchase Taxes](docs.user.buying.purchase_taxes.html)
-
-The columns in this table are similar to the Sales Taxes and Charges Master with the difference as follows:
-
-Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.
diff --git a/docs/user/setup/docs.user.setup.third_party_backups.md b/docs/user/setup/docs.user.setup.third_party_backups.md
deleted file mode 100644
index 04f6a4c..0000000
--- a/docs/user/setup/docs.user.setup.third_party_backups.md
+++ /dev/null
@@ -1,47 +0,0 @@
----
-{
-	"_label": "Third Party Backups"
-}
----
-
-If you wish to store your backups on a periodic basis,on Dropbox, you can do it directly through ERPNext.
-
-> Setup > Manage 3rd Party Backups
-
-
-
-![Third Party Backups](img/third-party-backups.png)
-
-
-On the Backup Manager page, enter the email addresses of those people whom you wish to notify about the upload status. Under the topic 'Sync with Dropbox', select whether you wish to upload Daily, Weekly or Never. The third step is to click on **Allow Dropbox Access**.
-
-> Tip: In future, if you wish to discontinue uploading backups to dropbox, then select the Never option.
-
-![Backup Manager](img/backup-manager.png)
-
-
-
- You need to login to your dropbox account, with your user id and password.
-
-
-
-![Dropbox Access](img/dropbox-access.png)
-
-
-
-## Open Source Users
-
-
-Installing Pre-Requisites
-
-    pip install dropbox
-    pip install google-api-python-client
-
-<br>
-#### Create an App in Dropbox
-
-First create your Dropbox account.After successful creation of account you will receive `app_key`, `app_secret` and `access_type`. Now open `conf.py` and set `app_key` as `dropbox_access_key` and `app_secret` as `dropbox_secret_key` 
-
-
-<br>
-> Note: Please ensure Allow Pop-ups are enabled in your browser.
diff --git a/docs/user/setup/docs.user.setup.users.md b/docs/user/setup/docs.user.setup.users.md
deleted file mode 100644
index 06ac910..0000000
--- a/docs/user/setup/docs.user.setup.users.md
+++ /dev/null
@@ -1,47 +0,0 @@
----
-{
-	"_label": "Adding Users"
-}
----
-
-ERPNext has a role-based permission system, which means that you can assign Roles to Users, and permissions on Roles.Each ERPNext user has a Profile. The Profile contains the user’s email and authentication and can be set from:
-
-> Setup > Profile
-
-#### Step 1: Adding a new User
-
-To add a new user, click on “Add” button and enter the user’s
-
-- Email Id
-- First Name
-- Last Name
-
-![User](img/user1.png)
-
-#### Step 2: Password and Image
-
-Enter a new password and select the image of the user. Write a small description about the User under the heading Short Bio
-
-![User](img/user2.png)
-
-<br>
-> Roles will be visible only after you save the Docuemnt.
-
-
-#### Step 3 :Setting Roles and Email Settings
-
-Check the boxes which the User can access. ERPNext comes with a bunch of predefined roles. 
-Enter his email settings. The message will appear at the end of every mail. 
-
-![User](img/user3.png)
-
-#### Step 4: Security Settings
-
-- Enabling / disabling users: You can enable or disable users. Disabled users will not be able to log in.
-- Setting login time: If login time is set, users can only log-in within the defined hours as per your timezone.
-
-If you wish to give the user access to the system only between office hours, or during weekends, mention it under security settings.
-
-
-![User](img/user4.png)
-
diff --git a/docs/user/setup/docs.user.setup.workflows.md b/docs/user/setup/docs.user.setup.workflows.md
deleted file mode 100644
index c7c320a..0000000
--- a/docs/user/setup/docs.user.setup.workflows.md
+++ /dev/null
@@ -1,52 +0,0 @@
----
-{
-	"_label": "Workflows"
-}
----
-In order to allow multiple people to submit  multiple requests, for approvals, by multiple users, ERPNext requires you to fill the workflow conditions. ERPNext tracks the multiple permissions before submission.
-
-Example of a leave application workflow is given below:
-
-If an user  applies for a leave, then his request will be sent to the HR department. The HR department(HR User) will either reject or approve this request. Once this process is completed, the user's Manager(leave approver) will get an indication that the HR department has Accepted or Rejected. The Manager, who is the approving authority, will either Approve or Reject this request. Accordingly,the user will get his Approved or Rejected status. 
-
-![Workflow](img/workflow-leave-fl.jpg)
-
-
-
-
-To make this Workflow and transition rules go to :
-
- > Setup > Workflow > New Workflow
-
-
-#### Step 1: Enter the different states of Leave Approval Process.
-
-
- ![Workflow](img/workflow-leave1.png)
-
-
-
-#### Step 2: Enter Transition Rules.
-
-
-![Workflow](img/workflow-leave2.png)
-
-
-Example of a Leave Application Process:
-
-Go to the Human Resources Module and click on Leave Application. Apply for a Leave.
-
-When a Leave Application is submitted, the status on the right hand corner of the page shows as "Applied"
-
-![Workflow Employee LA](img/workflow-employee-la.png)
-
-When the HR User logs in,  he can either Approve or Reject. If approved the status on the right hand corner of the page shows as Approved. However, a blue band of information is displayed saying approval is pending by leave approver.
-
-![Leave Approver](img/workflow-hr-user-la.png)
-
-
-When the leave approver opens the Leave Application page, he should select the status and convert to Approved or Rejected.
-
-![Workflow Leave Approver](img/workflow-leave-approver-la.png)
-
-
diff --git a/docs/user/stock/docs.user.stock.accounting_for_stock.md b/docs/user/stock/docs.user.stock.accounting_for_stock.md
deleted file mode 100644
index 8348c80..0000000
--- a/docs/user/stock/docs.user.stock.accounting_for_stock.md
+++ /dev/null
@@ -1,42 +0,0 @@
----
-{
-	"_label": "Accounting of Inventory / Stock"
-}
----
-
-The value of available inventory is treated as an Asset in company's Chart of Accounts. Depending on the type of items, it can be treated as Fixed Asset or Current Asset. To prepare Balance Sheet, you should make the accounting entries for those assets. 
-There are generally two different methods of accounting for inventory:
-
-
-### **Auto / Perpetual Inventory**
-
-In this process, for each stock transactions, the system posts relevant accounting entries to sync stock balance and accounting balance. This is the default setting in ERPNext for new accounts.
-
-When you buy and receive items, those items are booked as the company’s assets (stock-in-hand / fixed-assets). When you sell and deliver those items, an expense (cost-of-goods-sold) equal to the buying cost of the items is booked. General Ledger entries are made after every stock transaction.  As a result, the value as per Stock Ledger always remains same with the relevant account balance. This improves accuracy of Balance Sheet and Profit and Loss statement.
-
-To check accounting entries for a particular stock transaction, please check [**examples**](docs.user.stock.perpetual_inventory.html)
-
-#### **Advantages**
-
-Perpetual Inventory system will make it easier for you to maintain accuracy of company's asset and expense values. Stock balances will always be synced with relevant account balances, so no more periodic manual entry has to be done to balance them.
-
-In case of new back-dated stock transactions or cancellation/amendment of an existing transaction, all the future Stock Ledger entries and GL Entries will be recalculated for all items of that transaction.
-The same is applicable if any cost is added to the submitted Purchase Receipt, later through the Landed Cost Wizard.
-
->Note: Perpetual Inventory totally depends upon the item valuation rate. Hence, you have to be more careful entering valuation rate while making any incoming stock transactions like Purchase Receipt, Material Receipt, or Manufacturing / Repack.
-
--
-
-### **Periodic Inventory**
-
-In this method, accounting entries are manually created periodically, to sync stock balance and relevant account balance. The system does not create accounting entries automatically for assets, at the time of material purchases or sales.
-
-In an accounting period, when you buy and receive items, an expense is booked in your accounting system. You sell and deliver some of these items.
-
-At the end of an accounting period, the total value of items to be sold, need to be booked as the company’s assets, often known as stock-in-hand. 
-
-The difference between the value of the items remaining to be sold and the previous period’s stock-in-hand value can be positive or negative. If positive, this value is removed from expenses (cost-of-goods-sold) and is added to assets (stock-in-hand / fixed-assets). If negative, a reverse entry is passed. 
-
-This complete process is called Periodic Inventory.
-
-If you are an existing user using Periodic Inventory and want to use Perpetual Inventory, you have to follow some steps to migrate. For details, check [**Migration From Periodic Inventory**](docs.user.stock.periodic_to_perpetual.html)
diff --git a/docs/user/stock/docs.user.stock.delivery_note.md b/docs/user/stock/docs.user.stock.delivery_note.md
deleted file mode 100644
index 3017a1b..0000000
--- a/docs/user/stock/docs.user.stock.delivery_note.md
+++ /dev/null
@@ -1,53 +0,0 @@
----
-{
-	"_label": "Delivery Note"
-}
----
-A Delivery Note is made when a shipment is shipped from the company’s Warehouse. 
-
-A copy of the Delivery Note is usually sent with the transporter. The Delivery Note contains the list of Items that are sent in the shipment and updates the inventory.
-
-The entry of the Delivery Note is very similar to a Purchase Receipt. You can create a new Delivery Note from:
-
-> Stock > Delivery Note > New Delivery Note
-
-or from a “Submitted” Sales Order (that is not already shipped) by clicking on “Make Delivery Note”.
-
-
-
-
-![Delivery Note](img/delivery-note.png)
-
-
-
-
-
-
-You can also “fetch” the details from an unshipped Sales Order. 
-
-You will notice that all the information about unshipped Items and other details are carried over from your Sales Order.
-
-### Shipping Packets or Items with Sales BOM
-
-If you are shipping Items that have a Sales BOM, ERPNext will automatically create a “Packing List” table for you based on the sub-Items in that Item. (See the Item explanation for more information).
-
-If your Items are serialized, then for Sales BOM type of Items, you will have to update the Serial Number in the “Packing List” table.
-
-### Packing Items in to Cases, for Container Shipment
-
-If you are doing container shipment or by weight, then you can use the Packing Slip to breakup your Delivery Note into smaller units. To make a Packing Slip go to:
-
-Stock > Packing Slip > New Packing Slip
-
-You can create multiple Packing Slips for your Delivery Note and ERPNext will ensure that the quantities in the Packing Slip do not exceed the quantities in the Delivery Note.
-
----
-
-#### Print Without Amounts
-
-If you want to print your Delivery Notes without the amount (this might be useful if you are shipping high value items), just check the “Print without Amount” box in the “More Info” section.
-
-#### What happens when the Delivery Note is “Submitted”?
-
-A Stock Ledger Entry is made for each Item and stock is updated.
-Pending Quantity in the Sales Order is updated (if applicable).
diff --git a/docs/user/stock/docs.user.stock.how_to.md b/docs/user/stock/docs.user.stock.how_to.md
deleted file mode 100644
index 0f38091..0000000
--- a/docs/user/stock/docs.user.stock.how_to.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-{
-	"_label": "How to"
-}
----
-
-
-This page contains most frequently asked questions on Stocks.
diff --git a/docs/user/stock/docs.user.stock.how_to_repack_products.md b/docs/user/stock/docs.user.stock.how_to_repack_products.md
deleted file mode 100644
index 4c386e4..0000000
--- a/docs/user/stock/docs.user.stock.how_to_repack_products.md
+++ /dev/null
@@ -1,38 +0,0 @@
----
-{
-	"_label": "How to repack products?"
-}
----
-
-
-#### Step 1: Go to Stock Entry
-
-#### Step 2: Select Purpose as Manufacture/Repack.
-
-![Repack](img/repack-1.png)
-
-#### Step 3: Fill Item details and BOM details.
-<br>
-
-### FAQ
-
-#### Q. How to repack products/items into smaller units?
-
-A lot of retailers / distributors buy large quantities of an item and repack them into smaller units. You can do this in ERPNext through Stock Entry.
-
-This entry is explained with an example.
-
-If you have a product, say - wheat, create a Stock Entry for the total amount of wheat stock in the Source Warehouse. Keep the UOM as KG.
-
-![Repack](img/stock-entry-repack.png)
-
-If you pack your item-wheat in boxes, and want to measure stock in terms of numbers, say - [5 kg wheat in 1 box];then, go to Stock Entry and select purpose as 'Manufacture/Repack'. Create one Item as Wheat with UOM KG. In this case mention only the source warehouse. Create another Item as Wheat Bag and mention UOM as Nos. Mention Target Warehouse for Wheat Bags. Mention Valuation numbers, save and submit the entry.
-
-The stock will be calculated as per the entry and will reflect in the stock report.
-
-
-![Repack](img/repack-2.png)
-
-
-
-
diff --git a/docs/user/stock/docs.user.stock.item.md b/docs/user/stock/docs.user.stock.item.md
deleted file mode 100644
index 14c1831..0000000
--- a/docs/user/stock/docs.user.stock.item.md
+++ /dev/null
@@ -1,95 +0,0 @@
----
-{
-	"_label": "Item Master",
-	"_toc": [
-		"docs.user.stock.valuation",
-		"docs.user.setup.codification"
-	]
-}
----
-An Item is your company's product or a service.The term Item is applicable to your core products as well as your raw materials. It can be a product or service that you buy/sell from your customers/ suppliers. ERPNext allows you to manage all sorts of items like raw-materials, sub-assemblies, finished goods, item variants and service items. 
-
-ERPNext is optimized for itemized management of your sales and purchase. If you are in services, you can create an Item for each services that your offer. Completing the Item Master is very essential for successful implementation of ERPNext.
-
-## Item Properties
-
-- **Item Name:** Item name is the actual name of your product or service.
-- **Item Code:** Item Code is a short-form to denote your Item. If you have very few Items, it is advisable to keep the Item Name and the Item Code same. This helps new users to recognise and update Item details in all transactions. In case you have lot of Items with long names and the list runs in hundreds, it is advisable to code. To understand naming Item codes see [Item Codification](docs.user.setup.codification.html)
-- **Item Group:** Item Group is used to categorize an Item under various criterias like products, raw materials, services, sub-assemblies, consumables or all Item groups. Create your default Item Group list under Setup> Item Group and pre-select the option while filling your New Item details under [Item Group](docs.user.stock.item_group.html)
-- **Default Unit of Measure:** This is the default measuring unit that you will use for your product. It could be in nos, kgs, meters, etc. You can store all the UOM’s that your product will require under Set Up> Master Data > UOM. These can be preselected while filling New Item by using % sign to get a pop up of the UOM list. 
-- **Brand:** If you have more than one brand save them under Set Up> Master Data> Brand and pre-select them while filling a New Item.
-
-![Item Properties](img/item-properties.png)
-
-### Upload an Image
-
-To  upload an image for your icon that will appear in all transactions, save the partially filled form. Only after your file is saved a “+” button will appear besides the Image icon. Click on this sign and upload the image.
-
-![Item Properties](img/item-add-image.png)
-
-### Inventory : Warehouse and Stock Setting
-
-In ERPNext, you can select  different type of Warehouses to stock your different Items. This can be selected based on Item types. It could be Fixed Asset Item, Stock Item or even Manufacturing Item. 
-
-- **Stock Item:** If you are maintaining stock of this Item in your Inventory, ERPNext will make a stock ledger entry for each transaction of this item.
-- **Default Warehouse:** This is the Warehouse that is automatically selected in your transactions. 
-- **Allowance Percentage:** This is the  percent by which you will be allowed to over-bill or  over-deliver this Item. If not set, it will select from  the Global Defaults. 
-- **Valuation Method:** There are two options to maintain valuation of stock. FIFO (first in -  first out) and Moving Average. To understand this topic in detail please visit “ Item Valuation, FIFO and Moving Average”.
-
-### Serialized and Batched Inventory
-
-These numbers help to track individual units or batches of Items which you sell. It also tracks warranty and returns. In case any individual Item is recalled by the supplier the number system helps to track individual Item. The numbering system  also manages expiry dates. Please note that if you sell your items in thousands, and if the items are very small like pens or erasers, you need not serialize them. In ERPNext, you will have to mention the serial number in some accounting entries. To create serial numbers you will have to manually create all the numbers in your entries. If your product is not a big consumer durable Item, if it has no warranty and has no chances of being recalled, avoid giving serial numbers. 
-
-> Important: Once you mark an item as serialized or batched or neither, you cannot change it after you have made any stock entry.
-
-- [Discussion on Serialized Inventory](docs.user.stock.serialized.html)
-
-### Re Ordering
-
-- **Re-order level** suggests the amount of stock balance in the Warehouse. 
-- **Re-order Qty** suggests the amount of stock to be ordered  to maintain minimum stock levels.
-- **Minimum Order Qty** is the minimum quantity for which a Material Request / Purchase Order must be made.
-
-### Item Tax
-
-These settings are required only if a particular Item has a different tax rate than the rate defined in the standard tax Account. For example,  If you have a tax Account, “VAT 10%” and this particular Item is exempted from tax, then you select “VAT 10%” in the first column, and set “0” as the tax rate in the second column. 
-
-Go to [Setting Up Taxes](docs.user.setup.taxes.html) to understand this topic in detail.
-
-### Inspection
-
-Inspection Required: If an incoming inspection (at the time of delivery from the Supplier) is mandatory for this Item, mention “Inspection Required” as “Yes”. The system will ensure that a Quality Inspection will be prepared and approved before a Purchase 	Receipt is submitted.
-
-Inspection Criteria: If a Quality Inspection is prepared for this Item, then this template of criteria will automatically be updated in the Quality Inspection table of the Quality Inspection. Examples of Criteria are: Weight, Length, Finish etc.
-
-### Purchase Details
-
-![Purchase Details](img/item-purchase.png)
-
-
-**Lead time days:** Lead time days are the number of days required for the Item to reach the warehouse.
-
-
-**Default Expense Account:** It is the account in which cost of the Item will be debited.
-
-**Default Cost Centre:** It is used for tracking expense for this Item.
-
-### Sales Details
-
-
-![Sales Details](img/item-sales.png)
-
-
-**Default Income Account:**  Income account selected here will be fetched automatically in sales invoice for this item.
-
-**Cost Centre:** Cost center selected here will be fetched automatically in sales invoice for this item.
-
-### Manufacturing And Website
-
-![Manufacturing](img/item-manufacturing-website.png)
-
-
-
-Visit [Manufacturing](docs.user.mfg.html) and [Website](docs.user.website.html) to understand these topics in detail.
-
-To list your products on the website and understand this process in detail, visit [Product Listing On Website](docs.user.stock.product_listing_on_website.html)
diff --git a/docs/user/stock/docs.user.stock.item_group.md b/docs/user/stock/docs.user.stock.item_group.md
deleted file mode 100644
index 22be9ae..0000000
--- a/docs/user/stock/docs.user.stock.item_group.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-{
-	"_label": "Item Group"
-}
----
-
-Item Group is the classification category. Depending on the type of product, you have to categorise it under its respective field. If the product is service oriented, you have to name it under the group head service. If the product is used as a raw-material, you have to name it under the Raw-material category. In case, your product is used only in trading, you can categorise it under Trading. 
-
-You can also create your own Item groups .
-
-> Stock > Item Group
-
-
-![Item Group](img/item-group-tree.png)
-
diff --git a/docs/user/stock/docs.user.stock.material_issue b/docs/user/stock/docs.user.stock.material_issue
deleted file mode 100644
index e372e7f..0000000
--- a/docs/user/stock/docs.user.stock.material_issue
+++ /dev/null
@@ -1,26 +0,0 @@
----
-{
-	"_label": "Material Issue"
-}
----
-
-A Warehouse stocks materials required for manufacturing or trading. The Material Issue form has to be submitted to order materials out of a Warehouse by any department.
-
-> Stock > Stock Entry > New Stock Entry
-
-
-Go to Stock Entry.
-Click on New Stock Entry
-Select the option “Material Issue” under Purpose.
-Provide Source Warehouse details.
-Provide the BOM Number.
-Save
-
-
-![Material Issue](img/material-issue.png)
-
-
-
-
-
-Note: If you have done a stock entry and selected “Material Issue” under Purpose, that particular amount of stock will reflect as negative in stock details.
diff --git a/docs/user/stock/docs.user.stock.material_issue.md b/docs/user/stock/docs.user.stock.material_issue.md
deleted file mode 100644
index 45e3d98..0000000
--- a/docs/user/stock/docs.user.stock.material_issue.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-{
-	"_label": "Material Issue"
-}
----
-
-A Warehouse stocks materials required for manufacturing or trading. The Material Issue form has to be submitted to order materials out of a Warehouse by any department.
-
-> Stock > Stock Entry > New Stock Entry
-
-
-Go to Stock Entry.
-Click on New Stock Entry
-Select the option “Material Issue” under Purpose.
-Provide Source Warehouse details.
-Provide the BOM Number.
-Save
-
-
-![Material Issue](img/material-issue.png)
-
-
-
-
-
-Note: If you have done a stock entry and selected “Material Issue” under Purpose, that particular amount of stock will reflect as negative in stock details.
\ No newline at end of file
diff --git a/docs/user/stock/docs.user.stock.md b/docs/user/stock/docs.user.stock.md
deleted file mode 100644
index 07662a7..0000000
--- a/docs/user/stock/docs.user.stock.md
+++ /dev/null
@@ -1,62 +0,0 @@
----
-{
-	"_label": "Stock / Inventory",
-	"_toc": [
-		"docs.user.stock.warehouse",
-		"docs.user.stock.item_group",
-		"docs.user.stock.item",
-		"docs.user.stock.product_listing_on_website",
-		"docs.user.stock.serialized",
-		"docs.user.stock.purchase_receipt",
-		"docs.user.stock.delivery_note",
-		"docs.user.stock.stock_entry",
-		"docs.user.stock.opening_stock",
-		"docs.user.stock.material_issue",
-		"docs.user.stock.sales_return",
-		"docs.user.stock.purchase_return",
-		"docs.user.stock.projected_quantity",
-		"docs.user.stock.accounting_for_stock",
-		"docs.user.stock.perpetual_inventory",
-		"docs.user.stock.migrate_to_perpetual",
-		"docs.user.stock.how_to_repack_products",
-		"docs.user.stock.how_to"
-	]
-}
----
-
-
-
-![Stock-Inventory](img/stock-inventory.png)
-
-
-
-
-
-For most small business that deal in physical goods, a large part of their net worth is invested in the stock in hand. 
-
-### Best Practice
-
-There are two aspects to good material management:
-
-- **Good housekeeping / visual control:** Keep all your items in separate bins,neatly stacked and labelled.  “A place for everything and everything in its place” 
-- **Accurate Data:** Accurate data comes from good processes and recording each and every transaction. If you are only partially recording your inventory then your reports will be incorrect   “Garbage In Garbage Out”
-
-If you have good processes to control movement of goods within your organization, implementation in ERPNext will be a breeze.
-
-### Material Flow
-
-There are three main types of entries:
-
-- Purchase Receipt: Items received from Suppliers against Purchase Orders. 
-- Stock Entry: Items transferred from one Warehouse to another. 
-- Delivery Note: Items shipped to Customers.
-
-#### How does ERPNext track stock movement / levels?
-
-Tracking stock is not just about adding and subtracting quantities. Some complications arise when:
-
-- Back-dated (past) entries are made / edited: This affects future stock levels and may lead to negative stock.
-- Stock has to be valued based on First-in-First-out: ERPNext needs to maintain a sequence of all transactions to know the exact value of your Items.
-- Stock reports are required at any point in time in the past: You have to lookup what was the quantity / value your stock of Item X on date Y. 
-
-To manage this, ERPNext collects all inventory transactions in a table called the Stock Ledger Entry. All Purchase Receipts, Stock Entries and Delivery Notes update this table.
\ No newline at end of file
diff --git a/docs/user/stock/docs.user.stock.migrate_to_perpetual.md b/docs/user/stock/docs.user.stock.migrate_to_perpetual.md
deleted file mode 100644
index d4e8ab9..0000000
--- a/docs/user/stock/docs.user.stock.migrate_to_perpetual.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-{
-	"_label": "Migrate to Perpetual Inventory"
-}
----
-
- Existing Users, need to follow some steps to activate the new Perpetual Inventory system. As Perpetual Inventory always maintains a sync between stock and account balance, it is not possible to enable it with existing Warehouse setup. You have to create a whole new set of Warehouses, each linked to relevant account. 
-
-Steps:
-
-- Nullify the balance of account heads (stock-in-hand / fixed-asset) which you are using to maintain available stock value, through a Journal Voucher.
-
-- As existing warehouses are linked to stock transactions which does not have corresponding accounting entries, those warehouses can not be used for perpetual inventory. You have to create new warehouses for the future stock transactions which will be linked to their respective accounts. While creating new warehouses, select an account group under which the child account for the warehouse will be created.
-
-- Setup the following default accounts for each Company 
-	- Stock Received But Not Billed
-	- Stock Adjustment Account
-	- Expenses Included In Valuation
-	- Cost Center
-
-- Activate Perpetual Inventory
-> Setup > Accounts Settings > Make Accounting Entry For Every Stock Movement
-
-![Activation](img/accounting-for-stock-1.png)
-<br><br>
-
-- Create Stock Entry (Material Transfer) to transfer available stock from existing warehouse to new warehouse. As stock will be available in the new warehouse, you should select the new warehouse for all the future transactions.
-
-System will not  post any accounting entries for existing stock transactions submitted prior to the activation of Perpetual Inventory as those old warehouses will not be linked to any account. If you create any new transaction or modify/amend existing transactions, with old warehouse, there will be no corresponding accounting entries.  You have to manually sync stock and account balance through Journal Voucher.
-
-> Note: If you are already using old Perpetual Inventory system, it will be deactivated automatically. You need to follow the above steps to reactivate it.
\ No newline at end of file
diff --git a/docs/user/stock/docs.user.stock.perpetual_inventory.md b/docs/user/stock/docs.user.stock.perpetual_inventory.md
deleted file mode 100644
index eb10326..0000000
--- a/docs/user/stock/docs.user.stock.perpetual_inventory.md
+++ /dev/null
@@ -1,313 +0,0 @@
----
-{
-	"_label": "Perpetual Inventory"
-}
----
-
-In perpetual inventory, system creates accounting entries for each stock transactions, so that stock and account balance will always remain same. The account balance will be posted against their respective account heads for each Warehouse. On saving of a Warehouse, the system will automatically create an account head with the same name as warehouse. As account balance is maintained for each Warehouse, you should create Warehouses, based on the type of items (Current / Fixed Assets) it stores.
-
-At the time of items received in a particular warehouse, the balance of asset account (linked to that warehouse) will be increased. Similarly when you deliver some items from that warehouse, an expense will be booked and the asset account will be reduced, based on the valuation amount of those items.
-
-
-## **Activation**
-
-1. Setup the following default accounts for each Company 
-	- Stock Received But Not Billed
-	- Stock Adjustment Account
-	- Expenses Included In Valuation
-	- Cost Center
-	
-2. In perpetual inventory, the system will maintain seperate account balance for each warehouse under separate account head. To create that account head, enter "Create Account Under" in Warehouse master.
-
-3. Activate Perpetual Inventory
-> Setup > Accounts Settings > Make Accounting Entry For Every Stock Movement
-
-
--
-
-## **Example**
-
-Consider following Chart of Accounts and Warehouse setup for your company:
-
-#### Chart of Accounts
-
-- Assets (Dr)
-  - Current Assets
-    - Accounts Receivable
-      - Jane Doe
-    - Stock Assets
-      - Stores
-      - Finished Goods
-      - Work In Progress
-    - Tax Assets
-      - VAT
-  - Fixed Assets
-    - Fixed Asset Warehouse
-- Liabilities (Cr)
-  - Current Liabilities
-    - Accounts Payable
-      - East Wind Inc.
-    - Stock Liabilities
-      - Stock Received But Not Billed
-    - Tax Liabilities
-      - Service Tax
-- Income (Cr)
-  - Direct Income
-    - Sales Account
-- Expenses (Dr)
-  - Direct Expenses
-    - Stock Expenses
-      - Cost of Goods Sold
-      - Expenses Included In Valuation
-      - Stock Adjustment
-      - Shipping Charges
-      - Customs Duty
-  
-#### Warehouse - Account Configuration
-
-- Stores
-- Work In Progress
-- Finished Goods
-- Fixed Asset Warehouse
-
-### **Purchase Receipt**
-
-Suppose you have purchased *10 nos* of item "RM0001" at *$200* and *5 nos* of item "Desktop" at **$100** from supplier "East Wind Inc". Following are the details of Purchase Receipt:
-
-<b>Supplier:</b> East Wind Inc.
-
-<b>Items:</b>
-<table class="table table-bordered">
-	<thead>
-		<tr>
-			<th>Item</th><th>Warehouse</th><th>Qty</th>
-			<th>Rate</th><th>Amount</th><th>Valuation Amount</th>
-		</tr>
-	</thead>
-	<tbody>
-		<tr>
-			<td>RM0001</td><td>Stores</td><td>10</td><td>200</td><td>2000</td><td>2200</td>
-		</tr>
-		<tr>
-			<td>Desktop</td><td>Fixed Asset Warehouse</td>
-			<td>5</td><td>100</td><td>500</td><td>550</td>
-		</tr>
-	</tbody>
-</table>
-	
-**Taxes:**
-
-<table class="table table-bordered">
-	<thead>
-		<tr><th>Account</th><th>Amount</th><th>Category</th></tr>
-	</thead>
-	<tbody>
-		<tr><td>Shipping Charges</td><td>100</td><td>Total and Valuation</td></tr>
-		<tr><td>VAT</td><td>120</td><td>Total</td></tr>
-		<tr><td>Customs Duty</td><td>150</td><td>Valuation</td></tr>
-	</tbody>
-</table>
-
-**Stock Ledger**
-
-![pr_stock_ledger](img/accounting-for-stock-2.png)
-
-**General Ledger**
-
-![pr_general_ledger](img/accounting-for-stock-3.png)
-
-As stock balance increases through Purchase Receipt, "Store" and "Fixed Asset Warehouse" accounts are debited and a temporary account "Stock Receipt But Not Billed" account is credited, to maintain double entry accounting system.
-
-
---
-
-### **Purchase Invoice**
-
-On receiving Bill from supplier, for the above Purchase Receipt, you will make Purchase Invoice for the same. The general ledger entries are as follows:
-
-**General Ledger**
-
-![pi_general_ledger](img/accounting-for-stock-4.png)
-
-
-Here "Stock Received But Not Billed" account is debited and nullified the effect of Purchase Receipt. "Expenses Included In Valuation" account has been credited which ensures the valuation expense accounts are not booked (debited) twice (in Purchase Invoice and Delivery Note).
-
---
-
-### **Delivery Note**
-
-Lets say, you have an order from "Jane Doe" to deliver 5 nos of item "RM0001" at $300. Following are the details of Delivery Note:
-
-**Customer:** Jane Doe
-
-**Items:**
-<table class="table table-bordered">
-	<thead>
-		<tr><th>Item</th><th>Warehouse</th><th>Qty</th><th>Rate</th><th>Amount</th></tr>
-	</thead>
-	<tbody>
-		<tr><td>RM0001</td><td>Stores</td><td>5</td><td>300</td><td>1500</td></tr>
-	</tbody>
-</table>
-	
-**Taxes:**
-
-<table class="table table-bordered">
-	<thead>
-		<tr><th>Account</th><th>Amount</th></tr>
-	</thead>
-	<tbody>
-		<tr><td>Service Tax</td><td>150</td></tr>
-		<tr><td>VAT</td><td>100</td></tr>
-	</tbody>
-</table>
-
-
-**Stock Ledger**
-
-![dn_stock_ledger](img/accounting-for-stock-5.png)
-
-**General Ledger**
-
-![dn_general_ledger](img/accounting-for-stock-6.png)
-
-As item is delivered from "Stores" warehouse, "Stores" account is credited and equal amount is debited to the expense account "Cost of Goods Sold". The debit/credit amount is equal to the total valuation amount (buying cost) of the selling items. And valuation amount is calculated based on your prefferred valuation method (FIFO / Moving Average) or actual cost of serialized items.
-<pre>
-	<code>
-In this example, we have considered valuation method as FIFO. 
-Valuation Rate 	= Purchase Rate + Charges Included in Valuation 
-				= 200 + (250 * (2000 / 2500) / 10) 
-				= 220
-Total Valuation Amount 	= 220 * 5 
-						= 1100
-	</code>
-</pre>
-
---
-
-### **Sales Invoice with Update Stock**
-
-Lets say, you did not make Delivery Note against the above order and instead you have made Sales Invoice directly, with "Update Stock" options.  The details of the Sales Invoice are same as the above Delivery Note.
-
-**Stock Ledger**
-
-![si_stock_ledger](img/accounting-for-stock-7.png)
-
-**General Ledger**
-
-![si_general_ledger](img/accounting-for-stock-8.png)
-
-Here, apart from normal account entries for invoice, "Stores" and "Cost of Goods Sold" accounts are also affected based on the valuation amount.
-
---
-
-### **Stock Entry (Material Receipt)**
-
-**Items:**
-<table class="table table-bordered">
-	<thead>
-		<tr><th>Item</th><th>Target Warehouse</th><th>Qty</th><th>Rate</th><th>Amount</th></tr>
-	</thead>
-	<tbody>
-		<tr><td>RM0001</td><td>Stores</td><td>50</td><td>220</td><td>11000</td></tr>
-	</tbody>
-</table>
-
-**Stock Ledger**
-
-![mr_stock_ledger](img/accounting-for-stock-9.png)
-
-**General Ledger**
-
-![mr_stock_ledger](img/accounting-for-stock-10.png)
- 
---
-
-### **Stock Entry (Material Issue)**
-
-**Items:**
-<table class="table table-bordered">
-	<thead>
-		<tr><th>Item</th><th>Source Warehouse</th><th>Qty</th><th>Rate</th><th>Amount</th></tr>
-	</thead>
-	<tbody>
-		<tr><td>RM0001</td><td>Stores</td><td>10</td><td>220</td><td>2200</td></tr>
-	</tbody>
-</table>
-
-**Stock Ledger**
-
-![mi_stock_ledger](img/accounting-for-stock-11.png)
-
-**General Ledger**
-
-![mi_stock_ledger](img/accounting-for-stock-12.png)
-
---
-
-### **Stock Entry (Material Transfer)**
-
-**Items:**
-<table class="table table-bordered">
-	<thead>
-		<tr><th>Item</th><th>Source Warehouse</th><th>Target Warehouse</th>
-		<th>Qty</th><th>Rate</th><th>Amount</th></tr>
-	</thead>
-	<tbody>
-		<tr><td>RM0001</td><td>Stores</td><td>Work In Progress</td>
-		<td>10</td><td>220</td><td>2200</td></tr>
-	</tbody>
-</table>
-
-**Stock Ledger**
-
-![mtn_stock_ledger](img/accounting-for-stock-13.png)
-
-**General Ledger**
-
-![mtn_general_ledger](img/accounting-for-stock-14.png)
-
---
-
-### **Stock Entry (Sales Return - Sales Invoice booked)**
-
-**Items:**
-<table class="table table-bordered">
-	<thead>
-		<tr><th>Item</th><th>Target Warehouse</th><th>Qty</th><th>Rate</th><th>Amount</th></tr>
-	</thead>
-	<tbody>
-		<tr><td>RM0001</td><td>Stores</td><td>2</td><td>200</td><td>400</td></tr>
-	</tbody>
-</table>
-
-**Stock Ledger**
-
-![sret_stock_ledger](img/accounting-for-stock-15.png)
-
-**General Ledger**
-
-![sret_general_ledger](img/accounting-for-stock-16.png)
-
-
---
-
-### **Stock Entry (Purchase Return)**
-
-**Items:**
-<table class="table table-bordered">
-	<thead>
-		<tr><th>Item</th><th>Source Warehouse</th><th>Qty</th><th>Rate</th><th>Amount</th></tr>
-	</thead>
-	<tbody>
-		<tr><td>RM0001</td><td>Stores</td><td>4</td><td>220</td><td>880</td></tr>
-	</tbody>
-</table>
-
-**Stock Ledger**
-
-![pret_stock_ledger](img/accounting-for-stock-17.png)
-
-**General Ledger**
-
-![pret_general_ledger](img/accounting-for-stock-18.png)
diff --git a/docs/user/stock/docs.user.stock.product_listing_on_website.md b/docs/user/stock/docs.user.stock.product_listing_on_website.md
deleted file mode 100644
index 6a544a1..0000000
--- a/docs/user/stock/docs.user.stock.product_listing_on_website.md
+++ /dev/null
@@ -1,61 +0,0 @@
----
-{
-	"_label": "Product Listing on Website"
-}
----
-
-### Listing Item on Website
-
-To list your Item on the Website, fill the Item details and save the file. Once the file is saved, a plus (+) button will appear next to the Image icon. Click on the plus button and add your Item image. The html code will be generated automatically. 
-
-##### Step 1: Save Image
-
-![Webimage](img/item-webimage.png)
-
-<br>
-
-##### Step 2: Check the 'Show in Website' box.
-
-Under the Website section, please check the box that says 'show in Website'. Once the box is checked, the page will display other fields for entering information. 
-
-![Webimage](img/item-webimage-1.png)
-
-<br>
-
-
-##### Step 3: Enter Website Details
-
-![Webimage](img/item-webimage-2.png)
-
-
-The page name will be generated automatically. Mention the Item-Group under which the Item will be displayed.
-
-#### Item Groups
-
-Mention the Item Group under this column. If you wish to list your Item under the broad category products, name your Item Group as Products. In case you have various varieties of Item and want to classify them under different names, make Item Groups with those names and check the box that says 'show in Website'. For Example, if you wish to create a category called 'Bags', create a Item Group named Bags.
-
-
-![Item Group](img/itemgroup-webimage-bags.png)
-
-Once the Item Group is created go to the Website Settings page under Website. Enter the Label, Url, and Parent Label.
-
-
-![Item Group](img/itemgroup-website-settings.png)
-
-<br>
-
-#### Webpage labels
-
-![Webpage](img/webpage-labels.png)
-
-Add more Items under a particular Item Group.
-
-To add more Items under a certain Label, mention the Item Group on the Item Page. The Items will be added automatically on the Webpage, under the Item Group Label. For Example, To add Item-Kiddies Bag and Butterfly Print Bag, check the 'Show in Website'box. The Items will be placed under the Label Bags on the Webpage.
-
-![Item Group](img/itemgroup-websettings.png)
-
-<br>
-
-Item Group Display
-
-![Item Group Display](img/webpage-itemgroup-display.png)
\ No newline at end of file
diff --git a/docs/user/stock/docs.user.stock.projected_quantity.md b/docs/user/stock/docs.user.stock.projected_quantity.md
deleted file mode 100644
index 8fff133..0000000
--- a/docs/user/stock/docs.user.stock.projected_quantity.md
+++ /dev/null
@@ -1,27 +0,0 @@
----
-{
-	"_label": "Projected Quantity"
-}
----
-
-Projected Quantity is the level of stock that is predicted for a particular Item, based on the current stock levels and other requirements.It is the quantity of gross inventory that includes supply and demand in the past which is done as part of the planning process.
-
-The projected inventory is used by the planning system to monitor the reorder point and to determine the reorder quantity. The projected Quantity is used by the planning engine to monitor the safety stock levels. These levels are maintained to serve unexpected demands.
-
-Having a tight control of the projected inventory is crucial to determine shortages and to calculate the right order quantity.
-
-
-
-![Projected Quantity Stock Report](img/projected-quantity-stock-report.png)
-
-
-
-
-
-> Projected Qty = Actual Qty + Planned Qty + Requested Qty + Ordered Qty - Reserved Qty
-
-- Actual Qty: Quantity available in the warehouse.
-- Planned Qty: Quantity, for which, Production Order has been raised, but is pending to be manufactured.
-- Requested Qty: Quantity requested for purchase, but not ordered.
-- Ordered Qty: Quantity ordered for purchase, but not received.
-- Reserved Qty: Quantity ordered for sale, but not delivered.
\ No newline at end of file
diff --git a/docs/user/stock/docs.user.stock.purchase_receipt b/docs/user/stock/docs.user.stock.purchase_receipt
deleted file mode 100644
index fd934d2..0000000
--- a/docs/user/stock/docs.user.stock.purchase_receipt
+++ /dev/null
@@ -1,24 +0,0 @@
----
-{
-	"_label": "Purchase Return"
-}
----
-ERPNext has an option to account for products that are returned to the supplier. This may be on account of a number of reasons like defects in goods, quality not matching, the buyer not needing the stock, etc. The transactions dealing with return of goods are also accounting transactions and have to be recorded in the books of accounts just like any other accounting transaction. 
-
-
-> Stock > Stock Entry > New Stock Entry
-
-
-![Purchase Return](img/purchase-return.png)
-
-
-
-
-
-
-- To select Purchase Return go to Stock Entry.
-- Select Purchase Return under Purpose.
-- Enter Purchase Receipt number.
-- Enter Source Warehouse details.
-- Provide Supplier Information.
-- Save the document.
\ No newline at end of file
diff --git a/docs/user/stock/docs.user.stock.purchase_receipt.md b/docs/user/stock/docs.user.stock.purchase_receipt.md
deleted file mode 100644
index a2e428d..0000000
--- a/docs/user/stock/docs.user.stock.purchase_receipt.md
+++ /dev/null
@@ -1,62 +0,0 @@
----
-{
-	"_label": "Purchase Receipt"
-}
----
-Purchase Receipts are made when you accept material from your Supplier usually against a Purchase Order. 
-
-You can also accept Purchase Receipts directly (you must set Purchase Order Required as “No” in Global Defaults).
-
-You can make a Purchase Receipt directly from:
-
-> Stock > Purchase Receipt > New Purchase Receipt
-
-or from a “Submitted” Purchase Order, by clicking on “Make Purchase Receipt”.
-
-
-
-![Purchase Receipt](img/purchase-receipt.png)
-
-
-
-
-
-### Rejections
-
-In the Purchase Receipt, you are required to enter whether all the materials you receive are of accepted quality (in case you check). If you have any rejections, update the “Rejected Quantity” column in the Items table.
-
-If you reject, you are required to enter a “Rejected Warehouse” to indicate where you are storing the rejected Items.
-
-### Quality Inspections
-
-If for certain Items, it is mandatory to record Quality Inspections (if you have set it in your Item master), you will need to update the “Quality Inspection No” (QA No) column. The system will only allow you to “Submit” the Purchase Receipt if you update the “Quality Inspection No”.
-
-### UOM Conversions
-
-If your Purchase Order for an Item is in a different Unit of Measure (UOM) than what you stock (Stock UOM), then you will need to update the “UOM Conversion Factor”. See the Item settings for more information.
-
-### Currency Conversions
-
-Since the incoming Item affects the value of your inventory, it is important to convert it into your base Currency, if you have ordered in another Currency. You will need to update the Currency Conversion Rate if applicable.
-
-### Taxes and Valuation
-
-Some of your taxes and charges may affect your Items value. For example a Tax may not be added to your Item’s valuation, because if you sell the Item, you will have to add the tax at that time. So make sure to mark all your taxes in the Taxes and Charges table correctly for accurate valuation.
-
-### Serial Numbers and Batches
-
-If your Item is serialized or batched, you will have to enter Serial Number and Batch in the Items table. You are allowed to enter multiple Serial Numbers in one row (each on a separate line) and you must enter the same number of Serial Numbers as the quantity. You must enter each Batch number on a separate line.
-
----
-
-#### What happens when the Purchase Receipt is “Submitted”?
-
-A Stock Ledger Entry is created for each Item adding the Item in the Warehouse by the “Accepted Quantity”
-If you have rejections, a Stock Ledger Entry is made for each Rejection.
-The “Pending Quantity” is updated in the Purchase Order.
-
----
-
-#### Adding value to your Items post Purchase Receipt: 
-
-Some times, certain expenses that add value to your purchased Items are known only after sometime. Common example is if you are importing the Items, you will come to know of Customs Duty etc only when your “Clearing Agent” sends you a bill. If you want to attribute this cost to your purchased Items, you will have to use the Landed Cost Wizard. Why “Landed Cost”? Because it represents the charges that you paid when it landed in your possession.
\ No newline at end of file
diff --git a/docs/user/stock/docs.user.stock.purchase_return.md b/docs/user/stock/docs.user.stock.purchase_return.md
deleted file mode 100644
index de2a312..0000000
--- a/docs/user/stock/docs.user.stock.purchase_return.md
+++ /dev/null
@@ -1,44 +0,0 @@
----
-{
-	"_label": "Purchase Return"
-}
----
-ERPNext has an option to account for products that are returned to the supplier.This may be on account of a number of reasons like defects in goods, quality not matching, the buyer not needing the stock, etc. The transactions dealing with return of goods are also accounting transactions and have to be recorded in the books of accounts just like any other accounting transaction. 
-
-
-> Stock > Stock Entry > New Stock Entry
-
-
-
-#### Step 1: Select Purpose as Purchase Return.
-#### Step 2: Enter Purchase Return No.
-
-
-![Purchase Return](img/purchase-return-1.png)
-
-<br>
-
-
-#### Step 3: Enter Item Details
-#### Step 4: Update Warehouse Details
-
-
-![Purchase Return](img/purchase-return-1.png)
-
-#### Step 5: Provide Supplier Details
-
-![Purchase Return](img/purchase-return-3.png)
-
-
-- To select Purchase Return go to Stock Entry.
-- Select Purchase Return under Purpose.
-- Enter Purchase Receipt number.
-- Enter Source Warehouse details.
-- Provide Supplier Information.
-- Save the document.
-
-#### Debit Note
-
-Once the Stock Entry is submitted, you can click on Make Debit Note  button and a new Journal Voucher will be created pre-filled with the customer's account and Items' income account.
-
-![Purchase Return](img/purchase-return-4.png)
\ No newline at end of file
diff --git a/docs/user/stock/docs.user.stock.sales_return.md b/docs/user/stock/docs.user.stock.sales_return.md
deleted file mode 100644
index 8ae7d49..0000000
--- a/docs/user/stock/docs.user.stock.sales_return.md
+++ /dev/null
@@ -1,48 +0,0 @@
----
-{
-	"_label": "Sales Return"
-}
----
-Goods sold being returned is quite a common practice in Business. They could be returned by the customer on quality issues, non-delivery on agreed date, or any other reason. ERPNext allows this transaction for ease of accounting.
-
-> Stock > Stock Entry > New Stock Entry
-
-#### Step 1: Select Purpose as "Sales Return"
-
-
-#### Step 2: Enter the Delivery Note No. or Sales Invoice No.
-
-<br>
-
-
-![Sales Return](img/sales-return-1.png)
-
-<br>
-
-#### Step 3: Enter Item Details
-
-
-![Sales Return](img/sales-return-2.png)
-
-<br>
-
-#### Step 4: Mention Contact Information of the Customer.
-
-
-![Sales Return](img/sales-return-3.png)
-
-<br>
-
-
-- For Sales Return click on Stock Entry
-- Select Sales Return under Purpose
-- Mention the Delivery Note number or the Sales Invoice number.
-- Mention Contact Information of the Customer.
-- Save the file and Submit the Stock Entry.
-
-#### Credit Note
-
-Once the Stock Entry is submitted, you can click on Make Credit Note  button and a new Journal Voucher will be created pre-filled with the customer's account and Items' income account.
-
-![Sales Return](img/sales-return-4.png)
-
diff --git a/docs/user/stock/docs.user.stock.serialized.md b/docs/user/stock/docs.user.stock.serialized.md
deleted file mode 100644
index 8c12534..0000000
--- a/docs/user/stock/docs.user.stock.serialized.md
+++ /dev/null
@@ -1,55 +0,0 @@
----
-{
-	"_label": "Serialized Inventory"
-}
----
-As we discussed in the **Item** section, if an **Item** is *serialized*, a **Serial Number** (Serial No) record is maintained for each quantity of that **Item**. This information is helpful in tracking the location of the Serial No, its warranty and end-of-life (expiry) information.
-
-**Serial Nos** are also useful to maintain fixed assets. **Maintenance Schedules** can also be created against serial numbers for planning and scheduling maintenance activity for these assets (if they require maintenance).
-
-You can also track from which **Supplier** you purchased the **Serial No** and to which **Customer** you have sold it. The **Serial No** status will tell you its current inventory status.
-
-If your Item is *serialized* you will have to enter the Serial Nos in the related column with each Serial No in a new line.
-
-### Serial Nos and Inventory
-
-Inventory of an Item can only be affected if the Serial No is transacted via a Stock transaction (Stock Entry, Purchase Receipt, Delivery Note, Sales Invoice). When a new Serial No is created directly, its warehouse cannot be set.
-
-### Using Serial Nos
-
-To add a Serial No to a stock transaction, you can set the Serial No in the serial no field:
-
-![Serial No Entry](img/serial-no-entry.png)
-
-### Creation
-
-Serial Nos can automatically be created from a Stock Entry or Purchase Receipt. If you mention Serial No in the Serial Nos column, it will automatically create those serial Nos.
-
-### Automatic Series
-
-If in the Item Master, the Serial No Series is mentioned, you can leave the Serial No column blank in a Stock Entry / Purchase Receipt and Serial Nos will automatically be set from that series.
-
-#### Step 1: Mention the Series in the Item
-
-![Automatic Series](img/item-serial-no-series.png)
-
-#### Step 2: Keep Serial No field blank in your entry
-
-#### Step 3: Save / Submit your transaction (Serial Nos Automatically Updated)
-
-![Serial No Created Message](img/serial-no-auto-1.png)
-
-![Serial No Updated in Transaction](img/serial-no-auto-2.png)
-
-
-### Importing and Updating Serial Nos
-
-Serial Nos cannot be imported from Stock Reconciliation. To import Serial Nos, you will have to use the Data Import Tool.
-
-### Using Serial Numbers for Multiple Purposes
-
-Serial Nos are a useful tool for tracking different kinds of Items, by using it along with Custom Fields. For example, in our internal system at Web Notes, each ERP account is a Serial No, with type of user “Plan” as the Item, its expiry date, whether it is Trial or Paid and other details as Custom Fields.
-
-We have known customers who use Serial Nos to track fixed assets, real-estate properties or advertisement slots, even library books!
-
-Since Serial Nos are deeply linked with all the core modules, Selling, Buying, Inventory and Accounting, you may find many uses for them.
\ No newline at end of file
diff --git a/docs/user/stock/docs.user.stock.stock_entry.md b/docs/user/stock/docs.user.stock.stock_entry.md
deleted file mode 100644
index 0b49585..0000000
--- a/docs/user/stock/docs.user.stock.stock_entry.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-{
-	"_label": "Stock Entry"
-}
----
-A Stock Entry is a simple document that lets you record Item movement from a Warehouse, to a Warehouse and between Warehouses.
-
-To make a Stock Entry you have to go to:
-
-> Stock > Stock Entry
-
-
-
-
-
-![Stock Entry](img/stock-entry.png)
-
-
-
-
-
-This can also be useful in tracking:
-
-- Material Issues from Stores
-- Sales and Purchase Returns
-- Production (manufacturing).
-
-We will look into the special features of the Stock Entry later when we discuss Accounting and Manufacturing processes.
-
-
-In the Stock Entry you have to update the Items table with all your transactions. For each row, you must enter a “Source Warehouse” or a “Target Warehouse” or both (if you are recording a movement).
-
-> **Note:** To update Stock from a spreadsheet, see Stock Reconciliation.
\ No newline at end of file
diff --git a/docs/user/stock/docs.user.stock.sub_contracting.md b/docs/user/stock/docs.user.stock.sub_contracting.md
deleted file mode 100644
index 23a102c..0000000
--- a/docs/user/stock/docs.user.stock.sub_contracting.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-{
-	"_label": "Subcontracting"
-}
----
-If your business involves outsourcing certain processes to a third party Supplier, where you buy the raw material from, you can track this by using the sub-contracting feature of ERPNext.
-
-To setup sub-contracting:
-
-1. Create separate Items for the unprocessed and the processed product. For example if you supply unpainted X to your Supplier and the Supplier returns you X, you can create two Items: “X-unpainted” and “X”.
-1. Create a Warehouse for your Supplier so that you can keep track of Items supplied. (you may supply a months worth of Items in one go).
-1. For the processed Item, in the Item master, set “Is Sub Contracted Item” to “Yes”.
-
-
-
-![Subcontract](img/subcontract.png)
-
-
-
-
-
-
-1. Make a Bill of Materials for the processed Item, with the unprocessed Items as sub-items.For example, If you are manufacturing a pen, the processed pen will be named under Bill of Materials(BOM), whereas, the refill, knob, and other items which go into the making of pen, will be categorised as sub-items.
-1. Make a Purchase Order for the processed Item. When you “Save”, in the “Raw Materials Detail”, all your un-processed Items will be updated based on your Bill of Materials.
-	1. Make sure that the “Rate” of this Item is the processing rate (excluding the raw material rate).
-	1. ERPNext will automatically add the raw material rate for your valuation purpose when you receive the finished Item in your stock. 
-1. Make a Stock Entry to deliver the raw material Items to your Supplier.
-1. Receive the Items from your Supplier via Purchase Receipt. Make sure to check the “Consumed Quantity” in the “Raw Materials” table so that the correct stock is maintained at the Supplier’s end.
diff --git a/docs/user/stock/docs.user.stock.valuation.md b/docs/user/stock/docs.user.stock.valuation.md
deleted file mode 100644
index cd2ad23..0000000
--- a/docs/user/stock/docs.user.stock.valuation.md
+++ /dev/null
@@ -1,29 +0,0 @@
----
-{
-	"_label": "Item Valuation: FIFO and Moving Average"
-}
----
-### How are Items Valued?
-
-One of the major features of any inventory system is that you can find out the value of any item based on its historic or average price. You can also find the value of all your items for your balance sheet. 
-
-Valuation is important because:
-
-- The buying price may fluctuate.
-- The value may change because of some process (value add).
-- The value may change because of decay, loss etc.
-
-You may encounter these terms, so lets clarify:
-
-- Rate: Rate at which the transaction takes place.
-- Valuation Rate: Rate at which the items value is set for your valuation.
-
-There are two major ways in which ERPNext values your items.
-
-- **FIFO (First In First Out):** In this system, ERPNext assumes that you will consume / sell those Items first which you bought first. For example, if you buy an Item at price X and then after a few days at price Y, whenever you sell your Item, ERPNext will reduce the quantity of the Item priced at X first and then Y.
-
-![FIFO](img/fifo.png)
-
-- **Moving Average:** In this method, ERPNext assumes that the value of the item at any point is the average price of the units of that Item in stock. For example, if the value of an Item is X in a Warehouse with quantity Y and another quantity Y1 is added to the Warehouse at cost X1, the new value X2 would be:
-
-> New Value X2 = (X * Y + X1 * Y1) / (Y + Y1)
\ No newline at end of file
diff --git a/docs/user/stock/docs.user.stock.warehouse.md b/docs/user/stock/docs.user.stock.warehouse.md
deleted file mode 100644
index 38a559e..0000000
--- a/docs/user/stock/docs.user.stock.warehouse.md
+++ /dev/null
@@ -1,29 +0,0 @@
----
-{
-	"_label": "Warehouse"
-}
----
-
-A warehouse is a commercial building for storage of goods. Warehouses are used by manufacturers, importers, exporters, wholesalers, transport businesses, customs, etc. They are usually large plain buildings in industrial areas of cities,towns, and villages. They usually have loading docks to load and unload goods from trucks.
-
-To go to Warehouse, click on Stock and go to Warehouse under Masters.
-
-
-> Stock > Warehouse > New Warehouse
-
-
-
-![Warehouse](img/warehouse.png)
-
-
-
-
-In ERPNext, every Warehouse must belong to a specific company, to maintain company wise stock balance. The Warehouses are saved with their respective company’s abbreviations. This facilitates in identifying which Warehouse belongs to which company, at a glance.
-
-You can include user restrictions for these Warehouses. In case you do not wish a particular user to operate on a particular Warehouse, you can refrain the user from accessing that Warehouse.
-
-### Merge Warehouse
-
-In day to day transactions, duplicate entries are done by mistake, resulting in duplicate Warehouses. Duplicate records can be merged into a single Warehouse. Enter the correct Warehouse and click on the Merge button. The system will replace all the links of wrong Warehouse with the correct Warehouse, in all transactions. Also, the available quantity (actual qty, reserved qty, ordered qty etc) of all items in the duplicate warehouse will be transferred to the correct warehouse. Once merging is done, delete the duplicate Warehouse.
-
-> Note: ERPNext system maintains stock balance for every distinct combination of Item and Warehouse. Thus you can get stock balance for any specific Item in a particular Warehouse on any particular date.
\ No newline at end of file
diff --git a/docs/user/support/docs.user.support.customer_issue.md b/docs/user/support/docs.user.support.customer_issue.md
deleted file mode 100644
index 4c5afd1..0000000
--- a/docs/user/support/docs.user.support.customer_issue.md
+++ /dev/null
@@ -1,22 +0,0 @@
----
-{
-	"_label": "Customer Issue"
-}
----
-If you are selling **Items** under warranty or if you have sold and extended service contract like the Annual Maintenance Contract (AMC), your **Customer** may call you about an issue or a break-down and give you the Serial No of this Item.
-
-To record this, you can create a new **Customer Issue** and add the **Customer** and **Item** / **Serial No**. The system will then automatically fetch the Serial No’s details and indicate whether this is under warranty or AMC.
-
-You must also add a description of the **Customer**’s issue and assign it to the person who needs to look into solving the issue.
-
-To create a new **Customer Issue**:
-
-> Support > Customer Issue > New Customer Issue
-
-
-![Customer Issue](img/customer-issue.png)
-
-
-
-If a Customer visit is required to address the issue, you can create a new Maintenance Visit record from this.
-
diff --git a/docs/user/support/docs.user.support.maintenance_schedule.md b/docs/user/support/docs.user.support.maintenance_schedule.md
deleted file mode 100644
index a2bf5ea..0000000
--- a/docs/user/support/docs.user.support.maintenance_schedule.md
+++ /dev/null
@@ -1,42 +0,0 @@
----
-{
-	"_label": "Maintenance Schedule"
-}
----
-All machines require regular maintenance, specially those that contain a lot of moving parts, so if you are in the business of maintaining those or have some of them in your own premises, this is a useful tool to plan a calendar of activities for its maintenance.
-
-If the Customer Issue refers to “Breakdown Maintenance”, this refers to “Preventive Maintenance”.
-
-To create a new Maintenance Schedule go to:
-
-> Support > Maintenance Schedule > New Maintenance Schedule
-
-#### Step 1: Enter Customer Details
-
-
-![Maintenance Schedule](img/maintenance-schedule-1.png)
-
-
-
-<br>
-
-
-
-#### Step 2: Fill Item and Maintenance Details
-
-
-
-![Maintenance Schedule](img/maintenance-schedule-2.png)
-
-
-<br>
-
-In the Maintenance Schedule, there are two sections:
-
-In the first section, you select the Items for which you want to generate the schedule and set how frequently you want to plan a visit or a maintenance. These can be optionally fetched from a Sales Order. After selecting the Items, “Save” the record.
-
-The second section contains the maintenance activities planned in the schedule. “Generate Schedule” will generate a separate row for each maintenance activity.
-
-Each Item in a Maintenance Schedule is allocated to a Sales Person.
-
-When the document is “Submitted” Calendar events are created in the profile of the Sales Person for each maintenance.
\ No newline at end of file
diff --git a/docs/user/support/docs.user.support.maintenance_visit.md b/docs/user/support/docs.user.support.maintenance_visit.md
deleted file mode 100644
index 210277a..0000000
--- a/docs/user/support/docs.user.support.maintenance_visit.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-{
-	"_label": "Maintenance Visit"
-}
----
-A Maintenance Visit is a record for a visit made by an engineer to a Customer’s premises usually against a Customer Issue. You can create a new Maintenance Visit from:
-
-> Support > Maintenance Visit > New Maintenance Visit
-
-
-![Maintenance Visit](img/maintenance-visit.png)
-
-
-The Maintenance Visit contains information about the:
-
-- Customer.
-- The Items that were inspected / maintenance activity was carried out on.
-- Details of actions taken.
-- The person who carried out the actions.
-- Feedback from the Customer.
diff --git a/docs/user/support/docs.user.support.md b/docs/user/support/docs.user.support.md
deleted file mode 100644
index acd693f..0000000
--- a/docs/user/support/docs.user.support.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-{
-	"_label": "Support",
-	"_toc": [
-		"docs.user.support.support_ticket",
-		"docs.user.support.customer_issue",
-		"docs.user.support.maintenance_visit",
-		"docs.user.support.maintenance_schedule",
-		"docs.user.support.newsletter"
-	]
-}
----
-Great customer support and maintenance is at the heart of any successful small business.ERPNext gives you the tools to track all incoming requests and issues from your customers so that you can respond quickly. Your database of incoming queries will also help you track where the biggest opportunities are for improvements.
-
-In this module, you can track incoming queries from your email using Support Ticket. You can keep track on Customer Issues raised by Customers on specific Serial No and respond to them based on their warranty and other information. You can also make Maintenance Schedules for Serial Nos and keep a record of all Maintenance Visits made to your Customers.
diff --git a/docs/user/support/docs.user.support.newsletter.md b/docs/user/support/docs.user.support.newsletter.md
deleted file mode 100644
index 443a6e5..0000000
--- a/docs/user/support/docs.user.support.newsletter.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-{
-	"_label": "Newsletter"
-}
----
-
-A newsletter is a short written report that tells about the recent activities of an organization. It is generally sent to members of the organization, potential clients customers or potential leads.
-
-In ERPNext, you can use this UI to send any type of communication to a large number of audience. The process of sending bulk email to a target audience is very simple and easy. 
-
-Select  the list that you want to send the email to. Fill in your content in the message box, and send your newsletter.If you wish to test your email, to see how it looks to the recepient, you can use the test function.Save the document before testing. A test email will be sent to your email id. You can send the email to all the intended receipients by clicking on the send button.
-
-
-![Newsletter](img/newsletter.png)
diff --git a/docs/user/support/docs.user.support.support_ticket.md b/docs/user/support/docs.user.support.support_ticket.md
deleted file mode 100644
index c750462..0000000
--- a/docs/user/support/docs.user.support.support_ticket.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-{
-	"_label": "Support Ticket"
-}
----
-Support Ticket is an incoming query from your Customer, usually via email or from the “Contact” section of your website. (To fully integrate the Support Ticket to email, see the Email Settings section). 
-
-> Tip: A dedicated support email id is a good way to integrate incoming queries via email. For example, you can send support queries to ERPNext at support@erpnext.com and it will automatically create a Support Ticket in the Web Notes system.
-
-<br>
-
-
-> Support > Support Ticket > New Support Ticket
-
-
-
-![Support Ticket](img/support-ticket.png)
-
-
-
-#### Discussion Thread
-
-When a new email is fetched from your mailbox, a new Support Ticket record is created and an automatic reply is sent to the sender indicating the Support Ticket Number. The sender can send additional information to this email. All subsequent emails containing this Support Ticket number in the subject will be added to this Support Ticket thread. The sender can also add attachments to the email.
-
-Support Ticket maintains all the emails which are sent back and forth against this issue in the system so that you can track what transpired between the sender and the person responding. 
-
-#### Status
-
-When a new Support Ticket is created, its status is “Open”, when it is replied, its status becomes “Waiting for Reply”. If the sender replies back its status again becomes “Open”.
-
-#### Closing
-
-You can either “Close” the Support Ticket manually by clicking on “Close Ticket” in the toolbar or if its status is “Waiting For Reply” . If the sender does not reply in 7 days, then the Support Ticket closes automatically.
-
-#### Allocation
-
-You can allocate the Support Ticket by using the “Assign To” feature in the right sidebar. This will add a new To Do to the user and also send a message indicating that this Support Ticket is allocated.
\ No newline at end of file
diff --git a/docs/user/tools/docs.user.tools.assignment.md b/docs/user/tools/docs.user.tools.assignment.md
deleted file mode 100644
index 8ec04ea..0000000
--- a/docs/user/tools/docs.user.tools.assignment.md
+++ /dev/null
@@ -1,22 +0,0 @@
----
-{
-	"_label": "Assignment"
-}
----
-
-You can assign any transaction to any user by clicking on the “Assign” button on the right hand column and adding a user.
-
-#### Step 1: Click on the Assign To Button
-
-![Assigned To](img/assigned-to.png)
-
-
-
-#### Step 2: Add the User and other details￼
-
-
-![Assign User](img/assignment.png)
-
-
-This transaction will appear in the To-do list of the user in “My List” section. It will also appear 
-in the “Assigned by me” section of the user, who has assigned this activity.
diff --git a/docs/user/tools/docs.user.tools.calendar.md b/docs/user/tools/docs.user.tools.calendar.md
deleted file mode 100644
index df70186..0000000
--- a/docs/user/tools/docs.user.tools.calendar.md
+++ /dev/null
@@ -1,21 +0,0 @@
----
-{
-	"_label": "Calendar"
-}
----
-The Calendar is a tool where you can create and share Events and also see auto-generated events from the system.
-
-### Repeating Events
-
-You can set events to repeat on every interval by Checking the "Repeat This Event" 
-as shown in the example.
-
-![Set Repeat This Event](img/event-1.png)
-
-You can see the repeat events by switching back to the calendar.
-
-![Event Repeated in Calendar](img/event-2.png)
-
-### Reminders
-
-You will also get a daily digest of all upcoming events for the day if any if the reminder field is checked.
\ No newline at end of file
diff --git a/docs/user/tools/docs.user.tools.form_tools.md b/docs/user/tools/docs.user.tools.form_tools.md
deleted file mode 100644
index 1c88f5f..0000000
--- a/docs/user/tools/docs.user.tools.form_tools.md
+++ /dev/null
@@ -1,23 +0,0 @@
----
-{
-	"_label": "Collaborating around Forms"
-}
----
-### Assigned to
-
-You can email any transaction from the system by clicking on the “Assigned to” button in the right sidebar. A log of all your sent emails will be maintained in Communication.
-
-
-
-![Forms](img/forms.png)
-
-
-
-### Comments
-
-Comments are a great way to add information about a transaction that is not a part of the transactions. Like some background information etc. Comments can be added in the right sidebar.
-
-### Tags
-
-[Tags](docs.user.tools.tags.html)
-
diff --git a/docs/user/tools/docs.user.tools.md b/docs/user/tools/docs.user.tools.md
deleted file mode 100644
index 68abb96..0000000
--- a/docs/user/tools/docs.user.tools.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-{
-	"_label": "Collaboration Tools",
-	"_toc": [
-		"docs.user.tools.todo",
-		"docs.user.tools.form_tools",
-		"docs.user.tools.messages",
-		"docs.user.tools.notes",
-		"docs.user.tools.calendar",
-		"docs.user.tools.assignment",
-		"docs.user.tools.tags"
-	]
-}
----
-We live in an era when people are very comfortable communicating, discussing, asking, assigning work and getting feedback electronically. The Internet acts as a great medium to collaborate on work too. Taking this concept into ERP system, we have designed a bunch of tools whereby you can Assign transactions, manage your To Dos, share and maintain a Calendar, maintain a company wise Knowledge Base, Tag and Comment on transactions and send your Orders, Invoices etc via Email. You can also send instant messages to other users using the Messaging tool.
-
-These tools are integrated into all aspects of the product so that you can effectively manage your data and collaborate with your co-workers.
\ No newline at end of file
diff --git a/docs/user/tools/docs.user.tools.messages.md b/docs/user/tools/docs.user.tools.messages.md
deleted file mode 100644
index ea24146..0000000
--- a/docs/user/tools/docs.user.tools.messages.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-{
-	"_label": "Messages"
-}
----
-You can send and receive messages from the system by using the Messages tool. If you send a message to a user, and the user is logged in, it will appear as a popup message and the unread messages counter in the top toolbar will be updated.
diff --git a/docs/user/tools/docs.user.tools.notes.md b/docs/user/tools/docs.user.tools.notes.md
deleted file mode 100644
index 8cad69a..0000000
--- a/docs/user/tools/docs.user.tools.notes.md
+++ /dev/null
@@ -1,22 +0,0 @@
----
-{
-	"_label": "Notes"
-}
----
-
-You can store your long notes under this section. It can contain your partner lists, frequently used passwords, terms and conditions , or any other document which needs to be shared. 
-
-#### Step 1: Enter Title and Content
-
-
-![Notes](img/notes.png)
-
-<br>
-
-
-#### Step 2: Set Permissions to select Users
-
-
-
-![Notes](img/notes-1.png)
-
diff --git a/docs/user/tools/docs.user.tools.tags.md b/docs/user/tools/docs.user.tools.tags.md
deleted file mode 100644
index 34e7f27..0000000
--- a/docs/user/tools/docs.user.tools.tags.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-{
-	"_label": "Tags"
-}
----
-
-Like Assignments and Comments, you can also add your own tags to each type of transactions. These tags can help you search a document and also classify it. ERPNext will also show you all the important tags in the document list.
-
-
-![Tags](img/tags.png)
diff --git a/docs/user/tools/docs.user.tools.todo.md b/docs/user/tools/docs.user.tools.todo.md
deleted file mode 100644
index 46be2e2..0000000
--- a/docs/user/tools/docs.user.tools.todo.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-{
-	"_label": "To Do"
-}
----
-
-
-To Do is a simple tool where all the activities assigned to you and assigned by you are listed. You can also add your own to-do items in the list.
-
-
-![To Do](img/to-do.png)
-
diff --git a/docs/user/website/docs.user.website.add_products_to_website.md b/docs/user/website/docs.user.website.add_products_to_website.md
deleted file mode 100644
index 9259ec6..0000000
--- a/docs/user/website/docs.user.website.add_products_to_website.md
+++ /dev/null
@@ -1,60 +0,0 @@
----
-{
-	"_label": "Add Products to Website"
-}
----
-### Add Products to the Website
-
-To list your Item on the Website, fill the Item details and save the file. Once the file is saved, a plus (+) button will appear next to the Image icon. Click on the plus button and add your Item image. The html code will be generated automatically. 
-
-##### Step 1: Save Image
-
-![Webimage](img/item-webimage.png)
-
-<br>
-
-##### Step 2: Check the 'Show in Website' box.
-
-Under the Website section, please check the box that says 'show in Website'. Once the box is checked, the page will display other fields for entering information. 
-
-![Webimage](img/item-webimage-1.png)
-
-<br>
-
-
-##### Step 3: Enter Website Details
-
-![Webimage](img/item-webimage-2.png)
-
-
-The page name will be generated automatically. Mention the Item-Group under which the Item will be displayed.
-
-#### Item Groups
-
-Mention the Item Group under this column. If you wish to list your Item under the broad category products, name your Item Group as Products. In case you have various varieties of Item and want to classify them under different names, make Item Groups with those names and check the box that says 'show in Website'. For Example, if you wish to create a category called 'Bags', create a Item Group named Bags.
-
-
-![Item Group](img/itemgroup-webimage-bags.png)
-
-Once the Item Group is created go to the Website Settings page under Website. Enter the Label, Url, and Parent Label.
-
-
-![Item Group](img/itemgroup-website-settings.png)
-
-<br>
-
-#### Webpage labels
-
-![Webpage](img/webpage-labels.png)
-
-Add more Items under a particular Item Group.
-
-To add more Items under a certain Label, mention the Item Group on the Item Page. The Items will be added automatically on the Webpage, under the Item Group Label. For Example, To add Item-Kiddies Bag and Butterfly Print Bag, check the 'Show in Website'box. The Items will be placed under the Label Bags on the Webpage.
-
-![Item Group](img/itemgroup-websettings.png)
-
-<br>
-
-Item Group Display
-
-![Item Group Display](img/webpage-itemgroup-display.png)
\ No newline at end of file
diff --git a/docs/user/website/docs.user.website.blog_post.md b/docs/user/website/docs.user.website.blog_post.md
deleted file mode 100644
index 706492f..0000000
--- a/docs/user/website/docs.user.website.blog_post.md
+++ /dev/null
@@ -1,25 +0,0 @@
----
-{
-	"_label": "Blog Post"
-}
----
-Blogs are a great way to share your thoughts about your business and keep your customers and readers updated of what you are up to.
-
-In the age of internet, writing assumes a lot of significance because when people come to your website, they want to read about you and your product.
-
-To create a new blog, just create a new Blog from:
-
-> Website > Blog > New Blog
-
-
-![Blog](img/blog.png)
-
-
-You can format a blog using the Markdown format.You can also access your blog by going to the page “blog.html”.
-
-
-#### A sample blog-page.
-
-
-![Blog](img/blog-look.png)
-
diff --git a/docs/user/website/docs.user.website.md b/docs/user/website/docs.user.website.md
deleted file mode 100644
index 60d4b15..0000000
--- a/docs/user/website/docs.user.website.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-{
-	"_label": "Setting up your Website / Webshop",
-	"_toc": [
-		"docs.user.website.setup",
-		"docs.user.website.web_page",
-		"docs.user.website.style",
-		"docs.user.website.blog_post",
-		"docs.user.website.add_products_to_website"
-	]
-}
----
-Websites are a core component of any business and having a good website usually means:
-
-- Invest lot of money.
-- Difficult to update.
-- Not interactive.
-
-Unless you are a web designer yourself. 
-
-Wouldn't it be nice if there was a way to update your product catalog on your site automatically from your ERP? 
-
-We thought exactly the same and hence built a small Website Development app right inside ERPNext! Using ERPNext’s Website module, you can
-
-1. Create Web Pages
-1. Write a Blog
-1. Publish your Product Catalog using the Item master
-
-We will soon be adding a shopping cart facility so that your customers can place orders and pay you online!
-
-Though not necessary, to make a good website, you might have to know a bit of HTML / CSS or hire the services of a professional. The good part is that once this is setup, you can add and edit content, blogs and products directly from your ERP.
-
-> The ERPNext website (www.erpnext.com) is generated from the Website Module! In the world of startups, it's called eating-your-own-dog-food!
\ No newline at end of file
diff --git a/docs/user/website/docs.user.website.setup.md b/docs/user/website/docs.user.website.setup.md
deleted file mode 100644
index 4d1d7c7..0000000
--- a/docs/user/website/docs.user.website.setup.md
+++ /dev/null
@@ -1,79 +0,0 @@
----
-{
-	"_label": "Website Setup"
-}
----
-## Layout
-
-#### Top Bar
-
-The header has two main parts, the “Brand” or the logo section and the menu items. These menu items can directly link to Web Pages or the Blogs page or Products page. The standard Website header bar is with black background.
-
-#### Background
-
-The website is generated using a standard width of 900 pixels and has a page “effect”. You can set a background color or image to enhance the effect of the page.
-
-#### Content
-
-The inner content of your pages has a width of 800px and if it is a two-column layout like Blog, it will have a width of 540 px.
-
-#### Footer
-
-The footer section contains a list of links (this is where you typical put links like “Contact Us”, “Terms and Conditions” etc) and the name of your company.
-
----
-
-## Defining Menus and Home Page
-
-To define the Top Bar Menus, Brand, Footers and Home Page, go to: 
-
-> Website > Website Settings
-
-#### Step 1: Landing Page Details
-
-![Website Setting](img/website-settings.png)
-
-<br>
-
-#### Step 2: Banner Details
-
-![Website Setting](img/website-settings-1.png)
-
-<br>
-
-#### Step 3: Top Bar Labels 
-
-![Website Setting](img/website-settings-2.png)
-
-> Note: Create seperate web pages which will be linked to the main web-icons like company, contact, products etc.
-
-<br>
-#### Step 4: Footer Details
-
-![Website Setting](img/website-settings-3.png)
-
-A website can be generated once all the settings and style requirements are added.
-
-A sample website generated by ERPNext would look like this.
-
-![Website](img/website-settings-4.png)
-
-<br>
-
-#### Top Menu
-
-Add each top menu item on a new link.
-In the label column, add the label of the item.
-In the URL column, enter the name of the page or a full URL. If you want a new Web Page to open, just put the “Page Name” + “.html”. (URL is simply a web address like “http://google.com”)
-
-Similarly you can also set the Footer section to contain links. If you want to have links appear as a drop-down under another link, just add the name of the parent menu in “Parent Label”.
-
-#### Brand
-
-To set your brand, create a logo with a transparent background and white foreground of roughly height 24px and length of 150px, attach it to the Website Settings page, and add it in your Brand section as an image as follows:
-
----
-
-##### What is Website Analytics?
-
-Website analytics helps you to track each visitor on your website. The analytics will tell you from which country, at what time, and which pages the visitor viewed. This will help you understand who your visitors are and what they are looking for. There are many analytics engines available and the most popular and Free service is Google Analytics. We definitely recommend using one of them to gain insight into your website visitors.
\ No newline at end of file
diff --git a/docs/user/website/docs.user.website.style.md b/docs/user/website/docs.user.website.style.md
deleted file mode 100644
index 83854e0..0000000
--- a/docs/user/website/docs.user.website.style.md
+++ /dev/null
@@ -1,23 +0,0 @@
----
-{
-	"_label": "Styling the Website"
-}
----
-You can set some basic styles to your page using the styles feature.
-
-#### Background
-￼
-You can either set a solid background by selecting a color.
-You can attach a file and select it in the “Background Image” box.
-
-#### Fonts
-
-Fonts: Font family of your body text (includes some Open Source fonts).
-Font-size: Font-size of your website body text (large is good).
-Heading Font: Font family of your headings.
-
-Apart from this you can also add custom style rules using CSS
-
-#### Custom CSS
-
-There are tons of CSS rules and tricks that fall out of scope of this manual. But you could add your own style to certain elements like h1, h2 etc and also create your own style classes that you can use in elements in your body content.
\ No newline at end of file
diff --git a/docs/user/website/docs.user.website.web_page.md b/docs/user/website/docs.user.website.web_page.md
deleted file mode 100644
index a8f0e13..0000000
--- a/docs/user/website/docs.user.website.web_page.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-{
-	"_label": "Web Pages"
-}
----
-Static Content like your Home Page, About Us, Contact Us, Terms pages can be created using the Web Page. To create a new Web Page, go to:
-
-> Website > Web Page > New Web Page
-
-![Web Page](img/webpage.png)
-
-
-
-#### Title
-
-The first thing to set is the title of your page. The title has the maximum weight for search engines so choose a title that reflects the keywords that you are targeting for your audience.
-
-#### Content
-
-After selecting your layout, you can add content (text, images, etc) to each of your content boxes. You can add content in Markdown or HTML format. Read the section on how to format using Markdown for more details.
-
-#### Page Link
-
-The web link to your page will be the value of the “Page Name” field + “.html”. For example if your page name is contact-us, the web link of your page will be yoursite.com/contact-us.html.
-
-#### Images
-
-You can attach images to your web page and show them using the <img> HTML tag or using markdown format. the link to your file will be files/filename
\ No newline at end of file
diff --git a/patches/patch_list.py b/patches/patch_list.py
index 7175b63..80b84de 100644
--- a/patches/patch_list.py
+++ b/patches/patch_list.py
@@ -254,4 +254,5 @@
 	"patches.1311.p04_update_comments",
 	"patches.1311.p05_website_brand_html",
 	"patches.1311.p06_fix_report_columns",
+	"execute:webnotes.delete_doc('DocType', 'Documentation Tool')",
 ]
\ No newline at end of file
